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