private void ParseMemberScope(MemberScope memberScope, MethodDefinition methodDefinition, List <Triple> triples) { if (memberScope.HasNestedScope) { ParseObjectInitializerScope(memberScope.NestedScope, methodDefinition, triples); } foreach (var instruction in memberScope.Instructions) { ValidateInstruction(instruction); if (IsToTrigger(instruction)) { try { if (instruction.Next != null && instruction.Next.OpCode.Code == Mono.Cecil.Cil.Code.Nop && instruction.Next.Next == null) { ParseInstruction(instruction, methodDefinition, triples, memberScope.Parent.ConstructorInstructionKey); } else { ParseInstruction(instruction, methodDefinition, triples); } } catch (ILParseException ex) { _logOutput.LogAnalysis("ERROR " + ex.Message); } } } }
public void Should_PassValue() { var model = new MemberClass { Inner = new InnerClass() }; var executed = 0; Predicate <InnerClass> isValid = c => { Assert.Same(c, model.Inner); executed++; return(true); }; Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m .Valid(isValid) ); memberScope.TryGetErrors(model, new ExecutionContextStub(), ValidationStrategy.Complete, 0, out _); Assert.Equal(1, executed); }
public void Should_InsertErrors() { Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m .Valid(c => false).WithMessage("error1") ); var target = new ErrorsCollection(); var scopeErrors = new ErrorsCollection(); scopeErrors.AddError(new Error("error1")); memberScope.InsertErrors(target, scopeErrors); Assert.Empty(target.Errors); Assert.Equal(1, target.Members.Count); Assert.Equal("error1", target.Members["Inner"].Errors.Single().Message); Assert.Empty(target.Members["Inner"].Members); }
public void Should_PassStrategy(ValidationStrategy validationStrategy) { var model = new MemberClass { Inner = new InnerClass() }; var executed = new int[3]; Predicate <InnerClass> isValid1 = c => { Assert.Same(c, model.Inner); executed[0]++; return(false); }; Predicate <InnerClass> isValid2 = c => { Assert.Same(c, model.Inner); executed[1]++; return(false); }; Predicate <InnerClass> isValid3 = c => { Assert.Same(c, model.Inner); executed[2]++; return(false); }; Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m .Valid(isValid1) .Valid(isValid2) .Valid(isValid3) ); memberScope.TryGetErrors(model, new ExecutionContextStub(), validationStrategy, 0, out _); if (validationStrategy == ValidationStrategy.Complete) { Assert.True(executed.All(i => i == 1)); } else if (validationStrategy == ValidationStrategy.FailFast) { Assert.Equal(1, executed.ElementAt(0)); Assert.Equal(0, executed.ElementAt(1)); Assert.Equal(0, executed.ElementAt(2)); } else if (validationStrategy == ValidationStrategy.Force) { Assert.True(executed.All(i => i == 0)); } }
/// <summary> /// Creates an instance of the <see cref="MemberDescriptor"/> class. /// </summary> /// <param name="memberAccessibility"> /// Defines the accessibility of the member (Public, NonPublic, or Any) /// </param> /// <param name="memberScope"> /// Defines the declaration scope of the member (Static, Instance, or Any) /// </param> /// <param name="caseInsensitive"> /// Specifies whether the member identifier should be matched without case sensitivity. /// The default value for this parameter is <c>false</c> /// </param> private MemberDescriptor( MemberAccessibility memberAccessibility, MemberScope memberScope = MemberScope.Instance, bool caseInsensitive = false) { MemberAccessibility = memberAccessibility; MemberScope = memberScope; CaseInsensitive = caseInsensitive; }
public void Should_Name_MatchCommandInBuilder() { Expression <Func <MemberClass, string> > selector = m => m.Member; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var modelScope = new MemberScope <MemberClass, string>(propertyInfo, m => m); Assert.Equal("Member", modelScope.Name); }
public void Should_ThrowException_When_NullExecutionContext() { Expression <Func <MemberClass, string> > selector = m => m.Member; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var modelScope = new MemberScope <MemberClass, string>(propertyInfo, m => m); Assert.Throws <ArgumentNullException>(() => { modelScope.TryGetErrors(new MemberClass(), null, ValidationStrategy.Complete, 0, out _); }); }
public void Should_RuleSingleError_BeNullAfterInit() { Expression <Func <MemberClass, string> > selector = m => m.Member; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var modelScope = new MemberScope <MemberClass, string>(propertyInfo, m => m); Assert.Null(modelScope.RuleSingleError); }
public void Should_PropetyInfo_BeSet() { Expression <Func <MemberClass, string> > selector = m => m.Member; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var modelScope = new MemberScope <MemberClass, string>(propertyInfo, m => m); Assert.Same(propertyInfo, modelScope.MemberPropertyInfo); }
public void Should_ThrowException_When_NullTargetCollection() { Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m .Valid(c => false) ); Assert.Throws <ArgumentNullException>(() => { memberScope.InsertErrors(null, new ErrorsCollection()); }); }
public ISpecificationBuilder <TModel> Member <TMember>(Expression <Func <TModel, TMember> > memberSelector, MemberSpecification <TModel, TMember> memberSpecification = null) { if (memberSelector == null) { throw new ArgumentNullException(nameof(memberSelector)); } var memberScope = new MemberScope <TModel, TMember>(GetPropertyInfo(memberSelector), memberSpecification); AddCommand(memberScope); return(this); }
public void Should_AddScope_MultipleRules() { var validator = new Validator <object>(); Expression <Func <MemberClass, string> > selector = m => m.Member; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var scope1 = new ModelScope <object>(c => true); var scope2 = new MemberScope <object, object>(propertyInfo, m => m); validator.AddScope(scope1); validator.AddScope(scope2); Assert.Equal(2, validator.Scopes.Count); Assert.Same(scope1, validator.Scopes.ElementAt(0)); Assert.Same(scope2, validator.Scopes.ElementAt(1)); }
/// <summary> /// /// </summary> /// <param name="value"></param> /// <returns></returns> internal static string Format(this MemberScope value) { switch (value) { case MemberScope.Public: return("public"); case MemberScope.Internal: return("internal"); case MemberScope.ProtectedInternal: return("protected internal"); case MemberScope.Protected: return("protected"); case MemberScope.Private: return("private"); default: return(""); } }
public void Should_MemberValidator_BeSet() { Expression <Func <MemberClass, string> > selector = m => m.Member; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; Predicate <string> isValid = c => true; var modelScope = new MemberScope <MemberClass, string>(propertyInfo, m => m .Valid(isValid) ); Assert.NotNull(modelScope.MemberValidator); Assert.IsType <ValidRule <string> >(modelScope.MemberValidator.Rules.Single()); var validRule = (ValidRule <string>)modelScope.MemberValidator.Rules.Single(); Assert.Same(isValid, validRule.IsValid); }
public void Should_ReturnNoErrors_IfValid() { var model = new MemberClass { Inner = new InnerClass() }; Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m .Valid(c => true) ); var errors = memberScope.TryGetErrors(model, new ExecutionContextStub(), ValidationStrategy.Complete, 0, out var errorsCollection); Assert.False(errors); Assert.True(errorsCollection.IsEmpty); }
public void Should_ReturnRuleSingleError_IfValid() { var model = new MemberClass { Inner = new InnerClass() }; Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner; var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member; var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m .Valid(c => false) ); memberScope.RuleSingleError = new Error("single error"); var errors = memberScope.TryGetErrors(model, new ExecutionContextStub(), ValidationStrategy.Complete, 0, out var errorsCollection); Assert.True(errors); Assert.Single(errorsCollection.Errors); Assert.Equal("single error", errorsCollection.Errors.Single().Message); }
/// <summary> /// Foramt it to a declaretion statement. /// </summary> /// <param name="method"></param> /// <returns></returns> public static string FormatToDeclaretion(this MethodInfo method) { var genericArgs = method.IsGenericMethod ? method.GetGenericArguments() : Type.EmptyTypes; var sb = ZString.CreateStringBuilder(); // modifier & scope MemberScope scope = method.GetScope(); if (!method.DeclaringType.IsInterface) { sb.Append(scope.Format()); if (method.IsStatic) { sb.Append(" static"); } else if (method.IsAbstract) { sb.Append(" abstract"); } else if (method.IsVirtual) { sb.Append(" virtual"); } sb.Append(" "); } // return value sb.Append(method.ReturnType.FormatToReadableTypeName(false)); // name sb.Append(" "); sb.Append(method.Name); // generic arguments if (genericArgs.Length > 0) { sb.Append("<"); for (int i = 0; i < genericArgs.Length; ++i) { if (i > 0) { sb.Append(", "); } sb.Append(genericArgs[i].FormatToReadableTypeName(false)); } sb.Append(">"); } // arguments var parameters = method.GetParameters(); if (parameters.Length > 0) { sb.AppendLine(); sb.Append("("); for (int i = 0; i < parameters.Length; ++i) { sb.AppendLine(); sb.Append("\t"); if (i > 0) { sb.Append(", "); } if (i == 0 && method.IsExtensionMethod()) { sb.Append("this "); } if (parameters[i].IsIn) { sb.Append("in "); } if (parameters[i].IsOut) { sb.Append("out "); } sb.Append(parameters[i].ParameterType.FormatToReadableTypeName(false)); sb.Append(" "); sb.Append(parameters[i].Name); if (parameters[i].IsOptional) { if (parameters[i].DefaultValue == null) { sb.Append(" = null"); } else if (parameters[i].ParameterType == typeof(string)) { sb.AppendFormat(@" = ""{0}""", parameters[i].DefaultValue); } else if (parameters[i].ParameterType == typeof(char)) { sb.AppendFormat(" = '{0}'", parameters[i].DefaultValue); } else { sb.AppendFormat(" = {0}", parameters[i].DefaultValue); } } } sb.AppendLine(); sb.Append(")"); } else { sb.Append("()"); } // generic constraint foreach (var genericArg in genericArgs) { bool foundConstraint = false; foreach (var constraint in ClassDocUtility.EnumerateGenericConstraints(genericArg)) { if (foundConstraint) { sb.Append(", "); } else { sb.AppendLine(); sb.AppendFormat("where {0} : ", genericArg.Name); foundConstraint = true; } sb.Append(constraint); } } return(sb.ToString()); }
/// <summary> /// Foramt it to a declaretion statement. /// </summary> /// <param name="property"></param> /// <returns></returns> public static string FormatToDeclaretion(this PropertyInfo property) { MethodInfo?getter = property.GetGetMethod(true); MethodInfo?setter = property.GetSetMethod(true); if (getter == null && setter == null) { return(""); } MethodInfo method = getter ?? setter; MemberScope getterScope = getter?.GetScope() ?? MemberScope.None; MemberScope setterScope = setter?.GetScope() ?? MemberScope.None; MemberScope wideScope = getterScope > setterScope ? getterScope : setterScope; var sb = ZString.CreateStringBuilder(); if (!property.DeclaringType.IsInterface) { sb.Append(wideScope.Format()); if (method.IsStatic) { sb.Append(" static"); } else if (method.IsAbstract) { sb.Append(" abstract"); } else if (method.IsVirtual) { sb.Append(" virtual"); } sb.Append(" "); } sb.Append(property.PropertyType.FormatToReadableTypeName(false)); sb.Append(" "); sb.Append(property.Name); var parameters = property.GetIndexParameters(); if (parameters.Length > 0) { sb.Append("["); for (int i = 0; i < parameters.Length; ++i) { if (i > 0) { sb.Append(", "); } sb.Append(parameters[i].ParameterType.FormatToReadableTypeName(false)); sb.Append(" "); sb.Append(parameters[i].Name); } sb.Append("]"); } sb.Append(" {"); if (getter != null) { sb.Append(" "); if (getterScope != wideScope) { sb.Append(getterScope.Format()); sb.Append(" "); } sb.Append("get;"); } if (setter != null) { sb.Append(" "); if (setterScope != wideScope) { sb.Append(setterScope.Format()); sb.Append(" "); } sb.Append("set;"); } sb.Append(" }"); return(sb.ToString()); }
public static ObjectInitializerScope BuildObjectInitializer(Instruction contructorInstruction, MethodDefinition parentMethod) { var objectInitializerScope = new ObjectInitializerScope(); objectInitializerScope.ParentMethod = parentMethod; objectInitializerScope.ConstructorInstruction = contructorInstruction; objectInitializerScope.ConstructorInstructionKey = InstructionKeyService.GetInstructionKey(contructorInstruction, parentMethod); objectInitializerScope.ConstructorOwnerKey = Guid.NewGuid().ToString(); var currentMemberScope = new MemberScope(); currentMemberScope.Parent = objectInitializerScope; objectInitializerScope.MemberScopes.Add(currentMemberScope); try { var instructionCursor = contructorInstruction.Next; while (instructionCursor != null && instructionCursor.Next != null) { if (instructionCursor.OpCode.Code == Mono.Cecil.Cil.Code.Nop && instructionCursor.Next.OpCode.Code == Mono.Cecil.Cil.Code.Dup) { currentMemberScope.Instructions.Add(instructionCursor); currentMemberScope = new MemberScope(); currentMemberScope.Parent = objectInitializerScope; objectInitializerScope.MemberScopes.Add(currentMemberScope); } else if (instructionCursor.OpCode.Code == Mono.Cecil.Cil.Code.Nop && instructionCursor.Next.OpCode.Code != Mono.Cecil.Cil.Code.Dup) { currentMemberScope.Instructions.Add(instructionCursor); break; } else if (IsNewObjectInitializerScope(instructionCursor)) { currentMemberScope.Instructions.Add(instructionCursor); currentMemberScope.NestedScope = BuildObjectInitializer(instructionCursor, parentMethod); var nestedScopeEndOffset = currentMemberScope.NestedScope.GetEndOffset(); instructionCursor = JumpToInstructionAfterOffset(parentMethod, nestedScopeEndOffset); if (instructionCursor == null) { break; } currentMemberScope.Instructions.Add(instructionCursor); } else { currentMemberScope.Instructions.Add(instructionCursor); } instructionCursor = instructionCursor.Next; } } catch (Exception ex) { } foreach (var memberScope in objectInitializerScope.MemberScopes) { ReorderInstructions(memberScope.Instructions); } return(objectInitializerScope); }
/// <summary> /// Foramt it to a declaretion statement. /// </summary> /// <param name="ctor"></param> /// <returns></returns> public static string FormatToDeclaretion(this ConstructorInfo ctor) { var sb = ZString.CreateStringBuilder(); MemberScope scope = ctor.GetScope(); sb.Append(scope.Format()); if (ctor.IsStatic) { sb.Append(" static"); } else if (ctor.IsAbstract) { sb.Append(" abstract"); } else if (ctor.IsVirtual) { sb.Append(" virtual"); } sb.Append(" "); var name = ctor.DeclaringType.Name; var delimiter = name.IndexOf('`'); if (delimiter > 0) { sb.Append(name.Substring(0, delimiter)); } else { sb.Append(name); } sb.Append("("); var parameters = ctor.GetParameters(); if (parameters.Length > 0) { for (int i = 0; i < parameters.Length; ++i) { sb.AppendLine(); sb.Append("\t"); if (i > 0) { sb.Append(", "); } sb.Append(parameters[i].ParameterType.FormatToReadableTypeName(false)); sb.Append(" "); sb.Append(parameters[i].Name); } sb.AppendLine(); } sb.Append(")"); return(sb.ToString()); }