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