/// <summary>
/// Initialize an instance of <see cref="RegexNode"/>.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexNode(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
SetPattern(pattern);
Minimum = min;
Maximum = max;
RegexQuantifierOption = quantifierOption;
}
/// <summary>
/// Initialize an instance of <see cref="RegexNode"/>, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexNode(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
SetInnerNode(innerNode);
Minimum = min;
Maximum = max;
RegexQuantifierOption = quantifierOption;
}
public virtual string AddQuantifier(string pattern, int?min, int?max, RegexQuantifierOption quantifierOption)
{
if (min < 0)
{
throw new ArgumentOutOfRangeException(nameof(min));
}
if (max < 0)
{
throw new ArgumentOutOfRangeException(nameof(max));
}
var quantifierOptionString = ToQuantifierOptionString(quantifierOption);
string result = string.Empty;
if ((!min.HasValue && !max.HasValue) || (min == 1 && max == 1))
{
result = pattern;
}
else if (min.HasValue && max.HasValue)
{
if (min == 0 && max == 1)
{
result = pattern + ToTokenString(RegexToken.ZeroOrOne);
}
else if (min == max)
{
result = pattern + ToTokenString(RegexToken.QuantifierOpen) + min.Value + ToTokenString(RegexToken.QuantifierClose);
}
else
{
result = pattern + ToTokenString(RegexToken.QuantifierOpen) + min.Value + ToTokenString(RegexToken.QuantifierSeparator) + max.Value + ToTokenString(RegexToken.QuantifierClose);
}
}
else if (min == 0 && !max.HasValue)
{
result = pattern + ToTokenString(RegexToken.ZeroOrMore);
}
else if (min == 1 && !max.HasValue)
{
result = pattern + ToTokenString(RegexToken.OneOrMore);
}
else if (min.HasValue && !max.HasValue)
{
result = pattern + ToTokenString(RegexToken.QuantifierOpen) + min.Value + ToTokenString(RegexToken.QuantifierSeparator) + ToTokenString(RegexToken.QuantifierClose);
}
else if (!min.HasValue && max.HasValue)
{
result = pattern + ToTokenString(RegexToken.QuantifierOpen) + ToTokenString(RegexToken.QuantifierSeparator) + max.Value + ToTokenString(RegexToken.QuantifierClose);
}
else
{
throw new NotImplementedException();
}
return(result + quantifierOptionString);
}
public void AddNodeQuantifierTest(RegexQuantifierOption quantifierOption)
{
// Arrange
var regexGenerator = new RegexGenerator();
// Act
regexGenerator.Add(@"a", min: 1, max: 10, quantifierOption: quantifierOption);
// Assert
Assert.Equal($@"a{{1,10}}{regexGenerator.RegexLanguageStrategy.Stringifier.ToQuantifierOptionString(quantifierOption)}", regexGenerator.ToString());
}
public virtual string ToQuantifierOptionString(RegexQuantifierOption quantifierOption)
{
switch (quantifierOption)
{
case RegexQuantifierOption.Greedy:
return("");
case RegexQuantifierOption.Lazy:
return(ToTokenString(RegexToken.Lazy));
case RegexQuantifierOption.Possessive:
return(ToTokenString(RegexToken.Possessive));
default:
throw new ArgumentOutOfRangeException(nameof(quantifierOption));
}
}
/// <summary>
/// Create and add <see cref="RegexAtomicGroupNode"/> to the generator.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="AtomicGroupNotSupportedException">Atomic group is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddAtomicGroup(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var atomicGroup = new RegexAtomicGroupNode(pattern, min, max, quantifierOption);
return(AddAtomicGroup(atomicGroup));
}
/// <summary>
/// Create and add <see cref="RegexGroupNode"/> to the generator, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="node">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="capturing">Defines the group to be capturing or not.</param>
/// <param name="name">Optional name of capture group.</param>
/// <param name="options">Optional inline options for the group.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="NamedCapturingGroupNotSupportedException">Named capturing group is not supported by <see cref="RegexLanguage"/>.</exception>
/// <exception cref="InlineGroupOptionsNotSupportedException">Inline group option is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddGroup(RegexNode node, bool capturing = true, string name = null, string options = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var groupNode = new RegexGroupNode(node.ToString(RegexLanguageStrategy.Stringifier), capturing, name, options, min, max, quantifierOption);
return(AddGroup(groupNode));
}
/// <summary>
/// Create and add <see cref="RegexNode"/> to the generator, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
public RegexGenerator Add(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var node = new RegexNode(innerNode, min, max, quantifierOption);
return(Add(node));
}
/// <summary>
/// Create and add <see cref="RegexUnicodeCategoryNode"/> to the generator.
/// <seealso cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/>
/// <seealso cref="AddUnicodeCategory(RegexUnicodeCategoryNode)"/>
/// </summary>
/// <param name="unicodeDesignation">Unicode designation or named block.</param>
/// <param name="negative">Optional value to determine if negate the category.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="UnicodeCategoryNotSupportedException">Unicode category is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddUnicodeCategory(string unicodeDesignation, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var unicodeCategoryNode = new RegexUnicodeCategoryNode(unicodeDesignation, negative, min, max, quantifierOption);
return(AddUnicodeCategory(unicodeCategoryNode));
}
/// <summary>
/// Create and add <see cref="RegexNegativeLookbehindAssertionNode"/> to the generator, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="NegativeLookbehindAssertionNotSupportedException">Negative lookbehind assertion is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddNegativeLookbehindAssertion(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var negativeLookbehindAssertion = new RegexNegativeLookbehindAssertionNode(innerNode, min, max, quantifierOption);
return(AddNegativeLookbehindAssertion(negativeLookbehindAssertion));
}
/// <summary>
/// Create and add <see cref="RegexNegativeLookaheadAssertionNode"/> to the generator.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="NegativeLookaheadAssertionNotSupportedException">Negative lookahead assertion is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddNegativeLookaheadAssertion(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var negativeLookaheadAssertion = new RegexNegativeLookaheadAssertionNode(pattern, min, max, quantifierOption);
return(AddNegativeLookaheadAssertion(negativeLookaheadAssertion));
}
/// <summary>
/// Initialize an instance of <see cref="RegexAtomicGroupNode"/>, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexAtomicGroupNode(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(innerNode, min, max, quantifierOption)
{
}
/// <summary>
/// Initialize an instance of <see cref="RegexAtomicGroupNode"/>.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexAtomicGroupNode(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(pattern, min, max, quantifierOption)
{
}
/// <summary>
/// Initialize an instance of <see cref="RegexConditionalNode"/>, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="trueValue">Value of successful match.</param>
/// <param name="falseValue">Value of failed match.</param>
/// <param name="nameOrNumber">Name or number for backtracking.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexConditionalNode(RegexNode innerNode, string trueValue, string falseValue, string nameOrNumber = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(innerNode, min, max, quantifierOption)
{
TrueValue = trueValue;
FalseValue = falseValue;
NameOrNumber = nameOrNumber;
}
/// <summary>
/// Create and add <see cref="RegexAtomicGroupNode"/> to the generator, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="AtomicGroupNotSupportedException">Atomic group is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddAtomicGroup(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var atomicGroup = new RegexAtomicGroupNode(innerNode, min, max, quantifierOption);
return(AddAtomicGroup(atomicGroup));
}
/// <summary>
/// Create and add <see cref="RegexPositiveLookaheadAssertionNode"/> to the generator, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="PositiveLookaheadAssertionNotSupportedException">Positive lookahead assertion is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddPositiveLookaheadAssertion(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var positiveLookaheadAssertion = new RegexPositiveLookaheadAssertionNode(innerNode, min, max, quantifierOption);
return(AddPositiveLookaheadAssertion(positiveLookaheadAssertion));
}
/// <summary>
/// Initialize an instance of <see cref="RegexPositiveLookbehindAssertionNode"/>.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexPositiveLookbehindAssertionNode(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(pattern, min, max, quantifierOption)
{
}
/// <summary>
/// Create and add <see cref="RegexPositiveLookbehindAssertionNode"/> to the generator.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="PositiveLookbehindAssertionNotSupportedException">Positive lookbehind assertion is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddPositiveLookbehindAssertion(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var positiveLookbehnidAssertion = new RegexPositiveLookbehindAssertionNode(pattern, min, max, quantifierOption);
return(AddPositiveLookbehindAssertion(positiveLookbehnidAssertion));
}
/// <summary>
/// Initialize an instance of <see cref="RegexPositiveLookbehindAssertionNode"/>, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexPositiveLookbehindAssertionNode(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(innerNode, min, max, quantifierOption)
{
}
/// <summary>
/// Create and add <see cref="RegexConditionalNode"/> to the generator, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="trueValue">Value of successful match.</param>
/// <param name="falseValue">Value of failed match.</param>
/// <param name="nameOrNumber">Name or number for backtracking.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="ConditionalNotSupportedException">Conditional is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddConditional(RegexNode innerNode, string trueValue, string falseValue, string nameOrNumber = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var conditionalNode = new RegexConditionalNode(innerNode, trueValue, falseValue, nameOrNumber, min, max, quantifierOption);
return(AddConditional(conditionalNode));
}
/// <summary>
/// Initialize an instance of <see cref="RegexUnicodeCategoryNode"/> with flag <see cref="RegexUnicodeCategoryFlag"/>.
/// <para>Internally call <see cref="Enum.ToString()"/>. Therefore, only use one value from <see cref="RegexUnicodeCategoryFlag"/> while using this constructor;
/// Use <see cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/> instead for named unicode block.</para>
/// <seealso cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/>
/// </summary>
/// <remarks>
/// <code>
/// (RegexUnicodeCategoryFlag.Lu | RegexUnicodeCategoryFlag.Ll).ToString() // will generate "Lu, Ll", which is a invalid form.
/// </code>
/// </remarks>
/// <param name="unicodeCategory">Value from <see cref="RegexUnicodeCategoryFlag"/>.</param>
/// <param name="negative">Optional value to determine if negate the category.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexUnicodeCategoryNode(RegexUnicodeCategoryFlag unicodeCategory, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(unicodeCategory.ToString(), min, max, quantifierOption)
{
Negative = negative;
}
/// <summary>
/// Create and add <see cref="RegexNode"/> to the generator.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
public RegexGenerator Add(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var node = new RegexNode(pattern, min, max, quantifierOption);
return(Add(node));
}
/// <summary>
/// Initialize an instance of <see cref="RegexUnicodeCategoryNode"/> with unicode designation or name.
/// </summary>
/// <param name="unicodeDesignation">Unicode designation or named block.</param>
/// <param name="negative">Optional value to determine if negate the category.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexUnicodeCategoryNode(string unicodeDesignation, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(unicodeDesignation, min, max, quantifierOption)
{
Negative = negative;
}
/// <summary>
/// Initialize an instance of <see cref="RegexGroupNode"/>, and include another <see cref="RegexNode"/> inside.
/// </summary>
/// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param>
/// <param name="capturing">Defines the group to be capturing or not.</param>
/// <param name="name">Optional name of capture group.</param>
/// <param name="options">Optional inline options for the group.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexGroupNode(RegexNode innerNode, bool capturing = true, string name = null, string options = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(innerNode, min, max, quantifierOption)
{
SetName(name);
SetIsCapturingGroup(capturing);
Options = options;
}
/// <summary>
/// Create and add <see cref="RegexGroupNode"/> to the generator.
/// </summary>
/// <param name="pattern">Regex pattern.</param>
/// <param name="capturing">Defines the group to be capturing or not.</param>
/// <param name="name">Optional name of capture group.</param>
/// <param name="options">Optional inline options for the group.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="NamedCapturingGroupNotSupportedException">Named capturing group is not supported by <see cref="RegexLanguage"/>.</exception>
/// <exception cref="InlineGroupOptionsNotSupportedException">Inline group option is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddGroup(string pattern, bool capturing = true, string name = null, string options = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var groupNode = new RegexGroupNode(pattern, capturing, name, options, min, max, quantifierOption);
return(AddGroup(groupNode));
}
