func()

in codegen/module.go [556:636]

• 68 lines of code
• 15 McCabe index (conditional complexity)

func (system *ModuleSystem) ResolveModules(
	packageRoot string,
	baseDirectory string,
	targetGenDir string,
	options Options,
) (map[string][]*ModuleInstance, error) {
	// resolve module class order before read and resolve each module
	if err := system.resolveClassOrder(); err != nil {
		return nil, err
	}

	resolvedModules := map[string]map[string]*ModuleInstance{}

	// system.classOrder is important. Downstream dependencies **must** be resolved first
	for _, className := range system.classOrder {

		defaultDependencies, err := system.getDefaultDependencies(
			baseDirectory,
			className,
			system.defaultDependencies,
			system.moduleSearchPaths,
		)
		if err != nil {
			return nil, errors.Wrapf(err, "error getting default dependencies for class %s", className)
		}

		for _, moduleDirectoryGlob := range system.moduleSearchPaths[className] {
			moduleDirectoriesAbs, err := filepath.Glob(filepath.Join(baseDirectory, moduleDirectoryGlob))
			if err != nil {
				return nil, errors.Wrapf(err, "error globbing %q", moduleDirectoryGlob)
			}

			runner := parallelize.NewUnboundedRunner(len(moduleDirectoriesAbs))
			for _, moduleDirAbs := range moduleDirectoriesAbs {
				f := system.getInstanceFunc(baseDirectory, className, packageRoot, targetGenDir, defaultDependencies, moduleDirectoryGlob, options)
				wrk := &parallelize.SingleParamWork{Data: moduleDirAbs, Func: f}
				runner.SubmitWork(wrk)
			}

			results, err := runner.GetResult()
			if err != nil {
				return nil, err
			}
			for _, instanceInf := range results {
				if instanceInf == nil {
					continue
				}
				instance := instanceInf.(*ModuleInstance)
				instanceMap := resolvedModules[instance.ClassName]
				if instanceMap == nil {
					instanceMap = map[string]*ModuleInstance{}
					resolvedModules[instance.ClassName] = instanceMap
				}
				instanceMap[instance.InstanceName] = instance
			}

			// Resolve dependencies for all classes
			resolveErr := system.populateResolvedDependencies(
				resolvedModules[className],
				resolvedModules,
			)
			if resolveErr != nil {
				return nil, resolveErr
			}

			// Resolved recursive dependencies for all classes
			recursiveErr := system.populateRecursiveDependencies(resolvedModules[className])
			if recursiveErr != nil {
				return nil, recursiveErr
			}
		}
	}

	classArrayModuleMap := map[string][]*ModuleInstance{}
	for className, instanceMap := range resolvedModules {
		for _, instance := range instanceMap {
			classArrayModuleMap[className] = append(classArrayModuleMap[className], instance)
		}
	}
	return classArrayModuleMap, nil
}