From f6591732467490bd7943ddf9d8d7776bbdc4be7a Mon Sep 17 00:00:00 2001 From: Brian Zenger Date: Wed, 12 Aug 2020 11:51:54 -0700 Subject: [PATCH 1/4] Add DefaultPropertyValueParamIdentifier property Exposes a single method for generating a default Let\Set RHS property parameter IdentifierName. --- Rubberduck.Refactorings/Common/CodeBuilder.cs | 42 ++++++++----------- RubberduckTests/CodeBuilderTests.cs | 7 ++-- 2 files changed, 22 insertions(+), 27 deletions(-) diff --git a/Rubberduck.Refactorings/Common/CodeBuilder.cs b/Rubberduck.Refactorings/Common/CodeBuilder.cs index 3e14a75c5b..096640d78d 100644 --- a/Rubberduck.Refactorings/Common/CodeBuilder.cs +++ b/Rubberduck.Refactorings/Common/CodeBuilder.cs @@ -1,4 +1,5 @@ -using Rubberduck.Parsing.Grammar; +using Rubberduck.Common; +using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; using System; using System.Collections.Generic; @@ -11,19 +12,13 @@ public interface ICodeBuilder /// /// Returns ModuleBodyElementDeclaration signature with an ImprovedArgument list /// - /// - /// string ImprovedFullMemberSignature(ModuleBodyElementDeclaration declaration); /// /// Returns a ModuleBodyElementDeclaration block /// with an ImprovedArgument List /// - /// /// Main body content/logic of the member - /// - /// - /// string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration, string content = null, string accessibility = null, @@ -34,19 +29,14 @@ public interface ICodeBuilder /// 1. Explicitly declares Property Let\Set value parameter as ByVal /// 2. Ensures UserDefined Type parameters are declared either explicitly or implicitly as ByRef /// - /// - /// string ImprovedArgumentList(ModuleBodyElementDeclaration declaration); /// /// Generates a Property Get codeblock based on the prototype declaration /// /// VariableDeclaration or UserDefinedTypeMember - /// - /// /// Member body content. Formatting is the responsibility of the caller - /// Defaults to 'value' unless otherwise specified - /// + /// Defaults to 'Value' unless otherwise specified bool TryBuildPropertyGetCodeBlock(Declaration prototype, string propertyIdentifier, out string codeBlock, @@ -57,11 +47,8 @@ public interface ICodeBuilder /// Generates a Property Let codeblock based on the prototype declaration /// /// VariableDeclaration or UserDefinedTypeMember - /// - /// - /// Membmer body content. Formatting is the responsibility of the caller - /// Defaults to 'value' unless otherwise specified - /// + /// Member body content. Formatting is the responsibility of the caller + /// Defaults to 'Value' unless otherwise specified bool TryBuildPropertyLetCodeBlock(Declaration prototype, string propertyIdentifier, out string codeBlock, @@ -73,21 +60,28 @@ public interface ICodeBuilder /// Generates a Property Set codeblock based on the prototype declaration /// /// VariableDeclaration or UserDefinedTypeMember - /// - /// - /// Membmer body content. Formatting is the responsibility of the caller - /// Defaults to 'value' unless otherwise specified - /// + /// Member body content. Formatting is the responsibility of the caller + /// Defaults to 'Value' unless otherwise specified bool TryBuildPropertySetCodeBlock(Declaration prototype, string propertyIdentifier, out string codeBlock, string accessibility = null, string content = null, string parameterIdentifier = null); + /// + /// Generates a default RHS property parameter IdentifierName + /// + /// Let/Set Property IdentifierName + string DefaultPropertyValueParamIdentifier(string propertyIdentifier); } public class CodeBuilder : ICodeBuilder { + private static string ParameterSuffix => Resources.RubberduckUI.EncapsulateField_DefaultPropertyParameter.Capitalize(); + + public string DefaultPropertyValueParamIdentifier(string propertyIdentifier) + => $"{propertyIdentifier.ToLowerCaseFirstLetter()}{ParameterSuffix}"; + public string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration, string content = null, string accessibility = null, @@ -127,7 +121,7 @@ public bool TryBuildPropertySetCodeBlock(Declaration prototype, string propertyI return false; } - var propertyValueParam = parameterIdentifier ?? Resources.RubberduckUI.EncapsulateField_DefaultPropertyParameter; + var propertyValueParam = parameterIdentifier ?? DefaultPropertyValueParamIdentifier(propertyIdentifier); var asType = prototype.IsArray ? $"{Tokens.Variant}" diff --git a/RubberduckTests/CodeBuilderTests.cs b/RubberduckTests/CodeBuilderTests.cs index 58326a60be..2c00617b3e 100644 --- a/RubberduckTests/CodeBuilderTests.cs +++ b/RubberduckTests/CodeBuilderTests.cs @@ -1,4 +1,5 @@ using NUnit.Framework; +using Rubberduck.Common; using Rubberduck.Parsing.Symbols; using Rubberduck.Refactorings; using RubberduckTests.Mocks; @@ -10,6 +11,7 @@ namespace RubberduckTests [TestFixture] public class CodeBuilderTests { + private static string Param(string property) => $"{property.ToLowerCaseFirstLetter()}Value"; [TestCase("fizz", DeclarationType.Variable, "Integer")] [TestCase("FirstValue", DeclarationType.UserDefinedTypeMember, "Long")] @@ -192,8 +194,7 @@ End Enum declarationType, testParams, PropertyLetBlockFromPrototypeTest); - - StringAssert.Contains($"Property Let {testParams.Identifier}(ByVal value As {typeName})", result); + StringAssert.Contains($"Property Let {testParams.Identifier}(ByVal {Param(testParams.Identifier)} As {typeName})", result); } [TestCase("fizz", DeclarationType.Variable, "Variant")] @@ -219,7 +220,7 @@ End Type testParams, PropertySetBlockFromPrototypeTest); - StringAssert.Contains($"Property Set {testParams.Identifier}(ByVal value As {typeName})", result); + StringAssert.Contains($"Property Set {testParams.Identifier}(ByVal {Param(testParams.Identifier)} As {typeName})", result); } [TestCase(DeclarationType.PropertyLet)] From fa7723b8e4280f14d71b04549cd627271b46859e Mon Sep 17 00:00:00 2001 From: Brian Zenger Date: Wed, 12 Aug 2020 11:58:58 -0700 Subject: [PATCH 2/4] Change default property RHS parameter identifier Generates a property RHS parameter name based on the value of the property's IdentifierName. --- .../EncapsulateFieldElementsBuilder.cs | 11 +-- .../FieldCandidates/ArrayCandidate.cs | 4 +- .../ConvertToUDTMemberCandidate.cs | 13 +--- .../EncapsulateFieldCandidate.cs | 12 ++- .../EncapsulationIdentifiers.cs | 12 +-- .../UserDefinedTypeCandidate.cs | 4 +- .../UserDefinedTypeMemberCandidate.cs | 16 ++-- .../EncapsulateFieldConflictFinderBase.cs | 2 +- .../EncapsulateFieldValidationsProvider.cs | 13 ---- .../EncapsulateFIeldTestSupport.cs | 3 + .../EncapsulateField/EncapsulateFieldTests.cs | 72 +++++++++--------- .../EncapsulateFieldValidatorTests.cs | 1 - .../EncapsulateUsingStateUDTTests.cs | 20 ++--- .../EncapsulatedUDTFieldTests.cs | 73 ++++++++++--------- .../EncapsulationIdentifiersTests.cs | 25 ------- ...mplementInterfaceRefactoringActionTests.cs | 14 ++-- 16 files changed, 122 insertions(+), 173 deletions(-) diff --git a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs index 723ddd78c2..a655fe06d1 100644 --- a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs +++ b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs @@ -2,7 +2,6 @@ using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Common; -using Rubberduck.Refactorings.EncapsulateField.Extensions; using Rubberduck.VBEditor; using System; using System.Collections.Generic; @@ -16,12 +15,14 @@ public class EncapsulateFieldElementsBuilder private readonly IDeclarationFinderProvider _declarationFinderProvider; private QualifiedModuleName _targetQMN; private string _defaultObjectStateUDTTypeName; + private ICodeBuilder _codeBuilder; public EncapsulateFieldElementsBuilder(IDeclarationFinderProvider declarationFinderProvider, QualifiedModuleName targetQMN) { _declarationFinderProvider = declarationFinderProvider; _targetQMN = targetQMN; _defaultObjectStateUDTTypeName = $"T{_targetQMN.ComponentName}"; + _codeBuilder = new CodeBuilder(); CreateRefactoringElements(); } @@ -110,7 +111,7 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate if (target.IsUserDefinedType()) { var udtValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedType); - var udtField = new UserDefinedTypeCandidate(target, udtValidator) as IUserDefinedTypeCandidate; + var udtField = new UserDefinedTypeCandidate(target, udtValidator, _codeBuilder.DefaultPropertyValueParamIdentifier) as IUserDefinedTypeCandidate; (Declaration udtDeclaration, IEnumerable udtMembers) = GetUDTAndMembersForField(udtField); @@ -125,7 +126,7 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate { udtMemberValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMemberArray); } - var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField) as IUserDefinedTypeMemberCandidate; + var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField, _codeBuilder.DefaultPropertyValueParamIdentifier) as IUserDefinedTypeMemberCandidate; udtField.AddMember(candidateUDTMember); } @@ -141,10 +142,10 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate } else if (target.IsArray) { - return new ArrayCandidate(target, validator); + return new ArrayCandidate(target, validator, _codeBuilder.DefaultPropertyValueParamIdentifier); } - var candidate = new EncapsulateFieldCandidate(target, validator); + var candidate = new EncapsulateFieldCandidate(target, validator, _codeBuilder.DefaultPropertyValueParamIdentifier); return candidate; } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs index b9dd90744e..6bea93d78c 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs @@ -17,8 +17,8 @@ public interface IArrayCandidate : IEncapsulateFieldCandidate public class ArrayCandidate : EncapsulateFieldCandidate, IArrayCandidate { private string _subscripts; - public ArrayCandidate(Declaration declaration, IValidateVBAIdentifiers validator) - :base(declaration, validator) + public ArrayCandidate(Declaration declaration, IValidateVBAIdentifiers validator, Func paramNameBuilder) + :base(declaration, validator, paramNameBuilder) { ImplementLet = false; ImplementSet = false; diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ConvertToUDTMemberCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ConvertToUDTMemberCandidate.cs index 21cfd3e5a9..bb2720dd04 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ConvertToUDTMemberCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ConvertToUDTMemberCandidate.cs @@ -1,11 +1,6 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; using System.Linq; -using System.Text; -using System.Threading.Tasks; -using Antlr4.Runtime; using Rubberduck.Common; -using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; using Rubberduck.VBEditor; @@ -90,11 +85,7 @@ public bool IsReadOnly get => _wrapped.IsReadOnly; } - public string ParameterName - { - set => _wrapped.ParameterName = value; - get => _wrapped.ParameterName; - } + public string ParameterName => _wrapped.ParameterName; public IValidateVBAIdentifiers NameValidator { diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs index 88cab6b018..f5b2681730 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs @@ -3,9 +3,7 @@ using Rubberduck.Parsing.Symbols; using Rubberduck.Refactorings.Common; using Rubberduck.Refactorings.EncapsulateField.Extensions; -using Rubberduck.Resources; using Rubberduck.VBEditor; -using Rubberduck.VBEditor.SafeComWrappers; using System; using System.Collections.Generic; @@ -31,7 +29,7 @@ public interface IEncapsulateFieldCandidate : IEncapsulateFieldRefactoringElemen bool ImplementLet { get; } bool ImplementSet { get; } bool IsReadOnly { set; get; } - string ParameterName { set; get; } + string ParameterName { get; } IValidateVBAIdentifiers NameValidator { set; get; } IEncapsulateFieldConflictFinder ConflictFinder { set; get; } bool TryValidateEncapsulationAttributes(out string errorMessage); @@ -47,11 +45,13 @@ public class EncapsulateFieldCandidate : IEncapsulateFieldCandidate protected int _hashCode; private string _identifierName; protected EncapsulationIdentifiers _fieldAndProperty; + private Func _paramNameBuilder; - public EncapsulateFieldCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator) + public EncapsulateFieldCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator, Func paramNameBuilder) { _target = declaration; NameValidator = identifierValidator; + _paramNameBuilder = paramNameBuilder; _fieldAndProperty = new EncapsulationIdentifiers(declaration.IdentifierName, identifierValidator); IdentifierName = declaration.IdentifierName; @@ -164,8 +164,6 @@ public string PropertyIdentifier _fieldAndProperty.Property = value; TryRestoreNewFieldNameAsOriginalFieldIdentifierName(); - - EncapsulateFieldValidationsProvider.AssignNoConflictParameter(this); } } @@ -204,7 +202,7 @@ public string IdentifierName public virtual string ReferenceQualifier { set; get; } - public string ParameterName { set; get; } = RubberduckUI.EncapsulateField_DefaultPropertyParameter; + public string ParameterName => _paramNameBuilder(PropertyIdentifier); private bool _implLet; public bool ImplementLet { get => !IsReadOnly && _implLet; set => _implLet = value; } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulationIdentifiers.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulationIdentifiers.cs index a5e096d8cb..bb29bdb253 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulationIdentifiers.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulationIdentifiers.cs @@ -1,20 +1,13 @@ -using Rubberduck.Parsing.Symbols; -using Rubberduck.Parsing.VBA.Extensions; -using Rubberduck.Common; +using Rubberduck.Common; using System.Collections.Generic; using Rubberduck.Refactorings.EncapsulateField.Extensions; -using System; -using Rubberduck.Resources; namespace Rubberduck.Refactorings.EncapsulateField { public class EncapsulationIdentifiers { - private static string DEFAULT_WRITE_PARAMETER = RubberduckUI.EncapsulateField_DefaultPropertyParameter; - private KeyValuePair _fieldAndProperty; private string _targetIdentifier; - private string _setLetParameter; public EncapsulationIdentifiers(string field, IValidateVBAIdentifiers identifierValidator) { @@ -42,7 +35,6 @@ public EncapsulationIdentifiers(string field, IValidateVBAIdentifiers identifier } _fieldAndProperty = new KeyValuePair(DefaultNewFieldName, DefaultPropertyName); - _setLetParameter = DEFAULT_WRITE_PARAMETER; } public string TargetFieldName => _targetIdentifier; @@ -68,7 +60,5 @@ public string Property _fieldAndProperty = new KeyValuePair(_fieldAndProperty.Key, value); } } - - public string SetLetParameter => DEFAULT_WRITE_PARAMETER; } } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs index a6703dbd7b..64ce9b6fea 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs @@ -21,8 +21,8 @@ public interface IUserDefinedTypeCandidate : IEncapsulateFieldCandidate public class UserDefinedTypeCandidate : EncapsulateFieldCandidate, IUserDefinedTypeCandidate { - public UserDefinedTypeCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator) - : base(declaration, identifierValidator) + public UserDefinedTypeCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator, Func paramNameBuilder) + : base(declaration, identifierValidator, paramNameBuilder) { } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs index 88ddea4d7c..f2ea3ef546 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs @@ -1,11 +1,9 @@ -using Antlr4.Runtime; -using Rubberduck.Parsing; +using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; -using Rubberduck.Refactorings.EncapsulateField.Extensions; using Rubberduck.VBEditor; +using System; using System.Collections.Generic; -using System.Diagnostics; using System.Linq; namespace Rubberduck.Refactorings.EncapsulateField @@ -22,9 +20,11 @@ public class UserDefinedTypeMemberCandidate : IUserDefinedTypeMemberCandidate { private int _hashCode; private readonly string _uniqueID; - public UserDefinedTypeMemberCandidate(IEncapsulateFieldCandidate candidate, IUserDefinedTypeCandidate udtField) + private Func _paramNameBuilder; + public UserDefinedTypeMemberCandidate(IEncapsulateFieldCandidate candidate, IUserDefinedTypeCandidate udtField, Func paramNameBuilder) { _wrappedCandidate = candidate; + _paramNameBuilder = paramNameBuilder; UDTField = udtField; PropertyIdentifier = IdentifierName; BackingIdentifier = IdentifierName; @@ -203,11 +203,7 @@ public QualifiedModuleName QualifiedModuleName public string PropertyAsTypeName => _wrappedCandidate.PropertyAsTypeName; - public string ParameterName - { - set => _wrappedCandidate.ParameterName = value; - get => _wrappedCandidate.ParameterName; - } + public string ParameterName => _paramNameBuilder(PropertyIdentifier); public bool ImplementLet => _wrappedCandidate.ImplementLet; diff --git a/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldConflictFinderBase.cs b/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldConflictFinderBase.cs index 3fb141ef48..674e77cc0e 100644 --- a/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldConflictFinderBase.cs +++ b/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldConflictFinderBase.cs @@ -87,7 +87,7 @@ protected virtual IEncapsulateFieldCandidate AssignNoConflictIdentifier(IEncapsu isConflictingIdentifier = HasConflictingIdentifierIgnoreEncapsulationFlag(candidate, declarationType, out _); } - return EncapsulateFieldValidationsProvider.AssignNoConflictParameter(candidate); + return candidate; } public bool IsConflictingProposedIdentifier(string fieldName, IEncapsulateFieldCandidate candidate, DeclarationType declarationType) diff --git a/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldValidationsProvider.cs b/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldValidationsProvider.cs index 1ec9987cfe..0b755c87ca 100644 --- a/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldValidationsProvider.cs +++ b/Rubberduck.Refactorings/EncapsulateField/Validations/EncapsulateFieldValidationsProvider.cs @@ -82,19 +82,6 @@ private void LoadUDTMemberCandidates(IUserDefinedTypeCandidate udtCandidate) public static IValidateVBAIdentifiers NameOnlyValidator(NameValidators validatorType) => _nameOnlyValidators[validatorType]; - public static IEncapsulateFieldCandidate AssignNoConflictParameter(IEncapsulateFieldCandidate candidate) - { - candidate.ParameterName = RubberduckUI.EncapsulateField_DefaultPropertyParameter; - - var guard = 0; - while (guard++ < 10 && (candidate.BackingIdentifier.IsEquivalentVBAIdentifierTo(candidate.ParameterName) - || candidate.PropertyIdentifier.IsEquivalentVBAIdentifierTo(candidate.ParameterName))) - { - candidate.ParameterName = candidate.ParameterName.IncrementEncapsulationIdentifier(); - } - return candidate; - } - public static IObjectStateUDT AssignNoConflictIdentifiers(IObjectStateUDT stateUDT, IDeclarationFinderProvider declarationFinderProvider) { var members = declarationFinderProvider.DeclarationFinder.Members(stateUDT.QualifiedModuleName); diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs index b7878733e0..196a5bd2cc 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs @@ -1,4 +1,5 @@ using Moq; +using Rubberduck.Common; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.UIContext; @@ -18,6 +19,8 @@ namespace RubberduckTests.Refactoring.EncapsulateField { public class EncapsulateFieldTestSupport : InteractiveRefactoringTestBase { + public static string ParamNameBuilder(string property) => $"{property.ToLowerCaseFirstLetter()}Value"; + public string StateUDTDefaultType => $"T{MockVbeBuilder.TestModuleName}"; private TestEncapsulationAttributes UserModifiedEncapsulationAttributes(string field, string property = null, bool isReadonly = false, bool encapsulateFlag = true) diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs index 4b98f2bf47..3b65940b87 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs @@ -21,6 +21,8 @@ public class EncapsulateFieldTests : InteractiveRefactoringTestBase Param = EncapsulateFieldTestSupport.ParamNameBuilder; + [TestCase("fizz", true, "baz", true, "buzz", true)] [TestCase("fizz", false, "baz", true, "buzz", true)] [TestCase("fizz", false, "baz", false, "buzz", true)] @@ -69,8 +71,8 @@ public class EncapsulateFieldTests : InteractiveRefactoringTestBase Param = EncapsulateFieldTestSupport.ParamNameBuilder; + [Test] [Category("Refactorings")] [Category("Encapsulate Field")] @@ -28,7 +30,7 @@ public void EncapsulatePrivateFieldAsUDT() var presenterAction = Support.SetParametersForSingleTarget("fizz", "Name", asUDT: true); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Name As Integer", actualCode); - StringAssert.Contains("this.Name = value", actualCode); + StringAssert.Contains($"this.Name = {Param("Name")}", actualCode); } [TestCase("Public")] @@ -78,9 +80,9 @@ End Type var presenterAction = Support.SetParameters(userInput); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains("this.MyBar.First = value", actualCode); + StringAssert.Contains($"this.MyBar.First = {Param("First")}", actualCode); StringAssert.Contains($"First = this.MyBar.First", actualCode); - StringAssert.Contains("this.MyBar.Second = value", actualCode); + StringAssert.Contains($"this.MyBar.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Second = this.MyBar.Second", actualCode); StringAssert.Contains($"MyBar As TBar", actualCode); StringAssert.Contains($"MyBar As TBar", actualCode); @@ -246,9 +248,9 @@ End Type var presenterAction = Support.SetParameters(userInput); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains("this.MyBar.First = value", actualCode); + StringAssert.Contains($"this.MyBar.First = {Param("First")}", actualCode); StringAssert.Contains("First = this.MyBar.First", actualCode); - StringAssert.Contains("this.MyBar.Second = value", actualCode); + StringAssert.Contains($"this.MyBar.Second = {Param("Second")}", actualCode); StringAssert.Contains("Second = this.MyBar.Second", actualCode); var index = actualCode.IndexOf("Get Second", StringComparison.InvariantCultureIgnoreCase); var indexLast = actualCode.LastIndexOf("Get Second", StringComparison.InvariantCultureIgnoreCase); @@ -464,7 +466,7 @@ End Type StringAssert.Contains("Public Property Let Foo(", actualCode); StringAssert.Contains("Public Property Let Bar(", actualCode); - StringAssert.Contains("this.MyBar.FooBar.Foo = value", actualCode); + StringAssert.Contains($"this.MyBar.FooBar.Foo = {Param("Foo")}", actualCode); } [Test] @@ -496,7 +498,7 @@ End Type var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Public Property Let FooBar(", actualCode); - StringAssert.Contains("this.MyBar.FooBar = value", actualCode); + StringAssert.Contains($"this.MyBar.FooBar = {Param("FooBar")}", actualCode); } [Test] @@ -532,8 +534,8 @@ End Type StringAssert.Contains("Public Property Let Bar(", actualCode); StringAssert.Contains("Public Property Let Foo_1(", actualCode); StringAssert.Contains("Public Property Let Bar_1(", actualCode); - StringAssert.Contains("this.MyBar.FooBar.Foo = value", actualCode); - StringAssert.Contains("this.MyBar.ReBar.Foo = value", actualCode); + StringAssert.Contains($"this.MyBar.FooBar.Foo = {Param("Foo")}", actualCode); + StringAssert.Contains($"this.MyBar.ReBar.Foo = {Param("Foo_1")}", actualCode); } [Test] diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs index 40a2303817..33023e9c52 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs @@ -5,6 +5,7 @@ using Rubberduck.Refactorings.EncapsulateField; using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.Utility; +using System; using System.Collections.Generic; namespace RubberduckTests.Refactoring.EncapsulateField @@ -14,6 +15,8 @@ public class EncapsulatedUDTFieldTests : InteractiveRefactoringTestBase Param = EncapsulateFieldTestSupport.ParamNameBuilder; + [TestCase("Public")] [TestCase("Private")] [Category("Refactorings")] @@ -37,9 +40,9 @@ End Type StringAssert.DoesNotContain($"This = this", actualCode); StringAssert.Contains($"Public Property Get First", actualCode); StringAssert.Contains($"Public Property Get Second", actualCode); - StringAssert.Contains($"this.First = value", actualCode); + StringAssert.Contains($"this.First = {Param("First")}", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.Contains($"this.Second = value", actualCode); + StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); } @@ -76,16 +79,16 @@ End Type StringAssert.Contains($"Private {expectedThis.TargetFieldName} As TBar", actualCode); StringAssert.Contains($"First = {expectedThis.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second = {expectedThis.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.First = value", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = value", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.First = {Param("First")}", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Property Get First", actualCode); StringAssert.Contains($"Property Get Second", actualCode); StringAssert.Contains($"Private {expectedThat.TargetFieldName} As TBar", actualCode); StringAssert.Contains($"First_1 = {expectedThat.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second_1 = {expectedThat.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.First = value", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = value", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.First = {Param("First_1")}", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = {Param("Second_1")}", actualCode); StringAssert.Contains($"Property Get First_1", actualCode); StringAssert.Contains($"Property Get Second_1", actualCode); @@ -96,8 +99,8 @@ End Type { StringAssert.Contains($"First = {expectedThis.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second = {expectedThis.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.First = value", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = value", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.First = {Param("First")}", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Property Get First", actualCode); StringAssert.Contains($"Property Get Second", actualCode); @@ -108,8 +111,8 @@ End Type { StringAssert.Contains($"First = {expectedThat.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second = {expectedThat.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.First = value", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = value", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.First = {Param("First")}", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Property Get First", actualCode); StringAssert.Contains($"Property Get Second", actualCode); @@ -151,9 +154,9 @@ End Sub var presenterAction = Support.UserAcceptsDefaults(); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains("this.First = value", actualCode); + StringAssert.Contains($"this.First = {Param("First")}", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.Contains("this.Second = value", actualCode); + StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.Contains($" First = arg1", actualCode); StringAssert.Contains($" Second = arg2", actualCode); @@ -287,9 +290,9 @@ Private mFizz StringAssert.Contains("Private this As TBar", actualCode); StringAssert.DoesNotContain("this = value", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); - StringAssert.Contains($"this.First = value", actualCode); + StringAssert.Contains($"this.First = {Param("First")}", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.Contains($"this.Second = value", actualCode); + StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); StringAssert.Contains($"Private mFoo As String", actualCode); @@ -343,16 +346,16 @@ End Sub var actualCode = actualModuleCode["Module1"]; StringAssert.Contains("Private this As TBar", actualCode); - StringAssert.DoesNotContain("this = value", actualCode); + StringAssert.DoesNotContain($"this = {Param("this")}", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); - StringAssert.Contains("Property Set First(ByVal value As Class1)", actualCode); + StringAssert.Contains($"Property Set First(ByVal {Param("First")} As Class1)", actualCode); StringAssert.Contains("Property Get First() As Class1", actualCode); - StringAssert.Contains($"Set this.First = value", actualCode); + StringAssert.Contains($"Set this.First = {Param("First")}", actualCode); StringAssert.Contains($"Set First = this.First", actualCode); - StringAssert.Contains($"this.Second = value", actualCode); + StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); - Assert.AreEqual(actualCode.IndexOf("this.First = value"), actualCode.LastIndexOf("this.First = value")); + Assert.AreEqual(actualCode.IndexOf($"this.First = {Param("First")}"), actualCode.LastIndexOf($"this.First = {Param("First")}")); } [TestCase("Public")] @@ -377,12 +380,12 @@ End Type var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Private this As TBar", actualCode); - StringAssert.DoesNotContain("this = value", actualCode); + StringAssert.DoesNotContain($"this = {Param("this")}", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); - StringAssert.Contains($"this.First = value", actualCode); + StringAssert.Contains($"this.First = {Param("First")}", actualCode); StringAssert.Contains($"First = this.First", actualCode); StringAssert.Contains($"IsObject", actualCode); - StringAssert.Contains($"this.Second = value", actualCode); + StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); } @@ -410,11 +413,11 @@ End Type var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains($"Private this As TBar", actualCode); - StringAssert.DoesNotContain("this = value", actualCode); - StringAssert.DoesNotContain($"this.First = value", actualCode); + StringAssert.DoesNotContain($"this = {Param("this")}", actualCode); + StringAssert.DoesNotContain($"this.First = {Param("First")}", actualCode); StringAssert.Contains($"Property Get First() As Variant", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.DoesNotContain($"this.Second = value", actualCode); + StringAssert.DoesNotContain($"this.Second = {Param("First")}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.Contains($"Property Get Second() As Variant", actualCode); StringAssert.Contains($"Third = this.Third", actualCode); @@ -461,16 +464,16 @@ End Type var actualCode = actualModuleCode["Class1"]; StringAssert.Contains("Private this As TBar", actualCode); + if (accessibility == "Public") { - StringAssert.Contains("this = value", actualCode); + StringAssert.Contains($"this = {Param("MyType")}", actualCode); StringAssert.Contains("MyType = this", actualCode); StringAssert.Contains($"Public Property Get MyType", actualCode); - StringAssert.Contains($"Private this As TBar", actualCode); Assert.AreEqual(actualCode.IndexOf("MyType = this"), actualCode.LastIndexOf("MyType = this")); - StringAssert.DoesNotContain($"this.First = value", actualCode); - StringAssert.DoesNotContain($"this.Second = value", actualCode); + StringAssert.DoesNotContain($"this.First = {Param("First")}", actualCode); + StringAssert.DoesNotContain($"this.Second = {Param("Second")}", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); - StringAssert.Contains($"Public Property Let MyType(ByRef value As TBar", actualCode); + StringAssert.Contains($"Public Property Let MyType(ByRef {Param("MyType")} As TBar", actualCode); } } @@ -509,7 +512,7 @@ End Sub var actualCode = actualModuleCode["Module1"]; StringAssert.Contains($"Private mTheClass As Class1", actualCode); - StringAssert.Contains($"Set mTheClass = value", actualCode); + StringAssert.Contains($"Set mTheClass = {Param("TheClass")}", actualCode); StringAssert.Contains($"Set TheClass = mTheClass", actualCode); StringAssert.Contains($"Public Property Set TheClass", actualCode); } @@ -912,7 +915,7 @@ End Type StringAssert.Contains("Public Property Let Foo(", actualCode); StringAssert.Contains("Public Property Let Bar(", actualCode); - StringAssert.Contains("myBar.FooBar.Foo = value", actualCode); + StringAssert.Contains("myBar.FooBar.Foo = fooValue", actualCode); } [Test] @@ -944,8 +947,8 @@ End Type StringAssert.Contains("Public Property Let Bar(", actualCode); StringAssert.Contains("Public Property Let Foo_1(", actualCode); StringAssert.Contains("Public Property Let Bar_1(", actualCode); - StringAssert.Contains("myBar.FooBar.Foo = value", actualCode); - StringAssert.Contains("myBar.ReBar.Foo = value", actualCode); + StringAssert.Contains("myBar.FooBar.Foo = fooValue", actualCode); + StringAssert.Contains("myBar.ReBar.Foo = foo_1Value", actualCode); } [Test] @@ -973,7 +976,7 @@ End Type var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Public Property Let FooBar(", actualCode); - StringAssert.Contains("myBar.FooBar = value", actualCode); + StringAssert.Contains("myBar.FooBar = fooBarValue", actualCode); } protected override IRefactoring TestRefactoring( diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulationIdentifiersTests.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulationIdentifiersTests.cs index bee93fd54c..810368a3c7 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulationIdentifiersTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulationIdentifiersTests.cs @@ -1,13 +1,5 @@ using NUnit.Framework; -using Moq; using Rubberduck.Refactorings.EncapsulateField; -using RubberduckTests.Mocks; -using Rubberduck.SmartIndenter; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using System.Linq; -using Rubberduck.Parsing.Symbols; -using System.Collections.Generic; -using Rubberduck.VBEditor; namespace RubberduckTests.Refactoring.EncapsulateField { @@ -62,23 +54,6 @@ public void FieldNameValuesPerSequenceOfPropertyNameChanges() StringAssert.AreEqualIgnoringCase("fizz_1", encapsulatedField.BackingIdentifier); } - [TestCase("Test", "value_1")] - [TestCase("Value", "value_2")] - [Category("Refactorings")] - [Category("Encapsulate Field")] - public void PropertyNameChange_UniqueParamName(string PropertyName, string expectedParameterName) - { - string inputCode = "Public value As String"; - - var fieldUT = "value"; - - var presenterAction = Support.SetParametersForSingleTarget(fieldUT, PropertyName); - - var model = Support.RetrieveUserModifiedModelPriorToRefactoring(inputCode, fieldUT, DeclarationType.Variable, presenterAction); - var encapsulatedField = model[fieldUT]; - StringAssert.AreEqualIgnoringCase(expectedParameterName, encapsulatedField.ParameterName); - } - [TestCase("strValue", "Value", "strValue")] [TestCase("m_Text", "Text", "m_Text")] [TestCase("notAHungarianName", "NotAHungarianName", "notAHungarianName_1")] diff --git a/RubberduckTests/Refactoring/ImplementInterface/ImplementInterfaceRefactoringActionTests.cs b/RubberduckTests/Refactoring/ImplementInterface/ImplementInterfaceRefactoringActionTests.cs index f807a1cbc0..d016b42cd9 100644 --- a/RubberduckTests/Refactoring/ImplementInterface/ImplementInterfaceRefactoringActionTests.cs +++ b/RubberduckTests/Refactoring/ImplementInterface/ImplementInterfaceRefactoringActionTests.cs @@ -1,6 +1,6 @@ -using System; -using System.Linq; +using System.Linq; using NUnit.Framework; +using Rubberduck.Common; using Rubberduck.Parsing.Rewriter; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -16,6 +16,8 @@ public class ImplementInterfaceRefactoringActionTests : RefactoringActionTestBas { private string _todoImplementMessage = "Err.Raise 5 'TODO implement interface member"; + private static string Param(string property) => $"{property.ToLowerCaseFirstLetter()}Value"; + [Test] [Category("Refactorings")] [Category("Implement Interface")] @@ -493,7 +495,7 @@ public void ImplementInterface_PublicIntrinsic(string interfaceCode) {_todoImplementMessage} End Property -Private Property Let Interface1_Foo(ByVal value As Long) +Private Property Let Interface1_Foo(ByVal {Param("Interface1_Foo")} As Long) {_todoImplementMessage} End Property "; @@ -518,7 +520,7 @@ public void ImplementInterface_PublicObject(string interfaceCode) {_todoImplementMessage} End Property -Private Property Set Interface1_Foo(ByVal value As Object) +Private Property Set Interface1_Foo(ByVal {Param("Interface1_Foo")} As Object) {_todoImplementMessage} End Property "; @@ -545,11 +547,11 @@ public void ImplementInterface_PublicVariant(string interfaceCode) {_todoImplementMessage} End Property -Private Property Let Interface1_Foo(ByVal value As Variant) +Private Property Let Interface1_Foo(ByVal {Param("Interface1_Foo")} As Variant) {_todoImplementMessage} End Property -Private Property Set Interface1_Foo(ByVal value As Variant) +Private Property Set Interface1_Foo(ByVal {Param("Interface1_Foo")} As Variant) {_todoImplementMessage} End Property "; From dd845d14c9f55a86e3b30f92eee38b81fb844331 Mon Sep 17 00:00:00 2001 From: Brian Zenger Date: Wed, 12 Aug 2020 15:53:05 -0700 Subject: [PATCH 3/4] Move Property RHS Parameter Resource Relocate and reformat the 'value' resource string from Resources.RubberduckUI to Resources.Refactorings. --- Rubberduck.Refactorings/Common/CodeBuilder.cs | 4 +--- .../Refactorings/Refactorings.Designer.cs | 9 +++++++++ Rubberduck.Resources/Refactorings/Refactorings.resx | 4 ++++ Rubberduck.Resources/RubberduckUI.Designer.cs | 9 --------- Rubberduck.Resources/RubberduckUI.resx | 6 +----- 5 files changed, 15 insertions(+), 17 deletions(-) diff --git a/Rubberduck.Refactorings/Common/CodeBuilder.cs b/Rubberduck.Refactorings/Common/CodeBuilder.cs index 096640d78d..82e6509331 100644 --- a/Rubberduck.Refactorings/Common/CodeBuilder.cs +++ b/Rubberduck.Refactorings/Common/CodeBuilder.cs @@ -77,10 +77,8 @@ public interface ICodeBuilder public class CodeBuilder : ICodeBuilder { - private static string ParameterSuffix => Resources.RubberduckUI.EncapsulateField_DefaultPropertyParameter.Capitalize(); - public string DefaultPropertyValueParamIdentifier(string propertyIdentifier) - => $"{propertyIdentifier.ToLowerCaseFirstLetter()}{ParameterSuffix}"; + => string.Format(Resources.Refactorings.Refactorings.CodeBuilder_DefaultPropertyRHSParamFormat, propertyIdentifier.ToLowerCaseFirstLetter()); public string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration, string content = null, diff --git a/Rubberduck.Resources/Refactorings/Refactorings.Designer.cs b/Rubberduck.Resources/Refactorings/Refactorings.Designer.cs index 69fa6b0e6e..1c2e8f25a6 100644 --- a/Rubberduck.Resources/Refactorings/Refactorings.Designer.cs +++ b/Rubberduck.Resources/Refactorings/Refactorings.Designer.cs @@ -60,6 +60,15 @@ public class Refactorings { } } + /// + /// Looks up a localized string similar to {0}Value. + /// + public static string CodeBuilder_DefaultPropertyRHSParamFormat { + get { + return ResourceManager.GetString("CodeBuilder_DefaultPropertyRHSParamFormat", resourceCulture); + } + } + /// /// Looks up a localized string similar to 'TODO implement interface member. /// diff --git a/Rubberduck.Resources/Refactorings/Refactorings.resx b/Rubberduck.Resources/Refactorings/Refactorings.resx index c9e0ecb1b7..b474c9082e 100644 --- a/Rubberduck.Resources/Refactorings/Refactorings.resx +++ b/Rubberduck.Resources/Refactorings/Refactorings.resx @@ -117,6 +117,10 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + {0}Value + 0: Property Name (first char lower case) + 'TODO implement interface member VBA code (comment) diff --git a/Rubberduck.Resources/RubberduckUI.Designer.cs b/Rubberduck.Resources/RubberduckUI.Designer.cs index 4c28b29bb8..e3e927a26b 100644 --- a/Rubberduck.Resources/RubberduckUI.Designer.cs +++ b/Rubberduck.Resources/RubberduckUI.Designer.cs @@ -1463,15 +1463,6 @@ public class RubberduckUI { } } - /// - /// Looks up a localized string similar to value. - /// - public static string EncapsulateField_DefaultPropertyParameter { - get { - return ResourceManager.GetString("EncapsulateField_DefaultPropertyParameter", resourceCulture); - } - } - /// /// Looks up a localized string similar to Select one or more fields to encapsulate. Accept the default values or edit property names.. /// diff --git a/Rubberduck.Resources/RubberduckUI.resx b/Rubberduck.Resources/RubberduckUI.resx index 9f619a71eb..8ee57790a6 100644 --- a/Rubberduck.Resources/RubberduckUI.resx +++ b/Rubberduck.Resources/RubberduckUI.resx @@ -1763,10 +1763,6 @@ Import aborted. this VBA identifier; should not be translated - - value - VBA identifier; should not be translated - Name conflict @@ -1930,7 +1926,7 @@ Do you want to proceed? Several folders with the same name are being moved. This will merge them. -Do you want to proceed? +Do you want to proceed? A folder name cannot be empty. From 70edc9157074f48589eb389691f036999f104929 Mon Sep 17 00:00:00 2001 From: Brian Zenger Date: Thu, 13 Aug 2020 17:34:47 -0700 Subject: [PATCH 4/4] Address #5556 Review comments Renaming per suggestions. Also, clean-up of commented code and removal of non-required 'using' directives. --- Rubberduck.Refactorings/Common/CodeBuilder.cs | 6 +- .../EncapsulateFieldElementsBuilder.cs | 8 +- .../FieldCandidates/ArrayCandidate.cs | 7 +- .../EncapsulateFieldCandidate.cs | 8 +- .../UserDefinedTypeCandidate.cs | 10 +-- .../UserDefinedTypeMemberCandidate.cs | 8 +- RubberduckTests/CodeBuilderTests.cs | 2 +- .../EncapsulateFIeldTestSupport.cs | 2 +- .../EncapsulateField/EncapsulateFieldTests.cs | 69 ++++++--------- .../EncapsulateUsingStateUDTTests.cs | 32 ++++--- .../EncapsulatedUDTFieldTests.cs | 88 ++++++++++++------- 11 files changed, 126 insertions(+), 114 deletions(-) diff --git a/Rubberduck.Refactorings/Common/CodeBuilder.cs b/Rubberduck.Refactorings/Common/CodeBuilder.cs index 82e6509331..c8e7932b0e 100644 --- a/Rubberduck.Refactorings/Common/CodeBuilder.cs +++ b/Rubberduck.Refactorings/Common/CodeBuilder.cs @@ -72,12 +72,12 @@ public interface ICodeBuilder /// Generates a default RHS property parameter IdentifierName /// /// Let/Set Property IdentifierName - string DefaultPropertyValueParamIdentifier(string propertyIdentifier); + string BuildPropertyRhsParameterName(string propertyIdentifier); } public class CodeBuilder : ICodeBuilder { - public string DefaultPropertyValueParamIdentifier(string propertyIdentifier) + public string BuildPropertyRhsParameterName(string propertyIdentifier) => string.Format(Resources.Refactorings.Refactorings.CodeBuilder_DefaultPropertyRHSParamFormat, propertyIdentifier.ToLowerCaseFirstLetter()); public string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration, @@ -119,7 +119,7 @@ public bool TryBuildPropertySetCodeBlock(Declaration prototype, string propertyI return false; } - var propertyValueParam = parameterIdentifier ?? DefaultPropertyValueParamIdentifier(propertyIdentifier); + var propertyValueParam = parameterIdentifier ?? BuildPropertyRhsParameterName(propertyIdentifier); var asType = prototype.IsArray ? $"{Tokens.Variant}" diff --git a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs index a655fe06d1..aff59a9627 100644 --- a/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs +++ b/Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs @@ -111,7 +111,7 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate if (target.IsUserDefinedType()) { var udtValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedType); - var udtField = new UserDefinedTypeCandidate(target, udtValidator, _codeBuilder.DefaultPropertyValueParamIdentifier) as IUserDefinedTypeCandidate; + var udtField = new UserDefinedTypeCandidate(target, udtValidator, _codeBuilder.BuildPropertyRhsParameterName) as IUserDefinedTypeCandidate; (Declaration udtDeclaration, IEnumerable udtMembers) = GetUDTAndMembersForField(udtField); @@ -126,7 +126,7 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate { udtMemberValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMemberArray); } - var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField, _codeBuilder.DefaultPropertyValueParamIdentifier) as IUserDefinedTypeMemberCandidate; + var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField, _codeBuilder.BuildPropertyRhsParameterName) as IUserDefinedTypeMemberCandidate; udtField.AddMember(candidateUDTMember); } @@ -142,10 +142,10 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate } else if (target.IsArray) { - return new ArrayCandidate(target, validator, _codeBuilder.DefaultPropertyValueParamIdentifier); + return new ArrayCandidate(target, validator, _codeBuilder.BuildPropertyRhsParameterName); } - var candidate = new EncapsulateFieldCandidate(target, validator, _codeBuilder.DefaultPropertyValueParamIdentifier); + var candidate = new EncapsulateFieldCandidate(target, validator, _codeBuilder.BuildPropertyRhsParameterName); return candidate; } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs index 6bea93d78c..8d1ddf3fc3 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/ArrayCandidate.cs @@ -1,5 +1,4 @@ -using Antlr4.Runtime; -using Rubberduck.Parsing; +using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; using Rubberduck.Resources; @@ -17,8 +16,8 @@ public interface IArrayCandidate : IEncapsulateFieldCandidate public class ArrayCandidate : EncapsulateFieldCandidate, IArrayCandidate { private string _subscripts; - public ArrayCandidate(Declaration declaration, IValidateVBAIdentifiers validator, Func paramNameBuilder) - :base(declaration, validator, paramNameBuilder) + public ArrayCandidate(Declaration declaration, IValidateVBAIdentifiers validator, Func parameterNameBuilder) + :base(declaration, validator, parameterNameBuilder) { ImplementLet = false; ImplementSet = false; diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs index f5b2681730..f78f733e7f 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidate.cs @@ -45,13 +45,13 @@ public class EncapsulateFieldCandidate : IEncapsulateFieldCandidate protected int _hashCode; private string _identifierName; protected EncapsulationIdentifiers _fieldAndProperty; - private Func _paramNameBuilder; + private Func _parameterNameBuilder; - public EncapsulateFieldCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator, Func paramNameBuilder) + public EncapsulateFieldCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator, Func parameterNameBuilder) { _target = declaration; NameValidator = identifierValidator; - _paramNameBuilder = paramNameBuilder; + _parameterNameBuilder = parameterNameBuilder; _fieldAndProperty = new EncapsulationIdentifiers(declaration.IdentifierName, identifierValidator); IdentifierName = declaration.IdentifierName; @@ -202,7 +202,7 @@ public string IdentifierName public virtual string ReferenceQualifier { set; get; } - public string ParameterName => _paramNameBuilder(PropertyIdentifier); + public string ParameterName => _parameterNameBuilder(PropertyIdentifier); private bool _implLet; public bool ImplementLet { get => !IsReadOnly && _implLet; set => _implLet = value; } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs index 64ce9b6fea..96d8871512 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeCandidate.cs @@ -1,12 +1,8 @@ -using Antlr4.Runtime; -using Rubberduck.Common; -using Rubberduck.Parsing; -using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; using Rubberduck.Refactorings.Common; using System; using System.Collections.Generic; -using System.Linq; namespace Rubberduck.Refactorings.EncapsulateField { @@ -21,8 +17,8 @@ public interface IUserDefinedTypeCandidate : IEncapsulateFieldCandidate public class UserDefinedTypeCandidate : EncapsulateFieldCandidate, IUserDefinedTypeCandidate { - public UserDefinedTypeCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator, Func paramNameBuilder) - : base(declaration, identifierValidator, paramNameBuilder) + public UserDefinedTypeCandidate(Declaration declaration, IValidateVBAIdentifiers identifierValidator, Func parameterNameBuilder) + : base(declaration, identifierValidator, parameterNameBuilder) { } diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs index f2ea3ef546..93c089c4e0 100644 --- a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs +++ b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/UserDefinedTypeMemberCandidate.cs @@ -20,11 +20,11 @@ public class UserDefinedTypeMemberCandidate : IUserDefinedTypeMemberCandidate { private int _hashCode; private readonly string _uniqueID; - private Func _paramNameBuilder; - public UserDefinedTypeMemberCandidate(IEncapsulateFieldCandidate candidate, IUserDefinedTypeCandidate udtField, Func paramNameBuilder) + private Func _parameterNameBuilder; + public UserDefinedTypeMemberCandidate(IEncapsulateFieldCandidate candidate, IUserDefinedTypeCandidate udtField, Func parameterNameBuilder) { _wrappedCandidate = candidate; - _paramNameBuilder = paramNameBuilder; + _parameterNameBuilder = parameterNameBuilder; UDTField = udtField; PropertyIdentifier = IdentifierName; BackingIdentifier = IdentifierName; @@ -203,7 +203,7 @@ public QualifiedModuleName QualifiedModuleName public string PropertyAsTypeName => _wrappedCandidate.PropertyAsTypeName; - public string ParameterName => _paramNameBuilder(PropertyIdentifier); + public string ParameterName => _parameterNameBuilder(PropertyIdentifier); public bool ImplementLet => _wrappedCandidate.ImplementLet; diff --git a/RubberduckTests/CodeBuilderTests.cs b/RubberduckTests/CodeBuilderTests.cs index 2c00617b3e..a4f32ada81 100644 --- a/RubberduckTests/CodeBuilderTests.cs +++ b/RubberduckTests/CodeBuilderTests.cs @@ -339,7 +339,7 @@ private string ParseAndTest(string inputCode, string targetIdentifier, Declar private static string PropertyGetBlockFromPrototypeTest(T target, PropertyBlockFromPrototypeParams testParams) where T : Declaration { - new CodeBuilder().TryBuildPropertyGetCodeBlock(target, testParams.Identifier, out string result, testParams.Accessibility, testParams.Content); //, testParams.WriteParam); + new CodeBuilder().TryBuildPropertyGetCodeBlock(target, testParams.Identifier, out string result, testParams.Accessibility, testParams.Content); return result; } diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs index 196a5bd2cc..98e97d6b56 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFIeldTestSupport.cs @@ -19,7 +19,7 @@ namespace RubberduckTests.Refactoring.EncapsulateField { public class EncapsulateFieldTestSupport : InteractiveRefactoringTestBase { - public static string ParamNameBuilder(string property) => $"{property.ToLowerCaseFirstLetter()}Value"; + public string RhsParameterNameBuilder(string property) => $"{property.ToLowerCaseFirstLetter()}Value"; public string StateUDTDefaultType => $"T{MockVbeBuilder.TestModuleName}"; diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs index 3b65940b87..3fdfda77b9 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTests.cs @@ -21,8 +21,6 @@ public class EncapsulateFieldTests : InteractiveRefactoringTestBase Param = EncapsulateFieldTestSupport.ParamNameBuilder; - [TestCase("fizz", true, "baz", true, "buzz", true)] [TestCase("fizz", false, "baz", true, "buzz", true)] [TestCase("fizz", false, "baz", false, "buzz", true)] @@ -69,10 +67,12 @@ public class EncapsulateFieldTests : InteractiveRefactoringTestBase Param = EncapsulateFieldTestSupport.ParamNameBuilder; - [Test] [Category("Refactorings")] [Category("Encapsulate Field")] @@ -29,8 +27,10 @@ public void EncapsulatePrivateFieldAsUDT() var presenterAction = Support.SetParametersForSingleTarget("fizz", "Name", asUDT: true); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); + var rhsParameterName = Support.RhsParameterNameBuilder("Name"); + StringAssert.Contains("Name As Integer", actualCode); - StringAssert.Contains($"this.Name = {Param("Name")}", actualCode); + StringAssert.Contains($"this.Name = {rhsParameterName}", actualCode); } [TestCase("Public")] @@ -78,11 +78,13 @@ End Type userInput.EncapsulateUsingUDTField(); var presenterAction = Support.SetParameters(userInput); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains($"this.MyBar.First = {Param("First")}", actualCode); + StringAssert.Contains($"this.MyBar.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"First = this.MyBar.First", actualCode); - StringAssert.Contains($"this.MyBar.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.MyBar.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Second = this.MyBar.Second", actualCode); StringAssert.Contains($"MyBar As TBar", actualCode); StringAssert.Contains($"MyBar As TBar", actualCode); @@ -247,10 +249,13 @@ End Type userInput.EncapsulateUsingUDTField(); var presenterAction = Support.SetParameters(userInput); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); + var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains($"this.MyBar.First = {Param("First")}", actualCode); + StringAssert.Contains($"this.MyBar.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains("First = this.MyBar.First", actualCode); - StringAssert.Contains($"this.MyBar.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.MyBar.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains("Second = this.MyBar.Second", actualCode); var index = actualCode.IndexOf("Get Second", StringComparison.InvariantCultureIgnoreCase); var indexLast = actualCode.LastIndexOf("Get Second", StringComparison.InvariantCultureIgnoreCase); @@ -461,12 +466,13 @@ End Type userInput.EncapsulateUsingUDTField(); var presenterAction = Support.SetParameters(userInput); + var rhsParameterName = Support.RhsParameterNameBuilder("Foo"); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Public Property Let Foo(", actualCode); StringAssert.Contains("Public Property Let Bar(", actualCode); - StringAssert.Contains($"this.MyBar.FooBar.Foo = {Param("Foo")}", actualCode); + StringAssert.Contains($"this.MyBar.FooBar.Foo = {rhsParameterName}", actualCode); } [Test] @@ -494,11 +500,11 @@ End Type userInput.EncapsulateUsingUDTField(); var presenterAction = Support.SetParameters(userInput); + var rhsParameterName = Support.RhsParameterNameBuilder("FooBar"); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains("Public Property Let FooBar(", actualCode); - StringAssert.Contains($"this.MyBar.FooBar = {Param("FooBar")}", actualCode); + StringAssert.Contains($"this.MyBar.FooBar = {rhsParameterName}", actualCode); } [Test] @@ -529,13 +535,15 @@ End Type var presenterAction = Support.SetParameters(userInput); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); + var rhsParameterNameFoo = Support.RhsParameterNameBuilder("Foo"); + var rhsParameterNameFoo_1 = Support.RhsParameterNameBuilder("Foo_1"); StringAssert.Contains("Public Property Let Foo(", actualCode); StringAssert.Contains("Public Property Let Bar(", actualCode); StringAssert.Contains("Public Property Let Foo_1(", actualCode); StringAssert.Contains("Public Property Let Bar_1(", actualCode); - StringAssert.Contains($"this.MyBar.FooBar.Foo = {Param("Foo")}", actualCode); - StringAssert.Contains($"this.MyBar.ReBar.Foo = {Param("Foo_1")}", actualCode); + StringAssert.Contains($"this.MyBar.FooBar.Foo = {rhsParameterNameFoo}", actualCode); + StringAssert.Contains($"this.MyBar.ReBar.Foo = {rhsParameterNameFoo_1}", actualCode); } [Test] diff --git a/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs index 33023e9c52..ed82a61707 100644 --- a/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateField/EncapsulatedUDTFieldTests.cs @@ -5,7 +5,6 @@ using Rubberduck.Refactorings.EncapsulateField; using Rubberduck.VBEditor.SafeComWrappers; using Rubberduck.VBEditor.Utility; -using System; using System.Collections.Generic; namespace RubberduckTests.Refactoring.EncapsulateField @@ -15,8 +14,6 @@ public class EncapsulatedUDTFieldTests : InteractiveRefactoringTestBase Param = EncapsulateFieldTestSupport.ParamNameBuilder; - [TestCase("Public")] [TestCase("Private")] [Category("Refactorings")] @@ -34,15 +31,18 @@ End Type var presenterAction = Support.UserAcceptsDefaults(); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); + var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Private this As TBar", actualCode); StringAssert.DoesNotContain("this = value", actualCode); StringAssert.DoesNotContain($"This = this", actualCode); StringAssert.Contains($"Public Property Get First", actualCode); StringAssert.Contains($"Public Property Get Second", actualCode); - StringAssert.Contains($"this.First = {Param("First")}", actualCode); + StringAssert.Contains($"this.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); } @@ -73,22 +73,27 @@ End Type .AddUserInputSet(expectedThat.TargetFieldName, encapsulationFlag: encapsulateThat); var presenterAction = Support.SetParameters(userInput); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); + var rhsParameterNameFirst1 = Support.RhsParameterNameBuilder("First_1"); + var rhsParameterNameSecond1 = Support.RhsParameterNameBuilder("Second_1"); + var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); if (encapsulateThis && encapsulateThat) { StringAssert.Contains($"Private {expectedThis.TargetFieldName} As TBar", actualCode); StringAssert.Contains($"First = {expectedThis.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second = {expectedThis.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.First = {Param("First")}", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.First = {rhsParameterNameFirst}", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Property Get First", actualCode); StringAssert.Contains($"Property Get Second", actualCode); StringAssert.Contains($"Private {expectedThat.TargetFieldName} As TBar", actualCode); StringAssert.Contains($"First_1 = {expectedThat.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second_1 = {expectedThat.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.First = {Param("First_1")}", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = {Param("Second_1")}", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.First = {rhsParameterNameFirst1}", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = {rhsParameterNameSecond1}", actualCode); StringAssert.Contains($"Property Get First_1", actualCode); StringAssert.Contains($"Property Get Second_1", actualCode); @@ -99,8 +104,8 @@ End Type { StringAssert.Contains($"First = {expectedThis.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second = {expectedThis.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.First = {Param("First")}", actualCode); - StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.First = {rhsParameterNameFirst}", actualCode); + StringAssert.Contains($"{expectedThis.TargetFieldName}.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Property Get First", actualCode); StringAssert.Contains($"Property Get Second", actualCode); @@ -111,8 +116,8 @@ End Type { StringAssert.Contains($"First = {expectedThat.TargetFieldName}.First", actualCode); StringAssert.Contains($"Second = {expectedThat.TargetFieldName}.Second", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.First = {Param("First")}", actualCode); - StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.First = {rhsParameterNameFirst}", actualCode); + StringAssert.Contains($"{expectedThat.TargetFieldName}.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Property Get First", actualCode); StringAssert.Contains($"Property Get Second", actualCode); @@ -152,11 +157,13 @@ End Sub var presenterAction = Support.UserAcceptsDefaults(); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); - StringAssert.Contains($"this.First = {Param("First")}", actualCode); + StringAssert.Contains($"this.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.Contains($" First = arg1", actualCode); StringAssert.Contains($" Second = arg2", actualCode); @@ -286,13 +293,15 @@ Private mFizz var presenterAction = Support.SetParameters(userInput); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); StringAssert.Contains("Private this As TBar", actualCode); StringAssert.DoesNotContain("this = value", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); - StringAssert.Contains($"this.First = {Param("First")}", actualCode); + StringAssert.Contains($"this.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); StringAssert.Contains($"Private mFoo As String", actualCode); @@ -343,19 +352,22 @@ End Sub ("Class1", class1Code, ComponentType.ClassModule), ("Module1", codeString.Code, ComponentType.StandardModule)); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); + var rhsParameterNameThis = Support.RhsParameterNameBuilder("this"); var actualCode = actualModuleCode["Module1"]; StringAssert.Contains("Private this As TBar", actualCode); - StringAssert.DoesNotContain($"this = {Param("this")}", actualCode); + StringAssert.DoesNotContain($"this = {rhsParameterNameThis}", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); - StringAssert.Contains($"Property Set First(ByVal {Param("First")} As Class1)", actualCode); + StringAssert.Contains($"Property Set First(ByVal {rhsParameterNameFirst} As Class1)", actualCode); StringAssert.Contains("Property Get First() As Class1", actualCode); - StringAssert.Contains($"Set this.First = {Param("First")}", actualCode); + StringAssert.Contains($"Set this.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"Set First = this.First", actualCode); - StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); - Assert.AreEqual(actualCode.IndexOf($"this.First = {Param("First")}"), actualCode.LastIndexOf($"this.First = {Param("First")}")); + Assert.AreEqual(actualCode.IndexOf($"this.First = {rhsParameterNameFirst}"), actualCode.LastIndexOf($"this.First = {rhsParameterNameFirst}")); } [TestCase("Public")] @@ -377,15 +389,18 @@ End Type .UserSelectsField("this", "MyType"); var presenterAction = Support.SetParameters(userInput); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); + var rhsParameterNameThis = Support.RhsParameterNameBuilder("this"); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains("Private this As TBar", actualCode); - StringAssert.DoesNotContain($"this = {Param("this")}", actualCode); + StringAssert.DoesNotContain($"this = {rhsParameterNameThis}", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); - StringAssert.Contains($"this.First = {Param("First")}", actualCode); + StringAssert.Contains($"this.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"First = this.First", actualCode); StringAssert.Contains($"IsObject", actualCode); - StringAssert.Contains($"this.Second = {Param("Second")}", actualCode); + StringAssert.Contains($"this.Second = {rhsParameterNameSecond}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); } @@ -410,14 +425,16 @@ End Type .UserSelectsField("this", "MyType"); var presenterAction = Support.SetParameters(userInput); + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameThis = Support.RhsParameterNameBuilder("this"); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.Contains($"Private this As TBar", actualCode); - StringAssert.DoesNotContain($"this = {Param("this")}", actualCode); - StringAssert.DoesNotContain($"this.First = {Param("First")}", actualCode); + StringAssert.DoesNotContain($"this = {rhsParameterNameThis}", actualCode); + StringAssert.DoesNotContain($"this.First = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"Property Get First() As Variant", actualCode); StringAssert.Contains($"First = this.First", actualCode); - StringAssert.DoesNotContain($"this.Second = {Param("First")}", actualCode); + StringAssert.DoesNotContain($"this.Second = {rhsParameterNameFirst}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.Contains($"Property Get Second() As Variant", actualCode); StringAssert.Contains($"Third = this.Third", actualCode); @@ -464,16 +481,20 @@ End Type var actualCode = actualModuleCode["Class1"]; StringAssert.Contains("Private this As TBar", actualCode); + + var rhsParameterNameFirst = Support.RhsParameterNameBuilder("First"); + var rhsParameterNameSecond = Support.RhsParameterNameBuilder("Second"); + var rhsParameterNameMyType = Support.RhsParameterNameBuilder("MyType"); if (accessibility == "Public") { - StringAssert.Contains($"this = {Param("MyType")}", actualCode); + StringAssert.Contains($"this = {rhsParameterNameMyType}", actualCode); StringAssert.Contains("MyType = this", actualCode); StringAssert.Contains($"Public Property Get MyType", actualCode); Assert.AreEqual(actualCode.IndexOf("MyType = this"), actualCode.LastIndexOf("MyType = this")); - StringAssert.DoesNotContain($"this.First = {Param("First")}", actualCode); - StringAssert.DoesNotContain($"this.Second = {Param("Second")}", actualCode); + StringAssert.DoesNotContain($"this.First = {rhsParameterNameFirst}", actualCode); + StringAssert.DoesNotContain($"this.Second = {rhsParameterNameSecond}", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); - StringAssert.Contains($"Public Property Let MyType(ByRef {Param("MyType")} As TBar", actualCode); + StringAssert.Contains($"Public Property Let MyType(ByRef {rhsParameterNameMyType} As TBar", actualCode); } } @@ -498,6 +519,7 @@ End Sub "; var presenterAction = Support.UserAcceptsDefaults(); + var rhsParameterName = Support.RhsParameterNameBuilder("TheClass"); var codeString = inputCode.ToCodeString(); var actualModuleCode = RefactoredCode( @@ -512,7 +534,7 @@ End Sub var actualCode = actualModuleCode["Module1"]; StringAssert.Contains($"Private mTheClass As Class1", actualCode); - StringAssert.Contains($"Set mTheClass = {Param("TheClass")}", actualCode); + StringAssert.Contains($"Set mTheClass = {rhsParameterName}", actualCode); StringAssert.Contains($"Set TheClass = mTheClass", actualCode); StringAssert.Contains($"Public Property Set TheClass", actualCode); }