Match a glob ** joined to other characters like a single * [patch] (#203)

* Match a glob ** joined to other characters like a single * [patch]

DotNet.Glob only reads ** as a wildcard when it is a whole path segment.
Joined to other characters, as in **foo or a**b, it matched nothing, so a
doubled star emptied the list where * matches. ResolveGlob now collapses
each run of stars that is not a whole segment to a single *, leaving
whole-segment ** for ExpandGlobStarSegments and stars inside bracket
classes alone.

Fixes #135

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017vfJW3RphV1aRzPmhMhf5m

* Hold only the visible overloads to the README's documented defaults [patch]

The README API test required every overload's same-named parameter to carry
the documented default. The binary-compatibility overloads from #166 have no
defaults by design, so main has been red since #178. They are marked
[EditorBrowsable(Never)] and are not what the README documents, so the default
check now skips them. A wrong default on a visible overload still fails.

Fixes #183

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017vfJW6FzBtSrY5LKUuDYce
(cherry picked from commit 9328e00)

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: matt-edmondson

TextFilter.Test/TextFilterTests.cs

@@ -1391,6 +1391,51 @@ public void GlobStarInsideNegatedClassExclusionKeepsExcludedItems()
 		Assert.AreEqual("x*", result[0]);
 	}
 
+	[TestMethod]
+	[DataRow("xfoo", "**foo")]
+	[DataRow("foo", "**foo")]
+	[DataRow("ab", "a**b")]
+	[DataRow("axb", "a**b")]
+	[DataRow("a/b", "a**b")]
+	[DataRow("foobar", "foo**")]
+	[DataRow("xfoo", "***foo")]
+	[DataRow("src/xfoo", "src/**foo")]
+	public void GlobStarJoinedToLiteralMatchesLikeSingleStar(string text, string filter)
+	{
+		Assert.IsTrue(TextFilter.IsMatch(text, filter, TextFilterType.Glob, TextFilterMatchOptions.ByWholeString));
+	}
+
+	[TestMethod]
+	[DataRow("xbar", "**foo")]
+	[DataRow("ac", "a**b")]
+	public void GlobStarJoinedToLiteralStillRequiresTheLiteral(string text, string filter)
+	{
+		Assert.IsFalse(TextFilter.IsMatch(text, filter, TextFilterType.Glob, TextFilterMatchOptions.ByWholeString));
+	}
+
+	[TestMethod]
+	public void GlobStarJoinedToLiteralFiltersItems()
+	{
+		List<string> result = [.. TextFilter.Filter(["xfoo", "foo", "bar"], "**foo")];
+
+		Assert.AreEqual(2, result.Count);
+		Assert.AreEqual("xfoo", result[0]);
+		Assert.AreEqual("foo", result[1]);
+	}
+
+	[TestMethod]
+	[DataRow("x[**]", "x[**]")]
+	[DataRow("x[!**]", "x[!**]")]
+	[DataRow("**/a", "**/a")]
+	[DataRow("a/**", "a/**")]
+	[DataRow("**", "**")]
+	[DataRow("a**b", "a*b")]
+	[DataRow("foo**/bar", "foo*/bar")]
+	public void CollapseJoinedGlobStarsLeavesWholeSegmentsAndClasses(string token, string expected)
+	{
+		Assert.AreEqual(expected, TextFilter.CollapseJoinedGlobStars(token));
+	}
+
 	[TestMethod]
 	public void GlobStarSlashFiltersPathItems()
 	{

TextFilter/TextFilter.cs

@@ -508,6 +508,59 @@ internal static IReadOnlyList<string> ExpandGlobStarSegments(string maskedToken)
 		return [.. expansions.Select(prefix => prefix + tail).Distinct(StringComparer.Ordinal)];
 	}
 
+	// DotNet.Glob only reads "**" as a wildcard when it is a whole path segment; joined to anything
+	// else, as in "**foo" or "a**b", it matches no characters at all, so a doubled star
+	// would empty the list where "*" matches. Outside a whole segment a run of stars means no more than
+	// one star does, so each such run is collapsed to "*". A whole-segment "**" ("**/x", "a/**") is left
+	// for ExpandGlobStarSegments, and stars inside a bracket class are members, so they are left too.
+	internal static string CollapseJoinedGlobStars(string token)
+	{
+		if (!token.Contains("**", StringComparison.Ordinal))
+		{
+			return token;
+		}
+
+		StringBuilder result = new(token.Length);
+		int index = 0;
+		while (index < token.Length)
+		{
+			char current = token[index];
+			if (current == '[')
+			{
+				int close = FindGlobClassEnd(token, index, out _, out _);
+				if (close >= 0)
+				{
+					result.Append(token, index, close + 1 - index);
+					index = close + 1;
+					continue;
+				}
+			}
+
+			if (current != '*')
+			{
+				result.Append(current);
+				index++;
+				continue;
+			}
+
+			int runEnd = index;
+			while (runEnd < token.Length && token[runEnd] == '*')
+			{
+				runEnd++;
+			}
+
+			bool startsSegment = index == 0 || IsPathSeparator(token[index - 1]);
+			bool endsSegment = runEnd == token.Length || IsPathSeparator(token[runEnd]);
+			int runLength = runEnd - index;
+			result.Append('*', runLength > 1 && !(startsSegment && endsSegment) ? 1 : runLength);
+			index = runEnd;
+		}
+
+		return result.ToString();
+	}
+
+	private static bool IsPathSeparator(char value) => value is '/' or '\\';
+
 	// The spans of the closed bracket classes in a token, read with the same boundary rules as
 	// ExpandGlobClasses: a leading "]" is a member, and "!" or "^" negate. Scanning stops at a class
 	// with no closing "]", as ExpandGlobClasses does.
@@ -771,7 +824,7 @@ private static SortedSet<char> CollectGlobClassMembers(List<char> singles, List<
 				// discard the valid expansions with it. An empty pattern could only match empty text, which
 				// never reaches the matcher, so drop it; a token with nothing left is still unparseable.
 				Glob[]? parsed = expandedTokens is null ? null : [.. expandedTokens
-					.SelectMany(expandedToken => ExpandGlobStarSegments(MaskPathSeparators(expandedToken)))
+					.SelectMany(expandedToken => ExpandGlobStarSegments(MaskPathSeparators(CollapseJoinedGlobStars(expandedToken))))
 					.Distinct(StringComparer.Ordinal)
 					.Where(pattern => pattern.Length != 0)
 					.Select(pattern => caseSensitivity is TextFilterCaseSensitivity.CaseInsensitive