func()

in codegen/module_system.go [1603:1727]

• 115 lines of code
• 7 McCabe index (conditional complexity)

func (generator *GatewayServiceGenerator) Generate(instance *ModuleInstance) (*BuildResult, error) {
	var fileMap sync.Map
	workCount := 5
	runner := parallelize.NewUnboundedRunner(workCount)

	f := func() (interface{}, error) {
		service, err := ExecuteDefaultOrCustomTemplate(
			"service.tmpl",
			generator.templates,
			instance.CustomTemplates,
			instance.Config,
			instance,
			generator.packageHelper,
		)
		if err != nil {
			err = errors.Wrapf(
				err,
				"Error generating service service.go for %s",
				instance.InstanceName,
			)
			return nil, err
		}
		fileMap.Store("service.go", service)
		return nil, nil
	}
	runner.SubmitWork(parallelize.StatelessFunc(f))

	f = func() (interface{}, error) {
		// generate main.go
		main, err := ExecuteDefaultOrCustomTemplate(
			"main.tmpl",
			generator.templates,
			instance.CustomTemplates,
			instance.Config,
			instance,
			generator.packageHelper,
		)
		if err != nil {
			err = errors.Wrapf(
				err,
				"Error generating service main.go for %s",
				instance.InstanceName,
			)
			return nil, err
		}
		fileMap.Store("main/main.go", main)
		return nil, nil
	}
	runner.SubmitWork(parallelize.StatelessFunc(f))

	f = func() (interface{}, error) {
		// generate main_test.go
		mainTest, err := ExecuteDefaultOrCustomTemplate(
			"main_test.tmpl",
			generator.templates,
			instance.CustomTemplates,
			instance.Config,
			instance,
			generator.packageHelper,
		)
		if err != nil {
			err = errors.Wrapf(
				err,
				"Error generating service main_test.go for %s",
				instance.InstanceName,
			)
			return nil, err
		}
		fileMap.Store("main/main_test.go", mainTest)
		return nil, nil
	}
	runner.SubmitWork(parallelize.StatelessFunc(f))

	f = func() (interface{}, error) {
		dependencies, err := GenerateDependencyStruct(
			instance,
			generator.packageHelper,
			generator.templates,
		)
		if err != nil {
			err = errors.Wrapf(
				err,
				"Error generating service dependencies for %s",
				instance.InstanceName,
			)
			return nil, err
		}
		fileMap.Store("module/dependencies.go", dependencies)
		return nil, nil
	}
	runner.SubmitWork(parallelize.StatelessFunc(f))

	f = func() (interface{}, error) {
		initializer, err := GenerateInitializer(
			instance,
			generator.packageHelper,
			generator.templates,
		)
		if err != nil {
			err = errors.Wrapf(
				err,
				"Error generating service initializer for %s",
				instance.InstanceName,
			)
			return nil, err
		}
		fileMap.Store("module/init.go", initializer)
		return nil, nil
	}
	runner.SubmitWork(parallelize.StatelessFunc(f))

	if _, err := runner.GetResult(); err != nil {
		return nil, err
	}

	files := make(map[string][]byte)
	fileMap.Range(func(key, value interface{}) bool {
		files[key.(string)] = value.([]byte)
		return true
	})

	return &BuildResult{
		Files: files,
	}, nil
}