private async Task <Solution> CreateTestDataBuilderAsync(
Document contextDocument, TypeDeclarationSyntax declaration, CancellationToken cancellationToken)
{
try {
Project contextDocumentProject = contextDocument.Project;
Solution originalSolution = contextDocumentProject.Solution;
Project testProject = originalSolution.Projects.FirstOrDefault(p => p.Name == contextDocument.Project.Name + ".Test");
if (testProject == null)
{
return(originalSolution);
}
SemanticModel semanticModel = await contextDocument.GetSemanticModelAsync(cancellationToken);
ISymbol typeSymbol = semanticModel.GetDeclaredSymbol(declaration, cancellationToken);
/*Datei erstellen*/
string[] folders = { "src", "Builders" };
TestDataBuilderSyntaxWriter testDataBuilderSyntaxWriter = new TestDataBuilderSyntaxWriter(
typeSymbol.Name,
typeSymbol.ContainingNamespace.ToString());
SyntaxNode syntaxNode = testDataBuilderSyntaxWriter.CreateBuilderClass();
SyntaxNode formattedBuilderClassSyntax = Formatter.Format(syntaxNode, testProject.Solution.Workspace);
/*Klasse anpassen*/
SourceText sourceText = formattedBuilderClassSyntax.GetText();
Document testDataBuilderDocument = testProject.AddDocument(typeSymbol.Name + "Builder.cs", sourceText, folders);
return(testDataBuilderDocument.Project.Solution);
} catch (Exception e) {
Debug.WriteLine(e.Message);
throw;
}
}
internal static bool IsAccordingSetterMethod(IFieldSymbol field, IMethodSymbol setterMethod)
{
string fieldNameWithoutUnderscore = field.Name.Substring(1);
string expectedNameInMethod = TestDataBuilderSyntaxWriter.ToUpperCamelCase(fieldNameWithoutUnderscore);
if (setterMethod.Name.EndsWith(expectedNameInMethod) && !setterMethod.Parameters.Any())
{
/*Die Methode hat den gleichen Namen wie das Feld (ohne _ und mit großem Anfangsbuchstaben) und hat keine Parameter => sollte passen. */
/*Bsp.: _isPublished => Published() */
return(true);
}
else
{
foreach (IParameterSymbol methodParameter in setterMethod.Parameters)
{
if (methodParameter.Name == fieldNameWithoutUnderscore && TypeHelper.AreTypesEqual(field.Type, methodParameter.Type))
{
/*Der Name des Parameters entspricht dem Namen (ohne _) und die Typen sind gleich. => sollte passen*/
/*Bsp.: string _firstname => WithFirstname(string firstname) */
/*Bsp.: string _name => WithFirstname(string name) */
/*Bsp.: DateTime _createdAt und User _createdBy => CreatedByAndAt(User createdBy, DateTime createdAt) */
return(true);
}
}
}
return(false);
}
private ClassDeclarationSyntax AddCreateMethodForBuilder(
ClassDeclarationSyntax originalCreateClassDeclarationSyntax, ITypeSymbol builderTypeSymbol)
{
int indexForNewPublicMethod = TestDataBuilderSyntaxWriter.GetIndexForNewPublicMethod(originalCreateClassDeclarationSyntax);
SyntaxList <MemberDeclarationSyntax> memberDeclarationSyntaxs =
originalCreateClassDeclarationSyntax.Members.Insert(indexForNewPublicMethod, GetCreateMethodSyntax(builderTypeSymbol));
return(originalCreateClassDeclarationSyntax.WithMembers(memberDeclarationSyntaxs));
}
protected override async Task <Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
{
Project documentProject = Context.Document.Project;
string testProjectName = documentProject.Name + ".Test";
Project testProject = documentProject.Solution.Projects.SingleOrDefault(p => p.Name == testProjectName);
if (testProject == null)
{
return(null);
}
Compilation fieldCompilation = await documentProject.GetCompilationAsync(cancellationToken);
SemanticModel semanticModel = fieldCompilation.GetSemanticModel(Declaration.SyntaxTree);
IFieldSymbol fieldSymbol = (IFieldSymbol)semanticModel.GetDeclaredSymbol(Declaration.Declaration.Variables[0]);
ITypeSymbol type = fieldSymbol.ContainingType;
string builderTypeName = type.Name + "Builder";
Compilation compilation = await testProject.GetCompilationAsync(cancellationToken);
ITypeSymbol builderSymbol = compilation.GetSymbolsWithName(s => s == builderTypeName, SymbolFilter.Type).OfType <ITypeSymbol>()
.FirstOrDefault();
if (builderSymbol == null)
{
return(null);
}
SyntaxReference builderSymbolDeclaringSyntaxReference = builderSymbol.DeclaringSyntaxReferences[0];
ClassDeclarationSyntax classDeclarationFromSymbol = builderSymbolDeclaringSyntaxReference.GetSyntax() as ClassDeclarationSyntax;
if (classDeclarationFromSymbol == null)
{
return(null);
}
Document document = testProject.GetDocument(classDeclarationFromSymbol.SyntaxTree);
SyntaxTree documentSyntaxTree = document.GetSyntaxTreeAsync(cancellationToken).Result;
SyntaxNode root = documentSyntaxTree.GetRoot();
ClassDeclarationSyntax originalClassDeclarationSyntax = root.DescendantNodes().OfType <ClassDeclarationSyntax>().FirstOrDefault();
if (originalClassDeclarationSyntax == null)
{
return(null);
}
ClassDeclarationSyntax changedBuilderClassSyntax =
TestDataBuilderSyntaxWriter.UpdateBuilderToGenerateCodeToSetField(originalClassDeclarationSyntax, builderSymbol, fieldSymbol, type);
SyntaxNode formattedBuilderClassSyntax = Formatter.Format(changedBuilderClassSyntax, document.Project.Solution.Workspace);
SyntaxNode changedRootNode = root.ReplaceNode(originalClassDeclarationSyntax, formattedBuilderClassSyntax);
return(document.WithSyntaxRoot(changedRootNode));
}
