Merge pull request #5387 from MDoerner/SplitRefactorings

Split refactorings

Author: retailcoder

Rubberduck.Main/Root/RubberduckIoCInstaller.cs

@@ -149,15 +149,15 @@ public void Install(IWindsorContainer container, IConfigurationStore store)
                 .LifestyleSingleton());
 
             RegisterSettingsViewModel(container);
+            RegisterRefactoringPreviewProviders(container);
             RegisterRefactoringDialogs(container);
 
             container.Register(Component.For<ISearchResultsWindowViewModel>()
                 .ImplementedBy<SearchResultsWindowViewModel>()
                 .LifestyleSingleton());
             container.Register(Component.For<SearchResultPresenterInstanceManager>()
                 .LifestyleSingleton());
-
-            RegisterRefactoringDialogs(container);
+            
             RegisterDockablePresenters(container);
             RegisterDockableUserControls(container);
 
@@ -715,6 +715,23 @@ private void RegisterSettingsViewModel(IWindsorContainer container)
             );
         }
 
+        private void RegisterRefactoringPreviewProviders(IWindsorContainer container)
+        {
+            container.Register(Types
+                .FromAssemblyInThisApplication()
+                .IncludeNonPublicTypes()
+                .BasedOn(typeof(IRefactoringPreviewProvider<>))
+                .LifestyleSingleton()
+                .WithServiceSelect((type, types) =>
+                {
+                    var face = type.GetInterfaces().FirstOrDefault(i =>
+                        i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IRefactoringPreviewProvider<>));
+
+                    return face == null ? new[] { type } : new[] { type, face };
+                })
+            );
+        }
+
         private void RegisterRefactoringDialogs(IWindsorContainer container)
         {
             container.Register(Types

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.Parsing/Symbols/ClassModuleDeclaration.cs

@@ -1,6 +1,5 @@
 using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.ComReflection;
-using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
 using System;
 using System.Collections.Concurrent;

Rubberduck.Refactorings/Abstract/CodeOnlyRefactoringActionBase.cs

@@ -0,0 +1,40 @@
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Refactorings.Exceptions;
+
+namespace Rubberduck.Refactorings
+{
+    public abstract class CodeOnlyRefactoringActionBase<TModel> : ICodeOnlyRefactoringAction<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        private readonly IRewritingManager _rewritingManager;
+
+        protected CodeOnlyRefactoringActionBase(IRewritingManager rewritingManager)
+        {
+            _rewritingManager = rewritingManager;
+        }
+
+        public abstract void Refactor(TModel model, IRewriteSession rewriteSession);
+
+        public virtual void Refactor(TModel model)
+        {
+            var rewriteSession = RewriteSession(RewriteSessionCodeKind);
+
+            Refactor(model, rewriteSession);
+
+            if (!rewriteSession.TryRewrite())
+            {
+                throw new RewriteFailedException(rewriteSession);
+            }
+        }
+
+        private IExecutableRewriteSession RewriteSession(CodeKind codeKind)
+        {
+            return codeKind == CodeKind.AttributesCode
+                ? _rewritingManager.CheckOutAttributesSession()
+                : _rewritingManager.CheckOutCodePaneSession();
+        }
+
+        protected virtual CodeKind RewriteSessionCodeKind => CodeKind.CodePaneCode;
+    }
+}

Rubberduck.Refactorings/IRefactoring.cs renamed to Rubberduck.Refactorings/Abstract/IRefactoring.cs

@@ -0,0 +1,39 @@
+using Rubberduck.Parsing.Rewriter;
+
+namespace Rubberduck.Refactorings
+{
+    /// <summary>
+    /// The heart of a refactoring: this part of the refactoring performs the actual transformation of the code once all necessary information has been gathered.
+    /// </summary>
+    /// <typeparam name="TModel">The model used by the refactoring containing all information needed to specify what to do.</typeparam>
+    public interface IRefactoringAction<in TModel> where TModel : class, IRefactoringModel
+    {
+        /// <summary>
+        /// Performs the actual refactoring based on the parameters specified in the model.
+        /// </summary>
+        /// <param name="model">The model specifying all parameters of the refactoring</param>
+        void Refactor(TModel model);
+    }
+
+    public interface IRefactoringPreviewProvider<in TModel>
+        where TModel : class, IRefactoringModel
+    {
+        /// <summary>
+        /// Returns some preview of the refactored code.
+        /// </summary>
+        /// <param name="model">The model used by the refactoring containing all information needed to specify what to do.</param>
+        /// <returns>Preview of the refactored code</returns>
+        string Preview(TModel model);
+    }
+
+    public interface ICodeOnlyRefactoringAction<in TModel> : IRefactoringAction<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        /// <summary>
+        /// Performs the refactoring according to the model and using the provided rewrite session.
+        /// </summary>
+        /// <param name="model">The model specifying all parameters of the refactoring</param>
+        /// <param name="rewriteSession">Rewrite session used to manipulate the code (Does not get executed.)</param>
+        void Refactor(TModel model, IRewriteSession rewriteSession);
+    }
+}

Rubberduck.Refactorings/Abstract/IRefactoringAction.cs

@@ -1,5 +1,4 @@
-using Rubberduck.Parsing.Rewriter;
-using Rubberduck.VBEditor.Utility;
+using Rubberduck.VBEditor.Utility;
 using System;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.UIContext;
@@ -13,12 +12,11 @@ public abstract class InteractiveRefactoringBase<TPresenter, TModel> : Refactori
     {
         private readonly Func<TModel, IDisposalActionContainer<TPresenter>> _presenterFactory;
 
-        protected InteractiveRefactoringBase(
-            IRewritingManager rewritingManager, 
+        protected InteractiveRefactoringBase( 
             ISelectionProvider selectionProvider, 
             IRefactoringPresenterFactory factory,
             IUiDispatcher uiDispatcher) 
-        :base(rewritingManager, selectionProvider)
+        :base(selectionProvider)
         {
             Action<TPresenter> presenterDisposalAction = (TPresenter presenter) => uiDispatcher.Invoke(() => factory.Release(presenter)); 
             _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create<TPresenter, TModel>(model), presenterDisposalAction));

Rubberduck.Refactorings/IRefactoringDialog.cs renamed to Rubberduck.Refactorings/Abstract/IRefactoringDialog.cs

@@ -0,0 +1,40 @@
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Refactorings.Exceptions;
+
+namespace Rubberduck.Refactorings
+{
+    public abstract class RefactoringActionBase<TModel> : IRefactoringAction<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        private readonly IRewritingManager _rewritingManager;
+
+        protected RefactoringActionBase(IRewritingManager rewritingManager)
+        {
+            _rewritingManager = rewritingManager;
+        }
+
+        protected abstract void Refactor(TModel model, IRewriteSession rewriteSession);
+
+        public virtual void Refactor(TModel model)
+        {
+            var rewriteSession = RewriteSession(RewriteSessionCodeKind);
+
+            Refactor(model, rewriteSession);
+
+            if (!rewriteSession.TryRewrite())
+            {
+                throw new RewriteFailedException(rewriteSession);
+            }
+        }
+
+        private IExecutableRewriteSession RewriteSession(CodeKind codeKind)
+        {
+            return codeKind == CodeKind.AttributesCode 
+                ? _rewritingManager.CheckOutAttributesSession() 
+                : _rewritingManager.CheckOutCodePaneSession();
+        }
+
+        protected virtual CodeKind RewriteSessionCodeKind => CodeKind.CodePaneCode;
+    }
+}

Rubberduck.Refactorings/IRefactoringModel.cs renamed to Rubberduck.Refactorings/Abstract/IRefactoringModel.cs

@@ -0,0 +1,55 @@
+using System.Runtime.ExceptionServices;
+using NLog;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings.Exceptions;
+
+namespace Rubberduck.Refactorings
+{
+    public abstract class RefactoringActionWithSuspension<TModel> : RefactoringActionBase<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        private readonly IParseManager _parseManager;
+
+        private readonly Logger _logger;
+
+        protected RefactoringActionWithSuspension(IParseManager parseManager, IRewritingManager rewritingManager)
+            : base(rewritingManager)
+        {
+            _parseManager = parseManager;
+            _logger = LogManager.GetLogger(GetType().FullName);
+        }
+
+        protected abstract bool RequiresSuspension(TModel model);
+
+        public override void Refactor(TModel model)
+        {
+            if (RequiresSuspension(model))
+            {
+                RefactorWithSuspendedParser(model);
+            }
+            else
+            {
+                base.Refactor(model);
+            }
+        }
+
+        private void RefactorWithSuspendedParser(TModel model)
+        {
+            var suspendResult = _parseManager.OnSuspendParser(this, new[] { ParserState.Ready }, () => base.Refactor(model));
+            var suspendOutcome = suspendResult.Outcome;
+            if (suspendOutcome != SuspensionOutcome.Completed)
+            {
+                if ((suspendOutcome == SuspensionOutcome.UnexpectedError || suspendOutcome == SuspensionOutcome.Canceled)
+                    && suspendResult.EncounteredException != null)
+                {
+                    ExceptionDispatchInfo.Capture(suspendResult.EncounteredException).Throw();
+                    return;
+                }
+
+                _logger.Warn($"{GetType().Name} failed because a parser suspension request could not be fulfilled.  The request's result was '{suspendResult.ToString()}'.");
+                throw new SuspendParserFailureException();
+            }
+        }
+    }
+}

Rubberduck.Refactorings/IRefactoringPresenter.cs renamed to Rubberduck.Refactorings/Abstract/IRefactoringPresenter.cs

@@ -1,5 +1,4 @@
-using Rubberduck.Parsing.Rewriter;
-using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Refactorings.Exceptions;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.Utility;
@@ -8,12 +7,10 @@ namespace Rubberduck.Refactorings
 {
     public abstract class RefactoringBase : IRefactoring
     {
-        protected readonly IRewritingManager RewritingManager;
         protected readonly ISelectionProvider SelectionProvider;
 
-        protected RefactoringBase(IRewritingManager rewritingManager, ISelectionProvider selectionProvider)
+        protected RefactoringBase(ISelectionProvider selectionProvider)
         {
-            RewritingManager = rewritingManager;
             SelectionProvider = selectionProvider;
         }
 

Rubberduck.Refactorings/IRefactoringPresenterFactory.cs renamed to Rubberduck.Refactorings/Abstract/IRefactoringPresenterFactory.cs

@@ -0,0 +1,41 @@
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Refactorings
+{
+    public abstract class RefactoringPreviewProviderWrapperBase<TModel> : IRefactoringPreviewProvider<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        private readonly IRewritingManager _rewritingManager;
+        private readonly ICodeOnlyRefactoringAction<TModel> _refactoringAction;
+
+        protected RefactoringPreviewProviderWrapperBase(
+            ICodeOnlyRefactoringAction<TModel> refactoringAction,
+            IRewritingManager rewritingManager)
+        {
+            _refactoringAction = refactoringAction;
+            _rewritingManager = rewritingManager;
+        }
+
+        protected abstract QualifiedModuleName ComponentToShow(TModel model);
+
+        public string Preview(TModel model)
+        {
+            var rewriteSession = RewriteSession(RewriteSessionCodeKind);
+            _refactoringAction.Refactor(model, rewriteSession);
+            var componentToShow = ComponentToShow(model);
+            var rewriter = rewriteSession.CheckOutModuleRewriter(componentToShow);
+            return rewriter.GetText();
+        }
+
+        private IExecutableRewriteSession RewriteSession(CodeKind codeKind)
+        {
+            return codeKind == CodeKind.AttributesCode
+                ? _rewritingManager.CheckOutAttributesSession()
+                : _rewritingManager.CheckOutCodePaneSession();
+        }
+
+        protected virtual CodeKind RewriteSessionCodeKind => CodeKind.CodePaneCode;
+    }
+}

Rubberduck.Refactorings/IRefactoringView.cs renamed to Rubberduck.Refactorings/Abstract/IRefactoringView.cs

@@ -1,10 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Refactorings.EncapsulateField.Extensions;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Refactorings.EncapsulateField