private TypeDefinition _CreateTypeDefinition(ClassDeclarationSyntax inputClassDeclaration, CompilationUnitSyntax rootNode)
{
var _typeDefinition = TypeDefinition.Create(
inputClassDeclaration.Identifier.ToString(),
((NamespaceDeclarationSyntax)inputClassDeclaration.Parent).Name.ToString());
_typeDefinition = _typeDefinition
.AddUsings(rootNode.Usings);
var _typeValidationMethod = inputClassDeclaration.Members
.Where(_member => _member.Kind() == SyntaxKind.MethodDeclaration)
.Cast <MethodDeclarationSyntax>()
.Where(_method => _method.Modifiers.Any(SyntaxKind.StaticKeyword))
.Where(_method => _method.ParameterList.Parameters.Count == 1)
.SingleOrDefault(_method => _method.Identifier.Text == NameHelper.TextToPublicMethodIdentifier("IsValid").Text);
if (_typeValidationMethod != null)
{
var _valueParameter = _typeValidationMethod.ParameterList.Parameters[_typeValidationMethod.ParameterList.Parameters.Count - 1];
Must.Assert(_valueParameter.Type.ToString() == _typeDefinition.Name);
_typeDefinition = _typeDefinition
.WithValidateMethodName(SyntaxFactory.IdentifierName(_typeValidationMethod.Identifier));
}
_typeDefinition = _typeDefinition.AddProperties(_CreatePropertyDefinitions(inputClassDeclaration));
return(_typeDefinition);
}
public async Task <Project> PatchProjectAsync(Project project, CancellationToken cancellationToken = default(CancellationToken))
{
var _modified = false;
var _project = project;
foreach (var _documentId in project.DocumentIds)
{
var _document = _project.GetDocument(_documentId);
if (_document.SupportsSyntaxTree)
{
var _syntaxTree = await _document.GetSyntaxRootAsync(cancellationToken);
CompilationUnitSyntax _compilationUnit;
if (_syntaxTree?.Language == LanguageNames.CSharp && (_compilationUnit = _syntaxTree as CompilationUnitSyntax) != null)
{
var _typeDefinition = _TypeDefinitionGenerator.GenerateTypeDefinition(_compilationUnit);
if (_typeDefinition != null)
{
Must.Assert(!(Path.GetFileNameWithoutExtension(_document.Name) ?? string.Empty).EndsWith(_GeneratedImmutablerFileSufix, StringComparison.OrdinalIgnoreCase));
var _generatedImmutablerSyntax = _SyntaxBuilder.BuildSyntaxFromTypeDefinition(_typeDefinition);
var _generatedImmutablerDocumentName = Path.GetFileNameWithoutExtension(_document.Name) + _GeneratedImmutablerFileSufix + Path.GetExtension(_document.Name);
var _generatedImmutablerDocument = _project.Documents.SingleOrDefault(_d => _d.Name.Equals(_generatedImmutablerDocumentName, StringComparison.OrdinalIgnoreCase));
Must.Assert(_generatedImmutablerDocument == null || _generatedImmutablerDocument.Name.Equals(_generatedImmutablerDocumentName, StringComparison.Ordinal));
if (_generatedImmutablerDocument == null)
{
_generatedImmutablerDocument = _project.AddDocument(
_generatedImmutablerDocumentName,
_generatedImmutablerSyntax,
folders: _document.Folders);
_project = _generatedImmutablerDocument.Project;
_modified = true;
}
else
{
var _existingGeneratedImmutablerSyntax = await _generatedImmutablerDocument.GetSyntaxRootAsync(cancellationToken);
if (!string.Equals(_generatedImmutablerSyntax.ToFullString(), _existingGeneratedImmutablerSyntax.ToFullString(), StringComparison.Ordinal))
{
_generatedImmutablerDocument = _generatedImmutablerDocument.WithSyntaxRoot(_generatedImmutablerSyntax);
_project = _generatedImmutablerDocument.Project;
_modified = true;
}
}
}
}
}
}
return(_modified ? _project : null);
}
private static bool _ReadBoolFromConfiguration(string configurationKey, bool defaultValue)
{
var _value = ConfigurationManager.AppSettings[configurationKey];
if (string.Equals(_value, "true", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (string.Equals(_value, "false", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
Must.Assert(string.IsNullOrEmpty(_value), $"Value of configuration setting {configurationKey} is not a valid boolean. Must be empty, 'true' or 'false'.");
return(defaultValue);
}
public CompilationUnitSyntax BuildSyntaxFromTypeDefinition(TypeDefinition typeDefinition)
{
Must
.Assert(typeDefinition != null);
var _outputClass = _CreateOutputClass(typeDefinition);
var _outputDeclaration = SyntaxFactory
.CompilationUnit()
.AddUsings(typeDefinition.Usings.ToArray())
.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(SyntaxFactory
.NamespaceDeclaration(SyntaxFactory.IdentifierName(typeDefinition.Namespace))
.AddMembers(_outputClass)));
_outputDeclaration = _outputDeclaration
.RemoveNodes(_outputDeclaration.DescendantNodes().OfType <EmptyStatementSyntax>(), SyntaxRemoveOptions.KeepUnbalancedDirectives)
.NormalizeWhitespace()
.WithTrailingTrivia(_outputDeclaration.GetTrailingTrivia().Append(SyntaxFactory.EndOfLine(string.Empty)));
return(_outputDeclaration);
}
private PropertyDefinition _CreatePropertyDefinition(PropertyDeclarationSyntax inputPropertyDeclaration, ClassDeclarationSyntax inputClassDeclaration)
{
var _propertyDefinition = PropertyDefinition.Create(inputPropertyDeclaration.Identifier.Text, inputPropertyDeclaration.Type.ToString());
var _propertyValidationMethod = inputClassDeclaration.Members
.Where(_member => _member.Kind() == SyntaxKind.MethodDeclaration)
.Cast <MethodDeclarationSyntax>()
.Where(_method => _method.Modifiers.Any(SyntaxKind.StaticKeyword))
.Where(_method => _method.ParameterList.Parameters.Count == 1)
.SingleOrDefault(_method => _method.Identifier.Text == NameHelper.TextToPublicMethodIdentifier("Is" + _propertyDefinition.Name + "Valid").Text);
if (_propertyValidationMethod != null)
{
var _valueParameter = _propertyValidationMethod.ParameterList.Parameters[_propertyValidationMethod.ParameterList.Parameters.Count - 1];
Must.Assert(_valueParameter.Type.ToString() == _propertyDefinition.Type);
_propertyDefinition = _propertyDefinition
.WithValidateMethodName(SyntaxFactory.IdentifierName(_propertyValidationMethod.Identifier));
}
var _defaultProperty = inputClassDeclaration.Members
.Where(_member => _member.Kind() == SyntaxKind.PropertyDeclaration)
.Cast <PropertyDeclarationSyntax>()
.Where(_p => _p.Modifiers.Any(SyntaxKind.StaticKeyword))
.SingleOrDefault(_p => _p.Identifier.Text == NameHelper.TextToPublicPropertyIdentifier("Default" + _propertyDefinition.Name).Text);
if (_defaultProperty != null)
{
Must.Assert(_defaultProperty.Type.ToString() == _propertyDefinition.Type);
_propertyDefinition = _propertyDefinition.WithDefaultValuePropertyName(SyntaxFactory.IdentifierName(_defaultProperty.Identifier));
}
return(_propertyDefinition);
}
public TypeDefinition AddProperties(params PropertyDefinition[] properties)
{
Must.Assert(properties != null);
return(WithProperties(Properties.AddRange(properties)));
}
public TypeDefinition AddProperties(IEnumerable <PropertyDefinition> properties)
{
Must.Assert(properties != null);
return(WithProperties(Properties.AddRange(properties)));
}
public TypeDefinition AddUsings(IEnumerable <UsingDirectiveSyntax> usings)
{
Must.Assert(usings != null);
return(WithUsings(Usings.AddRange(usings)));
}