///<summary>Creates a new Minimatcher instance, parsing the pattern into a regex.</summary>
public Minimatcher(string pattern, Options options = null)
{
if (pattern == null) throw new ArgumentNullException("pattern");
this.options = options ?? new Options();
this.pattern = pattern.Trim();
if (this.options.AllowWindowsPaths)
this.pattern = this.pattern.Replace('\\', '/');
this.Make();
}
static void TestCase(string pattern, IList<string> expected, Options options = null, IEnumerable<string> input = null)
{
input = input ?? files;
Assert.Equal(
String.Join(Environment.NewLine, expected.OrderBy(s => s)),
String.Join(Environment.NewLine, Minimatcher.Filter(input, pattern, options).OrderBy(s => s))
);
var regex = Minimatcher.CreateRegex(pattern, options);
actualRegexes.Add(Tuple.Create(pattern, regex == null ? "false" : "/" + regex.ToString() + "/" + (regex.Options == RegexOptions.IgnoreCase ? "i" : "")));
}
public override string RegexSource(Options options)
{
return options.NoGlobStar ? star
: options.Dot ? twoStarDot
: twoStarNoDot;
}
public override bool Match(string input, Options options)
{
throw new NotSupportedException();
}
// Brace expansion:
// a{b,c}d -> abd acd
// a{b,}c -> abc ac
// a{0..3}d -> a0d a1d a2d a3d
// a{b,c{d,e}f}g -> abg acdfg acefg
// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
//
// Invalid sets are not expanded.
// a{2..}b -> a{2..}b
// a{b}c -> a{b}c
///<summary>Expands all brace ranges in a pattern, returning a sequence containing every possible combination.</summary>
public static IEnumerable<string> BraceExpand(string pattern, Options options)
{
if (options.NoBrace || !hasBraces.IsMatch(pattern))
{
// shortcut. no need to expand.
return new[] { pattern };
}
bool escaping = false;
int i;
// examples and comments refer to this crazy pattern:
// a{b,c{d,e},{f,g}h}x{y,z}
// expected:
// abxy
// abxz
// acdxy
// acdxz
// acexy
// acexz
// afhxy
// afhxz
// aghxy
// aghxz
// everything before the first \{ is just a prefix.
// So, we pluck that off, and work with the rest,
// and then prepend it to everything we find.
if (pattern[0] != '{')
{
// console.error(pattern)
string prefix = null;
for (i = 0; i < pattern.Length; i++)
{
var c = pattern[i];
// console.error(i, c)
if (c == '\\')
{
escaping = !escaping;
}
else if (c == '{' && !escaping)
{
prefix = pattern.Substring(0, i);
break;
}
}
// actually no sets, all { were escaped.
if (prefix == null)
{
// console.error("no sets")
return new[] { pattern };
}
return BraceExpand(pattern.Substring(i), options).Select(t => prefix + t);
}
// now we have something like:
// {b,c{d,e},{f,g}h}x{y,z}
// walk through the set, expanding each part, until
// the set ends. then, we'll expand the suffix.
// If the set only has a single member, then'll put the {} back
// first, handle numeric sets, since they're easier
var numset = numericSet.Match(pattern);
if (numset.Success)
{
// console.error("numset", numset[1], numset[2])
var suf = BraceExpand(pattern.Substring(numset.Length), options).ToList();
int start = int.Parse(numset.Groups[1].Value),
end = int.Parse(numset.Groups[2].Value),
inc = start > end ? -1 : 1;
var retVal = new List<string>();
for (var w = start; w != (end + inc); w += inc)
{
// append all the suffixes
for (var ii = 0; ii < suf.Count; ii++)
{
retVal.Add(w.ToString() + suf[ii]);
}
}
return retVal;
}
// ok, walk through the set
// We hope, somewhat optimistically, that there
// will be a } at the end.
// If the closing brace isn't found, then the pattern is
// interpreted as braceExpand("\\" + pattern) so that
// the leading \{ will be interpreted literally.
i = 1; // skip the \{
int depth = 1;
var set = new List<string>();
string member = "";
for (i = 1; i < pattern.Length && depth > 0; i++)
{
var c = pattern[i];
// console.error("", i, c)
if (escaping)
{
escaping = false;
member += "\\" + c;
}
else
{
switch (c)
{
case '\\':
escaping = true;
continue;
case '{':
depth++;
member += "{";
continue;
case '}':
depth--;
// if this closes the actual set, then we're done
if (depth == 0)
{
set.Add(member);
member = "";
// pluck off the close-brace
break;
}
else
{
member += c;
continue;
}
case ',':
if (depth == 1)
{
set.Add(member);
member = "";
}
else
{
member += c;
}
continue;
default:
member += c;
continue;
} // switch
} // else
} // for
// now we've either finished the set, and the suffix is
// pattern.substr(i), or we have *not* closed the set,
// and need to escape the leading brace
if (depth != 0)
{
// console.error("didn't close", pattern)
return BraceExpand("\\" + pattern, options);
}
// ["b", "c{d,e}","{f,g}h"] ->
// ["b", "cd", "ce", "fh", "gh"]
var addBraces = set.Count == 1;
set = set.SelectMany(p => BraceExpand(p, options)).ToList();
if (addBraces)
set = set.Select(s => "{" + s + "}").ToList();
// now attach the suffixes.
// x{y,z} -> ["xy", "xz"]
// console.error("set", set)
// console.error("suffix", pattern.substr(i))
return BraceExpand(pattern.Substring(i), options).SelectMany(s1 => set.Select(s2 => s2 + s1));
}
///<summary>Compiles a pattern into a single regular expression.</summary>
public static Regex CreateRegex(string pattern, Options options = null)
{
return new Minimatcher(pattern, options).MakeRegex();
}
///<summary>Filters a list of inputs against a single pattern.</summary>
///<remarks>This function reparses this input on each invocation. For performance, avoid this function and reuse a Minimatcher instance instead.</remarks>
public static IEnumerable<string> Filter(IEnumerable<string> list, string pattern, Options options = null)
{
var mm = new Minimatcher(pattern, options);
list = list.Where(mm.IsMatch);
if (options != null && options.NoNull)
list = list.DefaultIfEmpty(pattern);
return list;
}
///<summary>Tests a single input against a pattern.</summary>
///<remarks>This function reparses this input on each invocation. For performance, avoid this function and reuse a Minimatcher instance instead.</remarks>
public static bool Check(string input, string pattern, Options options = null)
{
if (input == null) throw new ArgumentNullException("input");
if (pattern == null) throw new ArgumentNullException("pattern");
// shortcut: comments match nothing.
if (options != null && !options.NoComment && pattern[0] == '#')
{
return false;
}
// "" only matches ""
if (String.IsNullOrWhiteSpace(pattern)) return input == "";
return new Minimatcher(pattern, options).IsMatch(input);
}
///<summary>Creates a filter function that tests input against a pattern.</summary>
public static Func<string, bool> CreateFilter(string pattern, Options options = null)
{
if (pattern == null) throw new ArgumentNullException("pattern");
// "" only matches ""
if (String.IsNullOrWhiteSpace(pattern)) return String.IsNullOrEmpty;
var m = new Minimatcher(pattern, options);
return m.IsMatch;
}
public abstract bool Match(string input, Options options);
public abstract string RegexSource(Options options);
public override string RegexSource(Options options)
{
return Source;
}
public override bool Match(string input, Options options)
{
return regex.Value.IsMatch(input);
}
public MagicItem(string source, Options options)
{
Source = source;
regex = new Lazy<Regex>(() => new Regex("^" + source + "$", options.RegexOptions));
}
public override string RegexSource(Options options)
{
return Regex.Escape(Source);
}
public override bool Match(string input, Options options)
{
return input.Equals(Source, options.NoCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
}
