Modify CodeBuilder to use Indenter settings

Author: BZngr

Rubberduck.Refactorings/Common/CodeBuilder.cs

@@ -1,6 +1,7 @@
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
+using Rubberduck.SmartIndenter;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -35,7 +36,7 @@ string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration,
         /// Generates a Property Get codeblock based on the prototype declaration 
         /// </summary>
         /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
-        /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
+        /// <param name="content">Member body content.</param>
         /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertyGetCodeBlock(Declaration prototype,
             string propertyIdentifier,
@@ -47,7 +48,7 @@ bool TryBuildPropertyGetCodeBlock(Declaration prototype,
         /// Generates a Property Let codeblock based on the prototype declaration 
         /// </summary>
         /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
-        /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
+        /// <param name="content">Member body content.</param>
         /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertyLetCodeBlock(Declaration prototype,
             string propertyIdentifier,
@@ -60,7 +61,7 @@ bool TryBuildPropertyLetCodeBlock(Declaration prototype,
         /// Generates a Property Set codeblock based on the prototype declaration 
         /// </summary>
         /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
-        /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
+        /// <param name="content">Member body content.</param>
         /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertySetCodeBlock(Declaration prototype,
             string propertyIdentifier,
@@ -73,27 +74,36 @@ bool TryBuildPropertySetCodeBlock(Declaration prototype,
         /// Generates a UserDefinedType (UDT) declaration using the prototype declarations for
         /// creating the UserDefinedTypeMember declarations.
         /// </summary>
-        /// <remarks>No validation or conflict analysis is applied to the identifiers.
+        /// <remarks>
+        /// No validation or conflict analysis is applied to the identifiers.
         /// </remarks>
         /// <param name="memberPrototypes">DeclarationTypes with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
         bool TryBuildUserDefinedTypeDeclaration(string udtIdentifier, IEnumerable<(Declaration Prototype, string UDTMemberIdentifier)> memberPrototypes, out string declaration, Accessibility accessibility = Accessibility.Private);
 
         /// <summary>
         /// Generates a <c>UserDefinedTypeMember</c> declaration expression based on the prototype declaration
         /// </summary>
+        /// <remarks>
+        /// No validation or conflict analysis is applied to the identifiers.
+        /// </remarks>
         /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
-        /// <param name="indentation">Defaults is 4 spaces</param>
-        bool TryBuildUDTMemberDeclaration(string identifier, Declaration prototype, out string declaration, string indentation = null);
+        bool TryBuildUDTMemberDeclaration(string identifier, Declaration prototype, out string declaration);
     }
 
     public class CodeBuilder : ICodeBuilder
     {
+        private readonly IIndenter _indenter;
+
+        public CodeBuilder(IIndenter indenter)
+        {
+            _indenter = indenter;
+        }
+
         public string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration, 
             string content = null, 
             string accessibility = null, 
             string newIdentifier = null)
         {
-
             var elements = new List<string>()
             {
                 ImprovedFullMemberSignatureInternal(declaration, accessibility, newIdentifier),
@@ -117,12 +127,8 @@ public bool TryBuildPropertySetCodeBlock(Declaration prototype, string propertyI
         private bool TryBuildPropertyBlockFromTarget<T>(T prototype, DeclarationType letSetGetType, string propertyIdentifier, out string codeBlock, string accessibility = null, string content = null, string parameterIdentifier = null) where T : Declaration
         {
             codeBlock = string.Empty;
-            if (!letSetGetType.HasFlag(DeclarationType.Property))
-            {
-                throw new ArgumentException();
-            }
-
-            if (!IsValidPrototypeDeclarationType(prototype.DeclarationType))
+            if (!letSetGetType.HasFlag(DeclarationType.Property)
+                || !IsValidPrototypeDeclarationType(prototype.DeclarationType))
             {
                 return false;
             }
@@ -144,6 +150,9 @@ private bool TryBuildPropertyBlockFromTarget<T>(T prototype, DeclarationType let
             codeBlock = letSetGetType.HasFlag(DeclarationType.PropertyGet)
                 ? string.Join(Environment.NewLine, $"{accessibility ?? Tokens.Public} {TypeToken(letSetGetType)} {propertyIdentifier}() {asTypeClause}", content, EndStatement(letSetGetType))
                 : string.Join(Environment.NewLine, $"{accessibility ?? Tokens.Public} {TypeToken(letSetGetType)} {propertyIdentifier}({letSetParamExpression})", content, EndStatement(letSetGetType));
+
+            codeBlock = string.Join(Environment.NewLine, _indenter.Indent(codeBlock));
+
             return true;
         }
 
@@ -168,8 +177,8 @@ private string ImprovedFullMemberSignatureInternal(ModuleBodyElementDeclaration
                 $"({ImprovedArgumentList(declaration)})",
                 asTypeName
             };
-            return string.Concat(elements).Trim();
 
+            return string.Concat(elements).Trim();
         }
 
         public string ImprovedArgumentList(ModuleBodyElementDeclaration declaration)
@@ -185,6 +194,7 @@ public string ImprovedArgumentList(ModuleBodyElementDeclaration declaration)
                             && declaration.DeclarationType.HasFlag(DeclarationType.Property)
                             && !declaration.DeclarationType.Equals(DeclarationType.PropertyGet)));
             }
+
             return $"{string.Join(", ", arguments)}";
         }
 
@@ -265,11 +275,12 @@ public bool TryBuildUserDefinedTypeDeclaration(string udtIdentifier, IEnumerable
 
             blockLines.Add($"{Tokens.End} {Tokens.Type}");
 
-            declaration = string.Join(Environment.NewLine, blockLines);
+            declaration = string.Join(Environment.NewLine, _indenter.Indent(blockLines));
+
             return true;
         }
 
-        public bool TryBuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration prototype, out string declaration, string indentation = null)
+        public bool TryBuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration prototype, out string declaration)
         {
             declaration = string.Empty;
 
@@ -280,11 +291,11 @@ public bool TryBuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration
                 return false;
             }
 
-            declaration = BuildUDTMemberDeclaration(udtMemberIdentifier, prototype, indentation);
+            declaration = BuildUDTMemberDeclaration(udtMemberIdentifier, prototype);
             return true;
         }
 
-        private static string BuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration prototype, string indentation = null)
+        private static string BuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration prototype)
         {
             var identifierExpression = udtMemberIdentifier;
             if (prototype.IsArray)
@@ -294,7 +305,7 @@ private static string BuildUDTMemberDeclaration(string udtMemberIdentifier, Decl
                     : $"{udtMemberIdentifier}()";
             }
 
-            return $"{indentation ?? "    "}{identifierExpression} {Tokens.As} {prototype.AsTypeName}";
+            return $"{identifierExpression} {Tokens.As} {prototype.AsTypeName}";
         }
 
         private static bool IsValidPrototypeDeclarationType(DeclarationType declarationType)

Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberRefactoringAction.cs

@@ -70,9 +70,9 @@ private IEnumerable<string> GenerateUserDefinedMemberDeclarations(IEnumerable<(D
             var declarations = new List<string>();
             foreach (var (Prototype, UDTMemberIdentifier) in newMemberPairs)
             {
-                if (_codeBuilder.TryBuildUDTMemberDeclaration(UDTMemberIdentifier, Prototype, out var declaration, indentation))
+                if (_codeBuilder.TryBuildUDTMemberDeclaration(UDTMemberIdentifier, Prototype, out var declaration))
                 {
-                    declarations.Add(declaration);
+                    declarations.Add($"{indentation}{declaration}");
                 }
             }
             return declarations;

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldInsertNewCode/EncapsulateFieldCodeBuilder.cs

@@ -20,9 +20,6 @@ public interface IEncapsulateFieldCodeBuilder
     /// </summary>
     public class EncapsulateFieldCodeBuilder : IEncapsulateFieldCodeBuilder
     {
-        private const string FourSpaces = "    ";
-        private static string _doubleSpace = $"{Environment.NewLine}{Environment.NewLine}";
-
         private readonly ICodeBuilder _codeBuilder;
 
         public EncapsulateFieldCodeBuilder(ICodeBuilder codeBuilder)
@@ -32,68 +29,60 @@ public EncapsulateFieldCodeBuilder(ICodeBuilder codeBuilder)
 
         public (string Get, string Let, string Set) BuildPropertyBlocks(PropertyAttributeSet propertyAttributes)
         {
-            string propertyLet = null;
-            string propertySet = null;
+            if (!(propertyAttributes.Declaration.DeclarationType.HasFlag(DeclarationType.Variable)
+                || propertyAttributes.Declaration.DeclarationType.HasFlag(DeclarationType.UserDefinedTypeMember)))
+            {
+                throw new ArgumentException("Invalid prototype DeclarationType", nameof(propertyAttributes));
+            }
+
+            (string Get, string Let, string Set) blocks = (string.Empty, string.Empty, string.Empty);
+
+            var mutatorBody = $"{propertyAttributes.BackingField} = {propertyAttributes.RHSParameterIdentifier}";
 
             if (propertyAttributes.GeneratePropertyLet)
             {
-                var letterContent = $"{FourSpaces}{propertyAttributes.BackingField} = {propertyAttributes.RHSParameterIdentifier}";
-                if (!_codeBuilder.TryBuildPropertyLetCodeBlock(propertyAttributes.Declaration, propertyAttributes.PropertyName, out propertyLet, content: letterContent))
-                {
-                    throw new ArgumentException();
-                }
+                _codeBuilder.TryBuildPropertyLetCodeBlock(propertyAttributes.Declaration, propertyAttributes.PropertyName, out blocks.Let, content: mutatorBody);
             }
 
             if (propertyAttributes.GeneratePropertySet)
             {
-                var setterContent = $"{FourSpaces}{Tokens.Set} {propertyAttributes.BackingField} = {propertyAttributes.RHSParameterIdentifier}";
-                if (!_codeBuilder.TryBuildPropertySetCodeBlock(propertyAttributes.Declaration, propertyAttributes.PropertyName, out propertySet, content: setterContent))
-                {
-                    throw new ArgumentException();
-                }
+                _codeBuilder.TryBuildPropertySetCodeBlock(propertyAttributes.Declaration, propertyAttributes.PropertyName, out blocks.Set, content: $"{Tokens.Set} {mutatorBody}");
             }
 
-            var getterContent = $"{propertyAttributes.PropertyName} = {propertyAttributes.BackingField}";
-            if (propertyAttributes.UsesSetAssignment)
-            {
-                getterContent = $"{Tokens.Set} {getterContent}";
-            }
+            var propertyGetBody = propertyAttributes.UsesSetAssignment
+                ? $"{Tokens.Set} {propertyAttributes.PropertyName} = {propertyAttributes.BackingField}"
+                : $"{propertyAttributes.PropertyName} = {propertyAttributes.BackingField}";
 
             if (propertyAttributes.AsTypeName.Equals(Tokens.Variant) && !propertyAttributes.Declaration.IsArray)
             {
-                getterContent = string.Join(Environment.NewLine,
+                propertyGetBody = string.Join(
                     $"{Tokens.If} IsObject({propertyAttributes.BackingField}) {Tokens.Then}",
-                    $"{FourSpaces}{Tokens.Set} {propertyAttributes.PropertyName} = {propertyAttributes.BackingField}",
+                    $"{Tokens.Set} {propertyAttributes.PropertyName} = {propertyAttributes.BackingField}",
                     Tokens.Else,
-                    $"{FourSpaces}{propertyAttributes.PropertyName} = {propertyAttributes.BackingField}",
-                    $"{Tokens.End} {Tokens.If}",
-                    Environment.NewLine);
+                    $"{propertyAttributes.PropertyName} = {propertyAttributes.BackingField}",
+                    $"{Tokens.End} {Tokens.If}");
             }
 
-            if (!_codeBuilder.TryBuildPropertyGetCodeBlock(propertyAttributes.Declaration, propertyAttributes.PropertyName, out var propertyGet, content: $"{FourSpaces}{getterContent}"))
-            {
-                throw new ArgumentException();
-            }
+            _codeBuilder.TryBuildPropertyGetCodeBlock(propertyAttributes.Declaration, propertyAttributes.PropertyName, out blocks.Get, content: propertyGetBody);
 
-            return (propertyGet, propertyLet, propertySet);
+            return (blocks.Get, blocks.Let, blocks.Set);
         }
 
         public string BuildUserDefinedTypeDeclaration(IObjectStateUDT objectStateUDT, IEnumerable<IEncapsulateFieldCandidate> candidates)
         {
-            var selected = candidates.Where(c => c.EncapsulateFlag);
-
-            var newUDTMembers = selected
+            var newUDTMembers = candidates.Where(c => c.EncapsulateFlag)
                 .Select(m => (m.Declaration, m.BackingIdentifier));
 
-            _codeBuilder.TryBuildUserDefinedTypeDeclaration(objectStateUDT.AsTypeName, newUDTMembers, out var declaration);
+            if (_codeBuilder.TryBuildUserDefinedTypeDeclaration(objectStateUDT.AsTypeName, newUDTMembers, out var declaration))
+            {
+                return declaration;
+            }
 
-            return declaration ?? string.Empty;
+            return string.Empty;
         }
 
-        public string BuildObjectStateFieldDeclaration(IObjectStateUDT objectStateUDT)
-        {
-            return $"{Accessibility.Private} {objectStateUDT.IdentifierName} {Tokens.As} {objectStateUDT.AsTypeName}";
-        }
+        public string BuildObjectStateFieldDeclaration(IObjectStateUDT objectStateUDT) 
+            => $"{Accessibility.Private} {objectStateUDT.IdentifierName} {Tokens.As} {objectStateUDT.AsTypeName}";
 
         public string BuildFieldDeclaration(Declaration target, string identifier)
         {