public void AccessorMethodDependenciesByProperty(PropertyMember accessedProperty, MethodMember accessorMethod)
{
accessorMethod.MemberDependencies.ForEach(dependency =>
{
Assert.Contains(dependency, accessedProperty.MemberDependencies);
});
}
public ModelFieldMetadata(ModelObjectMetadata @object, PropertyMember field)
{
var outputAttribute = field.TryGetAttribute <Semantic.OutputAttribute>();
var labelAttribute = field.TryGetAttribute <I18n.LabelAttribute>();
var requiredAttribute = field.TryGetAttribute <Validation.RequiredAttribute>();
this.Object = @object;
this.Property = field;
this.Direction = (outputAttribute != null ? FieldDirection.Output : FieldDirection.Input);
this.Label = (labelAttribute != null
? labelAttribute.GetConstructorArgumentOrDefault <string>(defaultValue: field.Name)
: field.Name.ToString(CasingStyle.Pascal));
if (requiredAttribute != null)
{
this.IsRequired = true;
this.AllowEmpty = requiredAttribute.GetPropertyValueOrDefault <bool>(Validation.RequiredAttribute.AllowEmptyPropertyName);
var tempMaxLength = requiredAttribute.GetPropertyValueOrDefault <int>(
Validation.RequiredAttribute.MaxLengthPropertyName,
defaultValue: -1);
this.MaxLength = (tempMaxLength >= 0 ? (int?)tempMaxLength : null);
}
else
{
this.AllowEmpty = true;
}
}
private static void MakeObservableInitialization(PropertyMember item)
{
if (item.Initialization != null)
{
var type = item.MemberType;
item.MemberType = null;
var init = item.Initialization;
item.Initialization = new RawStatements();
item.Initialization.Add("ko.observable");
item.Initialization.Add("(");
item.Initialization.Statements.AddRange(init.Statements);
item.Initialization.Add(")");
}
else
{
var type = item.MemberType;
item.MemberType = null;
item.Initialization = new RawStatements();
if (type != null && type.ReferencedType != null && type.ReferencedType is ArrayType)
{
item.Initialization.Add("ko.observableArray<");
item.Initialization.Add(type.ExtractArrayElement());
item.Initialization.Add(">()");
}
else
{
item.Initialization.Add("ko.observable<");
item.Initialization.Add(type);
item.Initialization.Add(">()");
}
}
}
private void MakeObservableInterfaceProperty(PropertyMember property)
{
property.Initialization = null;
var type = property.MemberType;
if (type != null && type.ReferencedType != null)
{
if (type.ReferencedType is ArrayType)
{
property.MemberType = new TypescriptTypeReference("KnockoutObservableArray")
{
GenericParameters = { type.ExtractArrayElement() }
};
}
else
{
property.MemberType = new TypescriptTypeReference("KnockoutObservable")
{
GenericParameters = { type }
};
}
}
else
{
property.MemberType = new TypescriptTypeReference("KnockoutObservable<any>");
}
}
protected override IIntermediateGenericParameterPropertyMember <TGenericParameter, TIntermediateGenericParameter> OnGetProperty(TypedName nameAndType)
{
var result = new PropertyMember(nameAndType.Name, this.Parent);
result.PropertyType = nameAndType.TypeReference;
return(result);
}
public PropertyDependencyTests()
{
_dependOnClass = Architecture.GetClassOfType(typeof(PropertyDependOnClass));
_propertyTestDataClass = Architecture.GetClassOfType(typeof(PropertyTestDataClass));
_testStringProperty = _propertyTestDataClass.GetPropertyMembersWithName("TestStringProperty").ToList().First();
_testStringPropertyGetter =
_propertyTestDataClass.GetMethodMembersWithName("get_TestStringProperty()").First();
}
public RegexUtilsTest()
{
var propertyClass = Architecture.GetClassOfType(typeof(BackingFieldExamples));
_autoPropertyMember = propertyClass.GetPropertyMembersWithName("AutoProperty").Single();
_expectedGetMethodName = BuildExpectedGetMethodName(_autoPropertyMember);
_expectedGetMethodFullName = BuildExpectedGetMethodFullName(_autoPropertyMember);
_expectedSetMethodName = BuildExpectedSetMethodName(_autoPropertyMember, _autoPropertyMember.DeclaringType);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public PropertyWriter(
PropertyMember ownerProperty,
Func <PropertyWriter <T>, PropertyWriterBase.IPropertyWriterGetter> getterScript,
Func <PropertyWriter <T>, PropertyWriterBase.IPropertyWriterSetter> setterScript)
: base(ownerProperty)
{
m_GetterScript = getterScript;
m_SetterScript = setterScript;
}
public AbstractExpression DOT(PropertyMember property)
{
return(new MemberExpression()
{
Target = this,
Member = property,
Type = property.PropertyType
});
}
public GetterSetterMethodDependencyTests()
{
var getterExampleClass = _architecture.GetClassOfType(typeof(GetterMethodDependencyExamples));
getterExampleClass.RequiredNotNull();
_acceptedCaseProperty = getterExampleClass.GetPropertyMembersWithName("AcceptedCase").First();
_firstUnacceptedCaseProperty = getterExampleClass.GetPropertyMembersWithName("FirstUnacceptedCase").First();
_secondUnacceptedCaseProperty = getterExampleClass.GetPropertyMembersWithName("SecondUnacceptedCase")
.First();
}
private MethodCallDependency CreateStubMethodCallDependencyForProperty(IType calledType,
MethodReference methodReference,
PropertyMember backedProperty)
{
var calledMethodMember =
_typeFactory.CreateStubMethodMemberFromMethodReference(calledType, methodReference);
var dependency = new MethodCallDependency(backedProperty, calledMethodMember);
return(dependency);
}
private static string BuildExpectedSetMethodName(PropertyMember propertyMember,
params IType[] parameterTypes)
{
var builder = new StringBuilder();
builder.Append("set_");
builder.Append(propertyMember.Name);
builder = AddParameterTypesToMethodName(builder, parameterTypes);
return(builder.ToString());
}
private void MakeObservableProperty(PropertyMember property)
{
if (_interfaceMapping.Peek())
{
MakeObservableInterfaceProperty(property);
}
else
{
MakeObservableInitialization(property);
}
}
public void AssertGetterMethodDependencies(PropertyMember propertyMember, Class mockTargetClass,
MethodCallDependency expectedDependency)
{
Assert.NotEmpty(propertyMember.MemberDependencies);
Assert.Single(propertyMember.GetMethodCallDependencies());
Assert.Contains(mockTargetClass,
propertyMember.GetMethodCallDependencies().Select(dependency => dependency.Target));
Assert.Contains(expectedDependency.TargetMember.FullName,
propertyMember.GetMethodCallDependencies()
.Select(dependency => dependency.TargetMember.FullName));
}
public void AssertSetterMethodDependencies(PropertyMember backedProperty, Class expectedTarget)
{
if (backedProperty.Setter != null)
{
foreach (var dependency in backedProperty.Setter.Dependencies)
{
Assert.Contains(dependency, backedProperty.Dependencies);
}
}
Assert.Contains(expectedTarget, backedProperty.Dependencies.Select(t => t.Target));
}
public virtual DeclarationMember GenerateProperty(PropertyInfo pi)
{
var pm = new PropertyMember(NamingStrategy.GetPropertyName(pi))
{
ExtraData = { { SOURCEMEMBER_KEY, pi } },
IsOptional = Nullable.GetUnderlyingType(pi.PropertyType) != null,
MemberType = GenerateFromType(pi.PropertyType)
};
return(pm);
}
public bool IsNull()
{
if (FieldMember != null)
{
return(FieldMember.GetValue(ReferencedObject) == null);
}
else if (PropertyMember != null)
{
return(PropertyMember.GetValue(ReferencedObject, null) == null);
}
return(false);
}
public virtual void VisitPropertyMember(PropertyMember m)
{
VisitAccessibility(m.Accessibility);
if (m.MemberType != null)
{
VisitTypeReference(m.MemberType);
}
if (m.Initialization != null)
{
VisitRaw(m.Initialization);
}
}
private PropertyMember GenerateObservableProperty(DeclarationBase target, PropertyMember source)
{
var property = new PropertyMember(source.Name);
property.Accessibility = source.Accessibility;
property.Initialization = MapRaw(source.Initialization);
//property.IsOptional = item.IsOptional;
property.MemberType = MapType(source.MemberType);
MakeObservableProperty(property);
target.Members.Add(property);
return(property);
}
public PropagatingPropertyWriter(PropertyMember ownerProperty, IOperand target)
: base(ownerProperty)
{
if (OwnerProperty.GetterMethod != null)
{
var getter = new PropagatingMethodWriter(OwnerProperty.GetterMethod, target);
}
if (OwnerProperty.SetterMethod != null)
{
var setter = new PropagatingMethodWriter(OwnerProperty.SetterMethod, target);
}
}
public virtual PropertyMember RewritePropertyMember(PropertyMember m)
{
var result = new PropertyMember(m.Name)
{
Accessibility = RewriteAccessibility(m.Accessibility),
Comment = RewriteComment(m.Comment),
ExtraData = RewriteExtraData(m),
IsOptional = m.IsOptional,
MemberType = RewriteTypeReference(m.MemberType),
Initialization = RewriteRaw(m.Initialization),
};
return(result);
}
/// <summary>
/// Adds a subquery to an existing parent type that returns a collection of items mapped to the parent type by a key property.
/// Method parameters with the following types are ignored in the schema and will have their value injected:
/// <list type="bullet">
/// <item><see cref="IResolveFieldContext"/></item>
/// <item>PARENT</item>
/// <item>IEnumerable<KEY></item>
/// </list>
/// </summary>
/// <remarks>The method's type must be registered in the <see cref="IServiceCollection"/>.</remarks>
/// <param name="method">Graph endpoint implementation</param>
/// <param name="parentPropertyKey">Parent property containing the key value</param>
/// <param name="childPropertyKey">Child property containing the key value</param>
/// <returns>The added <see cref="FieldType"/>.</returns>
public FieldType AddSubqueryCollection(MethodMember method, PropertyMember parentPropertyKey, PropertyMember childPropertyKey)
{
var handler = this._ServiceProvider.GetRequiredService(method.Type);
if (parentPropertyKey.PropertyType != childPropertyKey.PropertyType)
{
throw new ArgumentException($"{nameof(AddSubquery)}: Expected properties [{parentPropertyKey.Name}] and [{childPropertyKey.Name}] to have the same type; instead of [{parentPropertyKey.PropertyType.Name}] and [{childPropertyKey.PropertyType.Name}].");
}
var resolverType = typeof(CollectionBatchLoaderFieldResolver <, ,>).MakeGenericType(parentPropertyKey.Type, childPropertyKey.Type, childPropertyKey.PropertyType);
var resolver = (IFieldResolver)resolverType.GetTypeMember().Create(method, handler, this._DataLoader, parentPropertyKey, childPropertyKey);
return(this.Query.AddField(method.ToFieldType(resolver)));
}
public void AssertSetterMethodDependencies(FieldMember backingField, PropertyMember backedProperty,
Class expectedTarget)
{
backingField.MemberDependencies
.ForEach(dependency =>
{
Assert.Contains(dependency, backedProperty.MemberDependencies);
Assert.Contains(dependency, backedProperty.Setter.MemberDependencies);
});
var backingFieldDependencyTargets = backingField.MemberDependencies.Select(dependency => dependency.Target);
Assert.Contains(expectedTarget, backingFieldDependencyTargets);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private TypeMember BuildClassWithIntAndStringProperties(TypeKey key)
{
var classType = new TypeMember(new TypeGeneratorInfo(this.GetType(), key), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var intValueProperty = new PropertyMember {
Visibility = MemberVisibility.Public, PropertyType = typeof(int), Name = "IntValue"
};
var stringValueProperty = new PropertyMember {
Visibility = MemberVisibility.Public, PropertyType = typeof(string), Name = "StringValue"
};
var constructor = new ConstructorMember(
MemberVisibility.Public,
MemberModifier.None,
"ClassOne",
new MethodSignature(new MethodParameter[] {
new MethodParameter("intValue", 1, typeof(int)),
new MethodParameter("stringValue", 2, typeof(string)),
}, null, false)
);
constructor.Body = new BlockStatement(
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new MemberExpression {
Target = new ThisExpression(), Member = intValueProperty
},
Right = new ParameterExpression {
Parameter = constructor.Signature.Parameters.First(p => p.Name == "intValue")
},
}
},
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new MemberExpression {
Target = new ThisExpression(), Member = stringValueProperty
},
Right = new ParameterExpression {
Parameter = constructor.Signature.Parameters.First(p => p.Name == "stringValue")
},
}
}
);
classType.Members.Add(constructor);
classType.Members.Add(intValueProperty);
classType.Members.Add(stringValueProperty);
return(classType);
}
public void SetValue(object value)
{
if (FieldMember != null)
{
FieldMember.SetValue(ReferencedObject, value);
}
else if (PropertyMember != null)
{
PropertyMember.SetValue(ReferencedObject, value, null);
}
else
{
throw new Exception("Member is not assignable");
}
}
public bool?BuildUI()
{
Type type = Instance.GetType();
Grid grid = BuildGrid();
Window window = BuildWindow();
window.Content = (grid);
foreach (var member in type.GetMembers())
{
AbstractMember abstractMember = null;
if (member.MemberType == MemberTypes.Property)
{
abstractMember = new PropertyMember((PropertyInfo)member);
}
else if (member.MemberType == MemberTypes.Field)
{
abstractMember = new FieldMember((FieldInfo)member);
}
if (abstractMember != null)
{
BuildControl(grid, abstractMember, Instance);
}
}
PopulateControls(Instance);
StackPanel panel = BuildButtonPanel(window);
grid.RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(40)
});
Grid.SetRow(panel, grid.RowDefinitions.Count - 1);
Grid.SetColumn(panel, 2);
grid.Children.Add(panel);
grid.Height = grid.RowDefinitions.Sum(o => o.Height.Value);
grid.Width = grid.ColumnDefinitions.Sum(o => o.Width.Value);
window.Height = grid.Height + 60;
window.Width = grid.Width + 40;
window.Owner = System.Windows.Application.Current.MainWindow;
return(window.ShowDialog());
}
public TemplatePropertyWriter(
PropertyMember ownerProperty,
Func <TemplatePropertyWriter, PropertyWriterBase.IPropertyWriterGetter> getterScript,
Func <TemplatePropertyWriter, PropertyWriterBase.IPropertyWriterSetter> setterScript)
: base(ownerProperty)
{
if (getterScript != null)
{
getterScript(this);
}
if (setterScript != null)
{
setterScript(this);
}
}
public void ReadDeclaration()
{
_getterReader = MethodReaderMechanism.CreateAccessorMethodReader(_modelBuilder, _symbol.GetMethod);
_setterReader = MethodReaderMechanism.CreateAccessorMethodReader(_modelBuilder, _symbol.SetMethod);
_member = new PropertyMember {
Name = _symbol.Name,
DeclaringType = _modelBuilder.TryGetMember <TypeMember>(_symbol.ContainingType),
Status = MemberStatus.Incomplete,
Visibility = _symbol.GetMemberVisibility(),
Modifier = _symbol.GetMemberModifier(),
PropertyType = _modelBuilder.TryGetMember <TypeMember>(_symbol.Type),
Getter = _getterReader?.Member as MethodMember,
Setter = _setterReader?.Member as MethodMember
};
}
private IEnumerable <IMemberTypeDependency> CreateMethodCallDependenciesForProperty(
PropertyMember accessedProperty, MethodBody methodBody)
{
return(methodBody.Instructions
.Where(instruction => instruction.Operand is MethodReference)
.Where(instruction => instruction.IsMethodCallAssignment())
.Select(instruction => (methodReference: instruction.Operand as MethodReference,
instruction))
.Select <(MethodReference, Instruction), IMemberTypeDependency>(tuple =>
{
var(methodReference, _) = tuple;
var calledType = _typeFactory.GetOrCreateStubTypeFromTypeReference(methodReference.DeclaringType);
return CreateStubMethodCallDependencyForProperty(calledType, methodReference, accessedProperty);
}));
}
protected PropertyDefinition ParseProperty(
TokenStream tokens,
ClassDefinition classDef,
FileScope fileScope,
ModifierCollection modifiers,
AnnotationCollection annotations)
{
AType propertyType = this.parser.TypeParser.Parse(tokens);
tokens.EnsureNotEof();
Token propertyName = tokens.PopIfWord();
if (propertyName == null)
{
throw new ParserException(tokens.Peek(), "Expected property name.");
}
tokens.PopExpected("{");
PropertyMember getter = null;
PropertyMember setter = null;
PropertyDefinition property = new PropertyDefinition(propertyType.FirstToken, classDef, fileScope, modifiers);
while (!tokens.PopIfPresent("}"))
{
PropertyMember member = this.ParsePropertyMember(tokens, property);
if (member.IsGetter)
{
if (getter != null)
{
throw new ParserException(member.FirstToken, "Property has multiple getters");
}
getter = member;
}
else if (member.IsSetter)
{
if (setter != null)
{
throw new ParserException(member.FirstToken, "Property has multiple setters");
}
setter = member;
}
}
property.Getter = getter;
property.Setter = setter;
return(property);
}
private ReferenceComponentMapping CreateInstance()
{
var property = new PropertyMember(new DummyPropertyInfo("ComponentProperty", typeof(ComponentTarget)));
var instance = new ReferenceComponentMapping(property, typeof(ComponentTarget), typeof(Target), null);
instance.AssociateExternalMapping(new ExternalComponentMapping());
return instance;
}
