func getReport()

in coverage/report.go [155:287]
109 lines of code
29 McCabe index (conditional complexity)

func getReport(displayName string, model *Model) []string {
	out := make([]string, 0)
	style := getStyle(model.IsFullyCovered)

	if hasNoDetail(model) {
		// leaf property
		out = append(out,
			fmt.Sprintf(`<!-- %[1]v -->
<details>
<summary><span%[2]v>%[3]v</span></summary>

</details>`, model.Identifier, style, displayName),
		)
		return out
	}

	if isBoolEnumDisplayed {
		if model.Enum != nil {
			for k, isCovered := range *model.Enum {
				out = append(out, getEnumBoolReport(k, isCovered))
			}
			return out
		}

		if model.Bool != nil {
			for k, isCovered := range *model.Bool {
				out = append(out, getEnumBoolReport(fmt.Sprintf("%v", k), isCovered))
			}
			return out
		}
	}

	if model.Item != nil {
		return getReport(displayName, model.Item)
	}

	if model.Properties != nil {
		for k, v := range *model.Properties {
			if v.IsReadOnly {
				continue
			}

			if v.Item != nil && v.Item.IsReadOnly {
				continue
			}

			if v.Variants != nil {
				variantType := v.ModelName
				if v.VariantType != nil {
					variantType = *v.VariantType
				}
				variantKey := getDiscriminatorKey(k, variantType)
				out = append(out, getReport(variantKey, v)...)

				for variantType, variant := range *v.Variants {
					variantType := variantType
					if variant.VariantType != nil {
						variantType = *variant.VariantType
					}
					variantKey := getDiscriminatorKey(k, variantType)
					out = append(out, getReport(variantKey, variant)...)
				}
				continue
			}

			if v.Item != nil && v.Item.Variants != nil {
				variantType := v.Item.ModelName
				if v.Item.VariantType != nil {
					variantType = *v.Item.VariantType
				}
				variantKey := getDiscriminatorKey(k, variantType)
				out = append(out, getReport(variantKey, v)...)

				for variantType, variant := range *v.Item.Variants {
					variantType := variantType
					if variant.VariantType != nil {
						variantType = *variant.VariantType
					}
					variantKey := getDiscriminatorKey(k, variantType)
					out = append(out, getReport(variantKey, variant)...)
				}
				continue
			}

			out = append(out, getReport(k, v)...)
		}
	}

	sort.Strings(out)

	outWithoutVariant := []string{
		fmt.Sprintf(`<!-- %[1]v -->
<details>
<summary><span%[2]v>%[3]v %[4]v</span></summary>
<blockquote>

%[5]v

</blockquote>
</details>`, model.Identifier, style, displayName, getCoverageCount(model), strings.Join(out, "\n\n")),
	}

	if model.IsRoot {
		var variants *map[string]*Model
		if model.Variants != nil {
			variants = model.Variants
		}
		if model.Item != nil && model.Item.Variants != nil {
			variants = model.Item.Variants
		}

		if variants != nil {
			outWithVariant := make([]string, 0)
			outWithVariant = append(outWithVariant, outWithoutVariant...)

			for variantType, variant := range *variants {
				variantType := variantType
				if variant.VariantType != nil {
					variantType = *variant.VariantType
				}
				variantKey := getDiscriminatorKey(displayName, variantType)
				outWithVariant = append(outWithVariant, getReport(variantKey, variant)...)
			}

			sort.Strings(outWithVariant)

			return outWithVariant
		}
	}

	return outWithoutVariant

}