Stable implementation 0.1

2026-07-15 15:19:59 +00:00 · 2022-03-22 10:14:01 +01:00
parent ae34a4683d
commit bb536a88a3
15 changed files with 705 additions and 10 deletions
@@ -0,0 +1,67 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Sybil.IntegrationTests
+{
+    [TestClass]
+    public sealed class FlowTests
+    {
+        private const string ExpectedNamespace =
+@"namespace TestNamespace
+{
+    using System;
+
+    public sealed class TestClass
+    {
+        TestClass(string fieldString) : base(fieldString)
+        {
+            this.fieldString = fieldString ?? throw new ArgumentNullException();
+        }
+
+        private string fieldString;
+        public string PropertyString { private set; get; }
+
+        public string GetFieldString()
+        {
+            return this.fieldString;
+        }
+    }
+}";
+
+        [TestMethod]
+        public void NewNamespace_GeneratesExpected()
+        {
+            var namespaceSyntax = SyntaxBuilder.CreateNamespace("TestNamespace")
+                .WithUsing("System")
+                .WithClass(
+                    SyntaxBuilder.CreateClass("TestClass")
+                    .WithModifiers("public sealed")
+                    .WithConstructor(
+                        SyntaxBuilder.CreateConstructor("TestClass")
+                        .WithBase(
+                            SyntaxBuilder.CreateBaseConstructor()
+                            .WithArgument("fieldString"))
+                        .WithParameter("string", "fieldString")
+                        .WithBody("this.fieldString = fieldString ?? throw new ArgumentNullException();"))
+                    .WithField(
+                        SyntaxBuilder.CreateField("string", "fieldString")
+                        .WithModifier("private"))
+                    .WithProperty(
+                        SyntaxBuilder.CreateProperty("string", "PropertyString")
+                        .WithModifier("public")
+                        .WithAccessor(
+                            SyntaxBuilder.CreateSetter()
+                            .WithModifier("private"))
+                        .WithAccessor(
+                            SyntaxBuilder.CreateGetter()))
+                    .WithMethod(
+                        SyntaxBuilder.CreateMethod("string", "GetFieldString")
+                        .WithModifier("public")
+                        .WithBody("return this.fieldString;")))
+                .Build();
+
+            var namespaceString = namespaceSyntax.ToFullString();
+            namespaceString.Should().Be(ExpectedNamespace);
+        }
+    }
+}
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="6.5.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.7" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.7" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Sybil\Sybil.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -8,10 +8,18 @@
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="2.2.7" />
-    <PackageReference Include="MSTest.TestFramework" Version="2.2.7" />
-    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="FluentAssertions" Version="6.5.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.8" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.8" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Sybil\Sybil.csproj" />
  </ItemGroup>

 </Project>
@@ -3,9 +3,11 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sybil", "Sybil\Sybil.csproj", "{5B024A18-C109-4CED-8952-B1793EC634CD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sybil", "Sybil\Sybil.csproj", "{5B024A18-C109-4CED-8952-B1793EC634CD}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sybil.UnitTests", "Sybil.UnitTests\Sybil.UnitTests.csproj", "{458625E9-7427-47C6-BEE9-6269BDA00282}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sybil.UnitTests", "Sybil.UnitTests\Sybil.UnitTests.csproj", "{458625E9-7427-47C6-BEE9-6269BDA00282}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sybil.IntegrationTests", "Sybil.IntegrationTests\Sybil.IntegrationTests.csproj", "{4BE3F7BF-602C-447E-B29B-011AE7274E4A}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -21,6 +23,10 @@ Global
 		{458625E9-7427-47C6-BEE9-6269BDA00282}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{458625E9-7427-47C6-BEE9-6269BDA00282}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{458625E9-7427-47C6-BEE9-6269BDA00282}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4BE3F7BF-602C-447E-B29B-011AE7274E4A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4BE3F7BF-602C-447E-B29B-011AE7274E4A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4BE3F7BF-602C-447E-B29B-011AE7274E4A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4BE3F7BF-602C-447E-B29B-011AE7274E4A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -0,0 +1,79 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+
+namespace Sybil
+{
+    public sealed class AccessorBuilder : IBuilder<AccessorDeclarationSyntax>
+    {
+        private readonly SyntaxKind accessor;
+
+        private SyntaxTokenList Modifiers { get; set; }
+        private BlockSyntax BlockSyntax { get; set; }
+        private ArrowExpressionClauseSyntax ArrowExpressionClauseSyntax { get; set; }
+
+        internal AccessorBuilder(
+            SyntaxKind accessor)
+        {
+            this.accessor = accessor;
+        }
+
+        public AccessorBuilder WithModifier(string modifier)
+        {
+            _ = string.IsNullOrWhiteSpace(modifier) ? throw new ArgumentNullException(nameof(modifier)) : modifier;
+
+            this.Modifiers = SyntaxFactory.TokenList(SyntaxFactory.ParseToken(modifier));
+
+            return this;
+        }
+        public AccessorBuilder WithModifiers(string modifiers)
+        {
+            _ = string.IsNullOrWhiteSpace(modifiers) ? throw new ArgumentNullException(nameof(modifiers)) : modifiers;
+
+            this.Modifiers = SyntaxFactory.TokenList(SyntaxFactory.ParseTokens(modifiers));
+
+            return this;
+        }
+        public AccessorBuilder WithBody(string body)
+        {
+            _ = string.IsNullOrWhiteSpace(body) ? throw new ArgumentNullException(nameof(body)) : body;
+
+            this.ArrowExpressionClauseSyntax = null;
+            this.BlockSyntax = SyntaxFactory.Block(SyntaxFactory.ParseStatement(body));
+
+            return this;
+        }
+        public AccessorBuilder WithArrowExpression(string expression)
+        {
+            _ = string.IsNullOrWhiteSpace(expression) ? throw new ArgumentNullException(nameof(expression)) : expression;
+
+            this.BlockSyntax = null;
+            this.ArrowExpressionClauseSyntax = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(expression));
+
+            return this;
+        }
+
+        public AccessorDeclarationSyntax Build()
+        {
+            return this.BuildAccessorDeclaration().NormalizeWhitespace();
+        }
+
+        private AccessorDeclarationSyntax BuildAccessorDeclaration()
+        {
+            var accessorDeclaration = SyntaxFactory.AccessorDeclaration(
+                kind: this.accessor,
+                attributeLists: SyntaxFactory.List<AttributeListSyntax>(),
+                modifiers: this.Modifiers,
+                body: this.BlockSyntax,
+                expressionBody: this.ArrowExpressionClauseSyntax);
+
+            if (this.BlockSyntax is null && this.ArrowExpressionClauseSyntax is null)
+            {
+                accessorDeclaration = accessorDeclaration.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
+            }
+
+            return accessorDeclaration;
+        }
+    }
+}
@@ -0,0 +1,31 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+
+namespace Sybil
+{
+    public sealed class BaseConstructorBuilder : IBuilder<ConstructorInitializerSyntax>
+    {
+        private ConstructorInitializerSyntax ConstructorInitializerSyntax { get; set; }
+
+        internal BaseConstructorBuilder()
+        {
+            this.ConstructorInitializerSyntax = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer);
+        }
+
+        public BaseConstructorBuilder WithArgument(string argumentName)
+        {
+            _ = string.IsNullOrWhiteSpace(argumentName) ? throw new ArgumentNullException(nameof(argumentName)) : argumentName;
+
+            this.ConstructorInitializerSyntax = this.ConstructorInitializerSyntax.AddArgumentListArguments(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(argumentName)));
+
+            return this;
+        }
+
+        public ConstructorInitializerSyntax Build()
+        {
+            return ConstructorInitializerSyntax.NormalizeWhitespace();
+        }
+    }
+}
@@ -0,0 +1,85 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Sybil
+{
+    public sealed class ClassBuilder : IBuilder<ClassDeclarationSyntax>
+    {
+        private readonly string className;
+        private ClassDeclarationSyntax ClassDeclaration { get; set; }
+
+        private readonly List<ConstructorBuilder> Constructors = new List<ConstructorBuilder>();
+        private readonly List<FieldBuilder> Fields = new List<FieldBuilder>();
+        private readonly List<PropertyBuilder> Properties = new List<PropertyBuilder>();
+        private readonly List<MethodBuilder> Methods = new List<MethodBuilder>();
+
+        internal ClassBuilder(
+            string className)
+        {
+            _ = string.IsNullOrWhiteSpace(className) ? throw new ArgumentNullException(nameof(className)) : className;
+
+            this.className = className;
+            this.ClassDeclaration = SyntaxFactory.ClassDeclaration(className);
+        }
+
+        public ClassBuilder WithModifier(string modifier)
+        {
+            _ = string.IsNullOrWhiteSpace(modifier) ? throw new ArgumentNullException(nameof(modifier)) : modifier;
+
+            this.ClassDeclaration = this.ClassDeclaration.AddModifiers(SyntaxFactory.ParseToken(modifier));
+
+            return this;
+        }
+
+        public ClassBuilder WithModifiers(string modifiers)
+        {
+            _ = string.IsNullOrWhiteSpace(modifiers) ? throw new ArgumentNullException(nameof(modifiers)) : modifiers;
+
+            this.ClassDeclaration = this.ClassDeclaration.AddModifiers(SyntaxFactory.ParseTokens(modifiers).ToArray());
+
+            return this;
+        }
+
+        public ClassBuilder WithField(FieldBuilder fieldBuilder)
+        {
+            this.Fields.Add(fieldBuilder ?? throw new ArgumentNullException(nameof(fieldBuilder)));
+
+            return this;
+        }
+
+        public ClassBuilder WithProperty(PropertyBuilder propertyBuilder)
+        {
+            this.Properties.Add(propertyBuilder ?? throw new ArgumentNullException(nameof(propertyBuilder)));
+
+            return this;
+        }
+
+        public ClassBuilder WithMethod(MethodBuilder methodBuilder)
+        {
+            this.Methods.Add(methodBuilder ?? throw new ArgumentNullException(nameof(methodBuilder)));
+
+            return this;
+        }
+
+        public ClassBuilder WithConstructor(ConstructorBuilder constructorBuilder)
+        {
+            this.Constructors.Add(constructorBuilder ?? throw new ArgumentNullException(nameof(constructorBuilder)));
+
+            return this;
+        }
+
+        public ClassDeclarationSyntax Build()
+        {
+            return this.ClassDeclaration
+                .AddMembers(this.Constructors.Select(p => p.Build()).ToArray())
+                .AddMembers(this.Fields.Select(p => p.Build()).ToArray())
+                .AddMembers(this.Properties.Select(p => p.Build()).ToArray())
+                .AddMembers(this.Methods.Select(p => p.Build()).ToArray())
+                .NormalizeWhitespace();
+        }
+    }
+}
@@ -0,0 +1,86 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Linq;
+
+namespace Sybil
+{
+    public sealed class ConstructorBuilder : IBuilder<ConstructorDeclarationSyntax>
+    {
+        private BaseConstructorBuilder baseConstructorBuilder;
+
+        private ConstructorDeclarationSyntax ConstructorDeclarationSyntax { get; set; }
+
+        internal ConstructorBuilder(
+            string className)
+        {
+            _ = string.IsNullOrWhiteSpace(className) ? throw new ArgumentNullException(nameof(className)) : className;
+
+            this.ConstructorDeclarationSyntax = SyntaxFactory.ConstructorDeclaration(className);
+            this.ConstructorDeclarationSyntax = this.ConstructorDeclarationSyntax.WithBody(SyntaxFactory.Block());
+        }
+
+        public ConstructorBuilder WithBase(BaseConstructorBuilder baseConstructorBuilder)
+        {
+            this.baseConstructorBuilder = baseConstructorBuilder;
+            return this;
+        }
+        public ConstructorBuilder WithModifiers(string modifiers)
+        {
+            _ = string.IsNullOrWhiteSpace(modifiers) ? throw new ArgumentNullException(nameof(modifiers)) : modifiers;
+
+            this.ConstructorDeclarationSyntax = this.ConstructorDeclarationSyntax.AddModifiers(SyntaxFactory.ParseTokens(modifiers).ToArray());
+
+            return this;
+        }
+        public ConstructorBuilder WithModifier(string modifier)
+        {
+            _ = string.IsNullOrWhiteSpace(modifier) ? throw new ArgumentNullException(nameof(modifier)) : modifier;
+
+            this.ConstructorDeclarationSyntax = this.ConstructorDeclarationSyntax.AddModifiers(SyntaxFactory.ParseToken(modifier));
+
+            return this;
+        }
+        public ConstructorBuilder WithParameter(string parameterType, string parameterName, string defaultValue = null)
+        {
+            _ = string.IsNullOrWhiteSpace(parameterName) ? throw new ArgumentNullException(nameof(parameterName)) : parameterName;
+            _ = string.IsNullOrWhiteSpace(parameterType) ? throw new ArgumentNullException(nameof(parameterType)) : parameterType;
+
+            EqualsValueClauseSyntax equalsValueClauseSyntax = null;
+            if (string.IsNullOrWhiteSpace(defaultValue) is false)
+            {
+                equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(
+                    SyntaxFactory.ParseExpression(defaultValue));
+            }
+
+            var parameter = SyntaxFactory.Parameter(
+                new SyntaxList<AttributeListSyntax>(),
+                new SyntaxTokenList(),
+                SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(parameterType)),
+                SyntaxFactory.Identifier(parameterName),
+                equalsValueClauseSyntax);
+            this.ConstructorDeclarationSyntax = this.ConstructorDeclarationSyntax.AddParameterListParameters(parameter);
+
+            return this;
+        }
+        public ConstructorBuilder WithBody(string body)
+        {
+            _ = string.IsNullOrWhiteSpace(body) ? throw new ArgumentNullException(nameof(body)) : body;
+
+            this.ConstructorDeclarationSyntax = this.ConstructorDeclarationSyntax.WithBody(SyntaxFactory.Block(SyntaxFactory.ParseStatement(body)));
+
+            return this;
+        }
+
+        public ConstructorDeclarationSyntax Build()
+        {
+            if (this.baseConstructorBuilder is null is false)
+            {
+                this.ConstructorDeclarationSyntax = this.ConstructorDeclarationSyntax.WithInitializer(this.baseConstructorBuilder.Build());
+            }
+
+            return this.ConstructorDeclarationSyntax.NormalizeWhitespace();
+        }
+    }
+}
@@ -0,0 +1,48 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Linq;
+
+namespace Sybil
+{
+    public sealed class FieldBuilder : IBuilder<FieldDeclarationSyntax>
+    {
+        private FieldDeclarationSyntax FieldDeclarationSyntax { get; set; }
+
+        internal FieldBuilder(
+            string fieldType,
+            string fieldName)
+        {
+            _ = string.IsNullOrWhiteSpace(fieldType) ? throw new ArgumentNullException(nameof(fieldType)) : fieldType;
+            _ = string.IsNullOrWhiteSpace(fieldName) ? throw new ArgumentNullException(nameof(fieldName)) : fieldName;
+
+            var variableDeclaration = SyntaxFactory.VariableDeclaration(
+                SyntaxFactory.ParseTypeName(fieldType))
+                .AddVariables(SyntaxFactory.VariableDeclarator(fieldName));
+            this.FieldDeclarationSyntax = SyntaxFactory.FieldDeclaration(variableDeclaration);
+        }
+
+        public FieldBuilder WithModifier(string modifier)
+        {
+            _ = string.IsNullOrWhiteSpace(modifier) ? throw new ArgumentNullException(nameof(modifier)) : modifier;
+
+            this.FieldDeclarationSyntax = this.FieldDeclarationSyntax.AddModifiers(SyntaxFactory.ParseToken(modifier));
+
+            return this;
+        }
+        public FieldBuilder WithModifiers(string modifiers)
+        {
+            _ = string.IsNullOrWhiteSpace(modifiers) ? throw new ArgumentNullException(nameof(modifiers)) : modifiers;
+
+            this.FieldDeclarationSyntax = this.FieldDeclarationSyntax.AddModifiers(SyntaxFactory.ParseTokens(modifiers).ToArray());
+
+            return this;
+        }
+
+        public FieldDeclarationSyntax Build()
+        {
+            return this.FieldDeclarationSyntax.NormalizeWhitespace();
+        }
+    }
+}
@@ -0,0 +1,9 @@
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Sybil
+{
+    public interface IBuilder<T> where T : CSharpSyntaxNode
+    {
+        T Build();
+    }
+}
@@ -0,0 +1,97 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Linq;
+
+namespace Sybil
+{
+    public sealed class MethodBuilder : IBuilder<MethodDeclarationSyntax>
+    {
+        private BlockSyntax BlockBody { get; set; }
+        private ArrowExpressionClauseSyntax ArrowExpression { get; set; }
+        private MethodDeclarationSyntax MethodDeclarationSyntax { get; set; }
+
+        internal MethodBuilder(
+            string returnType, string name)
+        {
+            _ = string.IsNullOrWhiteSpace(returnType) ? throw new ArgumentNullException(nameof(returnType)) : returnType;
+            _ = string.IsNullOrWhiteSpace(name) ? throw new ArgumentNullException(nameof(name)) : name;
+
+            this.MethodDeclarationSyntax = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(returnType), SyntaxFactory.ParseToken(name));
+            this.ArrowExpression = SyntaxFactory.ArrowExpressionClause(
+                SyntaxFactory.ParseExpression("throw new NotImplementedException();"));
+        }
+
+        public MethodBuilder WithModifier(string modifier)
+        {
+            _ = string.IsNullOrWhiteSpace(modifier) ? throw new ArgumentNullException(nameof(modifier)) : modifier;
+
+            this.MethodDeclarationSyntax = this.MethodDeclarationSyntax.AddModifiers(SyntaxFactory.ParseToken(modifier));
+
+            return this;
+        }
+        public MethodBuilder WithModifiers(string modifiers)
+        {
+            _ = string.IsNullOrWhiteSpace(modifiers) ? throw new ArgumentNullException(nameof(modifiers)) : modifiers;
+
+            this.MethodDeclarationSyntax = this.MethodDeclarationSyntax.AddModifiers(SyntaxFactory.ParseTokens(modifiers).ToArray());
+
+            return this;
+        }
+        public MethodBuilder WithParameter(string parameterType, string parameterName, string defaultValue = null)
+        {
+            _ = string.IsNullOrWhiteSpace(parameterName) ? throw new ArgumentNullException(nameof(parameterName)) : parameterName;
+            _ = string.IsNullOrWhiteSpace(parameterType) ? throw new ArgumentNullException(nameof(parameterType)) : parameterType;
+
+            EqualsValueClauseSyntax equalsValueClauseSyntax = null;
+            if (string.IsNullOrWhiteSpace(defaultValue) is false)
+            {
+                equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(
+                    SyntaxFactory.ParseExpression(defaultValue));
+            }
+
+            var parameter = SyntaxFactory.Parameter(
+                SyntaxFactory.List<AttributeListSyntax>(),
+                new SyntaxTokenList(),
+                type: SyntaxFactory.ParseTypeName(parameterType),
+                identifier: SyntaxFactory.ParseToken(parameterName),
+                @default: equalsValueClauseSyntax);
+
+            this.MethodDeclarationSyntax = this.MethodDeclarationSyntax.AddParameterListParameters(parameter);
+
+            return this;
+        }
+        public MethodBuilder WithBody(string body)
+        {
+            this.BlockBody = SyntaxFactory.Block(
+                SyntaxFactory.ParseStatement(body));
+            this.ArrowExpression = null;
+
+            return this;
+        }
+        public MethodBuilder WithExpression(string expression)
+        {
+            this.ArrowExpression = SyntaxFactory.ArrowExpressionClause(
+                SyntaxFactory.ParseExpression(expression));
+            this.BlockBody = null;
+
+            return this;
+        }
+
+        public MethodDeclarationSyntax Build()
+        {
+            if (this.BlockBody is null is false)
+            {
+                return this.MethodDeclarationSyntax.WithBody(this.BlockBody);
+            }
+
+            if (this.ArrowExpression is null is false)
+            {
+                return this.MethodDeclarationSyntax.WithExpressionBody(this.ArrowExpression);
+            }
+
+            return this.MethodDeclarationSyntax;
+        }
+    }
+}
@@ -0,0 +1,51 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Sybil
+{
+    public sealed class NamespaceBuilder : IBuilder<NamespaceDeclarationSyntax>
+    {
+        private readonly List<ClassBuilder> classBuilders = new List<ClassBuilder>();
+        private NamespaceDeclarationSyntax NamespaceDeclaration { get; set; }
+
+        internal NamespaceBuilder(
+            string @namespace)
+        {
+            _ = string.IsNullOrWhiteSpace(@namespace) ? throw new ArgumentNullException(nameof(@namespace)) : @namespace;
+            
+            this.NamespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(@namespace));
+        }
+
+        public NamespaceBuilder WithUsing(string usingName)
+        {
+            _ = string.IsNullOrWhiteSpace(usingName) ? throw new ArgumentNullException(nameof(usingName)) : usingName;
+
+            this.NamespaceDeclaration = this.NamespaceDeclaration.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(usingName)));
+
+            return this;
+        }
+
+        public NamespaceBuilder WithClass(ClassBuilder classBuilder)
+        {
+            this.classBuilders.Add(classBuilder);
+
+            return this;
+        }
+
+        public NamespaceDeclarationSyntax Build()
+        {
+            return this.NamespaceDeclaration
+                .AddMembers(this.classBuilders.Select(c => c.Build()).ToArray())
+                .NormalizeWhitespace();
+        }
+
+        public static NamespaceBuilder Create(string @namespace)
+        {
+            return new NamespaceBuilder(@namespace);
+        }
+    }
+}
@@ -0,0 +1,62 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Sybil
+{
+    public sealed class PropertyBuilder : IBuilder<PropertyDeclarationSyntax>
+    {
+        private readonly List<AccessorBuilder> accessors = new List<AccessorBuilder>();
+
+        private PropertyDeclarationSyntax PropertyDeclarationSyntax { get; set; }
+
+        internal PropertyBuilder(
+            string typeName,
+            string propertyName)
+        {
+            _ = string.IsNullOrWhiteSpace(typeName) ? throw new ArgumentNullException(nameof(typeName)) : typeName;
+            _ = string.IsNullOrWhiteSpace(propertyName) ? throw new ArgumentNullException(nameof(propertyName)) : propertyName;
+
+            this.PropertyDeclarationSyntax = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(typeName), propertyName);
+        }
+
+        public PropertyBuilder WithModifier(string modifier)
+        {
+            _ = string.IsNullOrWhiteSpace(modifier) ? throw new ArgumentNullException(nameof(modifier)) : modifier;
+
+            this.PropertyDeclarationSyntax = this.PropertyDeclarationSyntax.AddModifiers(SyntaxFactory.ParseToken(modifier));
+
+            return this;
+        }
+        public PropertyBuilder WithModifiers(string modifiers)
+        {
+            _ = string.IsNullOrWhiteSpace(modifiers) ? throw new ArgumentNullException(nameof(modifiers)) : modifiers;
+
+            this.PropertyDeclarationSyntax = this.PropertyDeclarationSyntax.AddModifiers(SyntaxFactory.ParseTokens(modifiers).ToArray());
+
+            return this;
+        }
+        public PropertyBuilder WithAccessor(AccessorBuilder accessorBuilder)
+        {
+            this.accessors.Add(accessorBuilder);
+
+            return this;
+        }
+
+        public PropertyDeclarationSyntax Build()
+        {
+            return this.PropertyDeclarationSyntax.WithAccessorList(this.BuildAccessorList()).NormalizeWhitespace();
+        }
+
+        private AccessorListSyntax BuildAccessorList()
+        {
+            return SyntaxFactory.AccessorList(
+                SyntaxFactory.Token(SyntaxKind.OpenBraceToken),
+                accessors: SyntaxFactory.List(this.accessors.Select(a => a.Build())),
+                SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
+        }
+    }
+}
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
@@ -7,12 +7,12 @@
    <RepositoryUrl>https://github.com/AlexMacocian/Sybil</RepositoryUrl>
    <RepositoryType>git</RepositoryType>
    <Version>0.1</Version>
-    <PackageLicenseFile>C:\Users\Owner\source\repos\Sybil\LICENSE</PackageLicenseFile>
-    <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
  </PropertyGroup>

  <ItemGroup>
-    <None Include="..\LICENSE" Link="LICENSE" />
+    <EmbeddedResource Include="..\LICENSE" Link="LICENSE">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </EmbeddedResource>
    <None Include="..\README.md">
      <Pack>True</Pack>
      <PackagePath>\</PackagePath>
@@ -0,0 +1,44 @@
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Sybil
+{
+    public static class SyntaxBuilder
+    {
+        public static NamespaceBuilder CreateNamespace(string @namespace)
+        {
+            return new NamespaceBuilder(@namespace);
+        }
+        public static ClassBuilder CreateClass(string className)
+        {
+            return new ClassBuilder(className);
+        }
+        public static ConstructorBuilder CreateConstructor(string className)
+        {
+            return new ConstructorBuilder(className);
+        }
+        public static BaseConstructorBuilder CreateBaseConstructor()
+        {
+            return new BaseConstructorBuilder();
+        }
+        public static PropertyBuilder CreateProperty(string typeName, string propertyName)
+        {
+            return new PropertyBuilder(typeName, propertyName);
+        }
+        public static AccessorBuilder CreateSetter()
+        {
+            return new AccessorBuilder(SyntaxKind.SetAccessorDeclaration);
+        }
+        public static AccessorBuilder CreateGetter()
+        {
+            return new AccessorBuilder(SyntaxKind.GetAccessorDeclaration);
+        }
+        public static FieldBuilder CreateField(string fieldType, string fieldName)
+        {
+            return new FieldBuilder(fieldType, fieldName);
+        }
+        public static MethodBuilder CreateMethod(string returnType, string methodName)
+        {
+            return new MethodBuilder(returnType, methodName);
+        }
+    }
+}