Put AnnotateDeclaration in its own code pane menu

MDoerner · MDoerner · commit ea22e5808c42 · 2020-05-25T23:19:14.000+02:00
It now looks like the indent sub menu.
This also fixes that the Refactorings sub menu was in the wrong place for ages.
diff --git a/Rubberduck.Core/UI/Command/MenuItems/AnnotateSelectedDeclarationCommandMenuItem.cs b/Rubberduck.Core/UI/Command/MenuItems/AnnotateSelectedDeclarationCommandMenuItem.cs
@@ -4,14 +4,14 @@
 
 namespace Rubberduck.UI.Command.MenuItems
 {
-    public class CodePaneAnnotateDeclarationCommandMenuItem : CommandMenuItemBase
+    public class AnnotateSelectedDeclarationCommandMenuItem : CommandMenuItemBase
     {
-        public CodePaneAnnotateDeclarationCommandMenuItem(CodePaneAnnotateDeclarationCommand command)
+        public AnnotateSelectedDeclarationCommandMenuItem(AnnotateSelectedDeclarationCommand command)
             : base(command)
         { }
 
-        public override string Key => "RefactorMenu_AnnotateDeclaration";
-        public override int DisplayOrder => (int)RefactoringsMenuItemDisplayOrder.AnnotateDeclaration;
+        public override string Key => "AnnotateMenu_SelectedDeclaration";
+        public override int DisplayOrder => (int)AnnotateParentMenuItemDisplayOrder.SelectedDeclaration;
 
         public override bool EvaluateCanExecute(RubberduckParserState state)
         {
diff --git a/Rubberduck.Core/UI/Command/MenuItems/AnnotateSelectedMemberCommandMenuItem.cs b/Rubberduck.Core/UI/Command/MenuItems/AnnotateSelectedMemberCommandMenuItem.cs
@@ -0,0 +1,21 @@
+﻿using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Command.MenuItems.ParentMenus;
+using Rubberduck.UI.Command.Refactorings;
+
+namespace Rubberduck.UI.Command.MenuItems
+{
+    public class AnnotateSelectedMemberCommandMenuItem : CommandMenuItemBase
+    {
+        public AnnotateSelectedMemberCommandMenuItem(AnnotateSelectedMemberCommand command)
+            : base(command)
+        { }
+
+        public override string Key => "AnnotateMenu_SelectedMember";
+        public override int DisplayOrder => (int)AnnotateParentMenuItemDisplayOrder.SelectedMember;
+
+        public override bool EvaluateCanExecute(RubberduckParserState state)
+        {
+            return state != null && Command.CanExecute(null);
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/MenuItems/AnnotateSelectedModuleCommandMenuItem.cs b/Rubberduck.Core/UI/Command/MenuItems/AnnotateSelectedModuleCommandMenuItem.cs
@@ -0,0 +1,21 @@
+﻿using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Command.MenuItems.ParentMenus;
+using Rubberduck.UI.Command.Refactorings;
+
+namespace Rubberduck.UI.Command.MenuItems
+{
+    public class AnnotateSelectedModuleCommandMenuItem : CommandMenuItemBase
+    {
+        public AnnotateSelectedModuleCommandMenuItem(AnnotateSelectedModuleCommand command)
+            : base(command)
+        { }
+
+        public override string Key => "AnnotateMenu_SelectedModule";
+        public override int DisplayOrder => (int)AnnotateParentMenuItemDisplayOrder.SelectedModule;
+
+        public override bool EvaluateCanExecute(RubberduckParserState state)
+        {
+            return state != null && Command.CanExecute(null);
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/AnnotateParentMenu.cs b/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/AnnotateParentMenu.cs
@@ -0,0 +1,21 @@
+﻿using System.Collections.Generic;
+
+namespace Rubberduck.UI.Command.MenuItems.ParentMenus
+{
+    public class AnnotateParentMenu : ParentMenuItemBase
+    {
+        public AnnotateParentMenu(IEnumerable<IMenuItem> items)
+            : base("AnnotateMenu", items)
+        {
+        }
+
+        public override int DisplayOrder => (int)CodePaneContextMenuItemDisplayOrder.Annotate;
+    }
+
+    public enum AnnotateParentMenuItemDisplayOrder
+    {
+        SelectedDeclaration,
+        SelectedModule,
+        SelectedMember,
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/CodePaneContextParentMenu.cs b/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/CodePaneContextParentMenu.cs
@@ -15,6 +15,7 @@ public CodePaneContextParentMenu(IEnumerable<IMenuItem> items, int beforeIndex)
     public enum CodePaneContextMenuItemDisplayOrder
     {
         Refactorings,
+        Annotate,
         Indenter,
         RegexSearchReplace,
         FindSymbol,
diff --git a/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/CodePaneRefactoringsParentMenu.cs b/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/CodePaneRefactoringsParentMenu.cs
@@ -0,0 +1,14 @@
+﻿using System.Collections.Generic;
+
+namespace Rubberduck.UI.Command.MenuItems.ParentMenus
+{
+    public class CodePaneRefactoringsParentMenu : ParentMenuItemBase
+    {
+        public CodePaneRefactoringsParentMenu(IEnumerable<IMenuItem> items)
+            : base("RubberduckMenu_CodePaneRefactor", items)
+        { }
+
+        //This display order is different from the main menu; it is the sole reason this class is separate from the main menu one.
+        public override int DisplayOrder => (int)CodePaneContextMenuItemDisplayOrder.Refactorings;
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/RefactoringsParentMenu.cs b/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/RefactoringsParentMenu.cs
@@ -14,7 +14,6 @@ public RefactoringsParentMenu(IEnumerable<IMenuItem> items)
 
     public enum RefactoringsMenuItemDisplayOrder
     {
-        AnnotateDeclaration,
         RenameIdentifier,
         ExtractMethod,
         ExtractInterface,
diff --git a/Rubberduck.Core/UI/Command/Refactorings/AnnotateDeclarationCodePaneCommandBase.cs b/Rubberduck.Core/UI/Command/Refactorings/AnnotateDeclarationCodePaneCommandBase.cs
@@ -6,26 +6,25 @@
 
 namespace Rubberduck.UI.Command.Refactorings
 {
-    public class CodePaneAnnotateDeclarationCommand : RefactorCodePaneCommandBase
+    public abstract class AnnotateDeclarationCodePaneCommandBase : RefactorCodePaneCommandBase
     {
         private readonly RubberduckParserState _state;
-        private readonly ISelectedDeclarationProvider _selectedDeclarationProvider;
 
-        public CodePaneAnnotateDeclarationCommand(
+        protected AnnotateDeclarationCodePaneCommandBase(
             AnnotateDeclarationRefactoring refactoring,
             AnnotateDeclarationFailedNotifier failureNotifier, 
             ISelectionProvider selectionProvider, 
             IParserStatusProvider parserStatusProvider,
-            RubberduckParserState state,
-            ISelectedDeclarationProvider selectedDeclarationProvider) 
+            RubberduckParserState state) 
             : base(refactoring, failureNotifier, selectionProvider, parserStatusProvider)
         {
-            _selectedDeclarationProvider = selectedDeclarationProvider;
             _state = state;
 
             AddToCanExecuteEvaluation(SpecializedEvaluateCanExecute);
         }
 
+        protected abstract Declaration GetTarget();
+
         private bool SpecializedEvaluateCanExecute(object parameter)
         {
             var target = GetTarget();
@@ -47,10 +46,5 @@ private bool SpecializedEvaluateCanExecute(object parameter)
 
             return !_state.IsNewOrModified(target.QualifiedModuleName);
         }
-
-        private Declaration GetTarget()
-        {
-            return _selectedDeclarationProvider.SelectedDeclaration();
-        }
     }
 }
diff --git a/Rubberduck.Core/UI/Command/Refactorings/AnnotateSelectedDeclarationCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/AnnotateSelectedDeclarationCommand.cs
@@ -0,0 +1,30 @@
+﻿using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings.AnnotateDeclaration;
+using Rubberduck.UI.Command.Refactorings.Notifiers;
+using Rubberduck.VBEditor.Utility;
+
+namespace Rubberduck.UI.Command.Refactorings
+{
+    public class AnnotateSelectedDeclarationCommand : AnnotateDeclarationCodePaneCommandBase
+    {
+        private readonly ISelectedDeclarationProvider _selectedDeclarationProvider;
+
+        public AnnotateSelectedDeclarationCommand(
+            AnnotateDeclarationRefactoring refactoring,
+            AnnotateDeclarationFailedNotifier failureNotifier, 
+            ISelectionProvider selectionProvider, 
+            IParserStatusProvider parserStatusProvider,
+            RubberduckParserState state,
+            ISelectedDeclarationProvider selectedDeclarationProvider) 
+            : base(refactoring, failureNotifier, selectionProvider, parserStatusProvider, state)
+        {
+            _selectedDeclarationProvider = selectedDeclarationProvider;
+        }
+
+        protected override Declaration GetTarget()
+        {
+            return _selectedDeclarationProvider.SelectedDeclaration();
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/Refactorings/AnnotateSelectedMemberCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/AnnotateSelectedMemberCommand.cs
@@ -0,0 +1,30 @@
+﻿using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings.AnnotateDeclaration;
+using Rubberduck.UI.Command.Refactorings.Notifiers;
+using Rubberduck.VBEditor.Utility;
+
+namespace Rubberduck.UI.Command.Refactorings
+{
+    public class AnnotateSelectedMemberCommand : AnnotateDeclarationCodePaneCommandBase
+    {
+        private readonly ISelectedDeclarationProvider _selectedDeclarationProvider;
+
+        public AnnotateSelectedMemberCommand(
+            AnnotateDeclarationRefactoring refactoring,
+            AnnotateDeclarationFailedNotifier failureNotifier, 
+            ISelectionProvider selectionProvider, 
+            IParserStatusProvider parserStatusProvider,
+            RubberduckParserState state,
+            ISelectedDeclarationProvider selectedDeclarationProvider) 
+            : base(refactoring, failureNotifier, selectionProvider, parserStatusProvider, state)
+        {
+            _selectedDeclarationProvider = selectedDeclarationProvider;
+        }
+
+        protected override Declaration GetTarget()
+        {
+            return _selectedDeclarationProvider.SelectedMember();
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/Refactorings/AnnotateSelectedModuleCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/AnnotateSelectedModuleCommand.cs
@@ -0,0 +1,30 @@
+﻿using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings.AnnotateDeclaration;
+using Rubberduck.UI.Command.Refactorings.Notifiers;
+using Rubberduck.VBEditor.Utility;
+
+namespace Rubberduck.UI.Command.Refactorings
+{
+    public class AnnotateSelectedModuleCommand : AnnotateDeclarationCodePaneCommandBase
+    {
+        private readonly ISelectedDeclarationProvider _selectedDeclarationProvider;
+
+        public AnnotateSelectedModuleCommand(
+            AnnotateDeclarationRefactoring refactoring,
+            AnnotateDeclarationFailedNotifier failureNotifier, 
+            ISelectionProvider selectionProvider, 
+            IParserStatusProvider parserStatusProvider,
+            RubberduckParserState state,
+            ISelectedDeclarationProvider selectedDeclarationProvider) 
+            : base(refactoring, failureNotifier, selectionProvider, parserStatusProvider, state)
+        {
+            _selectedDeclarationProvider = selectedDeclarationProvider;
+        }
+
+        protected override Declaration GetTarget()
+        {
+            return _selectedDeclarationProvider.SelectedModule();
+        }
+    }
+}
diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs
@@ -530,7 +530,8 @@ private Type[] CodePaneContextMenuItems()
         {
             return new Type[]
             {
-                typeof(RefactoringsParentMenu),
+                typeof(CodePaneRefactoringsParentMenu),
+                typeof(AnnotateParentMenu),
                 typeof(SmartIndenterParentMenu),
                 typeof(FindSymbolCommandMenuItem),
                 typeof(FindAllReferencesCommandMenuItem),
@@ -634,8 +635,10 @@ private void RegisterParentMenus(IWindsorContainer container)
         {
             RegisterParentMenu<UnitTestingParentMenu>(container, UnitTestingMenuItems());
             RegisterParentMenu<RefactoringsParentMenu>(container, RefactoringsMenuItems());
+            RegisterParentMenu<CodePaneRefactoringsParentMenu>(container, RefactoringsMenuItems());
             RegisterParentMenu<NavigateParentMenu>(container, NavigateMenuItems());
             RegisterParentMenu<SmartIndenterParentMenu>(container, SmartIndenterMenuItems());
+            RegisterParentMenu<AnnotateParentMenu>(container, AnnotateMenuItems());
             RegisterParentMenu<ToolsParentMenu>(container, ToolsMenuItems());
         }
 
@@ -664,7 +667,6 @@ private Type[] RefactoringsMenuItems()
         {
             return new[]
             {
-                typeof(CodePaneAnnotateDeclarationCommandMenuItem),
                 typeof(CodePaneRefactorRenameCommandMenuItem),
                 typeof(RefactorExtractMethodCommandMenuItem),
                 typeof(RefactorReorderParametersCommandMenuItem),
@@ -703,6 +705,16 @@ private Type[] SmartIndenterMenuItems()
             };
         }
 
+        private Type[] AnnotateMenuItems()
+        {
+            return new[]
+            {
+                typeof(AnnotateSelectedDeclarationCommandMenuItem),
+                typeof(AnnotateSelectedModuleCommandMenuItem),
+                typeof(AnnotateSelectedMemberCommandMenuItem)
+            };
+        }
+
         private Type[] ToolsMenuItems()
         {
             var items = new List<Type>
diff --git a/Rubberduck.Refactorings/AnnotateDeclaration/AnnotateDeclarationModel.cs b/Rubberduck.Refactorings/AnnotateDeclaration/AnnotateDeclarationModel.cs
@@ -4,7 +4,7 @@
 
 namespace Rubberduck.Refactorings.AnnotateDeclaration
 {
-    //This is introduced in favor of a value tuple in order to ba able to bind to the components in XAML.
+    //This is introduced in favor of a value tuple in order to be able to bind to the components in XAML.
     public struct TypedAnnotationArgument
     {
         public AnnotationArgumentType ArgumentType { get; set; }
diff --git a/Rubberduck.Resources/Menus/RubberduckMenus.Designer.cs b/Rubberduck.Resources/Menus/RubberduckMenus.Designer.cs
diff --git a/Rubberduck.Resources/Menus/RubberduckMenus.de.resx b/Rubberduck.Resources/Menus/RubberduckMenus.de.resx
diff --git a/Rubberduck.Resources/Menus/RubberduckMenus.resx b/Rubberduck.Resources/Menus/RubberduckMenus.resx
diff --git a/RubberduckTests/Commands/RefactorCommands/AnnotateSelectedDeclarationCommandTests.cs b/RubberduckTests/Commands/RefactorCommands/AnnotateSelectedDeclarationCommandTests.cs
diff --git a/RubberduckTests/Commands/RefactorCommands/AnnotateSelectedMemberCommandTests.cs b/RubberduckTests/Commands/RefactorCommands/AnnotateSelectedMemberCommandTests.cs
diff --git a/RubberduckTests/Commands/RefactorCommands/AnnotateSelectedModuleCommandTests.cs b/RubberduckTests/Commands/RefactorCommands/AnnotateSelectedModuleCommandTests.cs

Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,14 @@`
`4`	`4`
`5`	`5`	`namespace Rubberduck.UI.Command.MenuItems`
`6`	`6`	`{`
`7`		`- public class CodePaneAnnotateDeclarationCommandMenuItem : CommandMenuItemBase`
	`7`	`+ public class AnnotateSelectedDeclarationCommandMenuItem : CommandMenuItemBase`
`8`	`8`	`{`
`9`		`- public CodePaneAnnotateDeclarationCommandMenuItem(CodePaneAnnotateDeclarationCommand command)`
	`9`	`+ public AnnotateSelectedDeclarationCommandMenuItem(AnnotateSelectedDeclarationCommand command)`
`10`	`10`	`: base(command)`
`11`	`11`	`{ }`
`12`	`12`
`13`		`- public override string Key => "RefactorMenu_AnnotateDeclaration";`
`14`		`- public override int DisplayOrder => (int)RefactoringsMenuItemDisplayOrder.AnnotateDeclaration;`
	`13`	`+ public override string Key => "AnnotateMenu_SelectedDeclaration";`
	`14`	`+ public override int DisplayOrder => (int)AnnotateParentMenuItemDisplayOrder.SelectedDeclaration;`
`15`	`15`
`16`	`16`	`public override bool EvaluateCanExecute(RubberduckParserState state)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ public CodePaneContextParentMenu(IEnumerable<IMenuItem> items, int beforeIndex)`
`15`	`15`	`public enum CodePaneContextMenuItemDisplayOrder`
`16`	`16`	`{`
`17`	`17`	`Refactorings,`
	`18`	`+ Annotate,`
`18`	`19`	`Indenter,`
`19`	`20`	`RegexSearchReplace,`
`20`	`21`	`FindSymbol,`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@ public RefactoringsParentMenu(IEnumerable<IMenuItem> items)`
`14`	`14`
`15`	`15`	`public enum RefactoringsMenuItemDisplayOrder`
`16`	`16`	`{`
`17`		`- AnnotateDeclaration,`
`18`	`17`	`RenameIdentifier,`
`19`	`18`	`ExtractMethod,`
`20`	`19`	`ExtractInterface,`
Original file line number	Diff line number	Diff line change
`@@ -6,26 +6,25 @@`
`6`	`6`
`7`	`7`	`namespace Rubberduck.UI.Command.Refactorings`
`8`	`8`	`{`
`9`		`- public class CodePaneAnnotateDeclarationCommand : RefactorCodePaneCommandBase`
	`9`	`+ public abstract class AnnotateDeclarationCodePaneCommandBase : RefactorCodePaneCommandBase`
`10`	`10`	`{`
`11`	`11`	`private readonly RubberduckParserState _state;`
`12`		`- private readonly ISelectedDeclarationProvider _selectedDeclarationProvider;`
`13`	`12`
`14`		`- public CodePaneAnnotateDeclarationCommand(`
	`13`	`+ protected AnnotateDeclarationCodePaneCommandBase(`
`15`	`14`	`AnnotateDeclarationRefactoring refactoring,`
`16`	`15`	`AnnotateDeclarationFailedNotifier failureNotifier,`
`17`	`16`	`ISelectionProvider selectionProvider,`
`18`	`17`	`IParserStatusProvider parserStatusProvider,`
`19`		`- RubberduckParserState state,`
`20`		`- ISelectedDeclarationProvider selectedDeclarationProvider)`
	`18`	`+ RubberduckParserState state)`
`21`	`19`	`: base(refactoring, failureNotifier, selectionProvider, parserStatusProvider)`
`22`	`20`	`{`
`23`		`- _selectedDeclarationProvider = selectedDeclarationProvider;`
`24`	`21`	`_state = state;`
`25`	`22`
`26`	`23`	`AddToCanExecuteEvaluation(SpecializedEvaluateCanExecute);`
`27`	`24`	`}`
`28`	`25`
	`26`	`+ protected abstract Declaration GetTarget();`
	`27`	`+`
`29`	`28`	`private bool SpecializedEvaluateCanExecute(object parameter)`
`30`	`29`	`{`
`31`	`30`	`var target = GetTarget();`
`@@ -47,10 +46,5 @@ private bool SpecializedEvaluateCanExecute(object parameter)`
`47`	`46`
`48`	`47`	`return !_state.IsNewOrModified(target.QualifiedModuleName);`
`49`	`48`	`}`
`50`		`-`
`51`		`- private Declaration GetTarget()`
`52`		`- {`
`53`		`- return _selectedDeclarationProvider.SelectedDeclaration();`
`54`		`- }`
`55`	`49`	`}`
`56`	`50`	`}`