public RuleRunnerTest()
{
IRule rule;
rule = new BeginWithRule();
RulesPrototypes.Add(rule.TypeName, rule);
rule = new EndWithRule();
RulesPrototypes.Add(rule.TypeName, rule);
rule = new AndRule();
RulesPrototypes.Add(rule.TypeName, rule);
}
public FeatureFlagState AndRule(FeatureFlagState p1, FeatureFlagState p2)
{
var or = new AndRule {
Rules = new Rule[] { new ConstantRule {
Value = p1
}, new ConstantRule {
Value = p2
} }
};
return(or.Evaluate(null));
}
public void IsValidIfAllRulesAreValid()
{
var r1 = new Mock<IRule<int>>();
var r2 = new Mock<IRule<int>>();
r1.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true);
r2.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true);
var combination = new AndRule<int>(new List<IRule<int>> { r1.Object, r2.Object });
var candidate = combination.IsValid(2);
Assert.IsTrue(candidate);
r1.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once());
r2.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once());
}
public void IsValidIfAllRulesAreValid()
{
var r1 = new Mock <IRule <int> >();
var r2 = new Mock <IRule <int> >();
r1.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true);
r2.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true);
var combination = new AndRule <int>(new List <IRule <int> > {
r1.Object, r2.Object
});
var candidate = combination.IsValid(2);
Assert.IsTrue(candidate);
r1.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once());
r2.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once());
}
protected override string DescribeAndRule(AndRule <T> rule)
{
var leftDescription = Describe(rule.Left);
if (NeedsParenthesis(rule, rule.Left))
{
leftDescription = string.Format("({0})", leftDescription);
}
var rightDescription = Describe(rule.Right);
if (NeedsParenthesis(rule, rule.Right))
{
rightDescription = string.Format("({0})", rightDescription);
}
return(string.Format("{0} AND {1}", leftDescription, rightDescription));
}
public void NotValidIfARuleFails()
{
var msg = "r2 message";
var r1 = new Mock<IRule<int>>();
var r2 = new Mock<IRule<int>>();
var r3 = new Mock<IRule<int>>();
r1.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true);
r2.Setup(r => r.IsValid(It.IsAny<int>())).Returns(false);
r2.Setup(r => r.Message).Returns(msg);
r3.Setup(r => r.IsValid(It.IsAny<int>())).Returns(true);
var combination = new AndRule<int>(new List<IRule<int>> { r1.Object, r2.Object, r3.Object });
var candidate = combination.IsValid(2);
Assert.IsFalse(candidate);
Assert.AreEqual(msg + Environment.NewLine, combination.Message);
r1.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once());
r2.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once());
r3.Verify(r => r.IsValid(It.IsAny<int>()), Times.Once());
}
protected override string DescribeAndRule(AndRule <T> rule)
{
var result = DescribeResult(rule.IsTrueFor(evaluateWith));
var leftDescription = Describe(rule.Left);
if (NeedsParenthesis(rule, rule.Left))
{
leftDescription = string.Format("({0})", leftDescription);
}
var rightDescription = Describe(rule.Right);
if (NeedsParenthesis(rule, rule.Right))
{
rightDescription = string.Format("({0})", rightDescription);
}
return(string.Format("{0} AND[{2}] {1}", leftDescription, rightDescription, result));
}
static IRule CompileNodeForRule(string ruletext, Dictionary <int, RuleCacheItem> ruleSet)
{
Function Head, BuildingRule;
Head = BuildingRule = new AndRule();
foreach (var item in ruletext.Split(' '))
{
if (item.Contains("\""))
{
var nodeToAdd = new StringRule {
toMatch = item[1]
};;
//Comment this line for multi string rule support
return(nodeToAdd);
BuildingRule.AddNode(nodeToAdd);
}
else if (item.Contains("|"))
{
//Split on left and right
Head = new OrRule();
Head.AddNode(BuildingRule);
BuildingRule = new AndRule();
Head.AddNode(BuildingRule);
}
else
{
var childToExplore = int.Parse(item);
//Check if the cached copy hasn't compiled yet and compile it
if (ruleSet[childToExplore].CachedRule == null)
{
ruleSet[childToExplore].CachedRule = CompileNodeForRule(ruleSet[childToExplore].Text, ruleSet);
}
BuildingRule.AddNode(ruleSet[childToExplore].CachedRule);
}
}
return(Head);
}
public void NotValidIfARuleFails()
{
var msg = "r2 message";
var r1 = new Mock <IRule <int> >();
var r2 = new Mock <IRule <int> >();
var r3 = new Mock <IRule <int> >();
r1.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true);
r2.Setup(r => r.IsValid(It.IsAny <int>())).Returns(false);
r2.Setup(r => r.Message).Returns(msg);
r3.Setup(r => r.IsValid(It.IsAny <int>())).Returns(true);
var combination = new AndRule <int>(new List <IRule <int> > {
r1.Object, r2.Object, r3.Object
});
var candidate = combination.IsValid(2);
Assert.IsFalse(candidate);
Assert.AreEqual(msg + Environment.NewLine, combination.Message);
r1.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once());
r2.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once());
r3.Verify(r => r.IsValid(It.IsAny <int>()), Times.Once());
}
static void Main(string[] args)
{
var r1 = new EqualRule();
r1.AttributeName = "a1";
r1.TargetValue.Add("test1");
var r2 = new EqualRule();
r2.AttributeName = "b2";
r2.TargetValue.Add("test2");
r2.TargetValue.Add("test2bis");
var r3 = new EqualRule();
r3.AttributeName = "c3";
r3.TargetValue.Add("test3");
var r4 = new NotEqualRule();
r4.AttributeName = "c4";
r4.TargetValue.Add("test4");
var r5 = new EqualRule();
r5.AttributeName = "or5";
r5.TargetValue.Add("test5");
var r6 = new EqualRule();
r6.AttributeName = "or6";
r6.TargetValue.Add("test6");
var orRule = new OrRule();
orRule.ChildRules.Add(r5);
orRule.ChildRules.Add(r6);
var andRule = new AndRule();
andRule.ChildRules.Add(r1);
andRule.ChildRules.Add(r2);
andRule.ChildRules.Add(r3);
andRule.ChildRules.Add(r4);
andRule.ChildRules.Add(orRule);
var rc = new RuleContainer();
rc.MetadataInputs.Add(new MetadataEntity()
{
AttributeName = "a1",
AttributeType = typeof(string)
});
rc.MetadataInputs.Add(new MetadataEntity()
{
AttributeName = "b2",
AttributeType = typeof(string)
});
rc.MetadataInputs.Add(new MetadataEntity()
{
AttributeName = "c3",
AttributeType = typeof(string)
});
rc.MetadataInputs.Add(new MetadataEntity()
{
AttributeName = "c4",
AttributeType = typeof(string)
});
rc.MetadataInputs.Add(new MetadataEntity()
{
AttributeName = "or5",
AttributeType = typeof(string)
});
rc.MetadataInputs.Add(new MetadataEntity()
{
AttributeName = "or6",
AttributeType = typeof(string)
});
rc.Rules.Add(andRule);
rc.ReturnValue = "false";
rc.CompileExpression();
var res1 = rc.CompiledFunction(new string[] { "test1", "test2", "test3", "test4444", "test5fdsfsd", "test6" });
}
static void Main(string[] args)
{
Dictionary <int, RuleCacheItem> ruleParse = new Dictionary <int, RuleCacheItem>();
List <string> toCheck = new List <string>();
foreach (var line in System.IO.File.ReadLines("puzzleinput.txt"))
{
if (line.Contains(':'))
{
var c = line.Split(':');
ruleParse.Add(int.Parse(c[0]), new RuleCacheItem {
Text = c[1].Substring(1)
});
}
else if (!string.IsNullOrEmpty(line))
{
toCheck.Add(line);
}
}
//build tree
var currentNode = ruleParse[0];
currentNode.CachedRule = CompileNodeForRule(currentNode.Text, ruleParse);
int SuccessCount = toCheck.Count(line => currentNode.CachedRule.Match(0, line, 100).Any(t => t == line.Length));
Console.WriteLine($"Part 1: {SuccessCount}");
//Disgusting hack to replace nodes 8 and 11:
var oldEight = ruleParse[8].CachedRule;
//Update rule 8
ruleParse[8].CachedRule = new OrRule();
//LHS
var lhs = new AndRule();
lhs.AddNode(ruleParse[42].CachedRule);
//RHS
var rhs = new AndRule();
rhs.AddNode(ruleParse[42].CachedRule);
rhs.AddNode(ruleParse[8].CachedRule);
((Function)ruleParse[8].CachedRule).AddNode(lhs);
((Function)ruleParse[8].CachedRule).AddNode(rhs);
//Update rule 11
var oldEleven = ruleParse[11].CachedRule;
ruleParse[11].CachedRule = new OrRule();
//LHS
lhs = new AndRule();
lhs.AddNode(ruleParse[42].CachedRule);
lhs.AddNode(ruleParse[31].CachedRule);
//RHS
rhs = new AndRule();
rhs.AddNode(ruleParse[42].CachedRule);
rhs.AddNode(ruleParse[11].CachedRule);
rhs.AddNode(ruleParse[31].CachedRule);
((Function)ruleParse[11].CachedRule).AddNode(lhs);
((Function)ruleParse[11].CachedRule).AddNode(rhs);
//Replace the old 8's and 11's with the new ones
foreach (var node in ruleParse.Values)
{
if (typeof(Function).IsAssignableFrom(node.CachedRule.GetType()))
{
((Function)node.CachedRule).ReplaceNode(oldEight, ruleParse[8].CachedRule);
((Function)node.CachedRule).ReplaceNode(oldEleven, ruleParse[11].CachedRule);
}
}
SuccessCount = toCheck.Count(line => currentNode.CachedRule.Match(0, line, 100).Any(t => t == line.Length));
Console.WriteLine($"Part 2: {SuccessCount}");
Console.ReadLine();
}
private Rule Interpret(Grammar grammar, ISemanticNode node)
{
Rule rule = null;
if (node is BranchSemanticNode branch)
{
switch ((EbnfNodeType)branch.NodeType)
{
case EbnfNodeType.Group:
rule = Interpret(grammar, branch.Children[0]);
break;
case EbnfNodeType.Repeat:
rule = new RepeatRule(grammar, Interpret(grammar, branch.Children[0]));
break;
case EbnfNodeType.Optional:
rule = new OptionalRule(grammar, Interpret(grammar, branch.Children[0]));
break;
case EbnfNodeType.Not:
rule = new NotRule(grammar, Interpret(grammar, branch.Children[0]));
break;
case EbnfNodeType.And:
rule = new AndRule(grammar, branch.Children.Select(child => Interpret(grammar, child)));
break;
case EbnfNodeType.Or:
rule = new OrRule(grammar, branch.Children.Select(child => Interpret(grammar, child)));
break;
case EbnfNodeType.None:
rule = Interpret(grammar, branch.Children.Single());
break;
case EbnfNodeType.Root:
case EbnfNodeType.Rule:
case EbnfNodeType.Token:
default:
throw new Exception();
}
}
else if (node is LeafSemanticNode leaf)
{
switch ((EbnfNodeType)leaf.NodeType)
{
case EbnfNodeType.Identifier:
rule = grammar.ReferenceRule(leaf.Value);
break;
case EbnfNodeType.String:
case EbnfNodeType.Regex:
break;
default:
throw new Exception();
}
}
if (rule == null)
{
throw new Exception();
}
else
{
return(rule);
}
}
public virtual void Visit(AndRule visitee) => Visit((CompositeRule)visitee);
protected abstract string DescribeAndRule(AndRule <T> rule);
protected override string DescribeAndRule(AndRule <T> rule)
{
var result = DescribeResult(rule.IsTrueFor(evaluateWith));
return(string.Format("({0} AND {1})[{2}]", Describe(rule.Left), Describe(rule.Right), result));
}
protected override string DescribeAndRule(AndRule <T> rule)
{
return(string.Format("({0} AND {1})", Describe(rule.Left), Describe(rule.Right)));
}
