Add MoveToFolderBaseRefactoring

Also adds BaseRefactoringTestBase to support testing the base refactorings in separation from the full implementations of IRefactoring.

Author: MDoerner

Rubberduck.Parsing/Annotations/Concrete/FolderAnnotation.cs

@@ -1,9 +1,4 @@
-using Rubberduck.VBEditor;
-using System.Collections.Generic;
-using System.Linq;
-using Rubberduck.Parsing.Grammar;
-
-namespace Rubberduck.Parsing.Annotations
+namespace Rubberduck.Parsing.Annotations
 {
     /// <summary>
     /// Used for specifying the Code Explorer folder a appears under.

Rubberduck.Refactorings/MoveToFolder/MoveToFolderBaseRefactoring.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA;
+
+namespace Rubberduck.Refactorings.MoveToFolder
+{
+    public class MoveToFolderBaseRefactoring : CodeOnlyBaseRefactoringBase<MoveToFolderModel>
+    {
+        private readonly IAnnotationUpdater _annotationUpdater;
+
+        public MoveToFolderBaseRefactoring(
+            IRewritingManager rewritingManager,
+            IAnnotationUpdater annotationUpdater)
+            : base(rewritingManager)
+        {
+            _annotationUpdater = annotationUpdater;
+        }
+
+        public override void Refactor(MoveToFolderModel model, IRewriteSession rewriteSession)
+        {
+            var oldFolderAnnotation = model.Target.Annotations.FirstOrDefault(pta => pta.Annotation is FolderAnnotation);
+            if (oldFolderAnnotation != null)
+            {
+                UpdateFolderAnnotation(model, oldFolderAnnotation, rewriteSession);
+            }
+            else
+            {
+                AddFolderAnnotation(model, rewriteSession);
+            }
+        }
+
+        private void UpdateFolderAnnotation(MoveToFolderModel model, IParseTreeAnnotation oldPta, IRewriteSession rewriteSession)
+        {
+            var oldFolderName = oldPta.AnnotationArguments.FirstOrDefault();
+            if (oldFolderName == null || oldFolderName.Equals(model.TargetFolder))
+            {
+                return;
+            }
+
+            var (annotation, annotationValues) = NewAnnotation(model.TargetFolder);
+
+            _annotationUpdater.UpdateAnnotation(rewriteSession, oldPta, annotation, annotationValues);
+        }
+
+        private static (IAnnotation annotation, IReadOnlyList<string> annotationArguments) NewAnnotation(string targetFolder)
+        {
+            var annotation = new FolderAnnotation();
+            var annotationValues = new List<string> { targetFolder.EnQuote() };
+
+            return (annotation, annotationValues);
+        }
+
+        private void AddFolderAnnotation(MoveToFolderModel model, IRewriteSession rewriteSession)
+        {
+            var (annotation, annotationValues) = NewAnnotation(model.TargetFolder);
+
+            _annotationUpdater.AddAnnotation(rewriteSession, model.Target, annotation, annotationValues);
+        }
+    }
+}

Rubberduck.Refactorings/MoveToFolder/MoveToFolderModel.cs

@@ -0,0 +1,16 @@
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Refactorings.MoveToFolder
+{
+    public class MoveToFolderModel : IRefactoringModel
+    {
+        public ModuleDeclaration Target { get; }
+        public string TargetFolder { get; }
+
+        public MoveToFolderModel(ModuleDeclaration target, string targetFolder)
+        {
+            Target = target;
+            TargetFolder = targetFolder;
+        }
+    }
+}

RubberduckTests/Refactoring/BaseRefactoringTestBase.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings;
+using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.SafeComWrappers;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+using RubberduckTests.Mocks;
+
+namespace RubberduckTests.Refactoring
+{
+    public abstract class BaseRefactoringTestBase<TModel>
+        where TModel : class, IRefactoringModel
+    {
+
+        protected string RefactoredCode(string code, Func<RubberduckParserState, TModel> modelBuilder)
+        {
+            var vbe = TestVbe(code, out _);
+            var componentName = vbe.SelectedVBComponent.Name;
+            var refactored = RefactoredCode(vbe, modelBuilder);
+            return refactored[componentName];
+        }
+
+        protected IDictionary<string, string> RefactoredCode(Func<RubberduckParserState, TModel> modelBuilder, params (string componentName, string content, ComponentType componentType)[] modules)
+        {
+            var vbe = TestVbe(modules);
+            return RefactoredCode(vbe, modelBuilder);
+        }
+
+        protected IDictionary<string, string> RefactoredCode(IVBE vbe, Func<RubberduckParserState, TModel> modelBuilder)
+        {
+            var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe);
+            using (state)
+            {
+                var baseRefactoring = TestBaseRefactoring(state, rewritingManager);
+                var model = modelBuilder(state);
+
+                baseRefactoring.Refactor(model);
+
+                return vbe.ActiveVBProject.VBComponents
+                    .ToDictionary(component => component.Name, component => component.CodeModule.Content());
+            }
+        }
+
+        protected abstract IBaseRefactoring<TModel> TestBaseRefactoring(
+            RubberduckParserState state,
+            IRewritingManager rewritingManager
+        );
+
+        protected virtual IVBE TestVbe(string content, out IVBComponent component, Selection? selection = null)
+        {
+            return MockVbeBuilder.BuildFromSingleStandardModule(content, out component, selection ?? default).Object;
+        }
+
+        protected virtual IVBE TestVbe(params (string componentName, string content, ComponentType componentType)[] modules)
+        {
+            return MockVbeBuilder.BuildFromModules(modules).Object;
+        }
+    }
+}

RubberduckTests/Refactoring/MoveToFolderTests.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings;
+using Rubberduck.Refactorings.MoveToFolder;
+
+namespace RubberduckTests.Refactoring
+{
+    [TestFixture]
+    public class MoveToFolderTests : BaseRefactoringTestBase<MoveToFolderModel>
+    {
+        [Test]
+        [Category("Refactorings")]
+        public void MoveToFolderBaseRefactoring_NoAnnotation()
+        {
+            const string code = @"
+Public Sub Foo()
+End Sub
+";
+            const string expectedCode = @"'@Folder ""MyNewFolder.MySubFolder""
+
+Public Sub Foo()
+End Sub
+";
+            Func<RubberduckParserState, MoveToFolderModel> modelBuilder = (state) =>
+            {
+                var module = state.DeclarationFinder
+                    .UserDeclarations(DeclarationType.ProceduralModule)
+                    .Single() as ModuleDeclaration; 
+                return new MoveToFolderModel(module, "MyNewFolder.MySubFolder");
+            };
+
+            var refactoredCode = RefactoredCode(code, modelBuilder);
+
+            Assert.AreEqual(expectedCode, refactoredCode);
+        }
+
+        [Test]
+        [Category("Refactorings")]
+        public void MoveToFolderBaseRefactoring_UpdateAnnotation()
+        {
+            const string code = @"
+'@Folder(""MyOldFolder.MyOldSubfolder.SubSub"")
+Public Sub Foo()
+End Sub
+";
+            const string expectedCode = @"
+'@Folder ""MyNewFolder.MySubFolder""
+Public Sub Foo()
+End Sub
+";
+            Func<RubberduckParserState, MoveToFolderModel> modelBuilder = (state) =>
+            {
+                var module = state.DeclarationFinder
+                    .UserDeclarations(DeclarationType.ProceduralModule)
+                    .Single() as ModuleDeclaration;
+                return new MoveToFolderModel(module, "MyNewFolder.MySubFolder");
+            };
+
+            var refactoredCode = RefactoredCode(code, modelBuilder);
+
+            Assert.AreEqual(expectedCode, refactoredCode);
+        }
+
+        protected override IBaseRefactoring<MoveToFolderModel> TestBaseRefactoring(RubberduckParserState state, IRewritingManager rewritingManager)
+        {
+            var annotationUpdater = new AnnotationUpdater();
+            return new MoveToFolderBaseRefactoring(rewritingManager, annotationUpdater);
+        }
+    }
+}