Refactoring - WIP

Returned to strategy pattern for the two methods of encapsulation
supported by the refactoring.   More files...but clearer code.

Author: BZngr

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementFactory.cs

@@ -13,42 +13,42 @@ namespace Rubberduck.Refactorings.EncapsulateField
     public class EncapsulateFieldElementFactory
     {
         private readonly IDeclarationFinderProvider _declarationFinderProvider;
-        private readonly IEncapsulateFieldValidator _validator;
-        private readonly IValidateEncapsulateFieldNames _namesValidator;
+        //private readonly IEncapsulateFieldValidator _validator;
+        //private readonly IValidateEncapsulateFieldNames _namesValidator;
         private QualifiedModuleName _targetQMN;
 
-        public EncapsulateFieldElementFactory(IDeclarationFinderProvider declarationFinderProvider, QualifiedModuleName targetQMN, IEncapsulateFieldValidator validator )
+        public EncapsulateFieldElementFactory(IDeclarationFinderProvider declarationFinderProvider, QualifiedModuleName targetQMN)//, IEncapsulateFieldValidator validator )
         {
             _declarationFinderProvider = declarationFinderProvider;
-            _validator = validator;
-            _namesValidator = validator as IValidateEncapsulateFieldNames;
+            //_validator = validator;
+            //_namesValidator = validator as IValidateEncapsulateFieldNames;
             _targetQMN = targetQMN;
         }
 
-        public IObjectStateUDT CreateStateUDTField()
+        public IObjectStateUDT CreateStateUDTField(IEncapsulateFieldValidator validator)
         {
             var stateUDT = new ObjectStateUDT(_targetQMN) as IObjectStateUDT;
 
-            stateUDT = SetNonConflictIdentifier(stateUDT, c => { return _validator.IsConflictingStateUDTFieldIdentifier(stateUDT); }, (s) => { stateUDT.FieldIdentifier = s; }, () => stateUDT.FieldIdentifier, _namesValidator);
+            stateUDT = SetNonConflictIdentifier(stateUDT, c => { return validator.IsConflictingStateUDTFieldIdentifier(stateUDT); }, (s) => { stateUDT.FieldIdentifier = s; }, () => stateUDT.FieldIdentifier, validator as IValidateEncapsulateFieldNames); // _namesValidator);
 
-            stateUDT = SetNonConflictIdentifier(stateUDT, c => { return _validator.IsConflictingStateUDTTypeIdentifier(stateUDT); }, (s) => { stateUDT.TypeIdentifier = s; }, () => stateUDT.TypeIdentifier, _namesValidator);
+            stateUDT = SetNonConflictIdentifier(stateUDT, c => { return validator.IsConflictingStateUDTTypeIdentifier(stateUDT); }, (s) => { stateUDT.TypeIdentifier = s; }, () => stateUDT.TypeIdentifier, validator as IValidateEncapsulateFieldNames); // _namesValidator);
 
             return stateUDT;
         }
 
-        private IEncapsulateFieldCandidate CreateCandidate(Declaration target)
+        private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidateEncapsulateFieldNames validator)
         {
             if (target.IsUserDefinedTypeField())
             {
-                var udtField = new UserDefinedTypeCandidate(target, _namesValidator) as IUserDefinedTypeCandidate;
+                var udtField = new UserDefinedTypeCandidate(target, validator) as IUserDefinedTypeCandidate;
 
                 (Declaration udtDeclaration, IEnumerable<Declaration> udtMembers) = GetUDTAndMembersForField(udtField);
 
                 udtField.TypeDeclarationIsPrivate = udtDeclaration.HasPrivateAccessibility();
 
                 foreach (var udtMemberDeclaration in udtMembers)
                 {
-                    var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration), udtField, _namesValidator) as IUserDefinedTypeMemberCandidate;
+                    var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, validator), udtField, validator) as IUserDefinedTypeMemberCandidate;
 
                     udtField.AddMember(candidateUDTMember);
                 }
@@ -62,12 +62,12 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target)
             }
             else if (target.IsArray)
             {
-                return new ArrayCandidate(target, _namesValidator);
+                return new ArrayCandidate(target, validator);
             }
-            return new EncapsulateFieldCandidate(target, _namesValidator);
+            return new EncapsulateFieldCandidate(target, validator);
         }
 
-        public IEnumerable<IEncapsulateFieldCandidate> CreateEncapsulationCandidates()
+        public IEnumerable<IEncapsulateFieldCandidate> CreateEncapsulationCandidates(IValidateEncapsulateFieldNames validator)
         {
             var fieldDeclarations = _declarationFinderProvider.DeclarationFinder
                 .Members(_targetQMN)
@@ -78,10 +78,12 @@ public IEnumerable<IEncapsulateFieldCandidate> CreateEncapsulationCandidates()
             {
                 Debug.Assert(!fieldDeclaration.DeclarationType.Equals(DeclarationType.UserDefinedTypeMember));
 
-                var fieldEncapsulationCandidate = CreateCandidate(fieldDeclaration);
+                var fieldEncapsulationCandidate = CreateCandidate(fieldDeclaration, validator);
 
-                _validator.RegisterFieldCandidate(fieldEncapsulationCandidate);
+                //_namesValidator.AssignNoConflictIdentifier(fieldEncapsulationCandidate, DeclarationType.Property);
+                //_namesValidator.AssignNoConflictIdentifier(fieldEncapsulationCandidate, DeclarationType.Variable);
 
+                //_validator.RegisterFieldCandidate(fieldEncapsulationCandidate);
 
                 candidates.Add(fieldEncapsulationCandidate);
             }

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldModel.cs

@@ -11,22 +11,24 @@ public class EncapsulateFieldModel : IRefactoringModel
     {
         private readonly Func<EncapsulateFieldModel, string> _previewDelegate;
         private QualifiedModuleName _targetQMN;
-        private IValidateEncapsulateFieldNames _validator;
+        //private IValidateEncapsulateFieldNames _validator;
         private IObjectStateUDT _newObjectStateUDT;
 
         private IDictionary<Declaration, (Declaration, IEnumerable<Declaration>)> _udtFieldToUdtDeclarationMap = new Dictionary<Declaration, (Declaration, IEnumerable<Declaration>)>();
 
-        public EncapsulateFieldModel(Declaration target, IEnumerable<IEncapsulateFieldCandidate> candidates, IObjectStateUDT stateUDTField, Func<EncapsulateFieldModel, string> previewDelegate, IValidateEncapsulateFieldNames validator)
+        public EncapsulateFieldModel(Declaration target, IEnumerable<IEncapsulateFieldCandidate> candidates, IObjectStateUDT stateUDTField, Func<EncapsulateFieldModel, string> previewDelegate, IEncapsulateFieldValidator validator)
         {
             _previewDelegate = previewDelegate;
             _targetQMN = target.QualifiedModuleName;
-            _validator = validator;
             _newObjectStateUDT = stateUDTField;
 
+            Validator = validator;
             EncapsulationCandidates = candidates.ToList();
             ConvertFieldsToUDTMembers = false;
         }
 
+        public IEncapsulateFieldValidator Validator {set; get;}
+
         public List<IEncapsulateFieldCandidate> EncapsulationCandidates { set; get; } = new List<IEncapsulateFieldCandidate>();
 
         public IEnumerable<IEncapsulateFieldCandidate> SelectedFieldCandidates