| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "fmt" |
| "os" |
| "path/filepath" |
| "regexp" |
| "sort" |
| "text/template" |
| |
| "go.fuchsia.dev/jiri" |
| "go.fuchsia.dev/jiri/cmdline" |
| "go.fuchsia.dev/jiri/project" |
| ) |
| |
| var ( |
| cleanAllFlag bool |
| cleanupFlag bool |
| useRemoteProjects bool |
| jsonOutputFlag string |
| regexpFlag bool |
| templateFlag string |
| useLocalManifest bool |
| ) |
| |
| func init() { |
| cmdProject.Flags.BoolVar(&cleanAllFlag, "clean-all", false, "Restore jiri projects to their pristine state and delete all branches.") |
| cmdProject.Flags.BoolVar(&cleanupFlag, "clean", false, "Restore jiri projects to their pristine state.") |
| cmdProject.Flags.StringVar(&jsonOutputFlag, "json-output", "", "Path to write operation results to.") |
| cmdProject.Flags.BoolVar(®expFlag, "regexp", false, "Use argument as regular expression.") |
| cmdProject.Flags.StringVar(&templateFlag, "template", "", "The template for the fields to display.") |
| cmdProject.Flags.BoolVar(&useLocalManifest, "local-manifest", false, "List project status based on local manifest.") |
| cmdProject.Flags.BoolVar(&useRemoteProjects, "list-remote-projects", false, "List remote projects instead of local projects.") |
| } |
| |
| // cmdProject represents the "jiri project" command. |
| var cmdProject = &cmdline.Command{ |
| Runner: jiri.RunnerFunc(runProject), |
| Name: "project", |
| Short: "Manage the jiri projects", |
| Long: `Cleans all projects if -clean flag is provided else inspect |
| the local filesystem and provide structured info on the existing |
| projects and branches. Projects are specified using either names or |
| regular expressions that are matched against project names. If no |
| command line arguments are provided the project that the contains the |
| current directory is used, or if run from outside of a given project, |
| all projects will be used. The information to be displayed can be |
| specified using a Go template, supplied via |
| the -template flag.`, |
| ArgsName: "<project ...>", |
| ArgsLong: "<project ...> is a list of projects to clean up or give info about.", |
| } |
| |
| func runProject(jirix *jiri.X, args []string) (e error) { |
| if cleanupFlag || cleanAllFlag { |
| return runProjectClean(jirix, args) |
| } else { |
| return runProjectInfo(jirix, args) |
| } |
| } |
| func runProjectClean(jirix *jiri.X, args []string) (e error) { |
| localProjects, err := project.LocalProjects(jirix, project.FullScan) |
| if err != nil { |
| return err |
| } |
| projects := make(project.Projects) |
| if len(args) > 0 { |
| if regexpFlag { |
| for _, a := range args { |
| re, err := regexp.Compile(a) |
| if err != nil { |
| return fmt.Errorf("failed to compile regexp %v: %v", a, err) |
| } |
| for _, p := range localProjects { |
| if re.MatchString(p.Name) { |
| projects[p.Key()] = p |
| } |
| } |
| } |
| } else { |
| for _, arg := range args { |
| p, err := localProjects.FindUnique(arg) |
| if err != nil { |
| fmt.Fprintf(jirix.Stderr(), "Error finding local project %q: %v.\n", p.Name, err) |
| } else { |
| projects[p.Key()] = p |
| } |
| } |
| } |
| } else { |
| projects = localProjects |
| } |
| if err := project.CleanupProjects(jirix, projects, cleanAllFlag); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| // projectInfoOutput defines JSON format for 'project info' output. |
| type projectInfoOutput struct { |
| Name string `json:"name"` |
| Path string `json:"path"` |
| |
| // Relative path w.r.t to root |
| RelativePath string `json:"relativePath"` |
| Remote string `json:"remote"` |
| Revision string `json:"revision"` |
| CurrentBranch string `json:"current_branch,omitempty"` |
| Branches []string `json:"branches,omitempty"` |
| Manifest string `json:"manifest,omitempty"` |
| GerritHost string `json:"gerrithost,omitempty"` |
| GitSubmoduleOf string `json:"gitsubmoduleof,omitempty"` |
| } |
| |
| // runProjectInfo provides structured info on local projects. |
| func runProjectInfo(jirix *jiri.X, args []string) error { |
| var tmpl *template.Template |
| var err error |
| if templateFlag != "" { |
| tmpl, err = template.New("info").Parse(templateFlag) |
| if err != nil { |
| return fmt.Errorf("failed to parse template %q: %v", templateFlag, err) |
| } |
| } |
| |
| regexps := []*regexp.Regexp{} |
| if len(args) > 0 && regexpFlag { |
| regexps = make([]*regexp.Regexp, len(args), len(args)) |
| for i, a := range args { |
| re, err := regexp.Compile(a) |
| if err != nil { |
| return fmt.Errorf("failed to compile regexp %v: %v", a, err) |
| } |
| regexps[i] = re |
| } |
| } |
| |
| var states map[project.ProjectKey]*project.ProjectState |
| var keys project.ProjectKeys |
| projects, err := project.LocalProjects(jirix, project.FastScan) |
| if err != nil { |
| return err |
| } |
| if useLocalManifest { |
| projects, _, _, err = project.LoadUpdatedManifest(jirix, projects, useLocalManifest) |
| if err := project.FilterOptionalProjectsPackages(jirix, jirix.FetchingAttrs, projects, nil); err != nil { |
| return err |
| } |
| } |
| if useRemoteProjects { |
| projects, _, _, err = project.LoadManifestFile(jirix, jirix.JiriManifestFile(), projects, false) |
| if err != nil { |
| return err |
| } |
| // filter optional projects |
| // we only need to filter in the remote projects path, otherwise it is only using |
| // projects that already exist on disk. |
| if err := project.FilterOptionalProjectsPackages(jirix, jirix.FetchingAttrs, projects, nil); err != nil { |
| return err |
| } |
| } |
| if len(args) == 0 { |
| currentProject, err := project.CurrentProject(jirix) |
| if err != nil { |
| return err |
| } |
| // Due to fuchsia.git is checked out at root. |
| // set currentProject to nil if current working |
| // dir is JIRI_ROOT to allow list all projects. |
| cwd, err := os.Getwd() |
| if cwd == jirix.Root { |
| currentProject = nil |
| } |
| if currentProject == nil { |
| // jiri was run from outside of a project so let's |
| // use all available projects. |
| states, err = project.GetProjectStates(jirix, projects, false) |
| if err != nil { |
| return err |
| } |
| for key := range states { |
| keys = append(keys, key) |
| } |
| } else { |
| state, err := project.GetProjectState(jirix, *currentProject, true) |
| if err != nil { |
| return err |
| } |
| states = map[project.ProjectKey]*project.ProjectState{ |
| currentProject.Key(): state, |
| } |
| keys = append(keys, currentProject.Key()) |
| } |
| } else { |
| var err error |
| states, err = project.GetProjectStates(jirix, projects, false) |
| if err != nil { |
| return err |
| } |
| for key, state := range states { |
| if regexpFlag { |
| for _, re := range regexps { |
| if re.MatchString(state.Project.Name) { |
| keys = append(keys, key) |
| break |
| } |
| } |
| } else { |
| for _, arg := range args { |
| if arg == state.Project.Name { |
| keys = append(keys, key) |
| break |
| } |
| } |
| } |
| } |
| } |
| sort.Sort(keys) |
| |
| info := make([]projectInfoOutput, len(keys)) |
| for i, key := range keys { |
| state := states[key] |
| rp, err := filepath.Rel(jirix.Root, state.Project.Path) |
| if err != nil { |
| // should not happen |
| panic(err) |
| } |
| info[i] = projectInfoOutput{ |
| Name: state.Project.Name, |
| Path: state.Project.Path, |
| RelativePath: rp, |
| Remote: state.Project.Remote, |
| Revision: state.Project.Revision, |
| CurrentBranch: state.CurrentBranch.Name, |
| Manifest: state.Project.ManifestPath, |
| GerritHost: state.Project.GerritHost, |
| GitSubmoduleOf: state.Project.GitSubmoduleOf, |
| } |
| for _, b := range state.Branches { |
| info[i].Branches = append(info[i].Branches, b.Name) |
| } |
| } |
| |
| for _, i := range info { |
| if templateFlag != "" { |
| out := &bytes.Buffer{} |
| if err := tmpl.Execute(out, i); err != nil { |
| return jirix.UsageErrorf("invalid format") |
| } |
| fmt.Fprintln(os.Stdout, out.String()) |
| } else { |
| fmt.Printf("* project %s\n", i.Name) |
| fmt.Printf(" Path: %s\n", i.Path) |
| fmt.Printf(" Remote: %s\n", i.Remote) |
| fmt.Printf(" Revision: %s\n", i.Revision) |
| fmt.Printf(" GitSubmoduleOf: %s\n", i.GitSubmoduleOf) |
| if useRemoteProjects { |
| fmt.Printf(" Manifest: %s\n", i.Manifest) |
| } |
| if len(i.Branches) != 0 { |
| fmt.Printf(" Branches:\n") |
| width := 0 |
| for _, b := range i.Branches { |
| if len(b) > width { |
| width = len(b) |
| } |
| } |
| for _, b := range i.Branches { |
| fmt.Printf(" %-*s", width, b) |
| if i.CurrentBranch == b { |
| fmt.Printf(" current") |
| } |
| fmt.Println() |
| } |
| } else { |
| fmt.Printf(" Branches: none\n") |
| } |
| } |
| } |
| |
| if jsonOutputFlag != "" { |
| if err := writeJSONOutput(info); err != nil { |
| return err |
| } |
| } |
| |
| return nil |
| } |
| |
| func writeJSONOutput(result interface{}) error { |
| out, err := json.MarshalIndent(&result, "", " ") |
| if err != nil { |
| return fmt.Errorf("failed to serialize JSON output: %s", err) |
| } |
| |
| err = os.WriteFile(jsonOutputFlag, out, 0600) |
| if err != nil { |
| return fmt.Errorf("failed write JSON output to %s: %s", jsonOutputFlag, err) |
| } |
| |
| return nil |
| } |
