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