Refactoring to make output additions more clearly navigable

Author: cftorres

cmd/root.go

@@ -116,31 +116,8 @@ func diffImages(image1Arg, image2Arg string, diffArgs []string) error {
 
 	req := differs.DiffRequest{image1, image2, diffTypes}
 	if diffs, err := req.GetDiff(); err == nil {
-		// Outputs diff results in alphabetical order by differ name
-		sortedTypes := []string{}
-		for name := range diffs {
-			sortedTypes = append(sortedTypes, name)
-		}
-		sort.Strings(sortedTypes)
 		glog.Info("Retrieving diffs")
-		diffResults := make([]interface{}, len(diffs))
-		for i, diffType := range sortedTypes {
-			diff := diffs[diffType]
-			if json {
-				diffResults[i] = diff.GetStruct()
-			} else {
-				err = diff.OutputText(diffType)
-				if err != nil {
-					glog.Error(err)
-				}
-			}
-		}
-		if json {
-			err = utils.JSONify(diffResults)
-			if err != nil {
-				glog.Error(err)
-			}
-		}
+		outputResults(diffs)
 		if !save {
 			cleanupImage(image1)
 			cleanupImage(image2)
@@ -175,31 +152,8 @@ func analyzeImage(imageArg string, analyzerArgs []string) error {
 
 	req := differs.SingleRequest{image, analyzeTypes}
 	if analyses, err := req.GetAnalysis(); err == nil {
-		// Outputs analysis results in alphabetical order by differ name
-		sortedTypes := []string{}
-		for name := range analyses {
-			sortedTypes = append(sortedTypes, name)
-		}
-		sort.Strings(sortedTypes)
-		glog.Info("Retrieving diffs")
-		analyzeResults := make([]interface{}, len(analyses))
-		for i, analyzeType := range sortedTypes {
-			analysis := analyses[analyzeType]
-			if json {
-				analyzeResults[i] = analysis.GetStruct()
-			} else {
-				err = analysis.OutputText(analyzeType)
-				if err != nil {
-					glog.Error(err)
-				}
-			}
-		}
-		if json {
-			err = utils.JSONify(analyzeResults)
-			if err != nil {
-				glog.Error(err)
-			}
-		}
+		glog.Info("Retrieving analyses")
+		outputResults(analyses)
 		if !save {
 			cleanupImage(image)
 		} else {
@@ -215,6 +169,34 @@ func analyzeImage(imageArg string, analyzerArgs []string) error {
 	return nil
 }
 
+func outputResults(resultMap map[string]utils.Result) {
+	// Outputs diff/analysis results in alphabetical order by analyzer name
+	sortedTypes := []string{}
+	for analyzerType := range resultMap {
+		sortedTypes = append(sortedTypes, analyzerType)
+	}
+	sort.Strings(sortedTypes)
+
+	results := make([]interface{}, len(resultMap))
+	for i, analyzerType := range sortedTypes {
+		result := resultMap[analyzerType]
+		if json {
+			results[i] = result.OutputStruct()
+		} else {
+			err := result.OutputText(analyzerType)
+			if err != nil {
+				glog.Error(err)
+			}
+		}
+	}
+	if json {
+		err := utils.JSONify(results)
+		if err != nil {
+			glog.Error(err)
+		}
+	}
+}
+
 func cleanupImage(image utils.Image) {
 	if !reflect.DeepEqual(image, (utils.Image{})) {
 		glog.Infof("Removing image filesystem directory %s from system", image.FSPath)

utils/analyze_output_utils.go

@@ -1,15 +1,7 @@
 package utils
 
-import (
-	"sort"
-
-	"code.cloudfoundry.org/bytefmt"
-)
-
-var SortSize bool
-
 type Result interface {
-	GetStruct() interface{}
+	OutputStruct() interface{}
 	OutputText(resultType string) error
 }
 
@@ -21,7 +13,7 @@ type AnalyzeResult struct {
 
 type ListAnalyzeResult AnalyzeResult
 
-func (r ListAnalyzeResult) GetStruct() interface{} {
+func (r ListAnalyzeResult) OutputStruct() interface{} {
 	return r
 }
 
@@ -32,7 +24,7 @@ func (r ListAnalyzeResult) OutputText(resultType string) error {
 
 type MultiVersionPackageAnalyzeResult AnalyzeResult
 
-func (r MultiVersionPackageAnalyzeResult) GetStruct() interface{} {
+func (r MultiVersionPackageAnalyzeResult) OutputStruct() interface{} {
 	analysis := r.Analysis.(map[string]map[string]PackageInfo)
 	analysisOutput := getMultiVersionPackageOutput(analysis)
 	output := struct {
@@ -66,7 +58,7 @@ func (r MultiVersionPackageAnalyzeResult) OutputText(resultType string) error {
 
 type SingleVersionPackageAnalyzeResult AnalyzeResult
 
-func (r SingleVersionPackageAnalyzeResult) GetStruct() interface{} {
+func (r SingleVersionPackageAnalyzeResult) OutputStruct() interface{} {
 	analysis := r.Analysis.(map[string]PackageInfo)
 	analysisOutput := getSingleVersionPackageOutput(analysis)
 	output := struct {
@@ -105,56 +97,6 @@ type PackageOutput struct {
 	Size    int64
 }
 
-type packageBy func(p1, p2 *PackageOutput) bool
-
-func (by packageBy) Sort(packages []PackageOutput) {
-	ps := &packageSorter{
-		packages: packages,
-		by:       by,
-	}
-	sort.Sort(ps)
-}
-
-type packageSorter struct {
-	packages []PackageOutput
-	by       func(p1, p2 *PackageOutput) bool
-}
-
-func (s *packageSorter) Len() int {
-	return len(s.packages)
-}
-
-func (s *packageSorter) Less(i, j int) bool {
-	return s.by(&s.packages[i], &s.packages[j])
-}
-
-func (s *packageSorter) Swap(i, j int) {
-	s.packages[i], s.packages[j] = s.packages[j], s.packages[i]
-}
-
-// If packages have the same name, means they exist where multiple version of the same package are allowed,
-// so sort by version.  If they have the same version, then sort by size.
-var packageNameSort = func(p1, p2 *PackageOutput) bool {
-	if p1.Name == p2.Name {
-		if p1.Version == p2.Version {
-			return p1.Size > p2.Size
-		}
-		return p1.Version < p2.Version
-	}
-	return p1.Name < p2.Name
-}
-
-// If packages have the same size, sort by name.  If they are two versions of the same package, sort by version.
-var packageSizeSort = func(p1, p2 *PackageOutput) bool {
-	if p1.Size == p2.Size {
-		if p1.Name == p2.Name {
-			return p1.Version < p2.Version
-		}
-		return p1.Name < p2.Name
-	}
-	return p1.Size > p2.Size
-}
-
 func getSingleVersionPackageOutput(packageMap map[string]PackageInfo) []PackageOutput {
 	packages := []PackageOutput{}
 	for name, info := range packageMap {
@@ -185,33 +127,9 @@ func getMultiVersionPackageOutput(packageMap map[string]map[string]PackageInfo)
 	return packages
 }
 
-type StrPackageOutput struct {
-	Name    string
-	Path    string
-	Version string
-	Size    string
-}
-
-func stringifySize(size int64) string {
-	strSize := "unknown"
-	if size != -1 {
-		strSize = bytefmt.ByteSize(uint64(size))
-	}
-	return strSize
-}
-
-func stringifyPackages(packages []PackageOutput) []StrPackageOutput {
-	strPackages := []StrPackageOutput{}
-	for _, pack := range packages {
-		strSize := stringifySize(pack.Size)
-		strPackages = append(strPackages, StrPackageOutput{pack.Name, pack.Path, pack.Version, strSize})
-	}
-	return strPackages
-}
-
 type FileAnalyzeResult AnalyzeResult
 
-func (r FileAnalyzeResult) GetStruct() interface{} {
+func (r FileAnalyzeResult) OutputStruct() interface{} {
 	analysis := r.Analysis.([]DirectoryEntry)
 	if SortSize {
 		directoryBy(directorySizeSort).Sort(analysis)
@@ -242,57 +160,3 @@ func (r FileAnalyzeResult) OutputText(analyzeType string) error {
 	}
 	return TemplateOutput(strResult, "FileAnalyze")
 }
-
-type directoryBy func(e1, e2 *DirectoryEntry) bool
-
-func (by directoryBy) Sort(entries []DirectoryEntry) {
-	ds := &directorySorter{
-		entries: entries,
-		by:      by,
-	}
-	sort.Sort(ds)
-}
-
-type directorySorter struct {
-	entries []DirectoryEntry
-	by      func(p1, p2 *DirectoryEntry) bool
-}
-
-func (s *directorySorter) Len() int {
-	return len(s.entries)
-}
-
-func (s *directorySorter) Less(i, j int) bool {
-	return s.by(&s.entries[i], &s.entries[j])
-}
-
-func (s *directorySorter) Swap(i, j int) {
-	s.entries[i], s.entries[j] = s.entries[j], s.entries[i]
-}
-
-// If packages have the same name, means they exist where multiple version of the same package are allowed,
-// so sort by version.  If they have the same version, then sort by size.
-var directoryNameSort = func(e1, e2 *DirectoryEntry) bool {
-	return e1.Name < e2.Name
-}
-
-// If packages have the same size, sort by name.  If they are two versions of the same package, sort by version.
-var directorySizeSort = func(e1, e2 *DirectoryEntry) bool {
-	if e1.Size == e2.Size {
-		return e1.Name < e2.Name
-	}
-	return e1.Size > e2.Size
-}
-
-type StrDirectoryEntry struct {
-	Name string
-	Size string
-}
-
-func stringifyDirectoryEntries(entries []DirectoryEntry) (strEntries []StrDirectoryEntry) {
-	for _, entry := range entries {
-		strEntry := StrDirectoryEntry{Name: entry.Name, Size: stringifySize(entry.Size)}
-		strEntries = append(strEntries, strEntry)
-	}
-	return
-}