public TypeViewModel(SDType type, NamespaceViewModel parent, ICoreConfigSection sharpDoxConfig)
: base(type.Identifier, parent, sharpDoxConfig)
{
Text = type.NameWithTypeArguments;
Accessibility = type.Accessibility;
Image = string.Format("pack://application:,,,/SharpDox.GUI;component/Resources/Icons/Class_{0}.png", Accessibility);
foreach (var sdEvent in type.Events)
{
Children.Add(new EventViewModel(sdEvent, this, sharpDoxConfig));
}
foreach (var sdField in type.Fields)
{
Children.Add(new FieldViewModel(sdField, this, sharpDoxConfig));
}
foreach (var sdMethod in type.Constructors)
{
Children.Add(new MethodViewModel(sdMethod, this, sharpDoxConfig));
}
foreach (var sdMethod in type.Methods)
{
Children.Add(new MethodViewModel(sdMethod, this, sharpDoxConfig));
}
foreach (var sdProperty in type.Properties)
{
Children.Add(new PropertyViewModel(sdProperty, this, sharpDoxConfig));
}
}
internal void ParseConstructors(SDType sdType, IType type)
{
var constructors = type.GetConstructors(null, GetMemberOptions.IgnoreInheritedMembers);
constructors = constructors.Where(o => !o.DeclaringType.FullName.StartsWith("System.Object"));
ParseMethodList(sdType.Constructors, constructors, true);
}
private SDType CreateSDType(INamedTypeSymbol typeSymbol, SDNamespace sdNamespace)
{
var sdType = new SDType(typeSymbol.GetIdentifier(), typeSymbol.Name, sdNamespace)
{
Accessibility = typeSymbol.DeclaredAccessibility.ToString().ToLower(),
IsAbstract = typeSymbol.IsAbstract,
IsReferenceType = typeSymbol.IsReferenceType,
IsSealed = typeSymbol.IsSealed,
IsStatic = typeSymbol.IsStatic,
IsProjectStranger = false,
Kind = typeSymbol.TypeKind.ToString().ToLower()
};
foreach (var reference in typeSymbol.DeclaringSyntaxReferences.ToList())
{
var region = new SDRegion
{
Start = reference.Span.Start,
End = reference.Span.End,
Filename = reference.SyntaxTree.FilePath
};
sdType.Regions.Add(region);
}
return(sdType);
}
private void AddParsedConstructorsAndMethods(SDType sdType, IType type)
{
var methodParser = new MethodParser(_repository, this, _excludedIdentifiers);
methodParser.ParseConstructors(sdType, type);
methodParser.ParseMethods(sdType, type);
}
private SDType CreateSDType(IType type, ITypeDefinition typeDefinition, bool isProjectStranger)
{
var nameSpace = _repository.GetNamespaceByIdentifier(typeDefinition.Namespace);
var namespaceRef = nameSpace ?? new SDNamespace(typeDefinition.Namespace)
{
IsProjectStranger = true
};
var sdType = new SDType(type.GetIdentifier(), typeDefinition.Name, namespaceRef)
{
Accessibility = typeDefinition.Accessibility.ToString().ToLower(),
IsAbstract = typeDefinition.IsAbstract,
IsReferenceType = typeDefinition.IsReferenceType.GetValueOrDefault(),
IsSealed = typeDefinition.IsSealed,
IsShadowing = typeDefinition.IsShadowing,
IsStatic = typeDefinition.IsStatic,
IsSynthetic = typeDefinition.IsSynthetic,
IsProjectStranger = isProjectStranger,
Kind = typeDefinition.Kind.ToString().ToLower(),
Region = new SDRegion
{
BeginColumn = typeDefinition.Region.BeginColumn,
BeginLine = typeDefinition.Region.BeginLine,
EndColumn = typeDefinition.Region.EndColumn,
EndLine = typeDefinition.Region.EndLine,
Filename = typeDefinition.Region.FileName
},
Documentation = _documentationParser.ParseDocumentation(typeDefinition)
};
_repository.AddType(sdType);
return(sdType);
}
internal static void ParseMinimalMethods(SDType sdType, IType type)
{
var methods = type.GetMethods(null, GetMemberOptions.IgnoreInheritedMembers);
methods = methods.Where(o => !o.DeclaringType.FullName.StartsWith("System.Object"));
MinimalParseMethodList(sdType.Methods, methods, false);
}
private void StructureParseTypes(CSharpProject project, SDRepository sdRepository)
{
var types = project.Compilation.MainAssembly.TopLevelTypeDefinitions.ToList();
for (int j = 0; j < types.Count; j++)
{
var type = types[j];
if (types[j].Kind != TypeKind.Delegate)
{
PostParseMessage(_parserStrings.ParsingClass + ": " + string.Format("{0}.{1}", types[j].Namespace, types[j].Name));
var nameSpace = sdRepository.GetNamespaceByIdentifier(type.Namespace);
var namespaceRef = nameSpace ?? new SDNamespace(type.Namespace)
{
IsProjectStranger = true
};
var sdType = new SDType(type.GetIdentifier(), type.Name, namespaceRef)
{
Accessibility = type.GetDefinition().Accessibility.ToString().ToLower()
};
sdRepository.AddType(sdType);
EventParser.ParseMinimalFields(sdType, types[j]);
PropertyParser.ParseMinimalProperties(sdType, types[j]);
FieldParser.ParseMinimalFields(sdType, types[j]);
MethodParser.ParseMinimalConstructors(sdType, types[j]);
MethodParser.ParseMinimalMethods(sdType, types[j]);
sdRepository.AddNamespaceTypeRelation(types[j].Namespace, sdType.Identifier);
}
}
}
public CSharpMethodVisitor(SDRepository repository, SDMethod method, SDType type, Document file) : base(SyntaxWalkerDepth.StructuredTrivia)
{
_repository = repository;
_method = method;
_type = type;
_file = file;
_tokenList = method.Calls;
}
public MethodVisitor(SDRepository repository, SDMethod method, SDType type, CSharpFile file)
{
_repository = repository;
_method = method;
_type = type;
_file = file;
_tokenList = method.Calls;
}
private void InsertClassDiagram(SDType sdType)
{
if (!sdType.IsClassDiagramEmpty())
{
var tmpImagePath = Path.Combine(_outputPath, "tmp", sdType.Guid + ".png");
sdType.GetClassDiagram().ToPng(tmpImagePath);
_wordTemplater.AppendImage(tmpImagePath, "Diagram");
}
}
private void AddParsedArrayTypeElement(SDType sdType, IType type)
{
var arrayType = type as ArrayType;
if (arrayType != null)
{
sdType.ArrayElementType = GetParsedType(arrayType.ElementType);
}
}
private void AddParsedTypeArguments(SDType sdType, IEnumerable <IType> typeArguments)
{
foreach (var typeArgument in typeArguments)
{
var type = GetParsedType(typeArgument);
if (sdType.TypeArguments.SingleOrDefault((i => i.Identifier == type.Identifier)) == null)
{
sdType.TypeArguments.Add(GetParsedType(typeArgument));
}
}
}
public void ShouldReturnTrueForClassDiagramIsEmpty()
{
//Arrange
var sdType = new SDType("SharpDox.UML.Tests.DiagramExtensionsTests", "DiagramExtensionTests", new SDNamespace("SharpDox.UML.Tests"));
//Act
var isEmpty = sdType.IsClassDiagramEmpty();
//Assert
Assert.AreEqual(true, isEmpty);
}
private void AddParsedBaseType(SDType sdType, INamedTypeSymbol baseType)
{
if (baseType != null && baseType.TypeKind != TypeKind.Interface)
{
var typeRef = _typeRefParser.GetParsedTypeReference(baseType);
if (sdType.BaseTypes.SingleOrDefault((i => i.Type.Identifier == typeRef.Type.Identifier)) == null && typeRef.Type.Fullname != "System.Object")
{
sdType.BaseTypes.Add(typeRef);
}
}
}
private void AddParsedTypeArguments(SDType sdType, IEnumerable <ITypeSymbol> typeArguments)
{
foreach (var typeArgument in typeArguments)
{
var typeRef = _typeRefParser.GetParsedTypeReference(typeArgument);
if (sdType.TypeArguments.SingleOrDefault((i => i.Type.Identifier == typeRef.Type.Identifier)) == null)
{
sdType.TypeArguments.Add(typeRef);
}
}
}
private void ParseForeignTypeToModel(SDType sdType, ITypeSymbol typeSymbol)
{
var type = typeSymbol as INamedTypeSymbol;
if (type != null)
{
AddParsedTypeArguments(sdType, type.TypeArguments);
}
AddParsedBaseType(sdType, typeSymbol.BaseType);
AddParsedInterfaces(sdType, typeSymbol.Interfaces);
}
private void ParseTypeToModel(SDType sdType, IType type)
{
sdType.IsProjectStranger = false;
AddParsedTypeArguments(sdType, type.TypeArguments);
AddParsedTypeParameters(sdType, type.GetDefinition().TypeParameters);
AddParsedBaseTypes(sdType, type.DirectBaseTypes);
AddParsedInterfaces(sdType, type.DirectBaseTypes);
AddParsedProperties(sdType, type);
AddParsedFields(sdType, type);
AddParsedConstructorsAndMethods(sdType, type);
AddParsedEvents(sdType, type);
}
public void ShouldReturnFalseForClassDiagramIsEmptyBecauseFieldPresent()
{
//Arrange
var sdType = new SDType("SharpDox.UML.Tests.DiagramExtensionsTests", "DiagramExtensionTests", new SDNamespace("SharpDox.UML.Tests"));
sdType.Fields.Add(new SDField("SharpDox.UML.Tests.DiagramExtensionsTests.Field1"));
//Act
var isEmpty = sdType.IsClassDiagramEmpty();
//Assert
Assert.AreEqual(false, isEmpty);
}
internal static void ParseMinimalFields(SDType sdType, IType type)
{
var fields = type.GetFields(null, GetMemberOptions.IgnoreInheritedMembers);
foreach (var field in fields)
{
var parsedField = GetMinimalParsedField(field);
if (sdType.Fields.SingleOrDefault(f => f.Name == parsedField.Name) == null)
{
sdType.Fields.Add(parsedField);
}
}
}
internal static void ParseMinimalFields(SDType sdType, IType type)
{
var events = type.GetEvents(null, GetMemberOptions.IgnoreInheritedMembers);
foreach (var eve in events)
{
var parsedEvent = GetMinimalParsedEvent(eve);
if (sdType.Events.SingleOrDefault(f => f.Name == parsedEvent.Name) == null)
{
sdType.Events.Add(parsedEvent);
}
}
}
internal static void ParseMinimalProperties(SDType sdType, IType type)
{
var properties = type.GetProperties(null, GetMemberOptions.IgnoreInheritedMembers);
foreach (var property in properties)
{
var parsedProperty = GetMinimalParsedProperty(property);
if (sdType.Properties.SingleOrDefault(p => p.Name == parsedProperty.Name) == null)
{
sdType.Properties.Add(parsedProperty);
}
}
}
private void AddParsedNestedTypes(SDType sdType, IEnumerable <INamedTypeSymbol> nestedTypes)
{
foreach (var nestedType in nestedTypes)
{
if (nestedType.TypeKind != TypeKind.Interface)
{
var typeRef = _typeRefParser.GetParsedTypeReference(nestedType);
if (sdType.NestedTypes.SingleOrDefault((i => i.Type.Identifier == typeRef.Type.Identifier)) == null && typeRef.Type.Fullname != "System.Object")
{
sdType.NestedTypes.Add(typeRef);
}
}
}
}
private void AddParsedInterfaces(SDType sdType, IEnumerable <IType> implementedInterfaces)
{
foreach (var implementedInterface in implementedInterfaces)
{
if (implementedInterface.Kind == TypeKind.Interface)
{
var type = GetParsedType(implementedInterface);
if (sdType.ImplementedInterfaces.SingleOrDefault((i => i.Identifier == type.Identifier)) == null && type.Fullname != "System.Object")
{
sdType.ImplementedInterfaces.Add(type);
}
}
}
}
private void InsertUseUsedBlock(SDType sdType, int navigationLevel)
{
if (sdType.Uses.Count > 0)
{
_wordTemplater.AppendHeader(_wordStrings.Uses, navigationLevel);
sdType.Uses.Select(u => u.Fullname).ToList().ForEach(u => _wordTemplater.AppendParagraph(u, "CenteredNoMargin"));
}
if (sdType.UsedBy.Count > 0)
{
_wordTemplater.AppendHeader(_wordStrings.UsedBy, navigationLevel);
sdType.UsedBy.Select(u => u.Fullname).ToList().ForEach(u => _wordTemplater.AppendParagraph(u, "CenteredNoMargin"));
}
}
private void AddParsedBaseTypes(SDType sdType, IEnumerable <IType> directBaseTypes)
{
foreach (var baseType in directBaseTypes)
{
if (baseType.Kind != TypeKind.Interface)
{
var type = GetParsedType(baseType);
if (sdType.BaseTypes.SingleOrDefault((i => i.Identifier == type.Identifier)) == null && type.Fullname != "System.Object")
{
sdType.BaseTypes.Add(type);
}
}
}
}
private SDType CreateSDType(ITypeSymbol typeSymbol, bool isProjectStranger)
{
SDNamespace sdNamespace = null;
if (typeSymbol is IArrayTypeSymbol)
{
sdNamespace = ParserOptions.SDRepository.GetNamespaceByIdentifier(((IArrayTypeSymbol)typeSymbol).ElementType.ContainingNamespace.GetIdentifier());
sdNamespace = sdNamespace ?? new SDNamespace(((IArrayTypeSymbol)typeSymbol).ElementType.ContainingNamespace.GetIdentifier())
{
IsProjectStranger = true
};
}
else
{
sdNamespace = ParserOptions.SDRepository.GetNamespaceByIdentifier(typeSymbol.ContainingNamespace.GetIdentifier());
sdNamespace = sdNamespace ?? new SDNamespace(typeSymbol.ContainingNamespace.GetIdentifier())
{
IsProjectStranger = true
};
}
var sdType = new SDType(typeSymbol.GetIdentifier(), typeSymbol.Name, sdNamespace)
{
Accessibility = typeSymbol.DeclaredAccessibility.ToString().ToLower(),
IsAbstract = typeSymbol.IsAbstract,
IsReferenceType = typeSymbol.IsReferenceType,
IsSealed = typeSymbol.IsSealed,
IsStatic = typeSymbol.IsStatic,
IsProjectStranger = isProjectStranger,
Kind = typeSymbol.TypeKind.ToString().ToLower()
};
var declaringReferences = !isProjectStranger?typeSymbol.DeclaringSyntaxReferences.ToList() : new List <SyntaxReference>();
foreach (var reference in declaringReferences)
{
var region = new SDRegion
{
Start = reference.Span.Start,
End = reference.Span.End,
Filename = reference.SyntaxTree.FilePath
};
sdType.Regions.Add(region);
}
ParserOptions.SDRepository.AddType(sdType);
return(sdType);
}
internal void ParseProperties(SDType sdType, IType type)
{
var properties = type.GetProperties(null, GetMemberOptions.IgnoreInheritedMembers);
foreach (var property in properties)
{
if (!_excludedIdentifiers.Contains(property.GetIdentifier()))
{
var parsedProperty = GetParsedProperty(property);
if (sdType.Properties.SingleOrDefault(p => p.Name == parsedProperty.Name) == null)
{
sdType.Properties.Add(parsedProperty);
}
}
}
}
internal void ParseEvents(SDType sdType, INamedTypeSymbol typeSymbol)
{
var events = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Event).Select(m => m as IEventSymbol);
foreach (var eve in events)
{
if (!IsMemberExcluded(eve.GetIdentifier(), eve.DeclaredAccessibility))
{
var parsedEvent = GetParsedEvent(eve);
if (sdType.Events.SingleOrDefault(f => f.Name == parsedEvent.Name) == null)
{
sdType.Events.Add(parsedEvent);
}
}
}
}
internal void ParseFields(SDType sdType, INamedTypeSymbol typeSymbol)
{
var fields = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Field && !m.IsImplicitlyDeclared).Select(f => f as IFieldSymbol);
foreach (var field in fields)
{
if (!IsMemberExcluded(field.GetIdentifier(), field.DeclaredAccessibility))
{
var parsedField = GetParsedField(field);
if (sdType.Fields.SingleOrDefault(f => f.Name == parsedField.Name) == null)
{
sdType.Fields.Add(parsedField);
}
}
}
}
internal void ParseProperties(SDType sdType, INamedTypeSymbol typeSymbol)
{
var properties = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Property).Select(f => f as IPropertySymbol);
foreach (var property in properties)
{
if (!IsMemberExcluded(property.GetIdentifier(), property.DeclaredAccessibility))
{
var parsedProperty = GetParsedProperty(property);
if (sdType.Properties.SingleOrDefault(p => p.Name == parsedProperty.Name) == null)
{
sdType.Properties.Add(parsedProperty);
}
}
}
}
