public void PotentialInfiniteRecurse()
{
// Equivalent to:
// rule A = "a".."z";
// rule B = C "," C;
// rule C = A | B;
// Try to match "a" with C
var ruleA = new RangeRule("A", null, 'a', 'z');
var proxyC = new RuleProxy();
var ruleB = new SequenceRule("B", null, new[] {
new TaggedRule(proxyC),
new TaggedRule(new LiteralRule(null, null, ",")),
new TaggedRule(proxyC)
});
var ruleC = new DisjunctionRule("C", null, new[] {
new TaggedRule(ruleA),
new TaggedRule(ruleB)
});
proxyC.ReferencedRule = ruleC;
var match = ruleC.Match(new ExplorerContext("a")).FirstOrDefault();
Assert.IsNotNull(match, "Should be a success");
}
private static (IDictionary <string, Rule>, List <string>) Parse(List <string> lines)
{
var rules = new Dictionary <string, Rule>();
var messages = new List <string>();
foreach (var line in lines)
{
if (OrRule.MatchesRuleDescription(line))
{
var rule = OrRule.Parse(line);
rules.Add(rule.Id, rule);
}
else if (MatchRule.MatchesRuleDescription(line))
{
MatchRule matchRule = MatchRule.Parse(line);
rules.Add(matchRule.Id, matchRule);
}
else if (SequenceRule.MatchesRuleDescription(line))
{
SequenceRule sequenceRule = SequenceRule.Parse(line);
rules.Add(sequenceRule.Id, sequenceRule);
}
else if (!string.IsNullOrEmpty(line))
{
messages.Add(line);
}
}
return(rules, messages);
}
public void TestSequenceRule()
{
var rule = new SequenceRule(new StringRule("cat"), new StringRule("fish"));
Assert.IsFalse(rule.Match("catsomething"));
Assert.IsFalse(rule.Match("fishcat"));
Assert.IsTrue(rule.Match("catfish"));
Assert.IsTrue(rule.Match("catfish something"));
}
/// <summary>
/// Parses a sequence rule definition
/// </summary>
/// <param name="sequenceDefinition">The definition of the rule</param>
/// <returns>The initialized SequenceRule instance</returns>
private static SequenceRule ParseSequence(string sequenceDefinition)
{
var sequence = new SequenceRule();
string[] parts = sequenceDefinition.Split(' ', StringSplitOptions.RemoveEmptyEntries);
foreach (string ruleNum in parts)
{
sequence.AddRuleId(int.Parse(ruleNum));
}
return(sequence);
}
/// <summary>
/// 计数规则
/// </summary>
/// <param name="seqRule"></param>
/// <param name="code"></param>
/// <returns></returns>
private static string NumberingSeqRule(SequenceRule seqRule, int code)
{
string str = "";
if (seqRule.PaddingSide == "Left")
{
str += code.ToString().PadLeft(seqRule.PaddingWidth, seqRule.PaddingChar.ToChar());
}
if (seqRule.PaddingSide == "Right")
{
str += code.ToString().PadRight(seqRule.PaddingWidth, seqRule.PaddingChar.ToChar());
}
return(str);
}
public void SequenceWithInterleave()
{
var interleave = new LiteralRule(null, null, " ");
var rule = new SequenceRule("seq", null, new[]
{
new TaggedRule(new LiteralRule(null, null, "|")),
new TaggedRule("t", new LiteralRule(null, null, "a"))
});
var text = " | a ";
var match = rule.Match(new ExplorerContext(text, interleave)).FirstOrDefault();
Assert.IsNotNull(match, "Success");
Assert.AreEqual(rule.RuleName, match.Rule.RuleName, "seq");
Assert.AreEqual(1, ToMap(match.ComputeOutput()).Count(), "Contents");
}
public static OrRule Parse(string line)
{
var idIdx = line.IndexOf(":");
var id = line.Substring(0, idIdx);
var operands = line.Substring(idIdx + 1).Split("|", StringSplitOptions.RemoveEmptyEntries).ToList();
var left = operands[0];
var right = operands[1];
return(new OrRule(id)
{
Left = SequenceRule.Parse($"{id}: {left}"),
Right = SequenceRule.Parse($"{id}: {right}")
});
}
public void SequenceWithoutTags()
{
var rule = new SequenceRule("Seq", null, new[]
{
new TaggedRule(new LiteralRule(null, null, "Hi")),
new TaggedRule(new LiteralRule(null, null, "Bob")),
new TaggedRule(new LiteralRule(null, null, "!"))
});
var text = "HiBob!";
var match = rule.Match(new ExplorerContext(text)).FirstOrDefault();
Assert.IsNotNull(match, "Success");
Assert.AreEqual(rule.RuleName, match.Rule.RuleName, "Seq");
Assert.AreEqual(text.Length, match.Text.Length, "MatchLength");
Assert.AreEqual(text.ToString().TrimStart(), match.Text.ToString(), "Content");
Assert.AreEqual(3, ToList(match.ComputeOutput()).Count, "Fragments");
}
public void RepeatWithSequenceAndInterleave()
{
var interleave = new RepeatRule("interleave", null, new LiteralRule(null, null, " "), 0, null);
var seq = new SequenceRule("seq", null, new[]
{
new TaggedRule(new LiteralRule(null, null, "|")),
new TaggedRule("t", new LiteralRule(null, null, "a"))
});
var rule = new RepeatRule("rep", null, seq, 1, null);
var text = "|a | a | a";
var match = rule.Match(new ExplorerContext(text, interleave)).FirstOrDefault();
Assert.IsNotNull(match, "Success");
Assert.AreEqual(rule.RuleName, match.Rule.RuleName, "Rule");
Assert.AreEqual(text.Length, match.Text.Length, "MatchLength");
Assert.AreEqual(3, ToList(match.ComputeOutput()).Count(), "Contents");
}
public void SequenceWithTags()
{
var rule = new SequenceRule("Seq", null, new[]
{
new TaggedRule("h", new LiteralRule(null, null, "Hi")),
new TaggedRule("b", new LiteralRule(null, null, "Bob")),
new TaggedRule(new LiteralRule(null, null, "!"))
});
var text = "HiBob!";
var match = rule.Match(new ExplorerContext(text)).FirstOrDefault();
Assert.IsNotNull(match, "Success");
Assert.AreEqual(rule.RuleName, match.Rule.RuleName, "Seq");
Assert.AreEqual(text.Length, match.Text.Length, "MatchLength");
var output = ToMap(match.ComputeOutput());
Assert.AreEqual(2, output.Count(), "Fragments");
Assert.AreEqual("Hi", output["h"].ToString(), "Fragments - Hi");
Assert.AreEqual("Bob", output["b"].ToString(), "Fragments - Bob");
}
public void SequenceWithNoChildrenTags()
{
var rule = new SequenceRule("Seq", null, new[]
{
new TaggedRule("a", new RepeatRule(null, null, new LiteralRule(null, null, "a"), 1, null)),
new TaggedRule("b", new RepeatRule(null, null, new LiteralRule(null, null, "b"), 1, null))
});
var text = "aaaabb";
var match = rule.Match(new ExplorerContext(text)).FirstOrDefault();
Assert.IsNotNull(match, "Success");
Assert.AreEqual(rule.RuleName, match.Rule.RuleName, "Seq");
Assert.AreEqual(text.Length, match.Text.Length, "MatchLength");
var output = ToMap(match.ComputeOutput());
Assert.AreEqual(2, output.Count(), "Fragments");
Assert.AreEqual(
4, ToList(output["a"]).Count, "Fragments text - a");
Assert.AreEqual(
2, ToList(output["b"]).Count(), "Fragments text - b");
}
/// <summary>
/// 计数 方式 重置规则
/// </summary>
/// <param name="seq"></param>
/// <param name="seqRule"></param>
/// <returns></returns>
private static int CurrentReset(Sequence seq, SequenceRule seqRule)
{
int newNo = 0, ruleNo = 0;
try
{
ruleNo = seqRule.RuleValue.ToInt();
}
catch (Exception ex)
{
newNo = 1;
Log4NetHelper.Error(ex.Message, ex);
}
switch (seq.SequenceReset)
{
case "D": //每天重置
if (!string.IsNullOrEmpty(seq.CurrentReset) && seq.CurrentReset != DateTime.Now.ToString("yyyyMMdd"))
{
newNo = 1;
}
break;
case "M": //每月重置
if (!string.IsNullOrWhiteSpace(seq.CurrentReset))
{
if (!seq.CurrentReset.Contains(DateTime.Now.ToString("yyyyMM")))
{
newNo = ruleNo;
}
}
else
{
newNo = 1;
}
break;
case "Y": //每年重置
if (!string.IsNullOrWhiteSpace(seq.CurrentReset))
{
if (!seq.CurrentReset.Contains(DateTime.Now.ToString("yyyy")))
{
newNo = ruleNo;
}
}
else
{
newNo = 1;
}
break;
}
if (newNo == 0)
{
if (seq.CurrentNo == 0)
{
newNo = ruleNo;
}
else
{
//当前序号+步长
newNo = seq.CurrentNo + seq.Step;
}
}
return(newNo);
}
