Move RemoveParameter to the ISelectionService

MDoerner · MDoerner · commit b07582e87a69 · 2019-02-13T00:12:27.000+01:00
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveUnusedParameterQuickFix.cs
@@ -6,30 +6,31 @@
 using Rubberduck.Refactorings;
 using Rubberduck.Refactorings.RemoveParameters;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+using Rubberduck.VBEditor.Utility;
 
 namespace Rubberduck.Inspections.QuickFixes
 {
     public sealed class RemoveUnusedParameterQuickFix : QuickFixBase
     {
-        private readonly IVBE _vbe;
-        private readonly RubberduckParserState _state;
+        private readonly IDeclarationFinderProvider _declarationFinderProvider;
         private readonly IRefactoringPresenterFactory _factory;
         private readonly IRewritingManager _rewritingManager;
+        private readonly ISelectionService _selectionService;
 
-        public RemoveUnusedParameterQuickFix(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager)
+        public RemoveUnusedParameterQuickFix(IDeclarationFinderProvider declarationFinderProvider, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager, ISelectionService selectionService)
             : base(typeof(ParameterNotUsedInspection))
         {
-            _vbe = vbe;
-            _state = state;
+            _declarationFinderProvider = declarationFinderProvider;
             _factory = factory;
             _rewritingManager = rewritingManager;
+            _selectionService = selectionService;
         }
 
         //The rewriteSession is optional since it is not used in this particular quickfix because it is a refactoring quickfix.
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession = null)
         {
-            var refactoring = new RemoveParametersRefactoring(_state, _vbe, _factory, _rewritingManager);
-            refactoring.QuickFix(_state, result.QualifiedSelection);
+            var refactoring = new RemoveParametersRefactoring(_declarationFinderProvider, _factory, _rewritingManager, _selectionService);
+            refactoring.QuickFix(result.QualifiedSelection);
         }
 
         public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveUnusedParameterQuickFix;
diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs
@@ -7,6 +7,7 @@
 using Rubberduck.Refactorings;
 using Rubberduck.Refactorings.RemoveParameters;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+using Rubberduck.VBEditor.Utility;
 
 namespace Rubberduck.UI.Command.Refactorings
 {
@@ -16,13 +17,15 @@ public class RefactorRemoveParametersCommand : RefactorCommandBase
         private readonly RubberduckParserState _state;
         private readonly IRefactoringPresenterFactory _factory;
         private readonly IRewritingManager _rewritingManager;
+        private readonly ISelectionService _selectionService;
 
-        public RefactorRemoveParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager) 
+        public RefactorRemoveParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager, ISelectionService selectionService) 
             : base (vbe)
         {
             _state = state;
             _factory = factory;
             _rewritingManager = rewritingManager;
+            _selectionService = selectionService;
         }
 
         private static readonly DeclarationType[] ValidDeclarationTypes =
@@ -42,14 +45,14 @@ protected override bool EvaluateCanExecute(object parameter)
                 return false;
             }
 
-            var selection = Vbe.GetActiveSelection();
+            var activeSelection = _selectionService.ActiveSelection();
 
-            if (!selection.HasValue)
+            if (!activeSelection.HasValue)
             {
                 return false;
             }
 
-            var member = _state.AllUserDeclarations.FindTarget(selection.Value, ValidDeclarationTypes);
+            var member = _state.DeclarationFinder.AllUserDeclarations.FindTarget(activeSelection.Value, ValidDeclarationTypes);
             if (member == null)
             {
                 return false;
@@ -66,15 +69,18 @@ protected override bool EvaluateCanExecute(object parameter)
                     || member.DeclarationType == DeclarationType.PropertySet
                         ? parameters.Count > 1
                         : parameters.Any();
-            
         }
 
         protected override void OnExecute(object parameter)
         {
-            var selection = Vbe.GetActiveSelection();
-            
-            var refactoring = new RemoveParametersRefactoring(_state, Vbe, _factory, _rewritingManager);
-            refactoring.Refactor(selection.Value);
+            var activeSelection = _selectionService.ActiveSelection();
+            if (!activeSelection.HasValue)
+            {
+                return;
+            }
+
+            var refactoring = new RemoveParametersRefactoring(_state, _factory, _rewritingManager, _selectionService);
+            refactoring.Refactor(activeSelection.Value);
         }
     }
 }
diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs
@@ -99,6 +99,9 @@ public void Install(IWindsorContainer container, IConfigurationStore store)
             container.Register(Component.For<ISelectionChangeService>()
                 .ImplementedBy<SelectionChangeService>()
                 .LifestyleSingleton());
+            container.Register(Component.For<ISelectionService>()
+                .ImplementedBy<SelectionService>()
+                .LifestyleSingleton());
             container.Register(Component.For<AutoCompleteService>()
                 .LifestyleSingleton());
             container.Register(Component.For<IOperatingSystem>()
diff --git a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersModel.cs b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersModel.cs
@@ -11,17 +11,15 @@ namespace Rubberduck.Refactorings.RemoveParameters
 {
     public class RemoveParametersModel
     {
-        public RubberduckParserState State { get; }
         public IEnumerable<Declaration> Declarations { get; }
 
         public Declaration TargetDeclaration { get; private set; }
         public List<Parameter> Parameters { get; private set; }
         public List<Parameter> RemoveParameters { get; set; }
 
-        public RemoveParametersModel(RubberduckParserState state, QualifiedSelection selection)
+        public RemoveParametersModel(IDeclarationFinderProvider declarationFinderProvider, QualifiedSelection selection)
         {
-            State = state;
-            Declarations = state.AllDeclarations.ToList();
+            Declarations = declarationFinderProvider.DeclarationFinder.AllUserDeclarations.ToList();
 
             AcquireTarget(selection);
             LoadParameters();
diff --git a/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs b/Rubberduck.Refactorings/RemoveParameters/RemoveParametersRefactoring.cs
@@ -9,32 +9,31 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
-using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.Utility;
 
 namespace Rubberduck.Refactorings.RemoveParameters
 {
     public class RemoveParametersRefactoring : IRefactoring
     {
-        private readonly RubberduckParserState _state;
-        private readonly IVBE _vbe;
-        private readonly IRefactoringPresenterFactory _factory;
+        private readonly IDeclarationFinderProvider _declarationFinderProvider;
+        private readonly ISelectionService _selectionService;
+        private readonly Func<RemoveParametersModel, IDisposalActionContainer<IRemoveParametersPresenter>> _presenterFactory;
         private readonly IRewritingManager _rewritingManager;
         private RemoveParametersModel _model;
 
-        public RemoveParametersRefactoring(RubberduckParserState state, IVBE vbe, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager)
+        public RemoveParametersRefactoring(IDeclarationFinderProvider declarationFinderProvider, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager, ISelectionService selectionService)
         {
-            _state = state;
-            _vbe = vbe;
+            _declarationFinderProvider = declarationFinderProvider;
+            _selectionService = selectionService;
             _rewritingManager = rewritingManager;
-            _factory = factory;
+            _presenterFactory = (model => DisposalActionContainer.Create(factory.Create<IRemoveParametersPresenter, RemoveParametersModel>(model), factory.Release));
         }
 
         private RemoveParametersModel InitializeModel()
         {
-            var selection = _vbe.GetActiveSelection();
+            var activeSelection = _selectionService.ActiveSelection();
 
-            return !selection.HasValue ? null : new RemoveParametersModel(_state, selection.Value);
+            return !activeSelection.HasValue ? null : new RemoveParametersModel(_declarationFinderProvider, activeSelection.Value);
         }
 
         public void Refactor()
@@ -45,9 +44,9 @@ public void Refactor()
                 return;
             }
 
-            using (var container = DisposalActionContainer.Create(_factory.Create<IRemoveParametersPresenter, RemoveParametersModel>(_model), p => _factory.Release(p)))
+            using (var presenterContainer = _presenterFactory(_model))
             {
-                var presenter = container.Value;
+                var presenter = presenterContainer.Value;
                 if (presenter == null)
                 {
                     return;
@@ -59,33 +58,18 @@ public void Refactor()
                     return;
                 }
 
-                using (var pane = _vbe.ActiveCodePane)
-                {
-                    var oldSelection = pane.GetQualifiedSelection();
-
-                    RemoveParameters();
-
-                    if (oldSelection.HasValue && !pane.IsWrappingNullReference)
-                    {
-                        pane.Selection = oldSelection.Value.Selection;
-                    }
-                }
-
-                _model.State.OnParseRequested(this);
+                RemoveParameters();
             }
         }
 
         public void Refactor(QualifiedSelection target)
         {
-            using (var pane = _vbe.ActiveCodePane)
+            if (!_selectionService.TrySetActiveSelection(target))
             {
-                if (pane.IsWrappingNullReference)
-                {
-                    return;
-                }
-                pane.Selection = target.Selection;
-                Refactor();
+                return;
             }
+
+            Refactor();
         }
 
         public void Refactor(Declaration target)
@@ -95,20 +79,12 @@ public void Refactor(Declaration target)
                 throw new ArgumentException("Invalid declaration type");
             }
 
-            using (var pane = _vbe.ActiveCodePane)
-            {
-                if (pane.IsWrappingNullReference)
-                {
-                    return;
-                }
-                pane.Selection = target.QualifiedSelection.Selection;
-                Refactor();
-            }
+            Refactor(target.QualifiedSelection);
         }
 
-        public void QuickFix(RubberduckParserState state, QualifiedSelection selection)
+        public void QuickFix(QualifiedSelection selection)
         {
-            _model = new RemoveParametersModel(state, selection);
+            _model = new RemoveParametersModel(_declarationFinderProvider, selection);
             
             var target = _model.Parameters.SingleOrDefault(p => selection.Selection.Contains(p.Declaration.QualifiedSelection.Selection));
             Debug.Assert(target != null, "Target was not found");
@@ -259,10 +235,10 @@ private void AdjustSignatures(IRewriteSession rewriteSession)
                 RemoveSignatureParameters(eventImplementation, rewriteSession);
             }
 
-            var interfaceImplementations = _model.State.DeclarationFinder.FindAllInterfaceImplementingMembers().Where(item =>
-                item.ProjectId == _model.TargetDeclaration.ProjectId
-                &&
-                item.IdentifierName == $"{_model.TargetDeclaration.ComponentName}_{_model.TargetDeclaration.IdentifierName}");
+            var interfaceImplementations = _declarationFinderProvider.DeclarationFinder
+                .FindAllInterfaceImplementingMembers()
+                .Where(item => item.ProjectId == _model.TargetDeclaration.ProjectId 
+                               && item.IdentifierName == $"{_model.TargetDeclaration.ComponentName}_{_model.TargetDeclaration.IdentifierName}");
 
             foreach (var interfaceImplentation in interfaceImplementations)
             {
diff --git a/Rubberduck.Refactorings/Rename/RenameRefactoring.cs b/Rubberduck.Refactorings/Rename/RenameRefactoring.cs
@@ -24,7 +24,7 @@ public class RenameRefactoring : IRefactoring
         private const string AppendUnderscoreFormat = "{0}_";
         private const string PrependUnderscoreFormat = "_{0}";
 
-        private readonly IRefactoringPresenterFactory _factory;
+        private readonly Func<RenameModel, IDisposalActionContainer<IRenamePresenter>> _presenterFactory;
         private readonly IMessageBox _messageBox;
         private readonly IDeclarationFinderProvider _declarationFinderProvider;
         private readonly IProjectsProvider _projectsProvider;
@@ -39,13 +39,13 @@ public class RenameRefactoring : IRefactoring
         private bool IsUserEventHandlerRename { set; get; }
         public RenameRefactoring(IRefactoringPresenterFactory factory, IMessageBox messageBox, IDeclarationFinderProvider declarationFinderProvider, IProjectsProvider projectsProvider, IRewritingManager rewritingManager, ISelectionService selectionService)
         {
-            _factory = factory;
             _messageBox = messageBox;
             _declarationFinderProvider = declarationFinderProvider;
             _projectsProvider = projectsProvider;
             _rewritingManager = rewritingManager;
             _selectionService = selectionService;
             _model = null;
+            _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create<IRenamePresenter, RenameModel>(model), factory.Release));
 
             _renameActions = new Dictionary<DeclarationType, Action<IRewriteSession>>
             {
@@ -80,9 +80,9 @@ public void Refactor()
                 return;
             }
 
-            using (var container = DisposalActionContainer.Create(_factory.Create<IRenamePresenter, RenameModel>(_model), p => _factory.Release(p)))
+            using (var presenterContainer = _presenterFactory(_model))
             {
-                var presenter = container.Value;
+                var presenter = presenterContainer.Value;
                 if (presenter != null)
                 {
                     RefactorImpl(presenter.Model.Target, presenter);
@@ -98,9 +98,9 @@ public void Refactor(Declaration target)
                 return;
             }
 
-            using (var container = DisposalActionContainer.Create(_factory.Create<IRenamePresenter, RenameModel>(_model), p => _factory.Release(p)))
+            using (var presenterContainer = _presenterFactory(_model))
             {
-                var presenter = container.Value;
+                var presenter = presenterContainer.Value;
 
                 RefactorImpl(target, presenter);
             }
diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs
diff --git a/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveUnusedParameterQuickFixTests.cs
diff --git a/RubberduckTests/Refactoring/RemoveParametersTests.cs b/RubberduckTests/Refactoring/RemoveParametersTests.cs

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`using Rubberduck.Refactorings;`
`8`	`8`	`using Rubberduck.Refactorings.RemoveParameters;`
`9`	`9`	`using Rubberduck.VBEditor.SafeComWrappers.Abstract;`
	`10`	`+using Rubberduck.VBEditor.Utility;`
`10`	`11`
`11`	`12`	`namespace Rubberduck.UI.Command.Refactorings`
`12`	`13`	`{`
`@@ -16,13 +17,15 @@ public class RefactorRemoveParametersCommand : RefactorCommandBase`
`16`	`17`	`private readonly RubberduckParserState _state;`
`17`	`18`	`private readonly IRefactoringPresenterFactory _factory;`
`18`	`19`	`private readonly IRewritingManager _rewritingManager;`
	`20`	`+ private readonly ISelectionService _selectionService;`
`19`	`21`
`20`		`- public RefactorRemoveParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager)`
	`22`	`+ public RefactorRemoveParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager, ISelectionService selectionService)`
`21`	`23`	`: base (vbe)`
`22`	`24`	`{`
`23`	`25`	`_state = state;`
`24`	`26`	`_factory = factory;`
`25`	`27`	`_rewritingManager = rewritingManager;`
	`28`	`+ _selectionService = selectionService;`
`26`	`29`	`}`
`27`	`30`
`28`	`31`	`private static readonly DeclarationType[] ValidDeclarationTypes =`
`@@ -42,14 +45,14 @@ protected override bool EvaluateCanExecute(object parameter)`
`42`	`45`	`return false;`
`43`	`46`	`}`
`44`	`47`
`45`		`- var selection = Vbe.GetActiveSelection();`
	`48`	`+ var activeSelection = _selectionService.ActiveSelection();`
`46`	`49`
`47`		`- if (!selection.HasValue)`
	`50`	`+ if (!activeSelection.HasValue)`
`48`	`51`	`{`
`49`	`52`	`return false;`
`50`	`53`	`}`
`51`	`54`
`52`		`- var member = _state.AllUserDeclarations.FindTarget(selection.Value, ValidDeclarationTypes);`
	`55`	`+ var member = _state.DeclarationFinder.AllUserDeclarations.FindTarget(activeSelection.Value, ValidDeclarationTypes);`
`53`	`56`	`if (member == null)`
`54`	`57`	`{`
`55`	`58`	`return false;`
`@@ -66,15 +69,18 @@ protected override bool EvaluateCanExecute(object parameter)`
`66`	`69`	`\|\| member.DeclarationType == DeclarationType.PropertySet`
`67`	`70`	`? parameters.Count > 1`
`68`	`71`	`: parameters.Any();`
`69`		`-`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`protected override void OnExecute(object parameter)`
`73`	`75`	`{`
`74`		`- var selection = Vbe.GetActiveSelection();`
`75`		`-`
`76`		`- var refactoring = new RemoveParametersRefactoring(_state, Vbe, _factory, _rewritingManager);`
`77`		`- refactoring.Refactor(selection.Value);`
	`76`	`+ var activeSelection = _selectionService.ActiveSelection();`
	`77`	`+ if (!activeSelection.HasValue)`
	`78`	`+ {`
	`79`	`+ return;`
	`80`	`+ }`
	`81`	`+`
	`82`	`+ var refactoring = new RemoveParametersRefactoring(_state, _factory, _rewritingManager, _selectionService);`
	`83`	`+ refactoring.Refactor(activeSelection.Value);`
`78`	`84`	`}`
`79`	`85`	`}`
`80`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,17 +11,15 @@ namespace Rubberduck.Refactorings.RemoveParameters`
`11`	`11`	`{`
`12`	`12`	`public class RemoveParametersModel`
`13`	`13`	`{`
`14`		`- public RubberduckParserState State { get; }`
`15`	`14`	`public IEnumerable<Declaration> Declarations { get; }`
`16`	`15`
`17`	`16`	`public Declaration TargetDeclaration { get; private set; }`
`18`	`17`	`public List<Parameter> Parameters { get; private set; }`
`19`	`18`	`public List<Parameter> RemoveParameters { get; set; }`
`20`	`19`
`21`		`- public RemoveParametersModel(RubberduckParserState state, QualifiedSelection selection)`
	`20`	`+ public RemoveParametersModel(IDeclarationFinderProvider declarationFinderProvider, QualifiedSelection selection)`
`22`	`21`	`{`
`23`		`- State = state;`
`24`		`- Declarations = state.AllDeclarations.ToList();`
	`22`	`+ Declarations = declarationFinderProvider.DeclarationFinder.AllUserDeclarations.ToList();`
`25`	`23`
`26`	`24`	`AcquireTarget(selection);`
`27`	`25`	`LoadParameters();`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public class RenameRefactoring : IRefactoring`
`24`	`24`	`private const string AppendUnderscoreFormat = "{0}_";`
`25`	`25`	`private const string PrependUnderscoreFormat = "_{0}";`
`26`	`26`
`27`		`- private readonly IRefactoringPresenterFactory _factory;`
	`27`	`+ private readonly Func<RenameModel, IDisposalActionContainer<IRenamePresenter>> _presenterFactory;`
`28`	`28`	`private readonly IMessageBox _messageBox;`
`29`	`29`	`private readonly IDeclarationFinderProvider _declarationFinderProvider;`
`30`	`30`	`private readonly IProjectsProvider _projectsProvider;`
`@@ -39,13 +39,13 @@ public class RenameRefactoring : IRefactoring`
`39`	`39`	`private bool IsUserEventHandlerRename { set; get; }`
`40`	`40`	`public RenameRefactoring(IRefactoringPresenterFactory factory, IMessageBox messageBox, IDeclarationFinderProvider declarationFinderProvider, IProjectsProvider projectsProvider, IRewritingManager rewritingManager, ISelectionService selectionService)`
`41`	`41`	`{`
`42`		`- _factory = factory;`
`43`	`42`	`_messageBox = messageBox;`
`44`	`43`	`_declarationFinderProvider = declarationFinderProvider;`
`45`	`44`	`_projectsProvider = projectsProvider;`
`46`	`45`	`_rewritingManager = rewritingManager;`
`47`	`46`	`_selectionService = selectionService;`
`48`	`47`	`_model = null;`
	`48`	`+ _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create<IRenamePresenter, RenameModel>(model), factory.Release));`
`49`	`49`
`50`	`50`	`_renameActions = new Dictionary<DeclarationType, Action<IRewriteSession>>`
`51`	`51`	`{`
`@@ -80,9 +80,9 @@ public void Refactor()`
`80`	`80`	`return;`
`81`	`81`	`}`
`82`	`82`
`83`		`- using (var container = DisposalActionContainer.Create(_factory.Create<IRenamePresenter, RenameModel>(_model), p => _factory.Release(p)))`
	`83`	`+ using (var presenterContainer = _presenterFactory(_model))`
`84`	`84`	`{`
`85`		`- var presenter = container.Value;`
	`85`	`+ var presenter = presenterContainer.Value;`
`86`	`86`	`if (presenter != null)`
`87`	`87`	`{`
`88`	`88`	`RefactorImpl(presenter.Model.Target, presenter);`
`@@ -98,9 +98,9 @@ public void Refactor(Declaration target)`
`98`	`98`	`return;`
`99`	`99`	`}`
`100`	`100`
`101`		`- using (var container = DisposalActionContainer.Create(_factory.Create<IRenamePresenter, RenameModel>(_model), p => _factory.Release(p)))`
	`101`	`+ using (var presenterContainer = _presenterFactory(_model))`
`102`	`102`	`{`
`103`		`- var presenter = container.Value;`
	`103`	`+ var presenter = presenterContainer.Value;`
`104`	`104`
`105`	`105`	`RefactorImpl(target, presenter);`
`106`	`106`	`}`