Enhance AnnotateDeclarationRefactoringAction to allow adjusting corresponding attributes

The adjustment/addition of an attribute only happens if the corresponding flag is set on the model and the annotation is an IAttributeAnnotation.

Author: MDoerner

Rubberduck.Refactorings/Abstract/CodeOnlyRefactoringActionBase.cs

@@ -18,7 +18,7 @@ protected CodeOnlyRefactoringActionBase(IRewritingManager rewritingManager)
 
         public virtual void Refactor(TModel model)
         {
-            var rewriteSession = RewriteSession(RewriteSessionCodeKind);
+            var rewriteSession = RewriteSession(RewriteSessionCodeKind(model));
 
             Refactor(model, rewriteSession);
 
@@ -35,6 +35,6 @@ private IExecutableRewriteSession RewriteSession(CodeKind codeKind)
                 : _rewritingManager.CheckOutCodePaneSession();
         }
 
-        protected virtual CodeKind RewriteSessionCodeKind => CodeKind.CodePaneCode;
+        protected virtual CodeKind RewriteSessionCodeKind(TModel model) => CodeKind.CodePaneCode;
     }
 }

Rubberduck.Refactorings/AnnotateDeclaration/AnnotateDeclarationModel.cs

@@ -22,15 +22,18 @@ public class AnnotateDeclarationModel : IRefactoringModel
         public Declaration Target { get; }
         public IAnnotation Annotation { get; set; }
         public IList<TypedAnnotationArgument> Arguments { get; set; }
+        public bool AdjustAttribute { get; set; }
 
         public AnnotateDeclarationModel(
             Declaration target, 
             IAnnotation annotation = null,
-            IList<TypedAnnotationArgument> arguments = null)
+            IList<TypedAnnotationArgument> arguments = null,
+            bool adjustAttribute = false)
         {
             Target = target;
             Annotation = annotation;
             Arguments = arguments ?? new List<TypedAnnotationArgument>();
+            AdjustAttribute = adjustAttribute;
         }
     }
 }

Rubberduck.Refactorings/AnnotateDeclaration/AnnotateDeclarationRefactoringAction.cs

@@ -0,0 +1,96 @@
+using System.Linq;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Refactorings.Exceptions;
+
+namespace Rubberduck.Refactorings.AnnotateDeclaration
+{
+    public class AnnotateDeclarationRefactoringAction : CodeOnlyRefactoringActionBase<AnnotateDeclarationModel>
+    {
+        private readonly IAnnotationUpdater _annotationUpdater;
+        private readonly IAttributesUpdater _attributesUpdater;
+
+        public AnnotateDeclarationRefactoringAction(
+            IRewritingManager rewritingManager,
+            IAnnotationUpdater annotationUpdater,
+            IAttributesUpdater attributesUpdater) 
+            : base(rewritingManager)
+        {
+            _annotationUpdater = annotationUpdater;
+            _attributesUpdater = attributesUpdater;
+        }
+
+        protected override CodeKind RewriteSessionCodeKind(AnnotateDeclarationModel model)
+        {
+            return model.AdjustAttribute 
+                   && model.Annotation is IAttributeAnnotation
+                ? CodeKind.AttributesCode
+                : CodeKind.CodePaneCode;
+        }
+
+        public override void Refactor(AnnotateDeclarationModel model, IRewriteSession rewriteSession)
+        {
+            if (model.AdjustAttribute 
+                && rewriteSession.TargetCodeKind != CodeKind.AttributesCode
+                && model.Annotation is IAttributeAnnotation)
+            {
+                throw new AttributeRewriteSessionRequiredException();
+            }
+
+            var targetDeclaration = model.Target;
+
+            if (rewriteSession.TargetCodeKind == CodeKind.AttributesCode
+                && targetDeclaration.AttributesPassContext == null
+                && !targetDeclaration.DeclarationType.HasFlag(DeclarationType.Module))
+            {
+                throw new AttributeRewriteSessionNotSupportedException();
+            }
+
+            var arguments = model.Arguments.Select(ToCode).ToList();
+
+            if (model.AdjustAttribute 
+                && model.Annotation is IAttributeAnnotation attributeAnnotation)
+            {
+                var baseAttribute = attributeAnnotation.Attribute(arguments);
+                var attribute = targetDeclaration.DeclarationType.HasFlag(DeclarationType.Module)
+                    ? baseAttribute
+                    : Attributes.MemberAttributeName(baseAttribute, targetDeclaration.IdentifierName);
+                var attributeValues = attributeAnnotation.AnnotationToAttributeValues(arguments);
+                _attributesUpdater.AddOrUpdateAttribute(rewriteSession, targetDeclaration, attribute, attributeValues);
+            }
+
+            _annotationUpdater.AddAnnotation(rewriteSession, targetDeclaration, model.Annotation, arguments);
+        }
+
+        private string ToCode(TypedAnnotationArgument annotationArgument)
+        {
+            switch (annotationArgument.ArgumentType)
+            {
+                case AnnotationArgumentType.Text:
+                    return annotationArgument.Argument.ToVbaStringLiteral();
+                case AnnotationArgumentType.Boolean:
+                    return ToBooleanLiteral(annotationArgument.Argument);
+                default:
+                    return annotationArgument.Argument;
+            }
+        }
+
+        private const string NotABoolean = "NOT_A_BOOLEAN";
+        private string ToBooleanLiteral(string booleanText)
+        {
+            if (!bool.TryParse(booleanText, out var booleanValue))
+            {
+                return NotABoolean;
+            }
+
+            return booleanValue
+                ? Tokens.True
+                : Tokens.False;
+        }
+    }
+}

Rubberduck.Refactorings/AnnotateDeclaration/AnnotateFolderRefactoringAction.cs

@@ -0,0 +1,5 @@
+namespace Rubberduck.Refactorings.Exceptions
+{
+    public class AttributeRewriteSessionNotSupportedException : RefactoringException
+    { }
+}

Rubberduck.Refactorings/Exceptions/AttributeRewriteSessionNotSupportedException.cs

@@ -0,0 +1,5 @@
+namespace Rubberduck.Refactorings.Exceptions
+{
+    public class AttributeRewriteSessionRequiredException : RefactoringException
+    { }
+}

Rubberduck.Refactorings/Exceptions/AttributeRewriteSessionRequiredException.cs

@@ -31,7 +31,8 @@ public void AnnotateDeclaration_CanExecute_InvalidTargetType()
         }
 
         protected override CommandBase TestCommand(
-            IVBE vbe, RubberduckParserState state, 
+            IVBE vbe, 
+            RubberduckParserState state, 
             IRewritingManager rewritingManager,
             ISelectionService selectionService)
         {
@@ -45,7 +46,8 @@ protected override CommandBase TestCommand(
             var userInteraction = new RefactoringUserInteraction<IAnnotateDeclarationPresenter, AnnotateDeclarationModel>(factory, uiDispatcherMock.Object);
 
             var annotationUpdater = new AnnotationUpdater(state);
-            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater);
+            var attributesUpdater = new AttributesUpdater(state);
+            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater, attributesUpdater);
 
             var selectedDeclarationProvider = new SelectedDeclarationProvider(selectionService, state);
 

RubberduckTests/Commands/RefactorCommands/AnnotateSelectedDeclarationCommandTests.cs

@@ -45,7 +45,8 @@ protected override CommandBase TestCommand(
             var userInteraction = new RefactoringUserInteraction<IAnnotateDeclarationPresenter, AnnotateDeclarationModel>(factory, uiDispatcherMock.Object);
 
             var annotationUpdater = new AnnotationUpdater(state);
-            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater);
+            var attributesUpdater = new AttributesUpdater(state);
+            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater, attributesUpdater);
 
             var selectedDeclarationProvider = new SelectedDeclarationProvider(selectionService, state);
 

RubberduckTests/Commands/RefactorCommands/AnnotateSelectedMemberCommandTests.cs

@@ -45,7 +45,8 @@ protected override CommandBase TestCommand(
             var userInteraction = new RefactoringUserInteraction<IAnnotateDeclarationPresenter, AnnotateDeclarationModel>(factory, uiDispatcherMock.Object);
 
             var annotationUpdater = new AnnotationUpdater(state);
-            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater);
+            var attributesUpdater = new AttributesUpdater(state);
+            var annotateDeclarationAction = new AnnotateDeclarationRefactoringAction(rewritingManager, annotationUpdater, attributesUpdater);
 
             var selectedDeclarationProvider = new SelectedDeclarationProvider(selectionService, state);