chore: Join some long lines

Makefile

@@ -124,7 +124,7 @@ lint: ensure-actionlint ensure-editorconfig-checker ensure-find-typos ensure-gol
 
 .PHONY: format
 format: ensure-gofumpt ensure-golines
-	find . -name \*.go | xargs ./bin/golines --base-formatter="./bin/gofumpt -extra" -w
+	find . -name \*.go | xargs ./bin/golines --base-formatter="./bin/gofumpt -extra" --max-len=128 --write-output
 	find . -name \*.txtar | xargs ${GO} run ./internal/cmds/lint-txtar -w
 
 .PHONY: format-yaml

internal/chezmoi/actualstateentry.go

@@ -40,12 +40,7 @@ type ActualStateSymlink struct {
 
 // NewActualStateEntry returns a new ActualStateEntry populated with absPath
 // from system.
-func NewActualStateEntry(
-	system System,
-	absPath AbsPath,
-	fileInfo fs.FileInfo,
-	err error,
-) (ActualStateEntry, error) {
+func NewActualStateEntry(system System, absPath AbsPath, fileInfo fs.FileInfo, err error) (ActualStateEntry, error) {
 	if fileInfo == nil {
 		fileInfo, err = system.Lstat(absPath)
 	}

internal/chezmoi/ageencryption.go

@@ -84,9 +84,8 @@ func (e *AgeEncryption) EncryptFile(plaintextAbsPath AbsPath) ([]byte, error) {
 		return e.builtinEncrypt(plaintext)
 	}
 
-	cmd := exec.Command( //nolint:gosec
-		e.Command,
-		append(append(e.encryptArgs(), e.Args...), plaintextAbsPath.String())...)
+	args := append(append(e.encryptArgs(), e.Args...), plaintextAbsPath.String())
+	cmd := exec.Command(e.Command, args...) //nolint:gosec
 	cmd.Stderr = os.Stderr
 	return chezmoilog.LogCmdOutput(cmd)
 }

internal/chezmoi/archivereadersystem.go

@@ -26,7 +26,10 @@ type ArchiveReaderSystemOptions struct {
 // NewArchiveReaderSystem returns a new ArchiveReaderSystem reading from data
 // and using archivePath as a hint for the archive format.
 func NewArchiveReaderSystem(
-	archivePath string, data []byte, format ArchiveFormat, options ArchiveReaderSystemOptions,
+	archivePath string,
+	data []byte,
+	format ArchiveFormat,
+	options ArchiveReaderSystemOptions,
 ) (*ArchiveReaderSystem, error) {
 	s := &ArchiveReaderSystem{
 		fileInfos: make(map[AbsPath]fs.FileInfo),

internal/chezmoi/archivereadersystem_test.go

@@ -21,15 +21,11 @@ func TestArchiveReaderSystemTar(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
-	archiveReaderSystem, err := NewArchiveReaderSystem(
-		"archive.tar",
-		data,
-		ArchiveFormatTar,
-		ArchiveReaderSystemOptions{
-			RootAbsPath:     NewAbsPath("/home/user"),
-			StripComponents: 1,
-		},
-	)
+	options := ArchiveReaderSystemOptions{
+		RootAbsPath:     NewAbsPath("/home/user"),
+		StripComponents: 1,
+	}
+	archiveReaderSystem, err := NewArchiveReaderSystem("archive.tar", data, ArchiveFormatTar, options)
 	assert.NoError(t, err)
 
 	for _, tc := range []struct {

internal/chezmoi/autotemplate.go

@@ -105,9 +105,7 @@ func autoTemplate(contents []byte, data map[string]any) ([]byte, bool) {
 
 // appendVariables appends all template variables in data to variables
 // and returns variables. data is assumed to be rooted at parent.
-func appendVariables(
-	variables []templateVariable, parent []string, data map[string]any,
-) []templateVariable {
+func appendVariables(variables []templateVariable, parent []string, data map[string]any) []templateVariable {
 	for name, value := range data {
 		switch value := value.(type) {
 		case string:

internal/chezmoi/boltpersistentstate.go

@@ -31,11 +31,7 @@ type BoltPersistentState struct {
 }
 
 // NewBoltPersistentState returns a new BoltPersistentState.
-func NewBoltPersistentState(
-	system System,
-	path AbsPath,
-	mode BoltPersistentStateMode,
-) (*BoltPersistentState, error) {
+func NewBoltPersistentState(system System, path AbsPath, mode BoltPersistentStateMode) (*BoltPersistentState, error) {
 	empty := false
 	switch _, err := system.Stat(path); {
 	case errors.Is(err, fs.ErrNotExist):

internal/chezmoi/boltpersistentstate_test.go

@@ -140,11 +140,8 @@ func TestBoltPersistentStateGeneric(t *testing.T) {
 	testPersistentState(t, func() PersistentState {
 		tempDir, err := os.MkdirTemp("", "chezmoi-test")
 		assert.NoError(t, err)
-		b, err := NewBoltPersistentState(
-			system,
-			NewAbsPath(tempDir).JoinString("chezmoistate.boltdb"),
-			BoltPersistentStateReadWrite,
-		)
+		absPath := NewAbsPath(tempDir).JoinString("chezmoistate.boltdb")
+		b, err := NewBoltPersistentState(system, absPath, BoltPersistentStateReadWrite)
 		assert.NoError(t, err)
 		return b
 	})

internal/chezmoi/chezmoi.go

@@ -160,9 +160,7 @@ func FQDNHostname(fileSystem vfs.FS) (string, error) {
 }
 
 // FlagCompletionFunc returns a flag completion function.
-func FlagCompletionFunc(allCompletions []string) func(*cobra.Command, []string, string) (
-	[]string, cobra.ShellCompDirective,
-) {
+func FlagCompletionFunc(allCompletions []string) func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		var completions []string
 		for _, completion := range allCompletions {
@@ -201,9 +199,8 @@ func SuspiciousSourceDirEntry(base string, fileInfo fs.FileInfo, encryptedSuffix
 			return true
 		}
 		for _, encryptedSuffix := range encryptedSuffixes {
-			if fileAttr := parseFileAttr(fileInfo.Name(), encryptedSuffix); knownTargetFiles.contains(
-				fileAttr.TargetName,
-			) {
+			fileAttr := parseFileAttr(fileInfo.Name(), encryptedSuffix)
+			if knownTargetFiles.contains(fileAttr.TargetName) {
 				return true
 			}
 		}

internal/chezmoi/debugpersistentstate.go

@@ -12,10 +12,7 @@ type DebugPersistentState struct {
 
 // NewDebugPersistentState returns a new debugPersistentState that logs methods
 // on persistentState to logger.
-func NewDebugPersistentState(
-	persistentState PersistentState,
-	logger *zerolog.Logger,
-) *DebugPersistentState {
+func NewDebugPersistentState(persistentState PersistentState, logger *zerolog.Logger) *DebugPersistentState {
 	return &DebugPersistentState{
 		logger:          logger,
 		persistentState: persistentState,

internal/chezmoi/debugsystem.go

@@ -159,12 +159,7 @@ func (s *DebugSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *DebugSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) error {
+func (s *DebugSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) error {
 	err := s.system.RunScript(scriptname, dir, data, options)
 	s.logger.Err(err).
 		Stringer("scriptname", scriptname).

internal/chezmoi/diff.go

@@ -64,11 +64,7 @@ func (p *gitDiffPatch) Message() string               { return p.message }
 
 // DiffPatch returns a github.com/go-git/go-git/plumbing/format/diff.Patch for
 // path from the given data and mode to the given data and mode.
-func DiffPatch(
-	path RelPath,
-	fromData []byte, fromMode fs.FileMode,
-	toData []byte, toMode fs.FileMode,
-) (diff.Patch, error) {
+func DiffPatch(path RelPath, fromData []byte, fromMode fs.FileMode, toData []byte, toMode fs.FileMode) (diff.Patch, error) {
 	isBinary := isBinary(fromData) || isBinary(toData)
 
 	var from diff.File

internal/chezmoi/dryrunsystem.go

@@ -107,12 +107,7 @@ func (s *DryRunSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *DryRunSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) error {
+func (s *DryRunSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) error {
 	s.setModified()
 	return nil
 }

internal/chezmoi/dumpsystem.go

@@ -98,12 +98,7 @@ func (s *DumpSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *DumpSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) error {
+func (s *DumpSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) error {
 	scriptnameStr := scriptname.String()
 	scriptData := &scriptData{
 		Type:     dataTypeScript,

internal/chezmoi/dumpsystem_test.go

@@ -49,12 +49,10 @@ func TestDumpSystem(t *testing.T) {
 
 		dumpSystem := NewDumpSystem()
 		persistentState := NewMockPersistentState()
-		assert.NoError(
-			t,
-			s.applyAll(dumpSystem, system, persistentState, EmptyAbsPath, ApplyOptions{
-				Filter: NewEntryTypeFilter(EntryTypesAll, EntryTypesNone),
-			}),
-		)
+		err := s.applyAll(dumpSystem, system, persistentState, EmptyAbsPath, ApplyOptions{
+			Filter: NewEntryTypeFilter(EntryTypesAll, EntryTypesNone),
+		})
+		assert.NoError(t, err)
 		expectedData := map[string]any{
 			".dir": &dirData{
 				Type: dataTypeDir,

internal/chezmoi/entrytypeset.go

@@ -371,9 +371,7 @@ func StringSliceToEntryTypeSetHookFunc() mapstructure.DecodeHookFunc {
 }
 
 // EntryTypeSetFlagCompletionFunc completes EntryTypeSet flags.
-func EntryTypeSetFlagCompletionFunc(
-	cmd *cobra.Command, args []string, toComplete string,
-) ([]string, cobra.ShellCompDirective) {
+func EntryTypeSetFlagCompletionFunc(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	var completions []string
 	entryTypes := strings.Split(toComplete, ",")
 	lastEntryType := entryTypes[len(entryTypes)-1]

internal/chezmoi/entrytypeset_test.go

@@ -149,17 +149,10 @@ func TestEntryTypeSetFlagCompletionFunc(t *testing.T) {
 		},
 	} {
 		t.Run(tc.toComplete, func(t *testing.T) {
-			completions, shellCompDirective := EntryTypeSetFlagCompletionFunc(
-				nil,
-				nil,
-				tc.toComplete,
-			)
+			completions, shellCompDirective := EntryTypeSetFlagCompletionFunc(nil, nil, tc.toComplete)
 			assert.Equal(t, tc.expectedCompletions, completions)
-			assert.Equal(
-				t,
-				cobra.ShellCompDirectiveNoSpace|cobra.ShellCompDirectiveNoFileComp,
-				shellCompDirective,
-			)
+			expectedShellCompDirective := cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
+			assert.Equal(t, expectedShellCompDirective, shellCompDirective)
 		})
 	}
 }

internal/chezmoi/erroronwritesystem.go

@@ -95,12 +95,7 @@ func (s *ErrorOnWriteSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *ErrorOnWriteSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) error {
+func (s *ErrorOnWriteSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) error {
 	return s.err
 }
 

internal/chezmoi/errors.go

@@ -24,11 +24,8 @@ type TooOldError struct {
 }
 
 func (e *TooOldError) Error() string {
-	return fmt.Sprintf(
-		"source state requires chezmoi version %s or later, chezmoi is version %s",
-		e.Need,
-		e.Have,
-	)
+	format := "source state requires chezmoi version %s or later, chezmoi is version %s"
+	return fmt.Sprintf(format, e.Need, e.Have)
 }
 
 type inconsistentStateError struct {
@@ -37,11 +34,8 @@ type inconsistentStateError struct {
 }
 
 func (e *inconsistentStateError) Error() string {
-	return fmt.Sprintf(
-		"%s: inconsistent state (%s)",
-		e.targetRelPath,
-		strings.Join(e.origins, ", "),
-	)
+	format := "%s: inconsistent state (%s)"
+	return fmt.Sprintf(format, e.targetRelPath, strings.Join(e.origins, ", "))
 }
 
 type NotInAbsDirError struct {

internal/chezmoi/externaldiffsystem.go

@@ -181,12 +181,7 @@ func (s *ExternalDiffSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *ExternalDiffSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) error {
+func (s *ExternalDiffSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) error {
 	bits := EntryTypeScripts
 	if options.Condition == ScriptConditionAlways {
 		bits |= EntryTypeAlways

internal/chezmoi/findexecutable_darwin_test.go

@@ -47,12 +47,8 @@ func TestFindExecutable(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		name := fmt.Sprintf(
-			"FindExecutable %#v in %#v as %#v",
-			test.files,
-			test.paths,
-			test.expected,
-		)
+		format := "FindExecutable %#v in %#v as %#v"
+		name := fmt.Sprintf(format, test.files, test.paths, test.expected)
 		t.Run(name, func(t *testing.T) {
 			actual, err := FindExecutable(test.files, test.paths)
 			assert.NoError(t, err)

internal/chezmoi/findexecutable_unix_test.go

@@ -48,12 +48,8 @@ func TestFindExecutable(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		name := fmt.Sprintf(
-			"FindExecutable %#v in %#v as %#v",
-			test.files,
-			test.paths,
-			test.expected,
-		)
+		format := "FindExecutable %#v in %#v as %#v"
+		name := fmt.Sprintf(format, test.files, test.paths, test.expected)
 		t.Run(name, func(t *testing.T) {
 			actual, err := FindExecutable(test.files, test.paths)
 			assert.NoError(t, err)

internal/chezmoi/gitdiffsystem.go

@@ -41,12 +41,7 @@ type GitDiffSystemOptions struct {
 // NewGitDiffSystem returns a new GitDiffSystem. Output is written to w, the
 // dirAbsPath is stripped from paths, and color controls whether the output
 // contains ANSI color escape sequences.
-func NewGitDiffSystem(
-	system System,
-	w io.Writer,
-	dirAbsPath AbsPath,
-	options *GitDiffSystemOptions,
-) *GitDiffSystem {
+func NewGitDiffSystem(system System, w io.Writer, dirAbsPath AbsPath, options *GitDiffSystemOptions) *GitDiffSystem {
 	unifiedEncoder := diff.NewUnifiedEncoder(w, diff.DefaultContextLines)
 	if options.Color {
 		unifiedEncoder.SetColor(diff.NewColorConfig())
@@ -206,12 +201,7 @@ func (s *GitDiffSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *GitDiffSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) error {
+func (s *GitDiffSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) error {
 	bits := EntryTypeScripts
 	if options.Condition == ScriptConditionAlways {
 		bits |= EntryTypeAlways

internal/chezmoi/glob.go

@@ -28,12 +28,10 @@ func (s lstatFS) Stat(name string) (fs.FileInfo, error) {
 // Glob is like github.com/bmatcuk/doublestar/v4.Glob except that it does not
 // follow symlinks.
 func Glob(fileSystem vfs.FS, prefix string) ([]string, error) {
-	return doublestar.Glob(
-		lstatFS{
-			wrapped: fileSystem,
-		},
-		prefix,
+	fsys := lstatFS{wrapped: fileSystem}
+	opts := []doublestar.GlobOption{
 		doublestar.WithFailOnIOErrors(),
 		doublestar.WithNoFollow(),
-	)
+	}
+	return doublestar.Glob(fsys, prefix, opts...)
 }

internal/chezmoi/realsystem.go

@@ -83,12 +83,7 @@ func (s *RealSystem) RunCmd(cmd *exec.Cmd) error {
 }
 
 // RunScript implements System.RunScript.
-func (s *RealSystem) RunScript(
-	scriptname RelPath,
-	dir AbsPath,
-	data []byte,
-	options RunScriptOptions,
-) (err error) {
+func (s *RealSystem) RunScript(scriptname RelPath, dir AbsPath, data []byte, options RunScriptOptions) (err error) {
 	// Create the script temporary directory, if needed.
 	s.createScriptTempDirOnce.Do(func() {
 		if !s.scriptTempDir.Empty() {