func()

in newt/syscfg/syscfg.go [962:1099]
113 lines of code
29 McCabe index (conditional complexity)

func (cfg *Cfg) ErrorText() string {
	str := ""

	historyMap := map[string][]CfgPoint{}

	// Redefinition errors.
	if len(cfg.Redefines) > 0 {
		settingNames := make([]string, len(cfg.Redefines))
		i := 0
		for k, _ := range cfg.Redefines {
			settingNames[i] = k
			i++
		}
		sort.Strings(settingNames)

		str += "Settings defined by multiple packages:"
		for _, n := range settingNames {
			pkgNames := make([]string, len(cfg.Redefines[n]))
			i := 0
			for p, _ := range cfg.Redefines[n] {
				pkgNames[i] = p.FullName()
				i++
			}
			sort.Strings(pkgNames)

			str += fmt.Sprintf("\n    %s:", n)
			for _, pn := range pkgNames {
				str += " " + pn
			}
		}
	}

	// Violation errors.
	if len(cfg.SettingViolations) > 0 || len(cfg.PackageViolations) > 0 {
		str += "Syscfg restriction violations detected:\n"
		for settingName, rslice := range cfg.SettingViolations {
			baseEntry := cfg.Settings[settingName]
			historyMap[settingName] = baseEntry.History
			for _, r := range rslice {
				for _, name := range r.relevantSettingNames() {
					reqEntry := cfg.Settings[name]
					historyMap[name] = reqEntry.History
				}
				str += "    " + cfg.settingViolationText(baseEntry, r) + "\n"
			}
		}
		for pkgName, rslice := range cfg.PackageViolations {
			for _, r := range rslice {
				for _, name := range r.relevantSettingNames() {
					reqEntry := cfg.Settings[name]
					historyMap[name] = reqEntry.History
				}
				str += "    " + cfg.packageViolationText(pkgName, r) + "\n"
			}
		}
	}

	// Ambiguity errors.
	if len(cfg.Ambiguities) > 0 {
		str += "Syscfg ambiguities detected:\n"

		settingNames := make([]string, 0, len(cfg.Ambiguities))
		for k, _ := range cfg.Ambiguities {
			settingNames = append(settingNames, k)
		}
		sort.Strings(settingNames)

		for _, name := range settingNames {
			entry := cfg.Settings[name]
			historyMap[entry.Name] = entry.History
			str += "    " + entry.ambiguityText()
		}
	}

	// Priority violation errors.
	if len(cfg.PriorityViolations) > 0 {
		str += "Priority violations detected (Packages can only override " +
			"settings defined by packages of lower priority):\n"
		for _, priority := range cfg.PriorityViolations {
			entry := cfg.Settings[priority.SettingName]
			historyMap[priority.SettingName] = entry.History

			str += fmt.Sprintf(
				"    Package: %s overriding setting: %s defined by %s\n",
				priority.PackageSrc.FullName(), priority.SettingName,
				priority.PackageDef.FullName())
		}
	}

	// Flash conflicts.
	if len(cfg.FlashConflicts) > 0 {
		str += "Flash errors detected:\n"
		for _, conflict := range cfg.FlashConflicts {
			for _, name := range conflict.SettingNames {
				entry := cfg.Settings[name]
				historyMap[name] = entry.History
			}

			str += "    " + cfg.flashConflictErrorText(conflict)
		}
	}

	// Overrides of defunct settings.
	if len(cfg.Defunct) > 0 {
		str += "Override of defunct settings detected:\n"
		for name, _ := range cfg.Defunct {
			entry := cfg.Settings[name]
			str += "    " + fmt.Sprintf("%s: %s\n", name, entry.Description)
			historyMap[name] = entry.History
		}
	}

	// Overrides of const settings.
	if len(cfg.Consts) > 0 {
		str += "Override of consts settings detected:\n"
		for name, _ := range cfg.Consts {
			entry := cfg.Settings[name]
			str += "    " + fmt.Sprintf("%s\n", name)
			historyMap[name] = entry.History
		}
	}

	// Unresolved value references
	if len(cfg.UnresolvedValueRefs) > 0 {
		str += "Unresolved value references:\n"
		for name, _ := range cfg.UnresolvedValueRefs {
			entry := cfg.Settings[name]
			str += "    " + fmt.Sprintf("%s -> %s\n", name, entry.ValueRefName)
			historyMap[name] = entry.History
		}
	}

	if len(historyMap) > 0 {
		str += "\n" + historyText(historyMap)
	}

	return str
}