func runCreateCommand()

in cmd/changelog/create.go [65:172]
89 lines of code
27 McCabe index (conditional complexity)

func runCreateCommand(args []string, repoRoot string) error {
	if err := createFlagSet.Parse(args); err != nil {
		return err
	}

	discoverer := gomod.NewDiscoverer(repoRoot)

	if err := discoverer.Discover(); err != nil {
		return fmt.Errorf("failed to discover repository go modules: %w", err)
	}

	modules := discoverer.Modules()

	if err := validateCreateCommandArguments(createFlagSet.Args(), modules); err != nil {
		return fmt.Errorf("invalid arguments: %w", err)
	}

	modulesToAnnotate := make(map[string]struct{})

	for _, arg := range createFlagSet.Args() {
		modulesToAnnotate[arg] = struct{}{}
	}

	var commitChanges []string

	var err error
	if createCommand.Commit != "" {
		commitChanges, err = git.Changed(repoRoot, createCommand.Commit)
		if err != nil {
			return fmt.Errorf("failed to get changed files for commit: %v", err)
		}
	} else if createCommand.CommitStart != "" && createCommand.CommitEnd != "" {
		commitChanges, err = git.Changes(repoRoot, createCommand.CommitStart, createCommand.CommitEnd)
		if err != nil {
			return fmt.Errorf("failed to get changed files for commit: %v", err)
		}
	}

	if len(commitChanges) > 0 {
		for it := modules.Iterator(); ; {
			module := it.Next()
			if module == nil {
				break
			}

			if changes, err := gomod.FilterModuleFiles(module, commitChanges); err != nil {
				return err
			} else if len(changes) != 0 {
				modulesToAnnotate[module.Path()] = struct{}{}
			}
		}
	}

	annotation, err := changelog.NewAnnotation()
	if err != nil {
		return err
	}

	annotation.Type = changelog.ChangeType(createCommand.Type)
	if annotation.Type == changelog.UnknownChangeType {
		annotation.Type = changelog.BugFixChangeType
	}

	if len(createCommand.DescriptionFile) > 0 {
		if createCommand.DescriptionFile == "-" {
			buff := &bytes.Buffer{}
			_, err := io.Copy(buff, os.Stdin)
			if err != nil {
				return err
			}
			annotation.Description = buff.String()
		} else {
			fileBytes, err := os.ReadFile(createCommand.DescriptionFile)
			if err != nil {
				return err
			}
			annotation.Description = string(fileBytes)
		}
	} else {
		annotation.Description = createCommand.Description
	}

	annotation.Collapse = createCommand.Collapse

	if len(modulesToAnnotate) > 0 {
		for moduleDir := range modulesToAnnotate {
			annotation.Modules = append(annotation.Modules, moduleDir)
		}
	}

	sort.Strings(annotation.Modules)

	if createCommand.NonInteractive {
		if invalid := validateModules(annotation.Modules, modules); len(invalid) > 0 {
			return fmt.Errorf("invalid modules: %v", invalid)
		}

		if err = changelog.Validate(annotation); err != nil {
			return err
		}
	} else {
		if err = interactiveEdit(&annotation, modules); err != nil {
			return err
		}
	}

	return changelog.WriteAnnotation(repoRoot, annotation)
}