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); }