public static DeclaredType Unresolved(TypeIdentifier typeIdentifier, Type declaration, Namespace ns) { var declaredType = new DeclaredType(typeIdentifier, ns) { IsResolved = false, declaration = declaration }; if (declaration.BaseType != null) { declaredType.ParentType = Unresolved( IdentifierFor.Type(declaration.BaseType), declaration.BaseType, Namespace.Unresolved(IdentifierFor.Namespace(declaration.BaseType.Namespace))); } IEnumerable <Type> interfaces = GetInterfaces(declaration); foreach (Type face in interfaces) { declaredType.Interfaces.Add( Unresolved(IdentifierFor.Type(face), face, Namespace.Unresolved(IdentifierFor.Namespace(face.Namespace)))); } return(declaredType); }
protected static DeclaredType FindType(IDocumentationMember association, List <Namespace> namespaces) { var typeName = IdentifierFor.Type(association.TargetType); var identifier = IdentifierFor.Namespace(association.TargetType.Namespace); return(namespaces.Find(x => x.IsIdentifiedBy(identifier)).Types.FirstOrDefault(x => x.IsIdentifiedBy(typeName))); }
public void Add(List <Namespace> namespaces, DocumentedMethod association) { if (association.Method == null) { return; } DeclaredType type = FindType(association, namespaces); DeclaredType methodReturnType = null; if (association.Method.MemberType == MemberTypes.Method) { methodReturnType = DeclaredType.Unresolved( IdentifierFor.Type(((MethodInfo)association.Method).ReturnType), ((MethodInfo)association.Method).ReturnType, Namespace.Unresolved(IdentifierFor.Namespace(((MethodInfo)association.Method).ReturnType.Namespace))); } Method doc = Method.Unresolved( IdentifierFor.Method(association.Method, association.TargetType), type, association.Method, methodReturnType); ParseSummary(association, doc); ParseRemarks(association, doc); ParseValue(association, doc); ParseReturns(association, doc); ParseExample(association, doc); foreach (ParameterInfo parameter in association.Method.GetParameters()) { DeclaredType reference = DeclaredType.Unresolved( IdentifierFor.Type(parameter.ParameterType), parameter.ParameterType, Namespace.Unresolved(IdentifierFor.Namespace(parameter.ParameterType.Namespace))); var docParam = new MethodParameter(parameter.Name, parameter.IsOptional, parameter.DefaultValue, reference); ParseParamSummary(association, docParam); doc.AddParameter(docParam); } if (_matchedAssociations.ContainsKey(association.Name)) { return; // weird case when a type has the same method declared twice } _matchedAssociations.Add(association.Name, doc); if (type == null) { return; } type.AddMethod(doc); }
protected DeclaredType Type <T>(Namespace ns) { var type = new DeclaredType(IdentifierFor.Type(typeof(T)), ns); ns.AddType(type); return(type); }
static DeclaredType to_type_in_namespace(this Type type, Namespace ns) { var declaredType = new DeclaredType(IdentifierFor.Type(type), ns); ns.AddType(declaredType); return(declaredType); }
public static IEnumerable <IDocumentationMember> ReflectMembersForDocumenting(IEnumerable <Type> types) { foreach (var type in types) { if (type.IsSpecialName) { continue; } if (type.Name.StartsWith("__")) { continue; // probably a lambda generated class } yield return(new ReflectedType(IdentifierFor.Type(type), type)); foreach (var method in type.GetMethods()) { if (method.IsSpecialName || (method.DeclaringType != null && method.DeclaringType.Name.Equals("Object"))) { continue; //skip object base methods and special names } yield return(new ReflectedMethod(IdentifierFor.Method(method, type), method, type)); } foreach (var constructor in type.GetConstructors()) { yield return(new ReflectedMethod(IdentifierFor.Method(constructor, type), constructor, type)); } foreach (var property in type.GetProperties(BindingFlags.Static | BindingFlags.Public)) { yield return(new ReflectedProperty(IdentifierFor.Property(property, type, true), property, type, true)); } foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { yield return(new ReflectedProperty(IdentifierFor.Property(property, type, false), property, type, false)); } foreach (var ev in type.GetEvents()) { yield return(new ReflectedEvent(IdentifierFor.Event(ev, type), ev, type)); } if (type.IsEnum) { foreach (var member in type.GetMembers(BindingFlags.Static | BindingFlags.Public)) { yield return(new ReflectedEnum(IdentifierFor.Enum(member, type), member, type)); } } else { foreach (var field in type.GetFields()) { yield return(new ReflectedField(IdentifierFor.Field(field, type), field, type)); } } } }
public void should_match_type() { var undocumentedMembers = DocumentableMemberFinder.ReflectMembersForDocumenting(new[] { typeof(First), typeof(Second), typeof(Third) }); var snippets = new[] { @"<member name=""T:Example.Second"" />".ToNode() }; var members = DocumentationXmlMatcher.MatchDocumentationToMembers(undocumentedMembers, snippets); var member = members.FirstOrDefault(x => x.Name == IdentifierFor.Type(typeof(Second))) as DocumentedType; member.ShouldNotBeNull(); member.Xml.ShouldEqual(snippets[0]); member.TargetType.ShouldEqual(typeof(Second)); }
public void should_match_type_with_multiple_generic_arguments() { var undocumentedMembers = DocumentableMemberFinder.ReflectMembersForDocumenting(new[] { typeof(First), typeof(GenericDefinition <>), typeof(GenericDefinition <,>) }); var snippets = new[] { @"<member name=""T:Example.GenericDefinition`2"" />".ToNode() }; var members = DocumentationXmlMatcher.MatchDocumentationToMembers(undocumentedMembers, snippets); var member = members.FirstOrDefault(x => x.Name == IdentifierFor.Type(typeof(GenericDefinition <,>))) as DocumentedType; member.ShouldNotBeNull(); member.Xml.ShouldEqual(snippets[0]); member.TargetType.ShouldEqual(typeof(GenericDefinition <,>)); }
public void MatchesTypePatternFilename() { var resolver = new PatternTemplateResolver(); var namespaces = Namespaces("One", "Two"); namespaces[0].AddType(new DeclaredType(IdentifierFor.Type(typeof(First)), namespaces[0])); namespaces[1].AddType(new DeclaredType(IdentifierFor.Type(typeof(Second)), namespaces[1])); var results = resolver.Resolve("!type.htm.spark", namespaces); results.Count.ShouldEqual(2); results[0].OutputPath.ShouldEqual("One.First.htm"); results[0].TemplatePath.ShouldEqual("!type.htm.spark"); results[1].OutputPath.ShouldEqual("Two.Second.htm"); results[1].TemplatePath.ShouldEqual("!type.htm.spark"); }
public void ShouldHaveTypesInNamespaces() { var model = new DocumentationModelBuilder(StubParser, new EventAggregator()); var members = new[] { Type <First>(@"<member name=""T:Example.First"" />"), Type <Second>(@"<member name=""T:Example.Second"" />"), Type <DeepFirst>(@"<member name=""T:Example.Deep.DeepFirst"" />") }; var namespaces = model.CombineToTypeHierarchy(members); namespaces[0].Types .ShouldContain(x => x.IsIdentifiedBy(IdentifierFor.Type(typeof(First)))) .ShouldContain(x => x.IsIdentifiedBy(IdentifierFor.Type(typeof(Second)))); namespaces[1].Types .ShouldContain(x => x.IsIdentifiedBy(IdentifierFor.Type(typeof(DeepFirst)))); }
public static IEnumerable <IDocumentationMember> ReflectMembersForDocumenting(IEnumerable <Type> types) { foreach (var type in types) { if (type.IsSpecialName) { continue; } if (type.Name.StartsWith("__")) { continue; // probably a lambda generated class } yield return(new ReflectedType(IdentifierFor.Type(type), type)); foreach (var method in type.GetMethods()) { if (method.IsSpecialName) { continue; } yield return(new ReflectedMethod(IdentifierFor.Method(method, type), method, type)); } foreach (var constructor in type.GetConstructors()) { yield return(new ReflectedMethod(IdentifierFor.Method(constructor, type), constructor, type)); } foreach (var property in type.GetProperties()) { yield return(new ReflectedProperty(IdentifierFor.Property(property, type), property, type)); } foreach (var ev in type.GetEvents()) { yield return(new ReflectedEvent(IdentifierFor.Event(ev, type), ev, type)); } foreach (var field in type.GetFields()) { yield return(new ReflectedField(IdentifierFor.Field(field, type), field, type)); } } }
public void Add(List <Namespace> namespaces, DocumentedProperty association) { if (association.Property == null) { return; } DeclaredType type = FindType(association, namespaces); var isStatic = association.Property.GetGetMethod().IsStatic; DeclaredType propertyReturnType = DeclaredType.Unresolved( IdentifierFor.Type(association.Property.PropertyType), association.Property.PropertyType, Namespace.Unresolved(IdentifierFor.Namespace(association.Property.PropertyType.Namespace))); Property doc = Property.Unresolved( IdentifierFor.Property(association.Property, association.TargetType, isStatic), type, association.Property, propertyReturnType); ParseSummary(association, doc); ParseValue(association, doc); ParseRemarks(association, doc); ParseExample(association, doc); if (_matchedAssociations.ContainsKey(association.Name)) { return; } _matchedAssociations.Add(association.Name, doc); if (type == null) { return; } type.AddProperty(doc); }
public void Add(List <Namespace> namespaces, DocumentedField association) { if (association.Field == null) { return; } DeclaredType type = FindType(association, namespaces); DeclaredType returnType = DeclaredType.Unresolved( IdentifierFor.Type(association.Field.FieldType), association.Field.FieldType, Namespace.Unresolved(IdentifierFor.Namespace(association.Field.FieldType.Namespace))); Field doc = Field.Unresolved( IdentifierFor.Field(association.Field, association.TargetType), type, returnType); ParseSummary(association, doc); ParseRemarks(association, doc); ParseExample(association, doc); _matchedAssociations.Add(association.Name, doc); type.AddField(doc); }
protected static DeclaredType Type <T>() { return(new DeclaredType(IdentifierFor.Type(typeof(T)), Namespace.Unresolved(IdentifierFor.Namespace(typeof(T).Namespace)))); }
protected DocumentedType Type <T>(string xml) { return(new DocumentedType(IdentifierFor.Type(typeof(T)), xml.ToNode(), typeof(T))); }
protected DocumentedType Type(Type type, string xml) { return(new DocumentedType(IdentifierFor.Type(type), xml.ToNode(), type)); }
private IDocumentationMember find_member <T>() { return(members.FirstOrDefault(x => x.Name == IdentifierFor.Type(typeof(T)))); }