Adding sorting methods to output

Author: cftorres

cmd/root.go

@@ -123,11 +123,11 @@ func diffImages(image1Arg, image2Arg string, diffArgs []string) error {
 		}
 		sort.Strings(sortedTypes)
 		glog.Info("Retrieving diffs")
-		diffResults := []utils.DiffResult{}
+		diffResults := []utils.Result{}
 		for _, diffType := range sortedTypes {
 			diff := diffs[diffType]
 			if json {
-				diffResults = append(diffResults, diff.GetStruct())
+				diffResults = append(diffResults, diff.GetStruct().(utils.Result))
 			} else {
 				err = diff.OutputText(diffType)
 				if err != nil {
@@ -182,11 +182,11 @@ func analyzeImage(imageArg string, analyzerArgs []string) error {
 		}
 		sort.Strings(sortedTypes)
 		glog.Info("Retrieving diffs")
-		analyzeResults := []utils.AnalyzeResult{}
+		analyzeResults := []utils.Result{}
 		for _, analyzeType := range sortedTypes {
 			analysis := analyses[analyzeType]
 			if json {
-				analyzeResults = append(analyzeResults, analysis.GetStruct())
+				analyzeResults = append(analyzeResults, analysis.GetStruct().(utils.Result))
 			} else {
 				err = analysis.OutputText(analyzeType)
 				if err != nil {
@@ -313,4 +313,5 @@ func init() {
 	RootCmd.Flags().BoolVarP(&file, "file", "f", false, "Set this flag to use the file differ.")
 	RootCmd.Flags().BoolVarP(&history, "history", "d", false, "Set this flag to use the dockerfile history differ.")
 	RootCmd.Flags().BoolVarP(&save, "save", "s", false, "Set this flag to save rather than remove the final image filesystems on exit.")
+	RootCmd.Flags().BoolVarP(&utils.SortSize, "order", "o", false, "Set this flag to sort any file/package results by descending size. Otherwise, they will be sorted by name.")
 }

differs/aptDiff.go

@@ -15,12 +15,12 @@ type AptAnalyzer struct {
 }
 
 // AptDiff compares the packages installed by apt-get.
-func (a AptAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, error) {
+func (a AptAnalyzer) Diff(image1, image2 utils.Image) (utils.Result, error) {
 	diff, err := singleVersionDiff(image1, image2, a)
 	return diff, err
 }
 
-func (a AptAnalyzer) Analyze(image utils.Image) (utils.AnalyzeResult, error) {
+func (a AptAnalyzer) Analyze(image utils.Image) (utils.Result, error) {
 	analysis, err := singleVersionAnalysis(image, a)
 	return analysis, err
 }

differs/differs.go

@@ -21,8 +21,8 @@ type SingleRequest struct {
 }
 
 type Analyzer interface {
-	Diff(image1, image2 utils.Image) (utils.DiffResult, error)
-	Analyze(image utils.Image) (utils.AnalyzeResult, error)
+	Diff(image1, image2 utils.Image) (utils.Result, error)
+	Analyze(image utils.Image) (utils.Result, error)
 }
 
 var analyzers = map[string]Analyzer{
@@ -33,12 +33,20 @@ var analyzers = map[string]Analyzer{
 	"node":    NodeAnalyzer{},
 }
 
-func (req DiffRequest) GetDiff() (map[string]utils.DiffResult, error) {
+/*var diffResultMap = map[string]utils.DiffResult{
+	"HistoryAnalyzer": utils.HistDiffResult,
+	"FileAnalyzer":    utils.DirDiffResult,
+	"AptAnalyzer":     utils.SingleVersionPackageDiffResult,
+	"PipAnalyzer":     utils.MultiVersionPackageDiffResult,
+	"NodeAnalyzer":    utils.MultiVersionPackageDiffResult,
+}*/
+
+func (req DiffRequest) GetDiff() (map[string]utils.Result, error) {
 	img1 := req.Image1
 	img2 := req.Image2
 	diffs := req.DiffTypes
 
-	results := map[string]utils.DiffResult{}
+	results := map[string]utils.Result{}
 	for _, differ := range diffs {
 		differName := reflect.TypeOf(differ).Name()
 		if diff, err := differ.Diff(img1, img2); err == nil {
@@ -58,11 +66,11 @@ func (req DiffRequest) GetDiff() (map[string]utils.DiffResult, error) {
 	return results, err
 }
 
-func (req SingleRequest) GetAnalysis() (map[string]utils.AnalyzeResult, error) {
+func (req SingleRequest) GetAnalysis() (map[string]utils.Result, error) {
 	img := req.Image
 	analyses := req.AnalyzeTypes
 
-	results := map[string]utils.AnalyzeResult{}
+	results := map[string]utils.Result{}
 	for _, analyzer := range analyses {
 		analyzeName := reflect.TypeOf(analyzer).Name()
 		if analysis, err := analyzer.Analyze(img); err == nil {

differs/fileDiff.go

@@ -8,7 +8,7 @@ type FileAnalyzer struct {
 }
 
 // FileDiff diffs two packages and compares their contents
-func (a FileAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, error) {
+func (a FileAnalyzer) Diff(image1, image2 utils.Image) (utils.Result, error) {
 	diff, err := diffImageFiles(image1, image2)
 	return &utils.DirDiffResult{
 		Image1:   image1.Source,
@@ -18,7 +18,7 @@ func (a FileAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, error)
 	}, err
 }
 
-func (a FileAnalyzer) Analyze(image utils.Image) (utils.AnalyzeResult, error) {
+func (a FileAnalyzer) Analyze(image utils.Image) (utils.Result, error) {
 	var result utils.FileAnalyzeResult
 
 	imgDir, err := utils.GetDirectory(image.FSPath, true)

differs/historyDiff.go

@@ -9,7 +9,7 @@ import (
 type HistoryAnalyzer struct {
 }
 
-func (a HistoryAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, error) {
+func (a HistoryAnalyzer) Diff(image1, image2 utils.Image) (utils.Result, error) {
 	diff, err := getHistoryDiff(image1, image2)
 	return &utils.HistDiffResult{
 		Image1:   image1.Source,
@@ -19,7 +19,7 @@ func (a HistoryAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, err
 	}, err
 }
 
-func (a HistoryAnalyzer) Analyze(image utils.Image) (utils.AnalyzeResult, error) {
+func (a HistoryAnalyzer) Analyze(image utils.Image) (utils.Result, error) {
 	history := getHistoryList(image.Config.History)
 	result := utils.ListAnalyzeResult{
 		Image:       image.Source,

differs/nodeDiff.go

@@ -15,12 +15,12 @@ type NodeAnalyzer struct {
 }
 
 // NodeDiff compares the packages installed by apt-get.
-func (a NodeAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, error) {
+func (a NodeAnalyzer) Diff(image1, image2 utils.Image) (utils.Result, error) {
 	diff, err := multiVersionDiff(image1, image2, a)
 	return diff, err
 }
 
-func (a NodeAnalyzer) Analyze(image utils.Image) (utils.AnalyzeResult, error) {
+func (a NodeAnalyzer) Analyze(image utils.Image) (utils.Result, error) {
 	analysis, err := multiVersionAnalysis(image, a)
 	return analysis, err
 }

differs/package_differs.go

@@ -15,7 +15,7 @@ type SingleVersionPackageAnalyzer interface {
 	getPackages(image utils.Image) (map[string]utils.PackageInfo, error)
 }
 
-func multiVersionDiff(image1, image2 utils.Image, differ MultiVersionPackageAnalyzer) (utils.DiffResult, error) {
+func multiVersionDiff(image1, image2 utils.Image, differ MultiVersionPackageAnalyzer) (*utils.MultiVersionPackageDiffResult, error) {
 	pack1, err := differ.getPackages(image1)
 	if err != nil {
 		return &utils.MultiVersionPackageDiffResult{}, err
@@ -34,7 +34,7 @@ func multiVersionDiff(image1, image2 utils.Image, differ MultiVersionPackageAnal
 	}, nil
 }
 
-func singleVersionDiff(image1, image2 utils.Image, differ SingleVersionPackageAnalyzer) (utils.DiffResult, error) {
+func singleVersionDiff(image1, image2 utils.Image, differ SingleVersionPackageAnalyzer) (*utils.SingleVersionPackageDiffResult, error) {
 	pack1, err := differ.getPackages(image1)
 	if err != nil {
 		return &utils.SingleVersionPackageDiffResult{}, err
@@ -53,7 +53,7 @@ func singleVersionDiff(image1, image2 utils.Image, differ SingleVersionPackageAn
 	}, nil
 }
 
-func multiVersionAnalysis(image utils.Image, analyzer MultiVersionPackageAnalyzer) (utils.AnalyzeResult, error) {
+func multiVersionAnalysis(image utils.Image, analyzer MultiVersionPackageAnalyzer) (*utils.MultiVersionPackageAnalyzeResult, error) {
 	pack, err := analyzer.getPackages(image)
 	if err != nil {
 		return &utils.MultiVersionPackageAnalyzeResult{}, err
@@ -67,7 +67,7 @@ func multiVersionAnalysis(image utils.Image, analyzer MultiVersionPackageAnalyze
 	return &analysis, nil
 }
 
-func singleVersionAnalysis(image utils.Image, analyzer SingleVersionPackageAnalyzer) (utils.AnalyzeResult, error) {
+func singleVersionAnalysis(image utils.Image, analyzer SingleVersionPackageAnalyzer) (*utils.SingleVersionPackageAnalyzeResult, error) {
 	pack, err := analyzer.getPackages(image)
 	if err != nil {
 		return &utils.SingleVersionPackageAnalyzeResult{}, err

differs/pipDiff.go

@@ -15,12 +15,12 @@ type PipAnalyzer struct {
 }
 
 // PipDiff compares pip-installed Python packages between layers of two different images.
-func (a PipAnalyzer) Diff(image1, image2 utils.Image) (utils.DiffResult, error) {
+func (a PipAnalyzer) Diff(image1, image2 utils.Image) (utils.Result, error) {
 	diff, err := multiVersionDiff(image1, image2, a)
 	return diff, err
 }
 
-func (a PipAnalyzer) Analyze(image utils.Image) (utils.AnalyzeResult, error) {
+func (a PipAnalyzer) Analyze(image utils.Image) (utils.Result, error) {
 	analysis, err := multiVersionAnalysis(image, a)
 	return analysis, err
 }