private void handleType()

in src/main/java/aws/cfn/codegen/json/Codegen.java [312:420]
103 lines of code
20 McCabe index (conditional complexity)

    private void handleType(ObjectNode typeDefn,
                            String defnName,
                            String name,
                            ResourceType type,
                            boolean isResource,
                            Set<String> propertyNames) {
        typeDefn.put("type", "object");
        typeDefn.put("description", type.getDocumentation());
        ObjectNode properties, innerProps = null;
        if (isResource) {
            ObjectNode resProps = typeDefn.putObject("properties");
            ObjectNode enumType = resProps.putObject("Type");
            enumType.put("description", type.getDocumentation());
            enumType.put("type", "string");
            ArrayNode array = enumType.putArray("enum");
            array.add(name);

            for (String policyName: new String[]{"DeletionPolicy", "UpdateReplacePolicy"}) {
                ObjectNode policy = resProps.putObject(policyName);
                policy.put("description", "https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-" + policyName.toLowerCase() + ".html");
                policy.put("type", "string");
                ArrayNode policyArray = policy.putArray("enum");
                policyArray.add("Delete").add("Retain").add("Snapshot");
            }

            for (String attributeName: new String[]{"Metadata", "CreationPolicy", "UpdatePolicy"}) {
                ObjectNode attribute = resProps.putObject(attributeName);
                attribute.put("description", "https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-" + attributeName.toLowerCase() + ".html");
                attribute.put("type", "object");
            }

            innerProps = resProps.putObject("Properties");
            innerProps.put("type", "object");
            properties = innerProps.putObject("properties");
            // Add DependsOn
            addDependsOn(resProps);
        }
        else {
            properties = typeDefn.putObject("properties");
        }
        final List<String> required = new ArrayList<>(5);
        type.getProperties().forEach(
            (propName, propType) -> {
                ObjectNode each = properties.putObject(propName);
                if (propType.isObjectType()) {
                    each.put("$ref", "#/definitions/" +
                        (propertyNames.contains(propType.getType()) ? propType.getType() :
                         defnName + "_" + propType.getType()));
                }
                else {
                    each.put("description", propType.getDocumentation());
                    if (propType.isPrimitive()) {
                        addPrimitiveType(each, propType.getPrimitiveType());
                    } else if (propType.isCollectionType()) {
                        each.put("type", "array");
                        ObjectNode itemType = each.putObject("items");
                        if (propType.isContainerInnerTypePrimitive()) {
                            addPrimitiveType(itemType, propType.getPrimitiveItemType());
                        } else {
                            itemType.put("$ref", "#/definitions/" +
                                (propertyNames.contains(propType.getItemType()) ? propType.getItemType() :
                                    defnName + "_" + propType.getItemType()));
                        }
                        Boolean duplicates = propType.getDuplicatesAllowed();
                        if (duplicates != null && !duplicates) {
                            each.put("uniqueItems", true);
                        }
                        each.put("minItems", 0);
                    } else {
                        // Map Type
                        each.put("type", "object");
                        ObjectNode mapProps = each.putObject("patternProperties");
                        ObjectNode patPropKeyValue = mapProps.putObject("[a-zA-Z0-9]+");
                        if (propType.isContainerInnerTypePrimitive()) {
                            addPrimitiveType(patPropKeyValue, propType.getPrimitiveItemType());
                        } else {
                            patPropKeyValue.put("$ref", "#/definitions/" +
                                (propertyNames.contains(propType.getItemType()) ? propType.getItemType() :
                                    defnName + "_" + propType.getItemType()));
                        }
                    }
                    Boolean requiredB = propType.getRequired();
                    if (requiredB != null && requiredB) {
                        required.add(propName);
                    }
                }
            }
        );

        if (isResource) {
            if (!required.isEmpty()) {
                ArrayNode array = innerProps.putArray("required");
                required.forEach(array::add);
            }
            innerProps.put("additionalProperties", false);
            ArrayNode array = typeDefn.putArray("required");
            array.add("Type");
            if (!required.isEmpty()) {
                array.add("Properties");
            }
        }
        else {
            if (!required.isEmpty()) {
                ArrayNode array = typeDefn.putArray("required");
                required.forEach(array::add);
            }
        }
        typeDefn.put("additionalProperties", false);
    }