vendor: update all dependencies

vendor/github.com/aws/aws-sdk-go/private/model/api/example_test.go

@@ -32,11 +32,84 @@ func buildAPI() *API {
 		Shape:     intShape,
 	}
 
+	nestedComplexShape := &Shape{
+		API:       a,
+		ShapeName: "NestedComplexShape",
+		MemberRefs: map[string]*ShapeRef{
+			"NestedField": stringShapeRef,
+		},
+		Type: "structure",
+	}
+
+	nestedComplexShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "NestedComplexShape",
+		Shape:     nestedComplexShape,
+	}
+
+	nestedListShape := &Shape{
+		API:       a,
+		ShapeName: "NestedListShape",
+		MemberRef: *nestedComplexShapeRef,
+		Type:      "list",
+	}
+
+	nestedListShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "NestedListShape",
+		Shape:     nestedListShape,
+	}
+
+	complexShape := &Shape{
+		API:       a,
+		ShapeName: "ComplexShape",
+		MemberRefs: map[string]*ShapeRef{
+			"Field": stringShapeRef,
+			"List":  nestedListShapeRef,
+		},
+		Type: "structure",
+	}
+
+	complexShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "ComplexShape",
+		Shape:     complexShape,
+	}
+
+	listShape := &Shape{
+		API:       a,
+		ShapeName: "ListShape",
+		MemberRef: *complexShapeRef,
+		Type:      "list",
+	}
+
+	listShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "ListShape",
+		Shape:     listShape,
+	}
+
+	listsShape := &Shape{
+		API:       a,
+		ShapeName: "ListsShape",
+		MemberRef: *listShapeRef,
+		Type:      "list",
+	}
+
+	listsShapeRef := &ShapeRef{
+		API:       a,
+		ShapeName: "ListsShape",
+		Shape:     listsShape,
+	}
+
 	input := &Shape{
 		API:       a,
 		ShapeName: "FooInput",
 		MemberRefs: map[string]*ShapeRef{
-			"BarShape": stringShapeRef,
+			"BarShape":     stringShapeRef,
+			"ComplexField": complexShapeRef,
+			"ListField":    listShapeRef,
+			"ListsField":   listsShapeRef,
 		},
 		Type: "structure",
 	}
@@ -44,7 +117,10 @@ func buildAPI() *API {
 		API:       a,
 		ShapeName: "FooOutput",
 		MemberRefs: map[string]*ShapeRef{
-			"BazShape": intShapeRef,
+			"BazShape":     intShapeRef,
+			"ComplexField": complexShapeRef,
+			"ListField":    listShapeRef,
+			"ListsField":   listsShapeRef,
 		},
 		Type: "structure",
 	}
@@ -91,7 +167,27 @@ func TestExampleGeneration(t *testing.T) {
     "Foo": [
       {
         "input": {
-          "BarShape": "Hello world"
+          "BarShape": "Hello world",
+					"ComplexField": {
+						"Field": "bar",
+						"List": [
+							{
+								"NestedField": "qux"
+							}
+						]
+					},
+					"ListField": [
+						{
+							"Field": "baz"
+						}
+					],
+					"ListsField": [
+						[
+							{
+								"Field": "baz"
+							}
+						]
+					]
         },
         "output": {
           "BazShape": 1
@@ -121,7 +217,7 @@ func TestExampleGeneration(t *testing.T) {
 	expected := `
 import (
 	"fmt"
-	"bytes"
+	"strings"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
@@ -131,7 +227,7 @@ import (
 )
 
 var _ time.Duration
-var _ bytes.Buffer
+var _ strings.Reader
 var _ aws.Config
 
 func parseTime(layout, value string) *time.Time {
@@ -149,6 +245,26 @@ func ExampleFooService_Foo_shared00() {
 	svc := fooservice.New(session.New())
 	input := &fooservice.FooInput{
 		BarShape: aws.String("Hello world"),
+		ComplexField: &fooservice.ComplexShape{
+			Field: aws.String("bar"),
+			List: []*fooservice.NestedComplexShape{
+				{
+					NestedField: aws.String("qux"),
+				},
+			},
+		},
+		ListField: []*fooservice.ComplexShape{
+			{
+				Field: aws.String("baz"),
+			},
+		},
+		ListsField: [][]*fooservice.ComplexShape{
+			{
+				{
+					Field: aws.String("baz"),
+				},
+			},
+		},
 	}
 
 	result, err := svc.Foo(input)

vendor/github.com/aws/aws-sdk-go/private/model/api/examples_builder.go

@@ -44,17 +44,20 @@ func (builder defaultExamplesBuilder) BuildShape(ref *ShapeRef, shapes map[strin
 		}
 
 		memName := name
+		passRef := ref.Shape.MemberRefs[name]
+
 		if isMap {
 			memName = fmt.Sprintf("%q", memName)
+			passRef = &ref.Shape.ValueRef
 		}
 
 		switch v := shape.(type) {
 		case map[string]interface{}:
-			ret += builder.BuildComplex(name, memName, ref, v)
+			ret += builder.BuildComplex(name, memName, passRef, v)
 		case []interface{}:
-			ret += builder.BuildList(name, memName, ref, v)
+			ret += builder.BuildList(name, memName, passRef, v)
 		default:
-			ret += builder.BuildScalar(name, memName, ref, v)
+			ret += builder.BuildScalar(name, memName, passRef, v, ref.Shape.Payload == name)
 		}
 	}
 	return ret
@@ -69,105 +72,86 @@ func (builder defaultExamplesBuilder) BuildList(name, memName string, ref *Shape
 		return ""
 	}
 
-	t := ""
-	dataType := ""
-	format := ""
-	isComplex := false
-	passRef := ref
-	isMap := false
+	passRef := &ref.Shape.MemberRef
+	ret += fmt.Sprintf("%s: %s {\n", memName, builder.GoType(ref, false))
+	ret += builder.buildListElements(passRef, v)
+	ret += "},\n"
+	return ret
+}
 
-	if ref.Shape.MemberRefs[name] != nil {
-		t = builder.GoType(&ref.Shape.MemberRefs[name].Shape.MemberRef, false)
-		dataType = ref.Shape.MemberRefs[name].Shape.MemberRef.Shape.Type
-		passRef = ref.Shape.MemberRefs[name]
-		if dataType == "map" {
-			t = fmt.Sprintf("map[string]%s", builder.GoType(&ref.Shape.MemberRefs[name].Shape.MemberRef.Shape.ValueRef, false))
-			passRef = &ref.Shape.MemberRefs[name].Shape.MemberRef.Shape.ValueRef
-			isMap = true
-		}
-	} else if ref.Shape.MemberRef.Shape != nil && ref.Shape.MemberRef.Shape.MemberRefs[name] != nil {
-		t = builder.GoType(&ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.MemberRef, false)
-		dataType = ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.MemberRef.Shape.Type
-		passRef = &ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.MemberRef
-	} else {
-		t = builder.GoType(&ref.Shape.MemberRef, false)
-		dataType = ref.Shape.MemberRef.Shape.Type
-		passRef = &ref.Shape.MemberRef
+func (builder defaultExamplesBuilder) buildListElements(ref *ShapeRef, v []interface{}) string {
+	if len(v) == 0 || ref == nil {
+		return ""
 	}
 
+	ret := ""
+	format := ""
+	isComplex := false
+	isList := false
+
+	// get format for atomic type. If it is not an atomic type,
+	// get the element.
 	switch v[0].(type) {
 	case string:
 		format = "%s"
 	case bool:
 		format = "%t"
 	case float64:
-		if dataType == "integer" || dataType == "int64" {
+		switch ref.Shape.Type {
+		case "integer", "int64", "long":
 			format = "%d"
-		} else {
+		default:
 			format = "%f"
 		}
-	default:
-		if ref.Shape.MemberRefs[name] != nil {
-		} else {
-			passRef = ref.Shape.MemberRef.Shape.MemberRefs[name]
-
-			// if passRef is nil that means we are either in a map or within a nested array
-			if passRef == nil {
-				passRef = &ref.Shape.MemberRef
-			}
-		}
+	case []interface{}:
+		isList = true
+	case map[string]interface{}:
 		isComplex = true
 	}
-	ret += fmt.Sprintf("%s: []%s {\n", memName, t)
+
 	for _, elem := range v {
 		if isComplex {
-			ret += fmt.Sprintf("{\n%s\n},\n", builder.BuildShape(passRef, elem.(map[string]interface{}), isMap))
+			ret += fmt.Sprintf("{\n%s\n},\n", builder.BuildShape(ref, elem.(map[string]interface{}), ref.Shape.Type == "map"))
+		} else if isList {
+			ret += fmt.Sprintf("{\n%s\n},\n", builder.buildListElements(&ref.Shape.MemberRef, elem.([]interface{})))
 		} else {
-			if dataType == "integer" || dataType == "int64" || dataType == "long" {
+			switch ref.Shape.Type {
+			case "integer", "int64", "long":
 				elem = int(elem.(float64))
 			}
-			ret += fmt.Sprintf("%s,\n", getValue(t, fmt.Sprintf(format, elem)))
+			ret += fmt.Sprintf("%s,\n", getValue(ref.Shape.Type, fmt.Sprintf(format, elem)))
 		}
 	}
-	ret += "},\n"
 	return ret
 }
 
 // BuildScalar will build atomic Go types.
-func (builder defaultExamplesBuilder) BuildScalar(name, memName string, ref *ShapeRef, shape interface{}) string {
+func (builder defaultExamplesBuilder) BuildScalar(name, memName string, ref *ShapeRef, shape interface{}, isPayload bool) string {
 	if ref == nil || ref.Shape == nil {
 		return ""
-	} else if ref.Shape.MemberRefs[name] == nil {
-		if ref.Shape.MemberRef.Shape != nil && ref.Shape.MemberRef.Shape.MemberRefs[name] != nil {
-			return correctType(memName, ref.Shape.MemberRef.Shape.MemberRefs[name].Shape.Type, shape)
-		}
-		if ref.Shape.Type != "structure" && ref.Shape.Type != "map" {
-			return correctType(memName, ref.Shape.Type, shape)
-		}
-		return ""
 	}
 
 	switch v := shape.(type) {
 	case bool:
-		return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%t", v))
+		return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%t", v))
 	case int:
-		if ref.Shape.MemberRefs[name].Shape.Type == "timestamp" {
+		if ref.Shape.Type == "timestamp" {
 			return parseTimeString(ref, memName, fmt.Sprintf("%d", v))
 		}
-		return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%d", v))
+		return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%d", v))
 	case float64:
-		dataType := ref.Shape.MemberRefs[name].Shape.Type
+		dataType := ref.Shape.Type
 		if dataType == "integer" || dataType == "int64" || dataType == "long" {
-			return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%d", int(shape.(float64))))
+			return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%d", int(shape.(float64))))
 		}
-		return convertToCorrectType(memName, ref.Shape.MemberRefs[name].Shape.Type, fmt.Sprintf("%f", v))
+		return convertToCorrectType(memName, ref.Shape.Type, fmt.Sprintf("%f", v))
 	case string:
-		t := ref.Shape.MemberRefs[name].Shape.Type
+		t := ref.Shape.Type
 		switch t {
 		case "timestamp":
 			return parseTimeString(ref, memName, fmt.Sprintf("%s", v))
 		case "blob":
-			if (ref.Shape.MemberRefs[name].Streaming || ref.Shape.MemberRefs[name].Shape.Streaming) && ref.Shape.Payload == name {
+			if (ref.Streaming || ref.Shape.Streaming) && isPayload {
 				return fmt.Sprintf("%s: aws.ReadSeekCloser(strings.NewReader(%q)),\n", memName, v)
 			}
 
@@ -182,47 +166,33 @@ func (builder defaultExamplesBuilder) BuildScalar(name, memName string, ref *Sha
 }
 
 func (builder defaultExamplesBuilder) BuildComplex(name, memName string, ref *ShapeRef, v map[string]interface{}) string {
-	t := ""
-	if ref == nil {
-		return builder.BuildShape(nil, v, true)
-	}
-
-	member := ref.Shape.MemberRefs[name]
-
-	if member != nil && member.Shape != nil {
-		t = ref.Shape.MemberRefs[name].Shape.Type
-	} else {
-		t = ref.Shape.Type
-	}
-
-	switch t {
+	switch ref.Shape.Type {
 	case "structure":
-		passRef := ref.Shape.MemberRefs[name]
-		// passRef will be nil if the entry is a map. In that case
-		// we want to pass the reference, because the previous call
-		// passed the value reference.
-		if passRef == nil {
-			passRef = ref
-		}
 		return fmt.Sprintf(`%s: &%s{
 				%s
 			},
-			`, memName, builder.GoType(passRef, true), builder.BuildShape(passRef, v, false))
+			`, memName, builder.GoType(ref, true), builder.BuildShape(ref, v, false))
 	case "map":
 		return fmt.Sprintf(`%s: %s{
 				%s
 			},
-			`, name, builder.GoType(ref.Shape.MemberRefs[name], false), builder.BuildShape(&ref.Shape.MemberRefs[name].Shape.ValueRef, v, true))
+			`, name, builder.GoType(ref, false), builder.BuildShape(ref, v, true))
+	default:
+		panic(fmt.Sprintf("Expected complex type but recieved %q", ref.Shape.Type))
 	}
 
 	return ""
 }
 
 func (builder defaultExamplesBuilder) GoType(ref *ShapeRef, elem bool) string {
+	if ref.Shape.Type != "structure" && ref.Shape.Type != "list" && ref.Shape.Type != "map" {
+		return ref.GoTypeWithPkgName()
+	}
+
 	prefix := ""
 	if ref.Shape.Type == "list" {
 		ref = &ref.Shape.MemberRef
-		prefix = "[]*"
+		prefix = "[]"
 	}
 
 	name := ref.GoTypeWithPkgName()
@@ -233,10 +203,6 @@ func (builder defaultExamplesBuilder) GoType(ref *ShapeRef, elem bool) string {
 		}
 	}
 
-	if ref.Shape.Type != "structure" && ref.Shape.Type != "list" {
-		return name
-	}
-
 	return prefix + name
 }
 

vendor/github.com/aws/aws-sdk-go/private/model/api/shape.go

@@ -516,17 +516,6 @@ var structShapeTmpl = template.Must(template.New("StructShape").Funcs(template.F
 	"GetCrosslinkURL": GetCrosslinkURL,
 }).Parse(`
 {{ .Docstring }}
-{{ if ne $.OrigShapeName "" -}}
-{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.Metadata.UID $.OrigShapeName -}}
-{{ if ne $crosslinkURL "" -}} 
-// See also, {{ $crosslinkURL }}
-{{ end -}}
-{{ else -}}
-{{ $crosslinkURL := GetCrosslinkURL $.API.BaseCrosslinkURL $.API.Metadata.UID $.ShapeName -}}
-{{ if ne $crosslinkURL "" -}} 
-// See also, {{ $crosslinkURL }}
-{{ end -}}
-{{ end -}}
 {{ $context := . -}}
 type {{ .ShapeName }} struct {
 	_ struct{} {{ .GoTags true false }}

vendor/github.com/aws/aws-sdk-go/private/model/cli/gen-api/main.go

@@ -132,7 +132,7 @@ func main() {
 
 	for svcName := range excludeServices {
 		if strings.Contains(os.Getenv("SERVICES"), svcName) {
-			fmt.Printf("Service %s is not supported\n", svcName)
+			fmt.Fprintf(os.Stderr, "Service %s is not supported\n", svcName)
 			os.Exit(1)
 		}
 	}
@@ -141,6 +141,10 @@ func main() {
 
 	// Remove old API versions from list
 	m := map[string]bool{}
+	// caches paths to ensure we are not overriding previously generated
+	// code.
+	servicePaths := map[string]struct{}{}
+
 	for i := range files {
 		idx := len(files) - 1 - i
 		parts := strings.Split(files[idx], string(filepath.Separator))
@@ -168,6 +172,13 @@ func main() {
 			continue
 		}
 
+		if _, ok := servicePaths[genInfo.PackageDir]; ok {
+			fmt.Fprintf(os.Stderr, "Path %q has already been generated", genInfo.PackageDir)
+			os.Exit(1)
+		}
+
+		servicePaths[genInfo.PackageDir] = struct{}{}
+
 		wg.Add(1)
 		go func(g *generateInfo, filename string) {
 			defer wg.Done()