AddWithOptions(All:true) doesn't respect .gitignore

[h4ck3rk3y]

Here is the repo I'll be using as an example,

Here's the code that I'm running to test the AddWithOptions(All:true)

package main

import (
	"fmt"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing/object"
	"time"
)

func main() {
	repository, err := git.PlainOpen("../testrepo")
	if err != nil {
		panic("this shouldnt happen")
	}

	worktree, err := repository.Worktree()
	fmt.Println(worktree.Status())

	err = worktree.AddWithOptions(&git.AddOptions{All: true})

	commitMsg := fmt.Sprintf("testing add with options")
	_, err = worktree.Commit(commitMsg, &git.CommitOptions{
		Author: &object.Signature{
			Name:  "foo",
			Email: "foo@bar.com",
			When:  time.Now(),
		},
	})
}

After running main.go this is what I get , even though the worker tree is empty (nil output in the first screenshot)

The gitignore contains this,

Is this expected behavior? How do I force AddWithOptions(all:true) to respect .gigignore?

[h4ck3rk3y]

Have fixed the .gitignore too

# gyani @ Gyanendras-MacBook-Pro in ~/work/testrepo on git:master o [18:43:57] 
$ cat .gitignore
/unusedfolder

I hadn't attached the screenshot from the execution, here it is
The .gitignore contains unusedfolder the worktree says its nil but for some reason it still gets added.

[jghal]

I have a gitignore as follows

$ cat .gitignore
# Local .terraform directories
.terraform/

# .tfplan files
*.tfplan
*.tfplan.*

I'm not seeing the gitignore file being used at all in either Add() or AddWithOptions() .

In Add() it's explicitly passing an empty list of excludes and then on line 277 it skips building the gitignore object.

In AddWithOptions() it's referencing the Worktree's Excludes field. But when I step through my code in debugger, I see after a call of w, err := repo.Worktree() that w.Excludes is empty

so once again the doAddDirectory() function skips over creating the gitignore object.

I'm now stepping through my Repo.PlainOpen() call to see if it ever attempts to read my gitignore.

[jghal]

Adding my ignore patterns to the Worktree explicitly before calling AddWithOptions() like this seems to work

	// Add the ignore patterns that aren't benig read from the .gitignore file
	w.Excludes = append(w.Excludes, gitignore.ParsePattern(".terraform/", nil))
	w.Excludes = append(w.Excludes, gitignore.ParsePattern("*.tfplan", nil))
	w.Excludes = append(w.Excludes, gitignore.ParsePattern("*.tfplan.*", nil))

edit: I also have the set All: true in the AddOptions, otherwise it just calls the Add() function instead of doAdd() and we're back to the hard coded list of ignore patterns.

Which is pretty lame, it should really be reading my gitignore file.

[Silthus]

Here is a little snippet that parses an existing .gitignore and adds everything to the excludes list. This does not work with nested .gitignore files however.

func AddGitignoreToWorktree(wt *git.Worktree, repositoryPath string) {
	readFile, err := os.Open(filepath.Join(repositoryPath, ".gitignore"))
	defer readFile.Close()

	if err != nil {
		fmt.Println("Failed to read .gitignore: %s", err.Error())
		return
	}

	fileScanner := bufio.NewScanner(readFile)
	fileScanner.Split(bufio.ScanLines)

	for fileScanner.Scan() {
		ignorePattern := fileScanner.Text()
		fmt.Println("add %s from .gitignore to ignore list", ignorePattern)
		wt.Excludes = append(wt.Excludes, gitignore.ParsePattern(ignorePattern, nil))
	}
}

Use it just before calling worktree.AddWithOptions(...).

AddGitignoreToWorktree(worktree, repo.Path())

fmt.Println(fmt.Sprint(worktree.Status()))
if err = worktree.AddWithOptions(&git.AddOptions{All: true}); err != nil {
  return "", err
}

---

Is this behavior intentional or are there contributions accepted to fix it? Maybe with a new parameter?

git.AddOptions{
  All: true, 
  ExcludeGitignore: true, // defaults to false?
}