Add long flag to diff command

cmd/common.go

@@ -91,10 +91,10 @@ func getRainBucket() string {
 	return bucketName
 }
 
-func colouriseDiff(d diff.Diff) string {
+func colouriseDiff(d diff.Diff, longFormat bool) string {
 	output := strings.Builder{}
 
-	for _, line := range strings.Split(diff.Format(d), "\n") {
+	for _, line := range strings.Split(diff.Format(d, longFormat), "\n") {
 		switch {
 		case strings.HasPrefix(line, diff.Added.String()):
 			output.WriteString(util.Green(line).String())

cmd/deploy.go

@@ -123,14 +123,14 @@ var deployCmd = &cobra.Command{
 
 				d := diff.Compare(oldTemplate, newTemplate)
 
-				if d == diff.Unchanged {
+				if d.Mode() == diff.Unchanged {
 					fmt.Println(util.Green("No changes to deploy!"))
 					return
 				}
 
 				util.ClearLine()
 				if util.Confirm(true, fmt.Sprintf("Stack '%s' exists. Do you wish to see the diff before deploying?", stackName)) {
-					fmt.Print(colouriseDiff(d))
+					fmt.Print(colouriseDiff(d, false))
 
 					if !util.Confirm(true, "Do you wish to continue?") {
 						panic(errors.New("User cancelled deployment."))

cmd/diff.go

@@ -8,6 +8,8 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var longDiff = false
+
 var diffCmd = &cobra.Command{
 	Use:                   "diff <from> <to>",
 	Short:                 "Compare CloudFormation templates",
@@ -27,10 +29,11 @@ var diffCmd = &cobra.Command{
 			panic(fmt.Errorf("Unable to parse template '%s': %s", leftFn, err))
 		}
 
-		fmt.Print(colouriseDiff(diff.Compare(left, right)))
+		fmt.Print(colouriseDiff(diff.Compare(left, right), longDiff))
 	},
 }
 
 func init() {
+	diffCmd.Flags().BoolVarP(&longDiff, "long", "l", false, "Include unchanged elements in diff output")
 	rootCmd.AddCommand(diffCmd)
 }

diff/compare.go

@@ -21,12 +21,12 @@ func Compare(old, new interface{}) Diff {
 		}
 	}
 
-	return Unchanged
+	return diffValue{old, Unchanged}
 }
 
 func compareSlices(old, new []interface{}) Diff {
 	if reflect.DeepEqual(old, new) {
-		return Unchanged
+		return diffValue{old, Unchanged}
 	}
 
 	max := int(math.Max(float64(len(old)), float64(len(new))))
@@ -47,7 +47,7 @@ func compareSlices(old, new []interface{}) Diff {
 
 func compareMaps(old, new map[string]interface{}) Diff {
 	if reflect.DeepEqual(old, new) {
-		return Unchanged
+		return diffValue{old, Unchanged}
 	}
 
 	d := make(diffMap)

diff/compare_test.go

@@ -12,7 +12,7 @@ func TestCompareScalar(t *testing.T) {
 		expected Diff
 	}{
 		{
-			"foo", "foo", Unchanged,
+			"foo", "foo", diffValue{"foo", Unchanged},
 		},
 		{
 			"foo", "bar", diffValue{"bar", Changed},
@@ -41,27 +41,27 @@ func TestCompareSlices(t *testing.T) {
 		expected Diff
 	}{
 		{
-			[]interface{}{1, 2, 3}, []interface{}{1, 2, 3}, Unchanged,
+			[]interface{}{1, 2, 3}, []interface{}{1, 2, 3}, diffValue{[]interface{}{1, 2, 3}, Unchanged},
 		},
 		{
 			[]interface{}{1, 2, 3}, []interface{}{1, 2, 4}, diffSlice{
-				Unchanged,
-				Unchanged,
+				diffValue{1, Unchanged},
+				diffValue{2, Unchanged},
 				diffValue{4, Changed},
 			},
 		},
 		{
 			[]interface{}{1, 2, 3}, []interface{}{1, 2, 3, 4}, diffSlice{
-				Unchanged,
-				Unchanged,
-				Unchanged,
+				diffValue{1, Unchanged},
+				diffValue{2, Unchanged},
+				diffValue{3, Unchanged},
 				diffValue{4, Added},
 			},
 		},
 		{
 			[]interface{}{1, 2, 3}, []interface{}{1, 2}, diffSlice{
-				Unchanged,
-				Unchanged,
+				diffValue{1, Unchanged},
+				diffValue{2, Unchanged},
 				diffValue{3, Removed},
 			},
 		},
@@ -85,7 +85,7 @@ func TestCompareMaps(t *testing.T) {
 		{
 			map[string]interface{}{"foo": "bar"},
 			map[string]interface{}{"foo": "bar"},
-			Unchanged,
+			diffValue{map[string]interface{}{"foo": "bar"}, Unchanged},
 		},
 		{
 			map[string]interface{}{"foo": "bar"},
@@ -95,7 +95,7 @@ func TestCompareMaps(t *testing.T) {
 		{
 			map[string]interface{}{"foo": "bar"},
 			map[string]interface{}{"foo": "bar", "baz": "quux"},
-			diffMap{"foo": Unchanged, "baz": diffValue{"quux", Added}},
+			diffMap{"foo": diffValue{"bar", Unchanged}, "baz": diffValue{"quux", Added}},
 		},
 		{
 			map[string]interface{}{"foo": "bar"},
@@ -135,7 +135,7 @@ func TestCompare(t *testing.T) {
 		{
 			original,
 			original,
-			Unchanged,
+			diffValue{original, Unchanged},
 		},
 		{
 			original,
@@ -158,15 +158,15 @@ func TestCompare(t *testing.T) {
 			diffMap{
 				"foo": diffSlice{
 					diffMap{
-						"foo": Unchanged,
+						"foo": diffValue{"bar", Unchanged},
 						"baz": diffSlice{
-							Unchanged,
-							Unchanged,
+							diffValue{"foo", Unchanged},
+							diffValue{"bar", Unchanged},
 							diffValue{"baz", Added},
 						},
 						"quux": diffValue{"mooz", Added},
 					},
-					Unchanged,
+					diffValue{"foo", Unchanged},
 					diffValue{"bar", Added},
 				},
 				"bar": diffValue{"baz", Added},
@@ -188,7 +188,7 @@ func TestCompare(t *testing.T) {
 					diffMap{
 						"foo": diffValue{"bar", Removed},
 						"baz": diffSlice{
-							Unchanged,
+							diffValue{"foo", Unchanged},
 							diffValue{"bar", Removed},
 						},
 					},

diff/diff.go

@@ -6,11 +6,11 @@ const (
 	Added     mode = "+ "
 	Removed   mode = "- "
 	Changed   mode = "| "
-	Unchanged mode = "= "
+	Unchanged mode = "  "
 )
 
 type Diff interface {
-	mode() mode
+	Mode() mode
 }
 
 type diffValue struct {
@@ -26,22 +26,18 @@ func (m mode) String() string {
 	return string(m)
 }
 
-func (m mode) mode() mode {
-	return m
-}
-
-func (d diffValue) mode() mode {
+func (d diffValue) Mode() mode {
 	return d.valueMode
 }
 
-func (d diffSlice) mode() mode {
+func (d diffSlice) Mode() mode {
 	mode := Added
 
 	for i, v := range d {
 		if i == 0 {
-			mode = v.mode()
+			mode = v.Mode()
 		} else {
-			if mode != v.mode() {
+			if mode != v.Mode() {
 				mode = Changed
 			}
 		}
@@ -50,14 +46,14 @@ func (d diffSlice) mode() mode {
 	return mode
 }
 
-func (d diffMap) mode() mode {
+func (d diffMap) Mode() mode {
 	slice := make(diffSlice, 0)
 
 	for _, v := range d {
 		slice = append(slice, v)
 	}
 
-	return slice.mode()
+	return slice.Mode()
 }
 
 func (d diffMap) Keys() []string {

diff/diff_test.go

@@ -19,62 +19,62 @@ func TestDiffMode(t *testing.T) {
 		},
 		{
 			diffSlice{
-				Added,
+				diffValue{"foo", Added},
 			},
 			Added,
 		},
 		{
 			diffSlice{
-				Added,
-				Added,
+				diffValue{"foo", Added},
+				diffValue{"bar", Added},
 			},
 			Added,
 		},
 		{
 			diffSlice{
-				Removed,
-				Removed,
+				diffValue{"foo", Removed},
+				diffValue{"bar", Removed},
 			},
 			Removed,
 		},
 		{
 			diffSlice{
-				Added,
-				Removed,
+				diffValue{"foo", Added},
+				diffValue{"bar", Removed},
 			},
 			Changed,
 		},
 		{
 			diffMap{
-				"foo": Added,
+				"foo": diffValue{"bar", Added},
 			},
 			Added,
 		},
 		{
 			diffMap{
-				"foo": Added,
-				"bar": Added,
+				"foo": diffValue{"bar", Added},
+				"baz": diffValue{"quux", Added},
 			},
 			Added,
 		},
 		{
 			diffMap{
-				"foo": Removed,
-				"bar": Removed,
+				"foo": diffValue{"bar", Removed},
+				"baz": diffValue{"quux", Removed},
 			},
 			Removed,
 		},
 		{
 			diffMap{
-				"foo": Added,
-				"bar": Removed,
+				"foo": diffValue{"bar", Added},
+				"baz": diffValue{"quux", Removed},
 			},
 			Changed,
 		},
 	}
 
 	for _, testCase := range cases {
-		actual := testCase.value.mode()
+		actual := testCase.value.Mode()
 
 		if actual != testCase.expected {
 			t.Errorf("%#v\n!=\n%#v", actual, testCase.expected)