create interfaces Stringable, StringListable that represent objects r…

…epresentable as StringExpr and StringListExpr respectively.

This reduces typing considerably because we can reply on the golang
type system to perform conversions implicitly. We get to replace 
some instances of:

    var foo Stringable = *Ref(“foo”).String() 

with:

    var foo Stringable = Ref(“foo”)

examples/app.go

@@ -38,10 +38,10 @@ func makeTemplate() *cf.Template {
 				LoadBalancerPort: cf.String("443"),
 				Protocol:         cf.String("SSL"),
 				SSLCertificateId: cf.Join("",
-					*cf.String("arn:aws:iam::"),
-					*cf.Ref("AWS::AccountID").String(),
-					*cf.String(":server-certificate/"),
-					*cf.Ref("DnsName").String()).String(),
+					cf.String("arn:aws:iam::"),
+					cf.Ref("AWS::AccountID"),
+					cf.String(":server-certificate/"),
+					cf.Ref("DnsName")),
 			},
 		},
 		Policies: &cf.ElasticLoadBalancingPolicyList{
@@ -58,11 +58,11 @@ func makeTemplate() *cf.Template {
 			},
 		},
 		Subnets: cf.StringList(
-			*cf.Ref("VpcSubnetA").String(),
-			*cf.Ref("VpcSubnetB").String(),
-			*cf.Ref("VpcSubnetC").String(),
+			cf.Ref("VpcSubnetA"),
+			cf.Ref("VpcSubnetB"),
+			cf.Ref("VpcSubnetC"),
 		),
-		SecurityGroups: cf.StringList(*cf.Ref("LoadBalancerSecurityGroup").String()),
+		SecurityGroups: cf.StringList(cf.Ref("LoadBalancerSecurityGroup")),
 	})
 
 	return t

examples/app_old.go

@@ -0,0 +1,66 @@
+// This program emits a cloudformation document for `app` to stdout
+package main
+
+import cf "github.com/crewjam/go-cloudformation"
+
+// makeTemplateTheOldWay is an implementation of makeTemplate that uses the
+// older pre-Stringable syntax. If this file builds, then maybe we haven't broken
+// backcompat.
+func makeTemplateTheOldWay() *cf.Template {
+	t := cf.NewTemplate()
+	t.Description = "example production infrastructure"
+	t.Parameters["DnsName"] = cf.Parameter{
+		Description: "The top level DNS name for the infrastructure",
+		Type:        "String",
+		Default:     "preview.example.io",
+	}
+
+	t.AddResource("ServerLoadBalancer", cf.ElasticLoadBalancingLoadBalancer{
+		ConnectionDrainingPolicy: &cf.ElasticLoadBalancingConnectionDrainingPolicy{
+			Enabled: cf.Bool(true),
+			Timeout: cf.Integer(30),
+		},
+		CrossZone: cf.Bool(true),
+		HealthCheck: &cf.ElasticLoadBalancingHealthCheck{
+			HealthyThreshold:   cf.String("2"),
+			Interval:           cf.String("60"),
+			Target:             cf.String("HTTP:80/"),
+			Timeout:            cf.String("5"),
+			UnhealthyThreshold: cf.String("2"),
+		},
+		Listeners: &cf.ElasticLoadBalancingListenerList{
+			cf.ElasticLoadBalancingListener{
+				InstancePort:     cf.String("8000"),
+				InstanceProtocol: cf.String("TCP"),
+				LoadBalancerPort: cf.String("443"),
+				Protocol:         cf.String("SSL"),
+				SSLCertificateId: cf.Join("",
+					*cf.String("arn:aws:iam::"),
+					*cf.Ref("AWS::AccountID").String(),
+					*cf.String(":server-certificate/"),
+					*cf.Ref("DnsName").String()).String(),
+			},
+		},
+		Policies: &cf.ElasticLoadBalancingPolicyList{
+			cf.ElasticLoadBalancingPolicy{
+				PolicyName: cf.String("EnableProxyProtocol"),
+				PolicyType: cf.String("ProxyProtocolPolicyType"),
+				Attributes: []map[string]interface{}{
+					map[string]interface{}{
+						"Name":  "ProxyProtocol",
+						"Value": "true",
+					},
+				},
+				InstancePorts: []int{8000},
+			},
+		},
+		Subnets: cf.StringList(
+			*cf.Ref("VpcSubnetA").String(),
+			*cf.Ref("VpcSubnetB").String(),
+			*cf.Ref("VpcSubnetC").String(),
+		),
+		SecurityGroups: cf.StringList(*cf.Ref("LoadBalancerSecurityGroup").String()),
+	})
+
+	return t
+}

func_base64.go

@@ -1,8 +1,8 @@
 package cloudformation
 
 // Base64 represents the Fn::Base64 function called over value.
-func Base64(value StringExpr) Base64Func {
-	return Base64Func{Value: value}
+func Base64(value Stringable) *StringExpr {
+	return Base64Func{Value: *value.String()}.String()
 }
 
 // Base64Func represents an invocation of Fn::Base64.
@@ -20,4 +20,5 @@ func (f Base64Func) String() *StringExpr {
 	return &StringExpr{Func: f}
 }
 
+var _ Stringable = Base64Func{} // Base64Func must implement Stringable
 var _ StringFunc = Base64Func{} // Base64Func must implement StringFunc

func_base64_test.go

@@ -29,6 +29,22 @@ func (testSuite *Base64FuncTest) TestRef(c *C) {
 	]]}}`
 	f, err := unmarshalFunc([]byte(inputBuf))
 	c.Assert(err, IsNil)
+	c.Assert(f.(Stringable).String(), DeepEquals, Base64(Join("",
+		String("#!/bin/bash -xe\n"),
+		String("yum update -y aws-cfn-bootstrap\n"),
+		String("# Install the files and packages from the metadata\n"),
+		String("/opt/aws/bin/cfn-init -v "),
+		String("         --stack "), Ref("AWS::StackName").String(),
+		String("         --resource LaunchConfig "),
+		String("         --region "), Ref("AWS::Region").String(), String("\n"),
+		String("# Signal the status from cfn-init\n"),
+		String("/opt/aws/bin/cfn-signal -e $? "),
+		String("         --stack "), Ref("AWS::StackName").String(),
+		String("         --resource WebServerGroup "),
+		String("         --region "), Ref("AWS::Region").String(), String("\n"),
+	)))
+
+	// old way still compiles
 	c.Assert(f.(StringFunc).String(), DeepEquals, Base64(*Join("",
 		*String("#!/bin/bash -xe\n"),
 		*String("yum update -y aws-cfn-bootstrap\n"),

func_findinmap.go

@@ -3,12 +3,12 @@ package cloudformation
 import "encoding/json"
 
 // FindInMap returns a new instance of FindInMapFunc.
-func FindInMap(mapName string, topLevelKey StringExpr, secondLevelKey StringExpr) FindInMapFunc {
+func FindInMap(mapName string, topLevelKey Stringable, secondLevelKey Stringable) *StringExpr {
 	return FindInMapFunc{
 		MapName:        mapName,
-		TopLevelKey:    topLevelKey,
-		SecondLevelKey: secondLevelKey,
-	}
+		TopLevelKey:    *topLevelKey.String(),
+		SecondLevelKey: *secondLevelKey.String(),
+	}.String()
 }
 
 // FindInMapFunc represents an invocation of the Fn::FindInMap intrinsic.
@@ -55,4 +55,5 @@ func (f FindInMapFunc) String() *StringExpr {
 	return &StringExpr{Func: f}
 }
 
+var _ Stringable = FindInMapFunc{} // FindInMapFunc must implement Stringable
 var _ StringFunc = FindInMapFunc{} // FindInMapFunc must implement StringFunc

func_findinmap_test.go

@@ -15,6 +15,12 @@ func (testSuite *FindInMapFuncTest) TestBasics(c *C) {
                           { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ] } ] }`
 	f, err := unmarshalFunc([]byte(inputBuf))
 	c.Assert(err, IsNil)
+	c.Assert(f.(StringFunc).String(), DeepEquals, FindInMap(
+		"AWSRegionArch2AMI", Ref("AWS::Region"),
+		FindInMap("AWSInstanceType2Arch", Ref("InstanceType"),
+			String("Arch"))))
+
+	// old way
 	c.Assert(f.(StringFunc).String(), DeepEquals, FindInMap(
 		"AWSRegionArch2AMI", *Ref("AWS::Region").String(),
 		*FindInMap("AWSInstanceType2Arch", *Ref("InstanceType").String(),

func_getatt.go

@@ -3,8 +3,8 @@ package cloudformation
 import "encoding/json"
 
 // GetAtt returns a new instance of GetAttFunc.
-func GetAtt(resource, name string) GetAttFunc {
-	return GetAttFunc{Resource: resource, Name: name}
+func GetAtt(resource, name string) *StringExpr {
+	return GetAttFunc{Resource: resource, Name: name}.String()
 }
 
 // GetAttFunc represents an invocation of the Fn::GetAtt intrinsic.

func_getatt_test.go

@@ -14,6 +14,9 @@ func (testSuite *GetAttFuncTest) TestBasics(c *C) {
 	inputBuf := `{"Fn::GetAtt" : ["MySQLDatabase", "Endpoint.Address"]}`
 	f, err := unmarshalFunc([]byte(inputBuf))
 	c.Assert(err, IsNil)
+	c.Assert(f.(StringFunc).String(), DeepEquals,
+		GetAtt("MySQLDatabase", "Endpoint.Address"))
+	// old way
 	c.Assert(f.(StringFunc).String(), DeepEquals,
 		GetAtt("MySQLDatabase", "Endpoint.Address").String())
 

func_getazs.go

@@ -1,8 +1,8 @@
 package cloudformation
 
 // GetAZs returns a new instance of GetAZsFunc.
-func GetAZs(region StringExpr) GetAZsFunc {
-	return GetAZsFunc{Region: region}
+func GetAZs(region Stringable) *StringListExpr {
+	return GetAZsFunc{Region: *region.String()}.StringList()
 }
 
 // GetAZsFunc represents an invocation of the Fn::GetAZs intrinsic.

func_getazs_test.go

@@ -14,6 +14,10 @@ func (testSuite *GetAZsFuncTest) TestBasics(c *C) {
 	inputBuf := `{"Fn::GetAZs" : {"Ref": "AWS::Region"}}`
 	f, err := unmarshalFunc([]byte(inputBuf))
 	c.Assert(err, IsNil)
+	c.Assert(f.(StringListFunc).StringList(), DeepEquals,
+		GetAZs(Ref("AWS::Region")))
+
+	// old way
 	c.Assert(f.(StringListFunc).StringList(), DeepEquals,
 		GetAZs(*Ref("AWS::Region").String()).StringList())
 

func_if.go

@@ -6,24 +6,24 @@ import "reflect"
 // If returns a new instance of IfFunc for the provided string expressions.
 //
 // See also: IfList
-func If(condition string, valueIfTrue, valueIfFalse StringExpr) IfFunc {
+func If(condition string, valueIfTrue, valueIfFalse Stringable) IfFunc {
 	return IfFunc{
 		list:         false,
 		Condition:    condition,
-		ValueIfTrue:  valueIfTrue,
-		ValueIfFalse: valueIfFalse,
+		ValueIfTrue:  *valueIfTrue.String(),
+		ValueIfFalse: *valueIfFalse.String(),
 	}
 }
 
 // IfList returns a new instance of IfFunc for the provided string list expressions.
 //
 // See also: If
-func IfList(condition string, valueIfTrue, valueIfFalse StringListExpr) IfFunc {
+func IfList(condition string, valueIfTrue, valueIfFalse StringListable) IfFunc {
 	return IfFunc{
 		list:         true,
 		Condition:    condition,
-		ValueIfTrue:  valueIfTrue,
-		ValueIfFalse: valueIfFalse,
+		ValueIfTrue:  *valueIfTrue.StringList(),
+		ValueIfFalse: *valueIfFalse.StringList(),
 	}
 }
 

func_join.go

@@ -3,8 +3,8 @@ package cloudformation
 import "encoding/json"
 
 // Join returns a new instance of JoinFunc that joins items with separator.
-func Join(separator string, items ...StringExpr) JoinFunc {
-	return JoinFunc{Separator: separator, Items: items}
+func Join(separator string, items ...Stringable) *StringExpr {
+	return JoinFunc{Separator: separator, Items: *StringList(items...)}.String()
 }
 
 // JoinFunc represents an invocation of the Fn::Join intrinsic.
@@ -16,7 +16,7 @@ func Join(separator string, items ...StringExpr) JoinFunc {
 // See http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html
 type JoinFunc struct {
 	Separator string
-	Items     []StringExpr
+	Items     StringListExpr
 }
 
 // MarshalJSON returns a JSON representation of the object

func_join_test.go

@@ -14,6 +14,10 @@ func (testSuite *JoinFuncTest) TestRef(c *C) {
 	inputBuf := `{"Fn::Join":["x",["y",{"Ref":"foo"},"1"]]}`
 	f, err := unmarshalFunc([]byte(inputBuf))
 	c.Assert(err, IsNil)
+	c.Assert(f.(StringFunc).String(), DeepEquals,
+		Join("x", String("y"), Ref("foo"), String("1")))
+
+	// old way
 	c.Assert(f.(StringFunc).String(), DeepEquals,
 		Join("x", *String("y"), *Ref("foo").String(), *String("1")).String())
 

func_select.go

@@ -2,9 +2,20 @@ package cloudformation
 
 import "encoding/json"
 
-// Select returns a new instance of SelectFunc chooses among items via selector.
-func Select(selector string, items ...StringExpr) SelectFunc {
-	return SelectFunc{Selector: selector, Items: StringListExpr{Literal: items}}
+type selectArg interface{}
+
+// Select returns a new instance of SelectFunc chooses among items via selector. If you
+func Select(selector string, items ...interface{}) *StringExpr {
+	if len(items) == 1 {
+		if itemList, ok := items[0].(StringListable); ok {
+			return SelectFunc{Selector: selector, Items: *itemList.StringList()}.String()
+		}
+	}
+	stringableItems := make([]Stringable, len(items))
+	for i, item := range items {
+		stringableItems[i] = item.(Stringable)
+	}
+	return SelectFunc{Selector: selector, Items: *StringList(stringableItems...)}.String()
 }
 
 // SelectFunc represents an invocation of the Fn::Select intrinsic.

func_select_test.go

@@ -14,6 +14,10 @@ func (testSuite *SelectFuncTest) TestRef(c *C) {
 	inputBuf := `{"Fn::Select":["2",{"Fn::GetAZs":{"Ref":"AWS::Region"}}]}`
 	f, err := unmarshalFunc([]byte(inputBuf))
 	c.Assert(err, IsNil)
+	c.Assert(f.(StringFunc).String(), DeepEquals,
+		Select("2", GetAZs(Ref("AWS::Region"))))
+
+	// old way
 	c.Assert(f.(StringFunc).String(), DeepEquals,
 		SelectFunc{Selector: "2",
 			Items: *GetAZs(*Ref("AWS::Region").String()).StringList()}.String())

string.go

@@ -2,6 +2,12 @@ package cloudformation
 
 import "encoding/json"
 
+// Stringable is an interface that describes structures that are convertable
+// to a *StringExpr.
+type Stringable interface {
+	String() *StringExpr
+}
+
 // StringExpr is a string expression. If the value is computed then
 // Func will be non-nil. If it is a literal string then Literal gives
 // the value. Typically instances of this function are created by
@@ -19,6 +25,11 @@ type StringExpr struct {
 	Literal string
 }
 
+// String implements Stringable
+func (x StringExpr) String() *StringExpr {
+	return &x
+}
+
 // MarshalJSON returns a JSON representation of the object
 func (x StringExpr) MarshalJSON() ([]byte, error) {
 	if x.Func != nil {
@@ -43,7 +54,7 @@ func (x *StringExpr) UnmarshalJSON(data []byte) error {
 	// function actually works in the boolean context
 	funcCall, err2 := unmarshalFunc(data)
 	if err2 == nil {
-		stringFunc, ok := funcCall.(StringFunc)
+		stringFunc, ok := funcCall.(Stringable)
 		if ok {
 			x.Func = stringFunc
 			return nil

string_list.go

@@ -5,6 +5,12 @@ import (
 	"fmt"
 )
 
+// StringListable is an interface that describes structures that are convertable
+// to a *StringListExpr.
+type StringListable interface {
+	StringList() *StringListExpr
+}
+
 // StringListExpr is a string expression. If the value is computed then
 // Func will be non-nil. If it is a literal string then Literal gives
 // the value. Typically instances of this function are created by
@@ -19,7 +25,12 @@ import (
 //
 type StringListExpr struct {
 	Func    StringListFunc
-	Literal []StringExpr
+	Literal []*StringExpr
+}
+
+// StringList implements StringListable
+func (x StringListExpr) StringList() *StringListExpr {
+	return &x
 }
 
 // MarshalJSON returns a JSON representation of the object
@@ -32,7 +43,7 @@ func (x StringListExpr) MarshalJSON() ([]byte, error) {
 
 // UnmarshalJSON sets the object from the provided JSON representation
 func (x *StringListExpr) UnmarshalJSON(data []byte) error {
-	var v []StringExpr
+	var v []*StringExpr
 	err := json.Unmarshal(data, &v)
 	if err == nil {
 		x.Func = nil
@@ -60,6 +71,10 @@ func (x *StringListExpr) UnmarshalJSON(data []byte) error {
 }
 
 // StringList returns a new StringListExpr representing the literal value v.
-func StringList(v ...StringExpr) *StringListExpr {
-	return &StringListExpr{Literal: v}
+func StringList(v ...Stringable) *StringListExpr {
+	rv := &StringListExpr{Literal: []*StringExpr{}}
+	for _, item := range v {
+		rv.Literal = append(rv.Literal, item.String())
+	}
+	return rv
 }