func()

in cft/build/build.go [164:229]

• 51 lines of code
• 16 McCabe index (conditional complexity)

func (b builder) newPropertyType(resourceType, propertyType string) (interface{}, []*cft.Comment) {
	defer func() {
		if r := recover(); r != nil {
			panic(fmt.Errorf("error building property type '%s.%s': %w", resourceType, propertyType, r))
		}
	}()

	var ptSpec *spec.PropertyType
	var ok bool

	// If we've used a property from another resource type
	// switch to that resource type for now
	parts := strings.Split(propertyType, ".")
	if len(parts) == 2 {
		resourceType = parts[0]
	}

	ptSpec, ok = b.Spec.PropertyTypes[propertyType]
	if !ok {
		ptSpec, ok = b.Spec.PropertyTypes[resourceType+"."+propertyType]
	}
	if !ok {
		panic(fmt.Errorf("unimplemented property type '%s.%s'", resourceType, propertyType))
	}

	// Deal with the case that a property type is directly a plain property
	// for example AWS::Glue::SecurityConfiguration.S3Encryptions
	if ptSpec.Property != emptyProp {
		return b.newProperty(resourceType, propertyType, &ptSpec.Property)
	}

	comments := make([]*cft.Comment, 0)

	// Generate properties
	properties := make(map[string]interface{})
	for name, pSpec := range ptSpec.Properties {
		if b.IncludeOptionalProperties || pSpec.Required {
			if !pSpec.Required {
				comments = append(comments, &cft.Comment{
					Path:  []interface{}{name},
					Value: optionalTag,
				})
			}

			var p interface{}
			var cs []*cft.Comment

			if b.BuildIamPolicies && (name == policyDocument || name == assumeRolePolicyDocument) {
				p, cs = iam.Policy()
			} else if pSpec.Type == propertyType || pSpec.ItemType == propertyType {
				p = make(map[string]interface{})
				cs = make([]*cft.Comment, 0)
			} else {
				p, cs = b.newProperty(resourceType, name, pSpec)
			}

			properties[name] = p
			for _, c := range cs {
				c.Path = append([]interface{}{name}, c.Path...)
			}
			comments = append(comments, cs...)
		}
	}

	return properties, comments
}