From 8316df15e8debc8337d7666d37cfd33aaa0cf2b2 Mon Sep 17 00:00:00 2001 From: Sunny Date: Sat, 20 May 2017 16:17:33 +0530 Subject: [PATCH 1/3] Implement unused run mode in status Adds runStatusUnused() to analyse and show only the unused dependencies in the project. --- cmd/dep/status.go | 38 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 36 insertions(+), 2 deletions(-) diff --git a/cmd/dep/status.go b/cmd/dep/status.go index eb57abc9f4..e4c4b979c9 100644 --- a/cmd/dep/status.go +++ b/cmd/dep/status.go @@ -214,8 +214,15 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error { } } - if err := runStatusAll(ctx.Loggers, out, p, sm); err != nil { - return err + switch { + case cmd.unused: + if err := runStatusUnused(ctx.Loggers, p); err != nil { + return err + } + default: + if err := runStatusAll(ctx.Loggers, out, p, sm); err != nil { + return err + } } ctx.Loggers.Out.Print(buf.String()) @@ -422,6 +429,33 @@ outer: return nil } +// runStatusUnused analyses the project for unused dependencies that are present +// in manifest but not imported in the project. +func runStatusUnused(loggers *dep.Loggers, p *dep.Project) error { + ptree, err := pkgtree.ListPackages(p.AbsRoot, string(p.ImportRoot)) + if err != nil { + return errors.Errorf("analysis of local packages failed: %v", err) + } + + rm, _ := ptree.ToReachMap(true, true, false, nil) + external := rm.FlattenOmitStdLib() + + var unusedDeps []string + for pr, _ := range p.Manifest.Dependencies { + if !contains(external, string(pr)) { + unusedDeps = append(unusedDeps, string(pr)) + } + } + + loggers.Err.Println("Unused dependencies present in manifest:\n") + + for _, d := range unusedDeps { + loggers.Err.Printf(" %v\n", d) + } + + return nil +} + func formatVersion(v gps.Version) string { if v == nil { return "" From 05023e5f1716341dd90cc6847faae0c3cd9755cb Mon Sep 17 00:00:00 2001 From: Sunny Date: Sat, 20 May 2017 16:58:28 +0530 Subject: [PATCH 2/3] Implement missing run mode for status Adds runStatusMissing() to analyse and show only the missing dependencies in the project. --- cmd/dep/status.go | 52 ++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 47 insertions(+), 5 deletions(-) diff --git a/cmd/dep/status.go b/cmd/dep/status.go index e4c4b979c9..2971e6bd73 100644 --- a/cmd/dep/status.go +++ b/cmd/dep/status.go @@ -219,6 +219,10 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error { if err := runStatusUnused(ctx.Loggers, p); err != nil { return err } + case cmd.missing: + if err := runStatusMissing(ctx.Loggers, p); err != nil { + return err + } default: if err := runStatusAll(ctx.Loggers, out, p, sm); err != nil { return err @@ -432,14 +436,11 @@ outer: // runStatusUnused analyses the project for unused dependencies that are present // in manifest but not imported in the project. func runStatusUnused(loggers *dep.Loggers, p *dep.Project) error { - ptree, err := pkgtree.ListPackages(p.AbsRoot, string(p.ImportRoot)) + external, err := getExternalPackages(p) if err != nil { - return errors.Errorf("analysis of local packages failed: %v", err) + return err } - rm, _ := ptree.ToReachMap(true, true, false, nil) - external := rm.FlattenOmitStdLib() - var unusedDeps []string for pr, _ := range p.Manifest.Dependencies { if !contains(external, string(pr)) { @@ -456,6 +457,47 @@ func runStatusUnused(loggers *dep.Loggers, p *dep.Project) error { return nil } +// runStatusMissing analyses the project for missing dependencies in lock file. +func runStatusMissing(loggers *dep.Loggers, p *dep.Project) error { + external, err := getExternalPackages(p) + if err != nil { + return err + } + + var missingDeps []string + +missingOuter: + for _, d := range external { + for _, lp := range p.Lock.Projects() { + if string(lp.Ident().ProjectRoot) == d { + continue missingOuter + } + } + + missingDeps = append(missingDeps, d) + } + + loggers.Err.Println("Missing dependencies (not present in lock):\n") + + for _, d := range missingDeps { + loggers.Err.Printf(" %v\n", d) + } + + return nil +} + +// getExternalPackages parses the project and returns a string slice of +// projects' ImportRoot +func getExternalPackages(p *dep.Project) ([]string, error) { + ptree, err := pkgtree.ListPackages(p.AbsRoot, string(p.ImportRoot)) + if err != nil { + return nil, errors.Errorf("analysis of local packages failed: %v", err) + } + + rm, _ := ptree.ToReachMap(true, true, false, nil) + return rm.FlattenOmitStdLib(), nil +} + func formatVersion(v gps.Version) string { if v == nil { return "" From 1fb29d822c6419b71d29beb8c4250e8be10b4ffb Mon Sep 17 00:00:00 2001 From: Sunny Date: Sat, 20 May 2017 17:45:10 +0530 Subject: [PATCH 3/3] Implement old run mode for status Adds runStatusOld() to analyse and list the out-of-date dependencies in the project. --- cmd/dep/status.go | 80 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 74 insertions(+), 6 deletions(-) diff --git a/cmd/dep/status.go b/cmd/dep/status.go index 2971e6bd73..e85dd19a4e 100644 --- a/cmd/dep/status.go +++ b/cmd/dep/status.go @@ -223,6 +223,10 @@ func (cmd *statusCommand) Run(ctx *dep.Ctx, args []string) error { if err := runStatusMissing(ctx.Loggers, p); err != nil { return err } + case cmd.old: + if err := runStatusOld(ctx.Loggers, p, sm); err != nil { + return err + } default: if err := runStatusAll(ctx.Loggers, out, p, sm); err != nil { return err @@ -448,10 +452,14 @@ func runStatusUnused(loggers *dep.Loggers, p *dep.Project) error { } } - loggers.Err.Println("Unused dependencies present in manifest:\n") + if unusedDeps != nil { + loggers.Err.Println("Unused dependencies present in manifest:\n") - for _, d := range unusedDeps { - loggers.Err.Printf(" %v\n", d) + for _, d := range unusedDeps { + loggers.Err.Printf(" %v\n", d) + } + } else { + loggers.Err.Println("No unused dependencies found.") } return nil @@ -477,10 +485,70 @@ missingOuter: missingDeps = append(missingDeps, d) } - loggers.Err.Println("Missing dependencies (not present in lock):\n") + if missingDeps != nil { + loggers.Err.Println("Missing dependencies (not present in lock):\n") + for _, d := range missingDeps { + loggers.Err.Printf(" %v\n", d) + } + } else { + loggers.Err.Println("No missing dependencies found.") + } + + return nil +} + +// runStatusOld analyses the project for old dependencies that have a newer +// version available. +func runStatusOld(loggers *dep.Loggers, p *dep.Project, sm gps.SourceManager) error { + var projects []BasicStatus + + for _, proj := range p.Lock.Projects() { + bs := BasicStatus{ + ProjectRoot: string(proj.Ident().ProjectRoot), + } + + switch tv := proj.Version().(type) { + case gps.UnpairedVersion: + bs.Version = tv + case gps.Revision: + bs.Revision = tv + case gps.PairedVersion: + bs.Version = tv.Unpair() + bs.Revision = tv.Underlying() + } + + if bs.Version != nil && bs.Version.Type() != gps.IsVersion { + c, has := p.Manifest.Dependencies[proj.Ident().ProjectRoot] + if !has { + c.Constraint = gps.Any() + } + bs.Constraint = c.Constraint + + vl, err := sm.ListVersions(proj.Ident()) + if err == nil { + gps.SortPairedForUpgrade(vl) + + for _, v := range vl { + if c.Constraint.Matches(v) { + bs.Latest = v.Underlying() + break + } + } + } + } - for _, d := range missingDeps { - loggers.Err.Printf(" %v\n", d) + if bs.Latest != bs.Revision { + projects = append(projects, bs) + } + } + + if projects != nil { + loggers.Err.Println("Following are the out-of-date dependencies:\n") + for _, project := range projects { + loggers.Err.Printf("%v is on %v, latest available is %v\n", project.ProjectRoot, project.Revision, project.Latest) + } + } else { + loggers.Err.Println("All the dependencies are up-to-date.") } return nil