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