Add code pane command for AnnotateDeclaration

MDoerner · MDoerner · commit 799b76ab4609 · 2020-05-13T23:32:23.000+02:00
Also fixes a bug in the setup of CodePane.GetQualifiedSelection in the MockProjectBuilder.
diff --git a/Rubberduck.CodeAnalysis/Inspections/Extensions/DeclarationTypeExtensions.cs b/Rubberduck.CodeAnalysis/Inspections/Extensions/DeclarationTypeExtensions.cs
@@ -4,8 +4,9 @@
 
 namespace Rubberduck.CodeAnalysis.Inspections.Extensions
 {
-    internal static class DeclarationTypeExtensions
+    public static class DeclarationTypeExtensions
     {
+        //ToDo: Move this to resources. (This will require moving resource lookups to Core.)
         public static string ToLocalizedString(this DeclarationType type)
         {
             return RubberduckUI.ResourceManager.GetString("DeclarationType_" + type, CultureInfo.CurrentUICulture);
diff --git a/Rubberduck.Core/UI/Command/MenuItems/CodePaneAnnotateDeclarationCommandMenuItem.cs b/Rubberduck.Core/UI/Command/MenuItems/CodePaneAnnotateDeclarationCommandMenuItem.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 CodePaneAnnotateDeclarationCommandMenuItem : CommandMenuItemBase
+    {
+        public CodePaneAnnotateDeclarationCommandMenuItem(CodePaneAnnotateDeclarationCommand command)
+            : base(command)
+        { }
+
+        public override string Key => "RefactorMenu_AnnotateDeclaration";
+        public override int DisplayOrder => (int)RefactoringsMenuItemDisplayOrder.AnnotateDeclaration;
+
+        public override bool EvaluateCanExecute(RubberduckParserState state)
+        {
+            return state != null && Command.CanExecute(null);
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/RefactoringsParentMenu.cs b/Rubberduck.Core/UI/Command/MenuItems/ParentMenus/RefactoringsParentMenu.cs
@@ -14,6 +14,7 @@ public RefactoringsParentMenu(IEnumerable<IMenuItem> items)
 
     public enum RefactoringsMenuItemDisplayOrder
     {
+        AnnotateDeclaration,
         RenameIdentifier,
         ExtractMethod,
         ExtractInterface,
diff --git a/Rubberduck.Core/UI/Command/Refactorings/CodePaneAnnotateDeclarationCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/CodePaneAnnotateDeclarationCommand.cs
@@ -0,0 +1,56 @@
+﻿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 CodePaneAnnotateDeclarationCommand : RefactorCodePaneCommandBase
+    {
+        private readonly RubberduckParserState _state;
+        private readonly ISelectedDeclarationProvider _selectedDeclarationProvider;
+
+        public CodePaneAnnotateDeclarationCommand(
+            AnnotateDeclarationRefactoring refactoring,
+            AnnotateDeclarationFailedNotifier failureNotifier, 
+            ISelectionProvider selectionProvider, 
+            IParserStatusProvider parserStatusProvider,
+            RubberduckParserState state,
+            ISelectedDeclarationProvider selectedDeclarationProvider) 
+            : base(refactoring, failureNotifier, selectionProvider, parserStatusProvider)
+        {
+            _selectedDeclarationProvider = selectedDeclarationProvider;
+            _state = state;
+
+            AddToCanExecuteEvaluation(SpecializedEvaluateCanExecute);
+        }
+
+        private bool SpecializedEvaluateCanExecute(object parameter)
+        {
+            var target = GetTarget();
+
+            if (target == null)
+            {
+                return false;
+            }
+
+            var targetType = target.DeclarationType;
+
+            if (!targetType.HasFlag(DeclarationType.Member)
+                && !targetType.HasFlag(DeclarationType.Module)
+                && !targetType.HasFlag(DeclarationType.Variable)
+                && !targetType.HasFlag(DeclarationType.Constant))
+            {
+                return false;
+            }
+
+            return !_state.IsNewOrModified(target.QualifiedModuleName);
+        }
+
+        private Declaration GetTarget()
+        {
+            return _selectedDeclarationProvider.SelectedDeclaration();
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/Refactorings/Notifiers/AnnotateDeclarationFailedNotifier.cs b/Rubberduck.Core/UI/Command/Refactorings/Notifiers/AnnotateDeclarationFailedNotifier.cs
@@ -0,0 +1,29 @@
+﻿using Rubberduck.CodeAnalysis.Inspections.Extensions;
+using Rubberduck.Interaction;
+using Rubberduck.Refactorings.Exceptions;
+using Rubberduck.Resources;
+
+namespace Rubberduck.UI.Command.Refactorings.Notifiers
+{
+    public class AnnotateDeclarationFailedNotifier : RefactoringFailureNotifierBase
+    {
+        public AnnotateDeclarationFailedNotifier(IMessageBox messageBox) 
+            : base(messageBox)
+        { }
+
+        protected override string Caption => RubberduckUI.AnnotateDeclarationDialog_Caption;
+
+        protected override string Message(RefactoringException exception)
+        {
+            if (exception is InvalidDeclarationTypeException invalidTypeException)
+            {
+                Logger.Warn(invalidTypeException);
+                return string.Format(
+                    RubberduckUI.RefactoringFailure_AnnotateDeclaration_InvalidType,
+                    invalidTypeException.TargetDeclaration.DeclarationType.ToLocalizedString());
+            }
+
+            return base.Message(exception);
+        }
+    }
+}
diff --git a/Rubberduck.Core/UI/Command/Refactorings/Notifiers/IntroduceParameterFailedNotifier.cs b/Rubberduck.Core/UI/Command/Refactorings/Notifiers/IntroduceParameterFailedNotifier.cs
@@ -2,6 +2,7 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Refactorings.Exceptions;
 using Rubberduck.Refactorings.Exceptions.IntroduceParameter;
+using Rubberduck.CodeAnalysis.Inspections.Extensions;
 
 namespace Rubberduck.UI.Command.Refactorings.Notifiers
 {
@@ -25,8 +26,8 @@ protected override string Message(RefactoringException exception)
                     Logger.Warn(invalidDeclarationType);
                     return string.Format(Resources.RubberduckUI.RefactoringFailure_InvalidDeclarationType,
                         invalidDeclarationType.TargetDeclaration.QualifiedModuleName,
-                        invalidDeclarationType.TargetDeclaration.DeclarationType,
-                        DeclarationType.Variable);
+                        invalidDeclarationType.TargetDeclaration.DeclarationType.ToLocalizedString(),
+                        DeclarationType.Variable.ToLocalizedString());
                 default:
                     return base.Message(exception);
             }
diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs
@@ -664,6 +664,7 @@ private Type[] RefactoringsMenuItems()
         {
             return new[]
             {
+                typeof(CodePaneAnnotateDeclarationCommandMenuItem),
                 typeof(CodePaneRefactorRenameCommandMenuItem),
                 typeof(RefactorExtractMethodCommandMenuItem),
                 typeof(RefactorReorderParametersCommandMenuItem),
diff --git a/Rubberduck.Refactorings/AnnotateDeclaration/AnnotateDeclarationRefactoring.cs b/Rubberduck.Refactorings/AnnotateDeclaration/AnnotateDeclarationRefactoring.cs
@@ -34,6 +34,16 @@ protected override AnnotateDeclarationModel InitializeModel(Declaration target)
                 throw new TargetDeclarationIsNullException();
             }
 
+            var targetType = target.DeclarationType;
+
+            if (!targetType.HasFlag(DeclarationType.Member)
+                && !targetType.HasFlag(DeclarationType.Module)
+                && !targetType.HasFlag(DeclarationType.Variable)
+                && !targetType.HasFlag(DeclarationType.Constant))
+            {
+                throw new InvalidDeclarationTypeException(target);
+            }
+
             return new AnnotateDeclarationModel(target);
         }
 
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
@@ -249,4 +249,7 @@
   <data name="RefactorMenu_MoveContainingFolder" xml:space="preserve">
     <value>Enthaltenden Ordner verschieben</value>
   </data>
+  <data name="RefactorMenu_AnnotateDeclaration" xml:space="preserve">
+    <value>Annotation hinzufügen</value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/Menus/RubberduckMenus.resx b/Rubberduck.Resources/Menus/RubberduckMenus.resx
@@ -250,4 +250,7 @@
   <data name="RefactorMenu_MoveContainingFolder" xml:space="preserve">
     <value>Move Containing Folder</value>
   </data>
+  <data name="RefactorMenu_AnnotateDeclaration" xml:space="preserve">
+    <value>Annotate Declaration</value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/RubberduckUI.Designer.cs b/Rubberduck.Resources/RubberduckUI.Designer.cs
diff --git a/Rubberduck.Resources/RubberduckUI.de.resx b/Rubberduck.Resources/RubberduckUI.de.resx
@@ -1679,4 +1679,7 @@ Import abgebrochen.</value>
   <data name="AnnotationArgument_ValidationError_TooLong" xml:space="preserve">
     <value>Annotationsargumente dürfen nicht länger als {0} Zeihen sein.</value>
   </data>
+  <data name="RefactoringFailure_AnnotateDeclaration_InvalidType" xml:space="preserve">
+    <value>Das Refactoring kann Annotationen nur zu Komponenten, Methoden und Variablen hinzufügen. Die Zieldeklaration hatte allerdings den Typ '{0}'.</value>
+  </data>
 </root>
diff --git a/Rubberduck.Resources/RubberduckUI.resx b/Rubberduck.Resources/RubberduckUI.resx
@@ -1895,4 +1895,8 @@ Import aborted.</value>
     <value>Annotation arguments cannot be longer than {0} characters.</value>
     <comment>{0} max allowed characters</comment>
   </data>
+  <data name="RefactoringFailure_AnnotateDeclaration_InvalidType" xml:space="preserve">
+    <value>The refactoring can only annotate components, members and variables, but the target had type '{0}'.</value>
+    <comment>{0} declaration type</comment>
+  </data>
 </root>
diff --git a/RubberduckTests/Commands/RefactorCommands/CodePaneAnnotateDeclarationCommandTests.cs b/RubberduckTests/Commands/RefactorCommands/CodePaneAnnotateDeclarationCommandTests.cs
@@ -0,0 +1,68 @@
+﻿using System;
+using Moq;
+using NUnit.Framework;
+using Rubberduck.Interaction;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.UIContext;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings;
+using Rubberduck.Refactorings.AnnotateDeclaration;
+using Rubberduck.UI.Command;
+using Rubberduck.UI.Command.Refactorings;
+using Rubberduck.UI.Command.Refactorings.Notifiers;
+using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.SafeComWrappers;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+using Rubberduck.VBEditor.Utility;
+
+namespace RubberduckTests.Commands.RefactorCommands
+{
+    [TestFixture]
+    public class CodePaneAnnotateDeclarationCommandTests : RefactorCodePaneCommandTestBase
+    {
+        [Category("Commands")]
+        [Test]
+        public void AnnotateDeclaration_CanExecute_InvalidTargetType()
+        {
+            var vbe = SetupAllowingExecution();
+            vbe.ActiveCodePane.Selection = new Selection(2,2);
+
+            Assert.IsFalse(CanExecute(vbe));
+        }
+
+        protected override CommandBase TestCommand(
+            IVBE vbe, RubberduckParserState state, 
+            IRewritingManager rewritingManager,
+            ISelectionService selectionService)
+        {
+            var factory = new Mock<IRefactoringPresenterFactory>().Object;
+            var msgBox = new Mock<IMessageBox>().Object;
+
+            var uiDispatcherMock = new Mock<IUiDispatcher>();
+            uiDispatcherMock
+                .Setup(m => m.Invoke(It.IsAny<Action>()))
+                .Callback((Action action) => action.Invoke());
+            var userInteraction = new RefactoringUserInteraction<IAnnotateDeclarationPresenter, AnnotateDeclarationModel>(factory, uiDispatcherMock.Object);
+
+            var annotationUpdater = new AnnotationUpdater();
+            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater);
+
+            var selectedDeclarationProvider = new SelectedDeclarationProvider(selectionService, state);
+
+            var refactoring = new AnnotateDeclarationRefactoring(annotateDeclarationAction, selectedDeclarationProvider, selectionService, userInteraction);
+            var notifier = new AnnotateDeclarationFailedNotifier(msgBox);
+
+            return new CodePaneAnnotateDeclarationCommand(refactoring, notifier, selectionService, state, state, selectedDeclarationProvider);
+        }
+
+        protected override IVBE SetupAllowingExecution()
+        {
+            const string input =
+                @"Public Sub Foo()
+myLabel: Debug.Print ""Label"";
+End Sub";
+            var selection = Selection.Home;
+            return TestVbe(input, selection, ComponentType.ClassModule);
+        }
+    }
+}
diff --git a/RubberduckTests/Commands/RefactorCommands/RefactorCodePaneCommandTestBase.cs b/RubberduckTests/Commands/RefactorCommands/RefactorCodePaneCommandTestBase.cs
@@ -7,12 +7,21 @@ public abstract class RefactorCodePaneCommandTestBase : RefactorCommandTestBase
     {
         [Category("Commands")]
         [Test]
-        public void EncapsulateField_CanExecute_NullActiveCodePane()
+        public void RefactoringCommand_CanExecute_ValidInput()
+        {
+            var vbe = SetupAllowingExecution();
+
+            Assert.IsTrue(CanExecute(vbe), GetType().FullName);
+        }
+
+        [Category("Commands")]
+        [Test]
+        public void RefactoringCommand_CanExecute_NullActiveCodePane()
         {
             var vbe = SetupAllowingExecution();
             vbe.ActiveCodePane = null;
 
-            Assert.IsFalse(CanExecute(vbe));
+            Assert.IsFalse(CanExecute(vbe), GetType().FullName);
         }
     }
 }
diff --git a/RubberduckTests/Mocks/MockProjectBuilder.cs b/RubberduckTests/Mocks/MockProjectBuilder.cs
@@ -422,7 +422,7 @@ private Mock<ICodePane> CreateCodePaneMock(string name, Selection selection, Moc
             codePane.SetupReferenceEqualityIncludingHashCode();
             codePane.Setup(p => p.GetQualifiedSelection()).Returns(() => {
                 if (selection.IsEmpty()) { return null; }
-                return new QualifiedSelection(new QualifiedModuleName(component.Object), selection);
+                return new QualifiedSelection(new QualifiedModuleName(component.Object), codePane.Object.Selection);
             });
             codePane.SetupProperty(p => p.Selection, selection);
             codePane.Setup(p => p.Show());
diff --git a/RubberduckTests/Refactoring/AnnotateDeclaration/AnnotateDeclarationRefactoringTests.cs b/RubberduckTests/Refactoring/AnnotateDeclaration/AnnotateDeclarationRefactoringTests.cs
@@ -5,6 +5,7 @@
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings;
 using Rubberduck.Refactorings.AnnotateDeclaration;
+using Rubberduck.Refactorings.Exceptions;
 using Rubberduck.VBEditor.SafeComWrappers;
 using Rubberduck.VBEditor.Utility;
 
@@ -63,6 +64,20 @@ End Sub
             Assert.IsFalse(model.Arguments.Any());
         }
 
+        [Test]
+        [Category("Refactorings")]
+        public void AnnotateDeclarationRefactoring_InvalidTargetType_Throws()
+        {
+            const string code = @"Public Sub Foo()
+myLabel: Debug.Print ""Label"";
+End Sub";
+            Assert.Throws<InvalidDeclarationTypeException>(() => 
+                InitialModel(
+                    "myLabel",
+                    DeclarationType.LineLabel,
+                    ("TestModule", code, ComponentType.StandardModule)));
+        }
+
         protected override IRefactoring TestRefactoring(
             IRewritingManager rewritingManager, 
             RubberduckParserState state,

Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,9 @@`
`4`	`4`
`5`	`5`	`namespace Rubberduck.CodeAnalysis.Inspections.Extensions`
`6`	`6`	`{`
`7`		`- internal static class DeclarationTypeExtensions`
	`7`	`+ public static class DeclarationTypeExtensions`
`8`	`8`	`{`
	`9`	`+ //ToDo: Move this to resources. (This will require moving resource lookups to Core.)`
`9`	`10`	`public static string ToLocalizedString(this DeclarationType type)`
`10`	`11`	`{`
`11`	`12`	`return RubberduckUI.ResourceManager.GetString("DeclarationType_" + type, CultureInfo.CurrentUICulture);`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ public RefactoringsParentMenu(IEnumerable<IMenuItem> items)`
`14`	`14`
`15`	`15`	`public enum RefactoringsMenuItemDisplayOrder`
`16`	`16`	`{`
	`17`	`+ AnnotateDeclaration,`
`17`	`18`	`RenameIdentifier,`
`18`	`19`	`ExtractMethod,`
`19`	`20`	`ExtractInterface,`
Original file line number	Diff line number	Diff line change
`@@ -664,6 +664,7 @@ private Type[] RefactoringsMenuItems()`
`664`	`664`	`{`
`665`	`665`	`return new[]`
`666`	`666`	`{`
	`667`	`+ typeof(CodePaneAnnotateDeclarationCommandMenuItem),`
`667`	`668`	`typeof(CodePaneRefactorRenameCommandMenuItem),`
`668`	`669`	`typeof(RefactorExtractMethodCommandMenuItem),`
`669`	`670`	`typeof(RefactorReorderParametersCommandMenuItem),`