implemented CanExecute for all refactoring commands; made corresponding CommandMenuItems call Command.CanExecute - result is a smart context menu that knows what refactorings to enable depending on current selection

retailcoder · retailcoder · commit 573632114929 · 2016-04-04T14:35:58.000-04:00
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorEncapsulateFieldCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorEncapsulateFieldCommandMenuItem.cs
@@ -1,7 +1,5 @@
-using System.Drawing;
 using System.Windows.Input;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Properties;
 using Rubberduck.UI.Command.MenuItems.ParentMenus;
 
 namespace Rubberduck.UI.Command.MenuItems
@@ -20,7 +18,7 @@ public RefactorEncapsulateFieldCommandMenuItem(ICommand command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorExtractInterfaceCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorExtractInterfaceCommandMenuItem.cs
@@ -20,7 +20,7 @@ public RefactorExtractInterfaceCommandMenuItem(ICommand command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorExtractMethodCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorExtractMethodCommandMenuItem.cs
@@ -26,7 +26,7 @@ public override bool BeginGroup
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorImplementInterfaceCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorImplementInterfaceCommandMenuItem.cs
@@ -20,7 +20,7 @@ public RefactorImplementInterfaceCommandMenuItem(ICommand command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorIntroduceFieldCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorIntroduceFieldCommandMenuItem.cs
@@ -22,7 +22,7 @@ public RefactorIntroduceFieldCommandMenuItem (ICommand command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorIntroduceParameterCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorIntroduceParameterCommandMenuItem.cs
@@ -22,7 +22,7 @@ public RefactorIntroduceParameterCommandMenuItem (ICommand command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorMoveCloserToUsageCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorMoveCloserToUsageCommandMenuItem.cs
@@ -17,7 +17,7 @@ public RefactorMoveCloserToUsageCommandMenuItem(ICommand command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorRemoveParametersCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorRemoveParametersCommandMenuItem.cs
@@ -21,7 +21,7 @@ public RefactorRemoveParametersCommandMenuItem(ICommand command) : base(command)
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RefactorReorderParametersCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/RefactorReorderParametersCommandMenuItem.cs
@@ -19,7 +19,7 @@ public RefactorReorderParametersCommandMenuItem(ICommand command) : base(command
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return state.Status == ParserState.Ready;
+            return Command.CanExecute(null);
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorEncapsulateFieldCommand.cs
@@ -1,9 +1,13 @@
-﻿using Microsoft.Vbe.Interop;
+﻿using System.Diagnostics;
+using Microsoft.Vbe.Interop;
 using System.Runtime.InteropServices;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.EncapsulateField;
 using Rubberduck.UI.Refactorings;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
 
 namespace Rubberduck.UI.Command.Refactorings
 {
@@ -18,6 +22,23 @@ public RefactorEncapsulateFieldCommand(VBE vbe, RubberduckParserState state, IAc
             _state = state;
         }
 
+        public override bool CanExecute(object parameter)
+        {
+            var pane = Vbe.ActiveCodePane;
+            if (pane == null || _state.Status != ParserState.Ready)
+            {
+                return false;
+            }
+
+            var selection = pane.GetSelection();
+            var target = _state.AllUserDeclarations.FindTarget(selection, new[] {DeclarationType.Variable,});
+
+            var canExecute = target != null && !target.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member);
+
+            Debug.WriteLine("{0}.CanExecute evaluates to {1}", GetType().Name, canExecute);
+            return canExecute;
+        }
+
         public override void Execute(object parameter)
         {
             if (Vbe.ActiveCodePane == null)
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorExtractInterfaceCommand.cs
@@ -1,20 +1,56 @@
+using System.Diagnostics;
+using System.Linq;
 using Microsoft.Vbe.Interop;
 using System.Runtime.InteropServices;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Refactorings.ImplementInterface;
+using Rubberduck.Refactorings.ExtractInterface;
+using Rubberduck.UI.Refactorings;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
 
 namespace Rubberduck.UI.Command.Refactorings
 {
     [ComVisible(false)]
-    public class RefactorImplementInterfaceCommand : RefactorCommandBase
+    public class RefactorExtractInterfaceCommand : RefactorCommandBase
     {
         private readonly RubberduckParserState _state;
+        private readonly IMessageBox _messageBox;
 
-        public RefactorImplementInterfaceCommand(VBE vbe, RubberduckParserState state, IActiveCodePaneEditor editor)
-            : base (vbe, editor)
+        public RefactorExtractInterfaceCommand(VBE vbe, RubberduckParserState state, IActiveCodePaneEditor editor, IMessageBox messageBox)
+            : base(vbe, editor)
         {
             _state = state;
+            _messageBox = messageBox;
+        }
+
+        private static readonly vbext_ComponentType[] ModuleTypes =
+        {
+            vbext_ComponentType.vbext_ct_ClassModule, 
+            vbext_ComponentType.vbext_ct_Document, 
+            vbext_ComponentType.vbext_ct_MSForm, 
+        };
+
+        public override bool CanExecute(object parameter)
+        {
+            var activePane = Vbe.ActiveCodePane;
+            if (activePane == null)
+            {
+                return false;
+            }
+
+            var selection = activePane.GetSelection();
+            var target = _state.AllUserDeclarations.SingleOrDefault(item =>
+                item.QualifiedName.QualifiedModuleName.Equals(selection.QualifiedName)
+                && item.IdentifierName == selection.QualifiedName.ComponentName
+                && (item.DeclarationType == DeclarationType.Class || item.DeclarationType == DeclarationType.Document || item.DeclarationType == DeclarationType.UserForm));
+            var hasMembers = _state.AllUserDeclarations.Any(item => item.DeclarationType.HasFlag(DeclarationType.Member) && item.ParentDeclaration.Equals(target));
+
+            // true if active code pane is for a class/document/form module
+            var canExecute = ModuleTypes.Contains(Vbe.ActiveCodePane.CodeModule.Parent.Type) && target != null && hasMembers;
+
+            Debug.WriteLine("{0}.CanExecute evaluates to {1}", GetType().Name, canExecute);
+            return canExecute;
         }
 
         public override void Execute(object parameter)
@@ -24,8 +60,12 @@ public override void Execute(object parameter)
                 return;
             }
 
-            var refactoring = new ImplementInterfaceRefactoring(_state, Editor, new MessageBox());
-            refactoring.Refactor();
+            using (var view = new ExtractInterfaceDialog())
+            {
+                var factory = new ExtractInterfacePresenterFactory(_state, Editor, view);
+                var refactoring = new ExtractInterfaceRefactoring(_state, _messageBox, factory, Editor);
+                refactoring.Refactor();
+            }
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorExtractMethodCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorExtractMethodCommand.cs
@@ -1,11 +1,11 @@
+using System.Diagnostics;
 using Microsoft.Vbe.Interop;
 using System.Runtime.InteropServices;
 using Antlr4.Runtime;
 using Rubberduck.Common;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.ExtractMethod;
-using Rubberduck.Settings;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
 
@@ -24,14 +24,22 @@ public RefactorExtractMethodCommand(VBE vbe, RubberduckParserState state, IActiv
 
         public override bool CanExecute(object parameter)
         {
-            if (Vbe.ActiveCodePane == null)
+            if (Vbe.ActiveCodePane == null || _state.Status != ParserState.Ready)
             {
                 return false;
             }
 
             var selection = Vbe.ActiveCodePane.GetSelection();
-            var target = _state.AllDeclarations.FindSelectedDeclaration(selection, DeclarationExtensions.ProcedureTypes, d => ((ParserRuleContext)d.Context.Parent).GetSelection());
-            return _state.Status == ParserState.Ready && target != null;
+            var code = Vbe.ActiveCodePane.CodeModule.Lines[selection.Selection.StartLine, selection.Selection.LineCount];
+
+            var parentProcedure = _state.AllDeclarations.FindSelectedDeclaration(selection, DeclarationExtensions.ProcedureTypes, d => ((ParserRuleContext)d.Context.Parent).GetSelection());
+            var canExecute = parentProcedure != null
+                && selection.Selection.StartColumn != selection.Selection.EndColumn
+                && selection.Selection.LineCount > 0
+                && !string.IsNullOrWhiteSpace(code);
+
+            Debug.WriteLine("{0}.CanExecute evaluates to {1}", GetType().Name, canExecute);
+            return canExecute;
         }
 
         public override void Execute(object parameter)
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorImplementInterfaceCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorImplementInterfaceCommand.cs
@@ -1,23 +1,45 @@
+using System.Diagnostics;
+using System.Linq;
 using Microsoft.Vbe.Interop;
 using System.Runtime.InteropServices;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Refactorings.ExtractInterface;
-using Rubberduck.UI.Refactorings;
+using Rubberduck.Refactorings.ImplementInterface;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
 
 namespace Rubberduck.UI.Command.Refactorings
 {
     [ComVisible(false)]
-    public class RefactorExtractInterfaceCommand : RefactorCommandBase
+    public class RefactorImplementInterfaceCommand : RefactorCommandBase
     {
         private readonly RubberduckParserState _state;
-        private readonly IMessageBox _messageBox;
 
-        public RefactorExtractInterfaceCommand(VBE vbe, RubberduckParserState state, IActiveCodePaneEditor editor, IMessageBox messageBox)
-            : base (vbe, editor)
+        public RefactorImplementInterfaceCommand(VBE vbe, RubberduckParserState state, IActiveCodePaneEditor editor)
+            : base(vbe, editor)
         {
             _state = state;
-            _messageBox = messageBox;
+        }
+
+        public override bool CanExecute(object parameter)
+        {
+            if (Vbe.ActiveCodePane == null || _state.Status != ParserState.Ready)
+            {
+                return false;
+            }
+
+            var selection = Vbe.ActiveCodePane.GetSelection();
+            var targetInterface = _state.AllUserDeclarations.FindInterface(selection);
+
+            var targetClass = _state.AllUserDeclarations.SingleOrDefault(d =>
+                        !d.IsBuiltIn && d.DeclarationType == DeclarationType.Class &&
+                        d.QualifiedSelection.QualifiedName.Equals(selection.QualifiedName));
+
+            var canExecute = targetInterface != null && targetClass != null;
+
+            Debug.WriteLine("{0}.CanExecute evaluates to {1}", GetType().Name, canExecute);
+            return canExecute;
         }
 
         public override void Execute(object parameter)
@@ -27,12 +49,8 @@ public override void Execute(object parameter)
                 return;
             }
 
-            using (var view = new ExtractInterfaceDialog())
-            {
-                var factory = new ExtractInterfacePresenterFactory(_state, Editor, view);
-                var refactoring = new ExtractInterfaceRefactoring(_state, _messageBox, factory, Editor);
-                refactoring.Refactor();
-            }
+            var refactoring = new ImplementInterfaceRefactoring(_state, Editor, new MessageBox());
+            refactoring.Refactor();
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorIntroduceFieldCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorIntroduceFieldCommand.cs
@@ -1,4 +1,7 @@
-﻿using Microsoft.Vbe.Interop;
+﻿using System.Diagnostics;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.IntroduceField;
 using Rubberduck.VBEditor;
@@ -18,6 +21,22 @@ public RefactorIntroduceFieldCommand (VBE vbe, RubberduckParserState state, IAct
             _wrapperWrapperFactory = wrapperWrapperFactory;
         }
 
+        public override bool CanExecute(object parameter)
+        {
+            if (Vbe.ActiveCodePane == null || _state.Status != ParserState.Ready)
+            {
+                return false;
+            }
+
+            var selection = Vbe.ActiveCodePane.GetSelection();
+            var target = _state.AllUserDeclarations.FindVariable(selection);
+
+            var canExecute = target != null && target.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member);
+
+            Debug.WriteLine("{0}.CanExecute evaluates to {1}", GetType().Name, canExecute);
+            return canExecute;
+        }
+
         public override void Execute(object parameter)
         {
             if (Vbe.ActiveCodePane == null)
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorIntroduceParameterCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorIntroduceParameterCommand.cs
@@ -1,4 +1,7 @@
-﻿using Microsoft.Vbe.Interop;
+﻿using System.Diagnostics;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.IntroduceParameter;
 using Rubberduck.VBEditor;
@@ -18,15 +21,30 @@ public RefactorIntroduceParameterCommand (VBE vbe, RubberduckParserState state,
             _wrapperWrapperFactory = wrapperWrapperFactory;
         }
 
+        public override bool CanExecute(object parameter)
+        {
+            if (Vbe.ActiveCodePane == null || _state.Status != ParserState.Ready)
+            {
+                return false;
+            }
+
+            var selection = Vbe.ActiveCodePane.GetSelection();
+            var target = _state.AllUserDeclarations.FindTarget(selection, new []{DeclarationType.Variable, DeclarationType.Constant});
+
+            var canExecute = target != null && target.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member);
+
+            Debug.WriteLine("{0}.CanExecute evaluates to {1}", GetType().Name, canExecute);
+            return canExecute;
+        }
+
         public override void Execute(object parameter)
         {
             if (Vbe.ActiveCodePane == null)
             {
                 return;
             }
-            var codePane = _wrapperWrapperFactory.Create(Vbe.ActiveCodePane);
-            var selection = new QualifiedSelection(new QualifiedModuleName(codePane.CodeModule.Parent), codePane.Selection);
 
+            var selection = Vbe.ActiveCodePane.GetSelection();
             var refactoring = new IntroduceParameterRefactoring(_state, Editor, new MessageBox());
             refactoring.Refactor(selection);
         }
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorMoveCloserToUsageCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorMoveCloserToUsageCommand.cs
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorRemoveParametersCommand.cs
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorReorderParametersCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorReorderParametersCommand.cs

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,5 @@`
`1`		`-using System.Drawing;`
`2`	`1`	`using System.Windows.Input;`
`3`	`2`	`using Rubberduck.Parsing.VBA;`
`4`		`-using Rubberduck.Properties;`
`5`	`3`	`using Rubberduck.UI.Command.MenuItems.ParentMenus;`
`6`	`4`
`7`	`5`	`namespace Rubberduck.UI.Command.MenuItems`
`@@ -20,7 +18,7 @@ public RefactorEncapsulateFieldCommandMenuItem(ICommand command)`
`20`	`18`
`21`	`19`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`22`	`20`	`{`
`23`		`- return state.Status == ParserState.Ready;`
	`21`	`+ return Command.CanExecute(null);`
`24`	`22`	`}`
`25`	`23`	`}`
`26`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public RefactorExtractInterfaceCommandMenuItem(ICommand command)`
`20`	`20`
`21`	`21`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`22`	`22`	`{`
`23`		`- return state.Status == ParserState.Ready;`
	`23`	`+ return Command.CanExecute(null);`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public override bool BeginGroup`
`26`	`26`
`27`	`27`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`28`	`28`	`{`
`29`		`- return state.Status == ParserState.Ready;`
	`29`	`+ return Command.CanExecute(null);`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public RefactorImplementInterfaceCommandMenuItem(ICommand command)`
`20`	`20`
`21`	`21`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`22`	`22`	`{`
`23`		`- return state.Status == ParserState.Ready;`
	`23`	`+ return Command.CanExecute(null);`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public RefactorIntroduceFieldCommandMenuItem (ICommand command)`
`22`	`22`
`23`	`23`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`24`	`24`	`{`
`25`		`- return state.Status == ParserState.Ready;`
	`25`	`+ return Command.CanExecute(null);`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public RefactorMoveCloserToUsageCommandMenuItem(ICommand command)`
`17`	`17`
`18`	`18`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`19`	`19`	`{`
`20`		`- return state.Status == ParserState.Ready;`
	`20`	`+ return Command.CanExecute(null);`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public RefactorRemoveParametersCommandMenuItem(ICommand command) : base(command)`
`21`	`21`
`22`	`22`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`23`	`23`	`{`
`24`		`- return state.Status == ParserState.Ready;`
	`24`	`+ return Command.CanExecute(null);`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public RefactorReorderParametersCommandMenuItem(ICommand command) : base(command`
`19`	`19`
`20`	`20`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`21`	`21`	`{`
`22`		`- return state.Status == ParserState.Ready;`
	`22`	`+ return Command.CanExecute(null);`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`	`}`