Split the remaining refactorings, except EncapsulateField

Author: MDoerner

Rubberduck.Refactorings/BaseRefactoringBase.cs renamed to Rubberduck.Refactorings/Abstract/BaseRefactoringBase.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 BaseRefactoringWithSuspensionBase<TModel> : BaseRefactoringBase<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        private readonly IParseManager _parseManager;
+
+        private readonly Logger _logger;
+
+        protected BaseRefactoringWithSuspensionBase(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/Abstract/BaseRefactoringWithSuspensionBase.cs

@@ -0,0 +1,40 @@
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA.Parsing;
+using Rubberduck.Refactorings.Exceptions;
+
+namespace Rubberduck.Refactorings
+{
+    public abstract class CodeOnlyBaseRefactoringBase<TModel> : ICodeOnlyBaseRefactoring<TModel>
+        where TModel : class, IRefactoringModel
+    {
+        private readonly IRewritingManager _rewritingManager;
+
+        protected CodeOnlyBaseRefactoringBase(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/Abstract/CodeOnlyBaseRefactoringBase.cs

@@ -1,4 +1,6 @@
-namespace Rubberduck.Refactorings
+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.
@@ -13,7 +15,7 @@ public interface IBaseRefactoring<in TModel> where TModel : class, IRefactoringM
         void Refactor(TModel model);
     }
 
-    public interface IBaseRefactoringWithPreview<in TModel> : IBaseRefactoring<TModel>
+    public interface IRefactoringPreviewProvider<in TModel>
         where TModel : class, IRefactoringModel
     {
         /// <summary>
@@ -23,4 +25,15 @@ public interface IBaseRefactoringWithPreview<in TModel> : IBaseRefactoring<TMode
         /// <returns>Preview of the refactored code</returns>
         string Preview(TModel model);
     }
+
+    public interface ICodeOnlyBaseRefactoring<in TModel> : IBaseRefactoring<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);
+    }
 }