/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type genericType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var genericRangeRuleType = typeof (RangeRule<>);
//var genericType = Type.GetTypeFromHandle(runtimeType);
if (genericType.IsGenericType && (genericType.GetGenericTypeDefinition().Equals(TypePointers.NullableType)))
{
genericType = genericType.GetGenericArguments()[0];
}
Type[] typeArgs = {genericType};
var constructedRangeRuleType = genericRangeRuleType.MakeGenericType(typeArgs);
var minimum = TypeConverterEx.ChangeType(ruleData.XmlAttributes["minimum"], genericType);
var maximum = TypeConverterEx.ChangeType(ruleData.XmlAttributes["maximum"], genericType);
var equalsMinimumIsValid = RuleData.TryGetValue(ruleData.XmlAttributes, "equalsMinimumIsValid", true);
var equalsMaximumIsValid = RuleData.TryGetValue(ruleData.XmlAttributes, "equalsMaximumIsValid", true);
var constructorInfo = constructedRangeRuleType.GetPublicInstanceConstructor(genericType, genericType);
var rule = (Rule)constructorInfo.Invoke(new[] {minimum, maximum});
rule.SetProperty("EqualsMinimumIsValid", equalsMinimumIsValid);
rule.SetProperty("EqualsMaximumIsValid", equalsMaximumIsValid);
return rule;
}
public void RuleContext_ShouldAddRuleToRepository_WhenAddingRule()
{
//Setup
Func <SampleFact, bool> cond = x => x.SampleInt == 0;
Func <SampleFact, SampleOutput> cons = y => new SampleOutput(3);
Guid ruleId = Guid.NewGuid();
_moqCondition.Setup(x => x.GetCondition()).Returns(cond);
_moqConsequence.Setup(x => x.GetConsequence()).Returns(cons);
_moqTemplateFactory.Setup(x => x.CreateCondition(It.IsAny <int>(), It.IsAny <string>())).Returns(
_moqCondition.Object);
_moqTemplateFactory.Setup(x => x.CreateConsequence(It.IsAny <int>(), It.IsAny <string>())).Returns(
_moqConsequence.Object);
_moqRuleExecuter.Setup(x => x.AddRule(It.IsAny <Rule <SampleFact, SampleOutput> >()))
.Returns(ruleId);
RuleData ruleData = null;
_moqRuleRepository.Setup(x => x.AddRule(It.IsAny <RuleData>())).Callback <RuleData>(x => ruleData = x);
var context = RuleContext <SampleFact, SampleOutput> .CreateContext(
_moqRuleExecuter.Object,
_moqRuleRepository.Object,
_moqTemplateFactory.Object);
//Execution
#pragma warning disable 4014
context.Result.AddRule(0, string.Empty, 0, string.Empty);
#pragma warning restore 4014
//Assertion
Assert.NotNull(ruleData);
}
public override bool Eval(ref TokenStack <T> stack, ref RuleData data)
{
Token <T> token = stack.Next();
// TEMP
//#if DEBUG
// new ColorConsole().WriteLine($" - Checking {GetType().Name.Replace("`1", string.Empty)}: '{Pattern}' (&-a;{string.Join(", ", TokenTypes)}&-^;) => '&-e;{token.Value}&-^;' (&-a;{token.TokenType}&-^;)");
//#endif
// Token type doesn't match, token isn't the one we are looking for... Revert stack, and return true.
if (!IsTokenTypeMatch(token))
{
stack.Prev();
UpdateData(ref data, token, false);
//TEMP
//#if DEBUG
// new ColorConsole().WriteLine(" - Optional token missing, reverting...");
//#endif
return(true);
}
// Token with correct type exists, check if pattern matches.
bool isMatch = IsPatternMatch(token);
UpdateData(ref data, token, isMatch);
return(isMatch);
}
private void SetRuleLabel()
{
ArrayList ruleList = XMLManager.Instance._ruleList;
RuleData ruleData = (RuleData)ruleList[1];
_ruleLabel.text = ruleData.rule;
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type genericType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var genericRequiredRuleType = typeof (RequiredRule<>);
//var genericType = Type.GetTypeFromHandle(runtimeType);
if (genericType.IsGenericType && (genericType.GetGenericTypeDefinition().Equals(TypePointers.NullableType)))
{
genericType = genericType.GetGenericArguments()[0];
}
Type[] typeArgs = {genericType};
var constructedRequiredRuleType = genericRequiredRuleType.MakeGenericType(typeArgs);
object initialValue = null;
if (ruleData.XmlAttributes != null)
{
string initialValueString;
if (ruleData.XmlAttributes.TryGetValue("initialValue", out initialValueString))
{
initialValue = TypeConverterEx.ChangeType(initialValueString, genericType);
}
}
var rule = (Rule)Activator.CreateInstance(constructedRequiredRuleType);
rule.SetProperty("InitialValue", initialValue );
return rule;
}
public void Initialize()
{
var mapper = new Mapper();
var persister = new TestDataPersister();
_ruleData = new RuleData(mapper, persister);
}
protected virtual void CopyProperties(Rule rule, RuleData ruleData)
{
rule.UseErrorMessageProvider = ruleData.UseErrorMessageProvider;
rule.ErrorMessage = ruleData.ErrorMessage;
rule.Severity = ruleData.Severity;
rule.RuleSet = ruleData.RuleSet;
}
public override bool Apply(RuleData data)
{
var superTime = data.Collider.GetComponent <SuperDot>().Timeout;
data.Player.SetSuperTimeLeft(superTime);
return(true);
}
/// <summary>
/// Adds the translated token value into the provided <paramref name="ruleData"/> object if the rule was a match.
/// </summary>
protected virtual void UpdateData(ref RuleData ruleData, Token <T> token, bool isMatch)
{
if (isMatch)
{
ruleData.Add(GetValue(token));
}
}
public static void testEveryColumn(State state, ref RuleData rule, PatternStorage patterns)
{
System.Console.WriteLine($"=== Test every column ===");
var gridSize = state.gridSize;
int h = gridSize.y;
int w = gridSize.x;
int n = patterns.len;
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h - 1; y++)
{
var fromId = state.patternIdAt(x, y, n);
var toId = state.patternIdAt(x, y + 1, n);
if (fromId == null || toId == null)
{
continue;
}
if (!rule.isLegal(fromId.Value, Dir4.S, toId.Value))
{
System.Console.WriteLine($"illegal: {x}, {y} ({fromId.Value.asIndex}) -> {x}, {y+1} ({toId.Value.asIndex})");
}
}
}
}
//public void AddRule(string ruleName, Type entityType, string condition, LuaFunction action)
//{
// AddRuleData(ruleName, entityType, condition, action, RuleTypeEnum.Lambda);
//}
private void AddRuleData(string ruleName, Type entityType, object condition, object action, RuleTypeEnum type)
{
var ruleData = new RuleData()
{
IsEnabled = true,
EntityType = entityType,
RuleCondition = condition,
RuleName = ruleName,
RuleType = type
};
//if (action is LuaFunction)
//{
// ruleData.Action = entity => { ((LuaFunction)action).Call(entity); };
//}
if (action is Action <INeonIoTEntity> action1)
{
ruleData.Action = action1;
}
_logger.LogInformation($"Adding rule {ruleName} for entity {entityType.Name} [Type: {type}]");
Rules.Add(ruleData);
AddRuleExecution(ruleData);
}
public override bool Apply(RuleData data)
{
var value = data.Collider.GetComponent <Dot>().Value;
data.Player.Score += value;
return(true);
}
public Model(Vec2i gridSize, PatternStorage patterns, RuleData rule)
{
// this.input = input;
this.gridSize = gridSize;
this.patterns = patterns;
this.rule = rule;
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var numberStyles = NumberStyles.None;
string numberStylesString;
if (ruleData.XmlAttributes.TryGetValue("numberStyles", out numberStylesString))
{
numberStyles = (NumberStyles) Enum.Parse(typeof (NumberStyles), numberStylesString, true);
}
var typeCodeString = ruleData.XmlAttributes["typeCode"];
var typeCode = (TypeCode) Enum.Parse(typeof (TypeCode), typeCodeString, true);
string numberFormatInfoTypeName;
ruleData.XmlAttributes.TryGetValue("numberFormatInfoTypeName", out numberFormatInfoTypeName);
string numberFormatInfoPropertyName;
ruleData.XmlAttributes.TryGetValue("numberFormatInfoPropertyName", out numberFormatInfoPropertyName);
var removeWhiteSpace = RuleData.TryGetValue(ruleData.XmlAttributes, "removeWhiteSpace", false);
var numberFormatInfo = (NumberFormatInfo) TypeExtensions.GetStaticProperty(numberFormatInfoTypeName, numberFormatInfoPropertyName);
return new NumberConversionRule(typeCode)
{
RemoveWhiteSpace = removeWhiteSpace,
NumberStyles = numberStyles,
NumberFormatInfo = numberFormatInfo
};
}
public static Model create(ref Map source, int N, Vec2i outputSize)
{
var patterns = RuleData.extractEveryPattern(ref source, N, PatternUtil.variations);
var rule = OverlappingModel.buildRule(patterns, ref source);
return(new Model(outputSize, patterns, rule));
}
public override bool Eval(ref TokenStack <T> stack, ref RuleData data)
{
//TEMP
// new ColorConsole().WriteLine(Level.Fine, $" - Checking {GetType().Name.Replace("`1", string.Empty)}");
foreach (Rule <T> rule in rules)
{
if (!rule.Eval(ref stack, ref data))
{
return(false);
}
}
if (IsTokenTypeMatch(stack.Next()))
{
UpdateData(ref data, stack.Peek(), includeSeperator);
return(Eval(ref stack, ref data));
}
else
{
stack.Prev();
}
return(true);
}
/// <summary>Creates an <c>AdjacencyRule</c> for the overlapping model</summary>
public static RuleData buildRule(PatternStorage patterns, ref Map source)
{
var rule = new RuleData();
int nPatterns = patterns.len;
rule.nPatterns = nPatterns;
{ // do not count symmetric combinations
int nCombinations = (nPatterns + 1) * (nPatterns) / 2;
rule.cache = new Grid2D <bool>(4, nCombinations);
}
for (int from = 0; from < nPatterns; from++)
{
for (int to = from; to < nPatterns; to++)
{
for (int d = 0; d < 4; d++)
{
var dir = (Dir4)d;
bool canOverlap = OverlappingModel.testCompatibility(from, dir, to, patterns, source);
rule.cache.add(canOverlap);
}
}
}
return(rule);
}
private static string BuildRuleGrammar(RuleData r)
{
string grammerA = "";
string grammerB = "";
string grammer = "";
foreach (PartData p in jsonCont.partData)
{
foreach (ConnectionData con in p.connections)
{
if (con.id == r.conn1 && p.name == r.part1)
{
grammerA = con.type;
}
if (con.id == r.conn2 && p.name == r.part2)
{
grammerB = con.type;
}
}
}
grammer = grammerA + ">" + grammerB;
return(grammer);
}
public override bool Execute(JObject rowJObject, string columnName = "")
{
var data = base.GetData(rowJObject, columnName);
if (data == null || string.IsNullOrEmpty(data.ToString()))
{
return(true);
}
string regexString = RuleData.ToString();// ObjectUtils.GetJobjectPropertyValue(RuleData, "value");
if (string.IsNullOrEmpty(regexString))
{
return(true);
}
try
{
Regex regex = new Regex(regexString);
var isMatch = regex.IsMatch(data.ToString());
if (!isMatch)
{
base.MarkError(rowJObject, string.Format(ErrorMessage, columnName));
}
return(isMatch);
}
catch (Exception ex)
{
//TODO: log the exception
return(false);
}
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("change counter", RuleGUI.ruleLabelStyle);
CounterName = RuleGUI.ShowParameter(CounterName);
ChangeParameter("CounterName", (ruleData as ReactionData).parameters, CounterName);
counter = Counter.Get(CounterName);
GUILayout.Label("by", RuleGUI.ruleLabelStyle);
ChangeBy = RuleGUI.ShowParameter(ChangeBy);
ChangeParameter("ChangeBy", (ruleData as ReactionData).parameters, ChangeBy);
KindOfChange = (Change)kindOfChangeDropDown.Draw();
ChangeParameter("KindOfChange", ruleData.parameters, KindOfChange);
if (KindOfChange == Change.OVER_TIME)
{
GUILayout.Label("every", RuleGUI.ruleLabelStyle);
PerSeconds = RuleGUI.ShowParameter(PerSeconds);
ChangeParameter("PerSeconds", (ruleData as ReactionData).parameters, PerSeconds);
GUILayout.Label("second(s).", RuleGUI.ruleLabelStyle);
}
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var propertyToCompare = ruleData.XmlAttributes["propertyToCompare"];
var compareOperator = (CompareOperator)Enum.Parse(typeof(CompareOperator), ruleData.XmlAttributes["compareOperator"], true);
return new ComparePropertyRule(propertyToCompare, compareOperator);
}
public override bool Apply(RuleData data)
{
foreach (var a in Actions)
{
a.Apply(data);
}
return(true);
}
public override bool Execute(JObject rowJObject, string columnName = "")
{
var data = base.GetData(rowJObject, columnName);
var list = RuleData.ToString().Split(",");
return(data == null || string.IsNullOrEmpty(data.ToString()) ||
data.ToString().Trim().Length == 0 || list.Contains(data.ToString()));
}
private void ExecuteCSharpRule(RuleData rule, INeonIoTEntity entity)
{
var func = (Func <INeonIoTEntity, bool>)rule.RuleCondition;
if (func.Invoke(entity))
{
rule.Action.Invoke(entity);
}
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("print", RuleGUI.ruleLabelStyle);
logText = RuleGUI.ShowParameter(logText);
ChangeParameter("logText", (ruleData as ReactionData).parameters, logText);
GUILayout.Label("to the console", RuleGUI.ruleLabelStyle);
}
public static RuleData ToRules(List<Token> input)
{
var output = new RuleData();
var currentTerm = new Term();
output.Terms.Add(currentTerm);
currentTerm.Id = output.Terms.Count;
while (input.Count > 0)
{
var currentAtom = new Atom();
currentTerm.Atoms.Add(currentAtom);
//negativeness
if (input[0].Type == TokenType.Negate)
{
currentAtom.Truthfulness = false;
TokenPop(input);
}
//name
var nameToken = TokenPop(input);
Expect(nameToken, TokenType.String);
currentAtom.Name = nameToken.Name;
//arguments
Expect(TokenPop(input), TokenType.ParenBegin);
GetArguments(input, currentAtom.Arguments);
var orOrPeriodOrQuestionMark = TokenPop(input);
switch (orOrPeriodOrQuestionMark.Type)
{
case TokenType.Or:
continue;
case TokenType.Period:
if (input.Count > 0)
{
currentTerm = new Term();
output.Terms.Add(currentTerm);
currentTerm.Id = output.Terms.Count;
}
continue;
case TokenType.QuestionMark:
output.Terms.Remove(currentTerm);
output.Goal = currentTerm.Atoms[0];
if (input.Count > 0)
{
currentTerm = new Term();
output.Terms.Add(currentTerm);
currentTerm.Id = output.Terms.Count;
}
continue;
}
throw new Exception("Not the right input: " + orOrPeriodOrQuestionMark.Name);
}
return output;
}
public override bool Eval(ref TokenStack <T> tokenStack, ref RuleData data)
{
bool isMatch = base.Eval(ref tokenStack, ref data);
if (isMatch)
{
tokenStack.Prev();
}
return(isMatch);
}
private int GetRuleData()
{
int ruleData = 0;
if (RuleData != null && Int32.TryParse(RuleData.ToString(), out ruleData))
{
return(ruleData);
}
return(ruleData);
}
public override bool Apply(RuleData data)
{
base.Apply(data);
dotsLeft--;
if (dotsLeft <= 0)
{
data.DidWin = true;
}
return(true);
}
public void ApplyTrigger(Character player, GameObject collider)
{
var data = new RuleData()
{
Character = player,
Collider = collider
};
RootRule.Apply(data);
}
private static bool EvalRules(ref TokenStack <T> stack, ref RuleData data, List <Rule <T> > rules)
{
foreach (Rule <T> rule in rules)
{
if (!rule.Eval(ref stack, ref data))
{
return(false);
}
}
return(true);
}
public override void ShowGui(RuleData ruleData)
{
base.ShowGui(ruleData);
GUILayout.Label("When ", RuleGUI.ruleLabelStyle);
TrackedButton = (MouseButton)trackedButtonDropDown.Draw();
ChangeParameter("TrackedButton", (ruleData as EventData).parameters, TrackedButton);
GUILayout.Label("mouse button was clicked", RuleGUI.ruleLabelStyle);
}
public override bool Apply(RuleData data)
{
loadingScene = true;
currentPlayer = gameManager.CurrentCharacter;
currentPlayer.transform.SetParent(null, true);
DestroyObject(World);
Instantiate(LoadingScreen);
currentScene = SceneManager.GetActiveScene();
op = SceneManager.LoadSceneAsync(SceneName, LoadSceneMode.Additive);
return(true);
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var equalsMinimumIsValid = RuleData.TryGetValue(ruleData.XmlAttributes, "equalsMinimumIsValid", true);
var equalsMaximumIsValid = RuleData.TryGetValue(ruleData.XmlAttributes, "equalsMaximumIsValid", true);
return new RangeStringRule(ruleData.XmlAttributes["minimum"], ruleData.XmlAttributes["maximum"])
{
EqualsMaximumIsValid = equalsMaximumIsValid,
EqualsMinimumIsValid = equalsMinimumIsValid
};
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var minimum = RuleData.TryGetValue(ruleData.XmlAttributes, "minimum", 0);
var maximum = int.Parse(ruleData.XmlAttributes["maximum"]);
var trimWhiteSpace = RuleData.TryGetValue(ruleData.XmlAttributes, "trimWhiteSpace", true);
return new LengthStringRule(minimum, maximum)
{
TrimWhiteSpace = trimWhiteSpace
};
}
/// <summary>
/// Evaluates the provided <paramref name="tokenStack"/> and returns true if the next token in the stack matches any of the <see cref="TokenTypes"/> and the token value matches the optional <see cref="Pattern"/>.
/// <br/>Note: Increments the provided <paramref name="tokenStack"/>. See <see cref="TokenStack{T}.Next"/>
/// </summary>
public virtual bool Eval(ref TokenStack <T> tokenStack, ref RuleData data)
{
Token <T> token = tokenStack.Next();
// TEMP
// new ColorConsole().WriteLine($" - Checking {GetType().Name.Replace("`1", string.Empty)}: '{Pattern}' (&-a;{string.Join(", ", TokenTypes)}&-^;) => '&-e;{token.Value}&-^;' (&-a;{token.TokenType}&-^;)");
bool isMatch = IsTokenTypeMatch(token) && IsPatternMatch(token);
UpdateData(ref data, token, isMatch);
return(isMatch);
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var errorMessage = ruleData.ErrorMessage;
XmlReader initialValueXmlReader = null;
if (!string.IsNullOrEmpty(ruleData.InnerXml))
{
initialValueXmlReader = XmlReader.Create(new StringReader(ruleData.InnerXml),null,(XmlParserContext)null);
}
return RequiredObjectRuleCreator.ReadConfig(errorMessage, ruleData.UseErrorMessageProvider, initialValueXmlReader, runtimeType);
}
/// <summary>`source` size must be dividable by `N`</summary>
public static Model create(ref Map source, int N, Vec2i outputSize)
{
if (outputSize.x % N != 0 || outputSize.y % N != 0)
{
throw new System.Exception($"output size {outputSize} must be dividable with N={N}");
}
var gridSize = outputSize / N;
var patterns = RuleData.extractEveryChunk(ref source, N, PatternUtil.variations);
var rule = AdjacencyModel.buildRule(patterns, ref source);
return(new Model(gridSize, patterns, rule));
}
/// <summary>
/// Helper method to copy data from a <see cref="RuleData"/>
/// to a <see cref="RuleInfo"/> instance.
/// </summary>
/// <param name="info">The full data instance.</param>
/// <param name="data">The data instance.</param>
public static void CopyFrom(this RuleInfo info, RuleData data)
{
info.Created = data?.Created;
info.Deleted = data?.Deleted;
info.Description = data?.Description;
info.Disabled = data?.Disabled;
info.Invalid = data?.Invalid;
info.Modified = data?.Modified;
info.Name = data?.Name;
info.Order = data?.Order;
info.Tags = data?.Tags;
info.Type = data?.Type;
}
private void AddRuleExecution(RuleData data)
{
var ruleData = RulesExecutionInfo.FirstOrDefault(r => r.RuleName == data.RuleName);
if (ruleData == null)
{
ruleData = new RuleInfo();
}
ruleData.RuleName = data.RuleName;
ruleData.LastExecutionDateTime = DateTime.MinValue;
ruleData.RuleExecutionCount = 0;
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var enumTypeName = ruleData.XmlAttributes["enumTypeName"];
var enumType = Type.GetType(enumTypeName);
var ignoreCase = RuleData.TryGetValue(ruleData.XmlAttributes, "ignoreCase", false);
return new EnumConversionRule(enumType)
{
IgnoreCase = ignoreCase
};
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("show the message:\"", RuleGUI.ruleLabelStyle);
Message = RuleGUI.ShowParameter(Message);
ChangeParameter("Message", ruleData.parameters, Message);
GUILayout.Label("\" for", RuleGUI.ruleLabelStyle);
Time = RuleGUI.ShowParameter(Time);
ChangeParameter("Time", ruleData.parameters, Time);
GUILayout.Label("seconds on the screen.", RuleGUI.ruleLabelStyle);
}
public override void ShowGui(RuleData ruleData)
{
base.ShowGui(ruleData);
GUILayout.Label("On Keypress", RuleGUI.ruleLabelStyle);
int resultIndex = keyDropDown.Draw();
if (resultIndex > -1)
{
InputKey = (KeyCode)System.Enum.Parse(typeof(KeyCode), dropdownNames[resultIndex]);
ChangeParameter("InputKey", (ruleData as EventData).parameters, (int)InputKey);
}
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("When", RuleGUI.ruleLabelStyle);
int resultIndex = actorDropDown.Draw();
if (resultIndex > -1)
{
int resultId = generator.Gui.GetActorDataByLabel(actorDropDown.Content[resultIndex].text).id;
(ruleData as EventData).actorId = resultId;
if (Actor.Id != resultId)
generator.ChangeActor(this, resultId);
}
GUILayout.Label("moves,", RuleGUI.ruleLabelStyle);
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("respawn", RuleGUI.ruleLabelStyle);
int index = actorDropdown.Draw();
if (index > -1)
{
RuleGenerator generator = FindObjectOfType<RuleGenerator>();
int resultId = generator.Gui.GetActorDataByLabel(actorDropdown.Content[index].text).id;
TargetObject = generator.GetActor(resultId);
if (resultId != Reactor.Id)
generator.ChangeActor(this, resultId);
ChangeParameter("TargetObject", ruleData.parameters, TargetObject.Id);
}
}
public void ConvertNullObjectRuleDataNullFieldAndValue()
{
var ruleData = new RuleData
{
Field = null,
Value = null,
RuleOperator = "",
ValidationMessage = "Name should be equal to Faenor."
};
var engine = new RuleEngine();
var translatedRule = engine.Convert(ruleData);
Assert.AreEqual(RuleOperator.None, translatedRule.Operator);
Assert.AreEqual("Name should be equal to Faenor.", translatedRule.ValidationMessage);
}
private static void UpdateParent(RuleData ruleData, AnswerData answerData, List <AnswerItem> answerList)
{
var answerItem = answerList.Single(x => x.Id == answerData.AnswerItemId);
if (answerData.ResultId == (int)TypeOfResult.Ok || answerData.ResultId == (int)TypeOfResult.Fail)
{
if (answerItem.LinkedParentFailedId != Guid.Empty)
{
var item = ruleData.AnswerDataList.Single(x => x.AnswerItemId == answerItem.LinkedParentFailedId);
item.ResultId = answerData.ResultId;
UpdateParent(ruleData, item, answerList);
}
}
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var regexOptions = RegexOptions.None;
string regexOptionsString;
if (ruleData.XmlAttributes.TryGetValue("regexOptions", out regexOptionsString))
{
regexOptions = (RegexOptions) Enum.Parse(typeof (RegexOptions), regexOptionsString, true);
}
return new RegexRule(ruleData.XmlAttributes["validationExpression"])
{
RegexOptions = regexOptions
};
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type genericType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var genericCompareStructRuleType = typeof (CompareRule<>);
//var genericType = Type.GetTypeFromHandle(runtimeTypeHandle);
if (genericType.IsGenericType && (genericType.GetGenericTypeDefinition().Equals(TypePointers.NullableType)))
{
genericType = genericType.GetGenericArguments()[0];
}
Type[] typeArgs = {genericType};
var constructedCompareStructRuleType = genericCompareStructRuleType.MakeGenericType(typeArgs);
var valueToCompare = TypeConverterEx.ChangeType(ruleData.XmlAttributes["valueToCompare"], genericType);
var compareOperator = (CompareOperator)Enum.Parse(typeof(CompareOperator), ruleData.XmlAttributes["compareOperator"], true);
var constructorInfo = constructedCompareStructRuleType.GetPublicInstanceConstructor(genericType, typeof(CompareOperator));
return (Rule) constructorInfo.Invoke(new[]{valueToCompare, compareOperator});
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var validationTypeName = ruleData.XmlAttributes["validationTypeName"];
var validationMethod = ruleData.XmlAttributes["validationMethod"];
var ruleInterpretation = ruleData.XmlAttributes["ruleInterpretation"];
Type validationType;
try
{
validationType = Type.GetType(validationTypeName, true);
}
catch (Exception exception)
{
throw new InvalidOperationException(string.Format("CustomRule could not load the validation type '{0}'.", validationTypeName), exception);
}
return new CustomRule(validationType, validationMethod, ruleInterpretation);
}
/// <summary>
/// Create a <see cref="Rule"/> from a <see cref="RuleData"/>.
/// </summary>
/// <param name="ruleData">The <see cref="RuleData"/> that represent the xml to create the <see cref="Rule"/> for.</param>
/// <param name="runtimeType">The <see cref="System.Type"/> for the <see cref="Type"/> to create the <see cref="Rule"/> for.</param>
/// <returns>A <see cref="Rule"/> that <paramref name="ruleData"/> represented</returns>
/// <exception cref="ArgumentNullException"><paramref name="ruleData"/> is null.</exception>
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var trimWhiteSpace = true;
bool? ignoreCase = null;
string initialValue = null;
if (ruleData.XmlAttributes != null)
{
trimWhiteSpace = RuleData.TryGetValue(ruleData.XmlAttributes, "trimWhiteSpace", true);
string ignoreCaseString;
if (ruleData.XmlAttributes.TryGetValue("ignoreCase", out ignoreCaseString))
{
ignoreCase = bool.Parse(ignoreCaseString);
}
ruleData.XmlAttributes.TryGetValue("initialValue", out initialValue);
}
if (initialValue == null)
{
if (ignoreCase != null)
{
throw new InvalidOperationException("ignoreCase cannot be set if there is no initialValue.");
}
return new RequiredStringRule
{
TrimWhiteSpace = trimWhiteSpace
};
}
else
{
if (ignoreCase == null)
{
ignoreCase = true;
}
return new RequiredStringRule
{
InitialValue = initialValue,
IgnoreCase = ignoreCase.Value,
TrimWhiteSpace = trimWhiteSpace
};
}
}
/// <summary>
/// Create a <see cref="Rule"/> from a <see cref="RuleData"/>.
/// </summary>
/// <param name="ruleData">The <see cref="RuleData"/> that represent the xml to create the <see cref="Rule"/> for.</param>
/// <param name="runtimeType">The <see cref="System.Type"/> for the <see cref="Type"/> to create the <see cref="Rule"/> for.</param>
/// <returns>A <see cref="Rule"/> that <paramref name="ruleData"/> represented</returns>
/// <exception cref="ArgumentNullException"><paramref name="ruleData"/> is null.</exception>
/// <exception cref="InvalidOperationException">Both equalityComparerTypeName and equalityComparerPropertyName have to be null or not null.</exception>
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var minimum = RuleData.TryGetValue(ruleData.XmlAttributes, "minimum", 0);
var maximum = int.Parse(ruleData.XmlAttributes["maximum"]);
var excludeDuplicatesFromCount = RuleData.TryGetValue(ruleData.XmlAttributes, "excludeDuplicatesFromCount", true);
string equalityComparerTypeName;
ruleData.XmlAttributes.TryGetValue("equalityComparerTypeName", out equalityComparerTypeName);
string equalityComparerPropertyName;
ruleData.XmlAttributes.TryGetValue("equalityComparerPropertyName", out equalityComparerPropertyName);
var equalityComparer = (IEqualityComparer) TypeExtensions.GetStaticProperty(equalityComparerTypeName, equalityComparerPropertyName);
return new LengthCollectionRule(minimum, maximum)
{
ExcludeDuplicatesFromCount = excludeDuplicatesFromCount,
Comparer = equalityComparer
};
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("When counter", RuleGUI.ruleLabelStyle);
CounterName = RuleGUI.ShowParameter(CounterName);
ChangeParameter("CounterName", (ruleData as EventData).parameters, CounterName);
counter = Counter.Get(CounterName);
GUILayout.Label("becomes", RuleGUI.ruleLabelStyle);
int resultIndex = comparisonDropDown.Draw();
if (resultIndex > -1)
{
Compare = (Comparison)resultIndex;
ChangeParameter("Compare", (ruleData as EventData).parameters, Compare);
}
CounterLimit = RuleGUI.ShowParameter(CounterLimit);
ChangeParameter("CounterLimit", (ruleData as EventData).parameters, CounterLimit);
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
if (ruleData.XmlAttributes == null)
{
return new EnumerableDuplicateRule();
}
else
{
string equalityComparerTypeName;
ruleData.XmlAttributes.TryGetValue("equalityComparerTypeName", out equalityComparerTypeName);
string equalityComparerPropertyName;
ruleData.XmlAttributes.TryGetValue("equalityComparerPropertyName", out equalityComparerPropertyName);
var equalityComparer = (IEqualityComparer)TypeExtensions.GetStaticProperty(equalityComparerTypeName, equalityComparerPropertyName);
return new EnumerableDuplicateRule
{
Comparer = equalityComparer
};
}
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
string initialValue = null;
if (ruleData.XmlAttributes != null)
{
string initialValueString;
if (ruleData.XmlAttributes.TryGetValue("initialValue", out initialValueString))
{
initialValue = initialValueString;
}
}
if (initialValue == null)
{
return RequiredEnumRuleCreator.ReadConfig(ruleData.ErrorMessage, ruleData.UseErrorMessageProvider, runtimeType);
}
else
{
return RequiredEnumRuleCreator.ReadConfig(initialValue, ruleData.ErrorMessage, ruleData.UseErrorMessageProvider, runtimeType);
}
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("Rotate", RuleGUI.ruleLabelStyle);
int resultIndex = actorDropDown.Draw();
if (resultIndex > -1)
{
int resultId = generator.ActorData.Find(item => item.label == actorDropDown.Content[resultIndex].text).id;
if (resultId != Reactor.Id)
generator.ChangeActor(this, resultId);
(ruleData as ReactionData).actorId = resultId;
}
GUILayout.Label("with mouse. Use a sensitivity of", RuleGUI.ruleLabelStyle);
Sensitivity = RuleGUI.ShowParameter(Sensitivity);
ChangeParameter("Sensitivity", (ruleData as ReactionData).parameters, Sensitivity);
GUILayout.Label("and a maximum up/down rotation of", RuleGUI.ruleLabelStyle);
MaxYRotation = RuleGUI.ShowParameter(MaxYRotation);
ChangeParameter("MaxYRotation", (ruleData as ReactionData).parameters, MaxYRotation);
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var dateTimeStyles = DateTimeStyles.None;
string dateTimeStylesString;
if (ruleData.XmlAttributes.TryGetValue("dateTimeStyles", out dateTimeStylesString))
{
dateTimeStyles = (DateTimeStyles)Enum.Parse(typeof(DateTimeStyles), dateTimeStylesString, true);
}
string format;
ruleData.XmlAttributes.TryGetValue("format", out format);
string dateTimeFormatInfoTypeName;
ruleData.XmlAttributes.TryGetValue("dateTimeFormatInfoTypeName", out dateTimeFormatInfoTypeName);
string dateTimeFormatInfoPropertyName;
ruleData.XmlAttributes.TryGetValue("dateTimeFormatInfoPropertyName", out dateTimeFormatInfoPropertyName);
var dateTimeFormatInfo = (DateTimeFormatInfo) TypeExtensions.GetStaticProperty(dateTimeFormatInfoTypeName, dateTimeFormatInfoPropertyName);
return new DateTimeConversionRule(format, dateTimeFormatInfo, dateTimeStyles);
}
/// <inheritdoc />
public override Rule CreateInstance(RuleData ruleData, Type runtimeType)
{
Guard.ArgumentNotNull(ruleData, "ruleData");
var useMemberErrorMessages = false;
if (ruleData.XmlAttributes != null)
{
useMemberErrorMessages = RuleData.TryGetValue(ruleData.XmlAttributes, "useMemberErrorMessages", false);
}
//TODO: refactor with ValidatableRuleAttribute
var instance = new ValidatableRule();
if (useMemberErrorMessages)
{
if (ruleData.ErrorMessage == null)
{
instance.UseMemberErrorMessages = true;
}
else
{
throw new InvalidOperationException("Cannot use 'useMemberErrorMessages'");
}
}
return instance;
}
public override void ShowGui(RuleData ruleData)
{
base.ShowGui(ruleData);
RuleGUI.VerticalLine();
// column 3
GUILayout.BeginVertical();
// parameters
GUILayout.BeginHorizontal();
GUILayout.Label("Horizontal Max Speed", RuleGUI.ruleLabelStyle);
HorizontalMaxSpeed = RuleGUI.ShowParameter(HorizontalMaxSpeed);
ChangeParameter("HorizontalMaxSpeed", ruleData.parameters, HorizontalMaxSpeed);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Vertical Max Speed", RuleGUI.ruleLabelStyle);
VerticalMaxSpeed = RuleGUI.ShowParameter(VerticalMaxSpeed);
ChangeParameter("VerticalMaxSpeed", ruleData.parameters, VerticalMaxSpeed);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Gravity", RuleGUI.ruleLabelStyle);
Gravity = RuleGUI.ShowParameter(Gravity);
ChangeParameter("Gravity", ruleData.parameters, Gravity);
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.FlexibleSpace();
}
internal static Rule GetRule(RuleData ruleData, Type runtimeType)
{
Type ruleConfigReaderType;
var typeName = ruleData.TypeName;
var containsCommas = ruleData.TypeName.Contains(",");
if (containsCommas)
{
Type type;
try
{
type = Type.GetType(typeName, true);
}
catch(Exception e)
{
throw new ArgumentException(string.Format("Could not load IRuleConfigReader type. Tried '{0}'.", typeName), e);
}
//is it a IRuleConfigReader
if (TypePointers.IRuleConfigReaderType.IsAssignableFrom(type))
{
ruleConfigReaderType = type;
}
else //not a IRuleConfigReader so assume it is a Rule and try to derive.
{
var assemblyName = type.Assembly.FullName;
var namespaceName = type.Namespace;
//Assumes ConfigReader is of the form {RuleName}ConfigReader in the same assembly and namespace
var configReaderTypeName = string.Format("{0}.{1}ConfigReader,{2}", namespaceName, type.Name, assemblyName);
try
{
ruleConfigReaderType = Type.GetType(configReaderTypeName, true);
}
catch (Exception e)
{
throw new ArgumentException(string.Format("Could not load IRuleConfigReader type. Tried '{0}'.", configReaderTypeName), e);
}
}
}
else
{
string internalTypeName;
if (typeName.Contains("ConfigReader"))
{
internalTypeName = string.Format("ValidationFramework.Configuration.{0},ValidationFramework", typeName);
}
else
{
internalTypeName = string.Format("ValidationFramework.Configuration.{0}ConfigReader,ValidationFramework", typeName);
}
try
{
ruleConfigReaderType = Type.GetType(internalTypeName, true);
}
catch (Exception e)
{
throw new ArgumentException(string.Format("Could not load IRuleConfigReader type. Tried '{0}'.", internalTypeName), e);
}
}
var ruleConfigReader = (IRuleConfigReader)Activator.CreateInstance(ruleConfigReaderType);
return ruleConfigReader.ReadConfig(ruleData, runtimeType);
}
