Extraction Engine: Simplify helper API

2015-04-21 15:00:40 +03:00
parent 9dd527b76c
commit 2cc39995bb
4 changed files with 48 additions and 53 deletions
@@ -37,15 +37,15 @@ public class ExtractKotlinFunctionHandler(
        public val allContainersEnabled: Boolean = false,
        private val helper: ExtractionEngineHelper = ExtractKotlinFunctionHandler.InteractiveExtractionHelper) : RefactoringActionHandler {

-    object InteractiveExtractionHelper : ExtractionEngineHelper() {
-        override fun configureInteractively(
+    object InteractiveExtractionHelper : ExtractionEngineHelper(EXTRACT_FUNCTION) {
+        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")
@@ -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(
-            descriptor: ExtractableCodeDescriptor,
-            generatorOptions: ExtractionGeneratorOptions
-    ): ExtractionGeneratorConfiguration {
-        return ExtractionGeneratorConfiguration(descriptor, generatorOptions)
+    fun doRefactor(config: ExtractionGeneratorConfiguration, onFinish: (ExtractionResult) -> Unit = {}) {
+        val project = config.descriptor.extractionData.project
+        onFinish(project.executeWriteCommand<ExtractionResult>(operationName) { config.generateDeclaration() })
    }

-    open fun configureInteractively(
+    abstract fun configureAndRun(
            project: Project,
            editor: Editor,
            descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
-            continuation: (ExtractionGeneratorConfiguration) -> Unit
-    ) {
-        continuation(ExtractionGeneratorConfiguration(descriptorWithConflicts.descriptor, ExtractionGeneratorOptions.DEFAULT))
-    }
-
-    companion object {
-        public val DEFAULT: ExtractionEngineHelper = ExtractionEngineHelper()
-    }
+            onFinish: (ExtractionResult) -> Unit = {}
+    )
 }

 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()) {
-                    doRefactor(helper.configure(validationResult.descriptor, ExtractionGeneratorOptions.DEFAULT))
-                }
-                else {
-                    helper.configureInteractively(project, editor, validationResult, ::doRefactor)
-                }
+                helper.configureAndRun(project, editor, validationResult, onFinish)
            }
        }

        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 -> {
@@ -34,17 +34,17 @@ import java.util.*
 public class KotlinIntroducePropertyHandler(
        val helper: ExtractionEngineHelper = KotlinIntroducePropertyHandler.InteractiveExtractionHelper
 ): KotlinIntroduceHandlerBase() {
-    object InteractiveExtractionHelper : ExtractionEngineHelper() {
-        override fun configureInteractively(
+    object InteractiveExtractionHelper : ExtractionEngineHelper(INTRODUCE_PROPERTY) {
+        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")
@@ -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() {
-                override fun configure(
-                        descriptor: ExtractableCodeDescriptor,
-                        generatorOptions: ExtractionGeneratorOptions
-                ): ExtractionGeneratorConfiguration {
-                    return ExtractionGeneratorConfiguration(
-                            descriptor,
-                            generatorOptions.copy(target = extractionTarget)
+            val helper = object : ExtractionEngineHelper(INTRODUCE_PROPERTY) {
+                override fun configureAndRun(
+                        project: Project,
+                        editor: Editor,
+                        descriptorWithConflicts: ExtractableCodeDescriptorWithConflicts,
+                        onFinish: (ExtractionResult) -> Unit
+                ) {
+                    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(
-                                descriptor: ExtractableCodeDescriptor,
-                                generatorOptions: ExtractionGeneratorOptions
-                        ): ExtractionGeneratorConfiguration {
+                        override fun configureAndRun(
+                                project: Project,
+                                editor: Editor,
+                                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)
                        }
                    }
            )