Match fails for wildcard in folder name

[AriehSchneier]

Here is a failing test which should pass:

func TestMatchWildcardInTheMiddle(t *testing.T) {
	m := setupMatcher(t, "v*o\n")

	if !m.Match("value/vulkano/tail") {
		t.Error("expected value/vulkano/tail to match")
	}
}

[andrew]

Thanks for reporting, pr for a fix over here: #5

[AriehSchneier]

Here are some more, should I leave them here or open a new issue?

package gitignore

import (
	"testing"
)

// TestGitPkgsBug_MalformedPattern demonstrates that git-pkgs/gitignore
// treats malformed bracket patterns as literals instead of rejecting them.
//
// Real Git behavior (verified):
//
//	$ echo 'v[ou]l[' > .gitignore && touch 'vol['
//	$ git check-ignore 'vol['
//	(exits 1 - no match)
//
// git-pkgs/gitignore behavior:
//
//	Matches 'vol[' (treats malformed pattern as literal)
func TestGitPkgsBug_MalformedPattern(t *testing.T) {
	m := New("/tmp")
	m.AddPatterns([]byte("v[ou]l["), "") // Malformed: unclosed bracket

	// Real Git: does NOT match
	// git-pkgs/gitignore: DOES match (bug)
	matched := m.MatchPath("vol[", false)

	if matched {
		t.Logf("BUG CONFIRMED: git-pkgs/gitignore matches malformed pattern 'v[ou]l[' on 'vol['")
		t.Logf("Real Git does NOT match this")
	} else {
		t.Logf("Bug appears to be fixed! Pattern correctly rejected")
	}
}

// TestGitPkgsBug_TrailingDoubleStarOnFile demonstrates that git-pkgs/gitignore
// incorrectly matches files with /** patterns when it should only match directories.
//
// Real Git behavior (verified):
//
//	$ echo '/a*/**' > .gitignore
//	$ touch ab && git check-ignore ab
//	(exits 1 - no match on file)
//	$ mkdir ab_dir && touch ab_dir/file && git check-ignore ab_dir/file
//	ab_dir/file (matches - file inside directory)
//
// git-pkgs/gitignore behavior:
//
//	Matches both 'ab' file AND 'ab_dir/file' (bug: shouldn't match files)
func TestGitPkgsBug_TrailingDoubleStarOnFile(t *testing.T) {
	m := New("/tmp")
	m.AddPatterns([]byte("/a*/**"), "")

	// Real Git: does NOT match file 'ab', only 'ab_dir/file'
	// git-pkgs/gitignore: DOES match file 'ab' (bug)
	matchedFile := m.MatchPath("ab", false)             // file
	matchedDirFile := m.MatchPath("ab_dir/file", false) // file inside dir

	if matchedFile {
		t.Logf("BUG CONFIRMED: /a*/** matches file 'ab' when it shouldn't")
		t.Logf("Real Git only matches directories and their contents, not files")
	} else {
		t.Logf("Bug appears to be fixed! Pattern correctly only matches dir contents")
	}

	if !matchedDirFile {
		t.Errorf("REGRESSION: /a*/** should match 'ab_dir/file' but doesn't")
	}
}

// TestGitPkgsBug_DirectoryNegation demonstrates that git-pkgs/gitignore
// doesn't correctly handle directory-specific negation patterns like !dir/**/
//
// Real Git behavior (verified):
//
//	$ cat > .gitignore << EOF
//	data/**
//	!data/**/
//	EOF
//	$ mkdir -p data/data1
//	$ git check-ignore data data/data1
//	(exits 1 - neither is ignored, both re-included)
//
// git-pkgs/gitignore behavior:
//
//	Both 'data' and 'data/data1' are NOT re-included (bug)
func TestGitPkgsBug_DirectoryNegation(t *testing.T) {
	m := New("/tmp")
	m.AddPatterns([]byte("data/**\n!data/**/"), "")

	// Real Git: data dir NOT ignored (re-included by !data/**/)
	// git-pkgs/gitignore: Still matches/ignores (bug)
	detail := m.MatchDetail("data")
	matchedData := m.MatchPath("data", true)

	if matchedData || !detail.Negate {
		t.Logf("BUG CONFIRMED: !data/**/ doesn't re-include directory 'data'")
		t.Logf("Real Git re-includes directories with !dir/**/ pattern")
		t.Logf("MatchPath: %v, Detail: M=%v I=%v N=%v",
			matchedData, detail.Matched, detail.Ignored, detail.Negate)
	} else {
		t.Logf("Bug appears to be fixed! Directory negation working")
	}

	// Also test subdirectory
	detailSub := m.MatchDetail("data/data1")
	matchedSub := m.MatchPath("data/data1", true)

	if matchedSub || !detailSub.Negate {
		t.Logf("BUG CONFIRMED: !data/**/ doesn't re-include subdirectory 'data/data1'")
		t.Logf("MatchPath: %v, Detail: M=%v I=%v N=%v",
			matchedSub, detailSub.Matched, detailSub.Ignored, detailSub.Negate)
	}
}

[andrew]

It's fine to leave them there, I'll add fixes for those to the existing pr as well

[andrew]

@AriehSchneier updated the pr with two more fixes, your third test was already passing

[AriehSchneier]

I tried running it against your latest code and I skill get detail.Negate as false.

[andrew]

MatchDetail("data") (no trailing slash) treats data as a file. Neither pattern applies to files, so detail.Negate is false because nothing matched. Git behaves the same way -- git check-ignore data returns no match when data is a file.

MatchPath("data", true) in your test correctly returns false (not ignored). To get the negation detail, use MatchDetail("data/") with the trailing slash.

Do you have a git example where the behavior differs from what you'd expect? Happy to look into it if so.

[AriehSchneier]

You're right, I was missing the trailing slash in MatchDetail("data/") to show that it was a directory not a file.

Looks good with the latest changes

[andrew]

Shipped in v1.1.1, thanks for the help working through it