public void ShouldReturnFalseForSequenceDiagramIsEmpty()
{
//Arrange
var sdType = new SDType("SharpDox.UML.Tests.DiagramExtensionsTests", "DiagramExtensionTests", new SDNamespace("SharpDox.UML.Tests"));
sdType.IsProjectStranger = false;
var sdMethod = new SDMethod("SharpDox.UML.Tests.DiagramExtensionsTests.Method1", "Method1");
var sdNode = new SDTargetNode();
sdNode.CalledMethod = new SDMethod("SharpDox.UML.Tests.DiagramExtensionsTests.Method2", "Method2");
sdNode.CallerMethod = sdMethod;
sdNode.CallerType = sdType;
sdNode.CalledType = sdType;
//Add this node twice, because the check will skipp call number one
//because this one is usually the first call to the method itself
sdMethod.Calls.Add(sdNode);
sdMethod.Calls.Add(sdNode);
//Act
var isEmpty = sdMethod.IsSequenceDiagramEmpty();
//Assert
Assert.AreEqual(false, isEmpty);
}
private void CreateReturn(SDMethod method)
{
if (!string.IsNullOrEmpty(method.ReturnType.Type.Name) && method.ReturnType.Type.Name.ToUpper() != "VOID")
{
_sequenceDiagram.AddConnection(_sequenceDiagram.StartNodeID, Guid.Empty, method.ReturnType.Type.Name, string.Empty, true);
}
}
public void AddMethod(SDMethod sdMethod)
{
if (!Methods.ContainsKey(sdMethod.Identifier))
{
Methods.Add(sdMethod.Identifier, sdMethod);
}
}
private SDMethod GetParsedMethod(IMethod method, bool isCtor)
{
var sdMethod = _repository.GetMethodByIdentifier(method.GetIdentifier());
if (sdMethod != null)
{
return(sdMethod);
}
var returnType = _typeParser.GetParsedType(method.ReturnType);
sdMethod = new SDMethod(method.GetIdentifier(), isCtor ? method.DeclaringType.Name : method.Name)
{
Namespace = method.Namespace,
DeclaringType = _typeParser.GetParsedType(method.DeclaringType),
ReturnType = returnType,
IsCtor = isCtor,
Accessibility = method.Accessibility.ToString().ToLower(),
IsAbstract = method.IsAbstract,
IsShadowing = method.IsShadowing,
IsOverride = method.IsOverride,
IsPrivate = method.IsPrivate,
IsProtected = method.IsProtected,
IsPublic = method.IsPublic,
IsSealed = method.IsSealed,
IsVirtual = method.IsVirtual,
IsStatic = method.IsStatic,
Documentations = _documentationParser.ParseDocumentation(method),
Region = new SDRegion
{
BeginColumn = method.Region.BeginColumn,
BeginLine = method.Region.BeginLine,
EndColumn = method.Region.EndColumn,
EndLine = method.Region.EndLine,
Filename = method.Region.FileName
}
};
foreach (ITypeParameter typeParameter in method.TypeParameters)
{
sdMethod.TypeParameters.Add(_typeParser.GetParsedType(typeParameter));
}
foreach (IParameter parameter in method.Parameters)
{
sdMethod.Parameters.Add(new SDParameter
{
Name = parameter.Name,
ParamType = _typeParser.GetParsedType(parameter.Type),
IsOptional = parameter.IsOptional,
IsConst = parameter.IsConst,
ConstantValue = parameter.ConstantValue,
IsRef = parameter.IsRef,
IsOut = parameter.IsOut
});
}
_repository.AddMethod(sdMethod);
return(sdMethod);
}
public MethodViewModel(SDMethod method, TypeViewModel parent, ICoreConfigSection sharpDoxConfig)
: base(method.Identifier, parent, sharpDoxConfig)
{
Text = method.Name;
Accessibility = method.Accessibility;
Image = string.Format("pack://application:,,,/SharpDox.GUI;component/Resources/Icons/Method_{0}.png", Accessibility);
}
public MethodViewModel(SDMethod method, TypeViewModel parent, ObservableCollection <string> excludedIdentifiers)
: base(method.Identifier, parent, excludedIdentifiers)
{
Text = method.Name;
Accessibility = method.Accessibility;
Image = string.Format("pack://application:,,,/SharpDox.Resources;component/Icons/Method_{0}.png", Accessibility);
}
public void AddMethod(SDMethod sdMethod)
{
if (!Methods.ContainsKey(sdMethod.Identifier))
{
sdMethod.ShortIdentifier = GetUniqueShortMethodIdentifier(sdMethod);
Methods.Add(sdMethod.Identifier, sdMethod);
}
}
/// <default>
/// <summary>
/// Returns a method, referenced by its identifier.
/// </summary>
/// <param name="identifier">The identifier of the method.</param>
/// <returns>The method, if it is available.</returns>
/// </default>
/// <de>
/// <summary>
/// Liefert die Methode mit dem angegebenen Identifikator.
/// </summary>
/// <param name="identifier">Der Identifikator der Methode.</param>
/// <returns>Die Methode, falls diese vorhanden ist.</returns>
/// </de>
public SDMethod GetMethodByIdentifier(string identifier)
{
SDMethod sdMethod = null;
Methods.TryGetValue(identifier, out sdMethod);
return(sdMethod);
}
public MethodVisitor(SDRepository repository, SDMethod method, SDType type, CSharpFile file)
{
_repository = repository;
_method = method;
_type = type;
_file = file;
_tokenList = method.Calls;
}
public CSharpMethodVisitor(SDRepository repository, SDMethod method, SDType type, Document file) : base(SyntaxWalkerDepth.StructuredTrivia)
{
_repository = repository;
_method = method;
_type = type;
_file = file;
_tokenList = method.Calls;
}
private SDMethod GetParsedMethod(IMethodSymbol method, bool isCtor)
{
var sdMethod = ParserOptions.SDRepository.GetMethodByIdentifier(method.GetIdentifier());
if (sdMethod != null)
{
return(sdMethod);
}
var returnType = _typeRefParser.GetParsedTypeReference(method.ReturnType);
var syntaxReference = method.DeclaringSyntaxReferences.Any() ? method.DeclaringSyntaxReferences.Single() : null;
sdMethod = new SDMethod(method.GetIdentifier(), isCtor ? method.ContainingType.Name : method.Name)
{
Namespace = method.ContainingNamespace.GetIdentifier(),
DeclaringType = _typeRefParser.GetParsedTypeReference(method.ContainingType),
ReturnType = returnType,
IsCtor = isCtor,
Accessibility = method.DeclaredAccessibility.ToString().ToLower(),
IsAbstract = method.IsAbstract,
IsOverride = method.IsOverride,
IsPrivate = method.DeclaredAccessibility == Accessibility.Private,
IsProtected = method.DeclaredAccessibility == Accessibility.Protected,
IsPublic = method.DeclaredAccessibility == Accessibility.Public,
IsSealed = method.IsSealed,
IsVirtual = method.IsVirtual,
IsStatic = method.IsStatic,
Documentations = DocumentationParser.ParseDocumentation(method),
Region = syntaxReference != null ? new SDRegion
{
Start = syntaxReference.Span.Start,
End = syntaxReference.Span.End,
StartLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).StartLinePosition.Line + 1,
EndLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).EndLinePosition.Line + 1,
FilePath = syntaxReference.SyntaxTree.FilePath,
Filename = Path.GetFileName(syntaxReference.SyntaxTree.FilePath)
} : null
};
sdMethod.TypeParameters = _typeParameterParser.ParseTypeParameters(method.TypeParameters);
foreach (var parameter in method.Parameters)
{
sdMethod.Parameters.Add(new SDParameter
{
Name = parameter.Name,
ParamType = _typeRefParser.GetParsedTypeReference(parameter.Type),
IsOptional = parameter.IsOptional,
IsConst = parameter.HasExplicitDefaultValue,
ConstantValue = parameter.HasExplicitDefaultValue ? parameter.ExplicitDefaultValue?.ToString() ?? "null" : null,
IsRef = parameter.RefKind == RefKind.Ref,
IsOut = parameter.RefKind == RefKind.Out
});
}
ParserOptions.SDRepository.AddMethod(sdMethod);
return(sdMethod);
}
public void ShouldReturnTrueForSequenceDiagramIsEmpty()
{
//Arrange
var sdMethod = new SDMethod("SharpDox.UML.Tests.DiagramExtensionsTests.Method1", "Method1");
//Act
var isEmpty = sdMethod.IsSequenceDiagramEmpty();
//Assert
Assert.AreEqual(true, isEmpty);
}
public void ShouldReturnTrueForSequenceDiagramIsEmptyBecauseOnlyCallsToStrangers()
{
//Arrange
var sdType = new SDType("SharpDox.UML.Tests.DiagramExtensionsTests", "DiagramExtensionTests", new SDNamespace("SharpDox.UML.Tests"));
var sdMethod = new SDMethod("SharpDox.UML.Tests.DiagramExtensionsTests.Method1", "Method1");
var sdTypeStranger = new SDType("System.String", "String", new SDNamespace("System"));
var sdMethodStranger = new SDMethod("System.String.Method1", "Method1");
var sdNode = new SDTargetNode();
sdNode.CalledType = sdTypeStranger;
sdNode.CalledMethod = sdMethodStranger;
sdNode.CallerMethod = sdMethod;
sdNode.CallerType = sdType;
sdMethod.Calls.Add(sdNode);
//Act
var isEmpty = sdMethod.IsSequenceDiagramEmpty();
//Assert
Assert.AreEqual(true, isEmpty);
}
/// <default>
/// <summary>
/// With this method you are able to check, if the sequence diagram, for the
/// given <c>SDMethod</c>, is empty.
/// </summary>
/// <param name="method">Check for this <c>SDMethod</c>.</param>
/// <returns>True, if it is empty. False, otherwise.</returns>
/// </default>
/// <de>
/// <summary>
/// Mit dieser Method kann überprüft werden, ob das Sequenzdiagramm , für den
/// gegebenen <c>SDMethod</c>, leer ist.
/// </summary>
/// <param name="method">Überprüfe diesen <c>SDMethod</c>.</param>
/// <returns>True, falls leer. False, ansonsten.</returns>
/// </de>
public static bool IsSequenceDiagramEmpty(this SDMethod method)
{
return(new SequenceDiagramParser(method).IsSequenceDiagramEmpty());
}
private void ParseTargetExpression(InvocationExpressionSyntax expression)
{
var compilation = _file.Project.GetCompilationAsync().Result;
var symbolInfo = compilation.GetSemanticModel(_file.GetSyntaxTreeAsync().Result).GetSymbolInfo(expression);
if (symbolInfo.Symbol != null)
{
var member = symbolInfo.Symbol;
var method = member as IMethodSymbol;
if (method != null)
{
var callerType = _type;
var callerMethod = _method;
SDType calledType = null;
var sdType = _repository.GetTypeByIdentifier(member.ContainingType.GetIdentifier());
if (sdType == null)
{
var sdNamespace = _repository.GetNamespaceByIdentifier(member.ContainingNamespace.ToDisplayString());
sdNamespace = sdNamespace ?? new SDNamespace(member.ContainingNamespace.ToDisplayString())
{
IsProjectStranger = true
};
calledType = new SDType(member.ContainingType.GetIdentifier(), member.ContainingType.Name, sdNamespace)
{
IsProjectStranger = true
};
}
else
{
calledType = sdType;
}
SDMethod calledMethod = null;
if (calledType.IsProjectStranger)
{
calledMethod = new SDMethod(method.GetIdentifier(), method.Name);
}
else
{
SDMethod sdMethod = sdType.Methods.Concat(sdType.Constructors).SingleOrDefault(m => m.Identifier == method.GetIdentifier());
if (sdMethod != null)
{
calledMethod = sdMethod;
}
}
// Only add method, if it is project stranger, public or private (if not only public members option on)
if (calledMethod != null)
{
var token = new SDTargetNode
{
CalledType = calledType,
CallerType = callerType,
CalledMethod = calledMethod,
CallerMethod = callerMethod
};
_tokenList.Add(token);
}
}
}
}
public SequenceDiagramParser(SDMethod method, List <SDType> repositoryTypes = null)
{
_method = method;
_repositoryTypes = repositoryTypes;
}
public SequenceDiagramParser(SDMethod method, SDRepository sdRepository = null)
{
_method = method;
_sdRepository = sdRepository;
}
private string GetUniqueShortMethodIdentifier(SDMethod sdMethod)
{
return(GetUniquieShortIdentifier(sdMethod.Identifier, sdMethod.Name, _methodNameCount, _uniqueShortMethodIdentifier));
}
/// <default>
/// <summary>
/// Creates the sequence diagram for the given <c>SDMethod</c>.
/// </summary>
/// <param name="method">Create the sequence diagram for this <c>SDMethod</c>.</param>
/// <param name="repositoryTypes">The method needs all known types of the current solution.
/// You are able to get it with the <c>GetAllTypes</c> method of the <c>SDRepository</c>.</param>
/// <returns>The sequence diagram for the given <c>SDMethod</c>.</returns>
/// </default>
/// <de>
/// <summary>
/// Erstellt das Sequenzdiagramm für die gegebene <c>SDMethod</c>.
/// </summary>
/// <param name="method">Erstellt das Sequenzdiagramm für dies <c>SDMethod</c>.</param>
/// <param name="repositoryTypes">Die Methode benötigt alle bekannten Typen der aktuellen Lösung.
/// Es ist möglich diese mit der <c>GetAllTypes</c> Methode des <c>SDRepository</c> zubekommen.</param>
/// <returns>Das Sequenzdiagramm für die <c>SDMethod</c>.</returns>
/// </de>
public static ISDDiagram GetSequenceDiagram(this SDMethod method, List <SDType> repositoryTypes)
{
var sequenceDiagramParser = new SequenceDiagramParser(method, repositoryTypes);
return(sequenceDiagramParser.CreateSequenceDiagram());
}
private void ParseTargetExpression(Expression expression)
{
if (_file != null)
{
var resolver = new CSharpAstResolver(_file.Project.Compilation, _file.SyntaxTree, _file.UnresolvedTypeSystemForFile);
var resolveResult = resolver.Resolve(expression);
if (resolveResult is CSharpInvocationResolveResult)
{
var member = ((CSharpInvocationResolveResult)resolveResult).Member;
var method = member as IMethod;
if (method != null)
{
var callerType = _type;
var callerMethod = _method;
SDType calledType = null;
var sdType = _repository.GetTypeByIdentifier(member.DeclaringType.GetIdentifier());
if (sdType == null)
{
var sdNamespace = _repository.GetNamespaceByIdentifier(member.DeclaringType.Namespace);
sdNamespace = sdNamespace == null ? new SDNamespace(member.DeclaringType.Namespace)
{
IsProjectStranger = true
} : sdNamespace;
calledType = new SDType(member.DeclaringType.GetIdentifier(), member.DeclaringType.Name, sdNamespace)
{
IsProjectStranger = true
};
}
else
{
calledType = sdType;
}
SDMethod calledMethod = null;
if (calledType.IsProjectStranger)
{
calledMethod = new SDMethod(method.GetIdentifier(), method.Name);
}
else
{
SDMethod sdMethod = sdType.Methods.Concat(sdType.Constructors).SingleOrDefault(m => m.Identifier == method.GetIdentifier());
if (sdMethod != null)
{
calledMethod = sdMethod;
}
}
// Only add method, if it is project stranger, public or private (if not only public members option on)
if (calledMethod != null)
{
var token = new SDTargetNode
{
CalledType = calledType,
CallerType = callerType,
CalledMethod = calledMethod,
CallerMethod = callerMethod
};
_tokenList.Add(token);
}
}
}
}
}
/// <default>
/// <summary>
/// Creates the sequence diagram for the given <c>SDMethod</c>.
/// </summary>
/// <param name="method">Create the sequence diagram for this <c>SDMethod</c>.</param>
/// <param name="sdProject">The method needs the complete parsed sharpDox project.</param>
/// <returns>The sequence diagram for the given <c>SDMethod</c>.</returns>
/// </default>
/// <de>
/// <summary>
/// Erstellt das Sequenzdiagramm für die gegebene <c>SDMethod</c>.
/// </summary>
/// <param name="method">Erstellt das Sequenzdiagramm für dies <c>SDMethod</c>.</param>
/// <param name="sdRepository">Die Methode benötigt das eingelesene Repository.</param>
/// <returns>Das Sequenzdiagramm für die <c>SDMethod</c>.</returns>
/// </de>
public static ISDDiagram GetSequenceDiagram(this SDMethod method, SDRepository sdRepository)
{
var sequenceDiagramParser = new SequenceDiagramParser(method, sdRepository);
return(sequenceDiagramParser.CreateSequenceDiagram());
}
