Extraction Engine: Simplify helper API

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ExtractKotlinFunctionHandler.kt

@@ -37,15 +37,15 @@ public class ExtractKotlinFunctionHandler(
         public val allContainersEnabled: Boolean = false,
         private val helper: ExtractionEngineHelper = ExtractKotlinFunctionHandler.InteractiveExtractionHelper) : RefactoringActionHandler {
 
-    object InteractiveExtractionHelper : ExtractionEngineHelper() {
+    object InteractiveExtractionHelper : ExtractionEngineHelper(EXTRACT_FUNCTION) {
-        override fun configureInteractively(
+        override fun configureAndRun(
                 project: Project,
                 editor: Editor,
                 descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
-                continuation: (ExtractionGeneratorConfiguration) -> Unit
+                onFinish: (ExtractionResult) -> Unit
         ) {
             KotlinExtractFunctionDialog(descriptorWithConflicts.descriptor.extractionData.project, descriptorWithConflicts) {
-                continuation(it.getCurrentConfiguration())
+                doRefactor(it.getCurrentConfiguration(), onFinish)
             }.show()
         }
     }
@@ -66,7 +66,7 @@ public class ExtractKotlinFunctionHandler(
         }
 
         val extractionData = ExtractionData(file, adjustElements(elements).toRange(false), targetSibling)
-        ExtractionEngine(EXTRACT_FUNCTION, helper).run(editor, extractionData) {
+        ExtractionEngine(helper).run(editor, extractionData) {
             processDuplicates(it.duplicateReplacers, file.getProject(), editor)
         }
     }
@@ -91,4 +91,4 @@ public class ExtractKotlinFunctionHandler(
     }
 }
 
-private val EXTRACT_FUNCTION: String = JetRefactoringBundle.message("extract.function")
+val EXTRACT_FUNCTION: String = JetRefactoringBundle.message("extract.function")

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionEngine.kt

@@ -32,32 +32,23 @@ import javax.swing.event.*
 import com.intellij.openapi.project.*
 import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
 
-public open class ExtractionEngineHelper {
+public abstract class ExtractionEngineHelper(val operationName: String) {
     open fun adjustExtractionData(data: ExtractionData): ExtractionData = data
 
-    open fun configure(
+    fun doRefactor(config: ExtractionGeneratorConfiguration, onFinish: (ExtractionResult) -> Unit = {}) {
-            descriptor: ExtractableCodeDescriptor,
+        val project = config.descriptor.extractionData.project
-            generatorOptions: ExtractionGeneratorOptions
+        onFinish(project.executeWriteCommand<ExtractionResult>(operationName) { config.generateDeclaration() })
-    ): ExtractionGeneratorConfiguration {
-        return ExtractionGeneratorConfiguration(descriptor, generatorOptions)
     }
 
-    open fun configureInteractively(
+    abstract fun configureAndRun(
             project: Project,
             editor: Editor,
             descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
-            continuation: (ExtractionGeneratorConfiguration) -> Unit
+            onFinish: (ExtractionResult) -> Unit = {}
-    ) {
+    )
-        continuation(ExtractionGeneratorConfiguration(descriptorWithConflicts.descriptor, ExtractionGeneratorOptions.DEFAULT))
-    }
-
-    companion object {
-        public val DEFAULT: ExtractionEngineHelper = ExtractionEngineHelper()
-    }
 }
 
 public class ExtractionEngine(
-        val operationName: String,
         val helper: ExtractionEngineHelper
 ) {
     fun run(editor: Editor,
@@ -72,26 +63,17 @@ public class ExtractionEngine(
             throw BaseRefactoringProcessor.ConflictsInTestsException(analysisResult.messages.map { it.renderMessage() })
         }
 
-        fun doRefactor(config: ExtractionGeneratorConfiguration) {
-            onFinish(project.executeWriteCommand<ExtractionResult>(operationName) { config.generateDeclaration() })
-        }
-
         fun validateAndRefactor() {
             val validationResult = analysisResult.descriptor!!.validate()
             project.checkConflictsInteractively(validationResult.conflicts) {
-                if (ApplicationManager.getApplication()!!.isUnitTestMode()) {
+                helper.configureAndRun(project, editor, validationResult, onFinish)
-                    doRefactor(helper.configure(validationResult.descriptor, ExtractionGeneratorOptions.DEFAULT))
-                }
-                else {
-                    helper.configureInteractively(project, editor, validationResult, ::doRefactor)
-                }
             }
         }
 
         val message = analysisResult.messages.map { it.renderMessage() }.joinToString("\n")
         when (analysisResult.status) {
             AnalysisResult.Status.CRITICAL_ERROR -> {
-                showErrorHint(project, editor, message, operationName)
+                showErrorHint(project, editor, message, helper.operationName)
             }
 
             AnalysisResult.Status.NON_CRITICAL_ERROR -> {

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinIntroducePropertyHandler.kt

@@ -34,17 +34,17 @@ import java.util.*
 public class KotlinIntroducePropertyHandler(
         val helper: ExtractionEngineHelper = KotlinIntroducePropertyHandler.InteractiveExtractionHelper
 ): KotlinIntroduceHandlerBase() {
-    object InteractiveExtractionHelper : ExtractionEngineHelper() {
+    object InteractiveExtractionHelper : ExtractionEngineHelper(INTRODUCE_PROPERTY) {
-        override fun configureInteractively(
+        override fun configureAndRun(
                 project: Project,
                 editor: Editor,
                 descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
-                continuation: (ExtractionGeneratorConfiguration) -> Unit
+                onFinish: (ExtractionResult) -> Unit
         ) {
             val descriptor = descriptorWithConflicts.descriptor
             val target = propertyTargets.filter { it.isAvailable(descriptor) }.firstOrNull()
             if (target != null) {
-                continuation(ExtractionGeneratorConfiguration(descriptor, ExtractionGeneratorOptions.DEFAULT.copy(target = target)))
+                doRefactor(ExtractionGeneratorConfiguration(descriptor, ExtractionGeneratorOptions.DEFAULT.copy(target = target)), onFinish)
             }
             else {
                 showErrorHint(project, editor, "Can't introduce property for this expression", INTRODUCE_PROPERTY)
@@ -66,7 +66,7 @@ public class KotlinIntroducePropertyHandler(
             if (adjustedElements.isNotEmpty()) {
                 val options = ExtractionOptions(extractAsProperty = true)
                 val extractionData = ExtractionData(file, adjustedElements.toRange(), targetSibling, options)
-                ExtractionEngine(INTRODUCE_PROPERTY, helper).run(editor, extractionData) {
+                ExtractionEngine(helper).run(editor, extractionData) {
                     val property = it.declaration as JetProperty
                     val descriptor = it.config.descriptor
 
@@ -106,4 +106,4 @@ public class KotlinIntroducePropertyHandler(
     }
 }
 
-private val INTRODUCE_PROPERTY: String = JetRefactoringBundle.message("introduce.property")
+val INTRODUCE_PROPERTY: String = JetRefactoringBundle.message("introduce.property")

idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractJetExtractionTest.kt

@@ -17,15 +17,19 @@
 package org.jetbrains.kotlin.idea.refactoring.introduce
 
 import com.intellij.ide.DataManager
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.refactoring.BaseRefactoringProcessor.ConflictsInTestsException
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
+import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.EXTRACT_FUNCTION
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ExtractKotlinFunctionHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.IntroduceParameterDescriptor
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.KotlinIntroduceParameterHandler
+import org.jetbrains.kotlin.idea.refactoring.introduce.introduceProperty.INTRODUCE_PROPERTY
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceProperty.KotlinIntroducePropertyHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinIntroduceVariableHandler
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
@@ -90,14 +94,19 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
             val extractionTarget = propertyTargets.single {
                 it.name == InTextDirectivesUtils.findStringWithPrefixes(file.getText(), "// EXTRACTION_TARGET: ")
             }
-            val helper = object : ExtractionEngineHelper() {
+            val helper = object : ExtractionEngineHelper(INTRODUCE_PROPERTY) {
-                override fun configure(
+                override fun configureAndRun(
-                        descriptor: ExtractableCodeDescriptor,
+                        project: Project,
-                        generatorOptions: ExtractionGeneratorOptions
+                        editor: Editor,
-                ): ExtractionGeneratorConfiguration {
+                        descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
-                    return ExtractionGeneratorConfiguration(
+                        onFinish: (ExtractionResult) -> Unit
-                            descriptor,
+                ) {
-                            generatorOptions.copy(target = extractionTarget)
+                    doRefactor(
+                            ExtractionGeneratorConfiguration(
+                                    descriptorWithConflicts.descriptor,
+                                    ExtractionGeneratorOptions.DEFAULT.copy(target = extractionTarget)
+                            ),
+                            onFinish
                     )
                 }
             }
@@ -132,15 +141,18 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
 
             val editor = fixture.getEditor()
             val handler = ExtractKotlinFunctionHandler(
-                    helper = object : ExtractionEngineHelper() {
+                    helper = object : ExtractionEngineHelper(EXTRACT_FUNCTION) {
                         override fun adjustExtractionData(data: ExtractionData): ExtractionData {
                             return data.copy(options = extractionOptions)
                         }
 
-                        override fun configure(
+                        override fun configureAndRun(
-                                descriptor: ExtractableCodeDescriptor,
+                                project: Project,
-                                generatorOptions: ExtractionGeneratorOptions
+                                editor: Editor,
-                        ): ExtractionGeneratorConfiguration {
+                                descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
+                                onFinish: (ExtractionResult) -> Unit
+                        ) {
+                            val descriptor = descriptorWithConflicts.descriptor
                             val actualNames = descriptor.suggestedNames
                             val allParameters = emptyOrSingletonList(descriptor.receiverParameter) + descriptor.parameters
                             val actualDescriptors = allParameters.map { renderer.render(it.originalDescriptor) }.joinToString()
@@ -160,7 +172,8 @@ public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTe
                             else {
                                 descriptor
                             }
-                            return ExtractionGeneratorConfiguration(newDescriptor, generatorOptions)
+
+                            doRefactor(ExtractionGeneratorConfiguration(newDescriptor, ExtractionGeneratorOptions.DEFAULT), onFinish)
                         }
                     }
             )