public void NegateFollowsConvention() { string equation = "q_test"; string negated = ConventionHelper.NegateEquationName(equation, this.CustomConfig.Convention); Assert.Equal("q_NOT_test", negated); }
public void NegateActionEx() { var exception = Assert.Throws <ConventionMisMatchException>(() => { string action = "action.test"; ConventionHelper.NegateEquationName(action, DefaultConfig.Convention); }); }
public void NegateConventionNotFoundEx() { var exception = Assert.Throws <ConventionMisMatchException>(() => { string equation = "mismatch.test"; ConventionHelper.NegateEquationName(equation, this.DefaultConfig.Convention); }); }
//this needs to // * ensure reaction rule is an equation // * ensure that any evaluators exist in the evaluators list private string LoadLogic(WorkDefine.Workflow workFlow, string equationId) { StepTraceNode <LintTrace> root = this.tracer.Root; //load conventions LogicDefine.Evaluator trueDef = workFlow.Evaluators.FirstOrDefault(z => z.Id == ConventionHelper.TrueEvaluator(this.config.Convention)); if (null == trueDef) { trueDef = new LogicDefine.Evaluator() { Id = ConventionHelper.TrueEvaluator(this.config.Convention), Description = "Always True" }; workFlow.Evaluators.Add(trueDef); } LogicDefine.Equation trueEqDef = workFlow.Equations.FirstOrDefault(z => z.Id == ConventionHelper.TrueEquation(this.config.Convention)); if (null == trueEqDef) { trueEqDef = new LogicDefine.Equation() { Condition = Logic.Operand.Or, First = trueDef.Id, Second = trueDef.Id, Id = ConventionHelper.TrueEquation(this.config.Convention) }; workFlow.Equations.Add(trueEqDef); } //Lint.... make sure we have everything we need first. Action <LogicDefine.Rule, StepTraceNode <LintTrace>, bool> LoadRule = null; LoadRule = (rule, parentStep, isRoot) => { StepTraceNode <LintTrace> step = this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.Inspecting, "Inspecting Rule", rule.Id)); //if id is an equation, we are creating an expression LogicDefine.Equation eq = workFlow.Equations.FirstOrDefault(g => g.Id.Equals(rule.Id)); if (null != eq) { if (null != eq.First) { LoadRule(eq.First, step, false); } else { eq.First = new LogicDefine.Rule() { Id = ConventionHelper.TrueEvaluator(this.config.Convention), Context = string.Empty, TrueCondition = true }; } if (null != eq.Second) { LoadRule(eq.Second.Id, step, false); } else { eq.Second = new LogicDefine.Rule() { Id = ConventionHelper.TrueEvaluator(this.config.Convention), Context = string.Empty, TrueCondition = true }; } if (!rule.TrueCondition) { //create a negation equation. string negationId = ConventionHelper.NegateEquationName(rule.Id, this.config.Convention); LogicDefine.Rule negated = (LogicDefine.Rule)rule.Clone(); //negated.TrueCondition = false; if (workFlow.Equations.Count(g => g.Id == negationId) == 0) { this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.InferringEquation, string.Format("Inferring negation equation from {0}", rule.Id), negationId)); LogicDefine.Equation toAdd = new LogicDefine.Equation() { First = negated, Id = negationId, Condition = Logic.Operand.And, Second = ConventionHelper.TrueEvaluator(this.config.Convention) }; workFlow.Equations.Add(toAdd); rule.TrueCondition = true; rule.Id = negationId; } } } else { //if reaction ruleid is not an equation, create an equation and update reaction LogicDefine.Evaluator ev = workFlow.Evaluators.FirstOrDefault(g => g.Id.Equals(rule.Id)); if (null == ev) { this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.LazyDefinition, "No definition found for evaluator", rule.Id)); ev = new LogicDefine.Evaluator() { Id = rule.Id, Description = string.Empty }; workFlow.Evaluators.Add(ev); } //if this is the rule referenced by the reaction, then create an equation also, //and update the equation. This isn't necessary, but consistent. if (isRoot) { LogicDefine.Rule cloned = (LogicDefine.Rule)rule.Clone(); string newId = string.Empty; Logic.Operand condition = Logic.Operand.And; if (rule.Id == ConventionHelper.TrueEquation(this.config.Convention)) { newId = ConventionHelper.TrueEquation(this.config.Convention); condition = Logic.Operand.Or; } else { newId = ConventionHelper.ChangePrefix(NamePrefixOptions.Evaluator, NamePrefixOptions.Equation, rule.Id, this.config.Convention); } if (!rule.TrueCondition) { newId = ConventionHelper.NegateEquationName(newId, this.config.Convention); } if (workFlow.Equations.Count(g => g.Id == newId) == 0) { this.tracer.TraceNext(parentStep, new LintTrace(LintStatusOptions.InferringEquation, string.Format("Inferring equation from {0}", rule.Id), newId)); workFlow.Equations.Add(new LogicDefine.Equation() { Condition = condition, First = cloned, Second = ConventionHelper.TrueEvaluator(this.config.Convention), Id = newId }); } rule.Id = newId; } } }; LogicDefine.Rule eqRule = equationId; LoadRule(eqRule, root, true); return(eqRule.Id); }
void IFluentExpressionBuilder <T> .Rule(Action <IRuleBuilder <T> > action) { RuleBuilder <T> builderRef = new RuleBuilder <T>(this); action.Invoke(builderRef); LogicDefine.Rule evaluatorId = builderRef.rule; evaluatorId.Id = ConventionHelper.EnsureConvention(NamePrefixOptions.Evaluator, evaluatorId.Id, this.config.Convention); string actionName = builderRef.evaluatorx.GetType().Name; string description = ConventionHelper.ParseMethodName(actionName, this.config.Convention.ParseMethodNamesAs).Literal; var descAttr = builderRef.evaluatorx.GetType().GetCustomAttributes(typeof(ArticulateOptionsAttribute), true) .OfType <ArticulateOptionsAttribute>() .FirstOrDefault(); if (descAttr != null) { description = descAttr.Description; } this.workflowManager.AddEvaluator(new LogicDefine.Evaluator() { Id = evaluatorId.Id, Description = description }); bool isRoot = this.epxressionStack.Count == 0; if (!this.evaluators.ContainsKey(evaluatorId.Id)) { this.evaluators.Add(evaluatorId.Id, builderRef.evaluatorx); } //if attmpeting to add another implementation with the same id, throw an exception //we can't handle this else if (this.evaluators[evaluatorId.Id].GetType() != builderRef.evaluatorx.GetType()) { throw new BuilderException(evaluatorId.Id); } if (isRoot) { string equationId = ConventionHelper.ChangePrefix(NamePrefixOptions.Evaluator, NamePrefixOptions.Equation, evaluatorId.Id, this.config.Convention); bool trueCond = true;; if (!evaluatorId.TrueCondition) { equationId = ConventionHelper.NegateEquationName(equationId, this.config.Convention); trueCond = false; } LogicDefine.Equation toAdd = new LogicDefine.Equation() { Condition = Logic.Operand.And, First = evaluatorId, Id = equationId, Second = ConventionHelper.TrueEvaluator(this.config.Convention), //TrueCondition = trueCond }; this.epxressionStack.Push(toAdd); this.workflowManager.AddEquation(toAdd); } else { this.epxressionStack.Push(evaluatorId); } //if root... then create euqations //otherwise, just use as evaluator }