Merge pull request #518 from koxudaxi/fix_ruff_formatter

Improve RuffAsyncFormatter

Author: koxudaxi

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 ## [Unreleased]
+- Improve RuffAsyncFormatter [[#518](https://github.com/koxudaxi/ruff-pycharm-plugin/pull/518)]
 
 ## [0.0.40] - 2024-09-18
 

gradle.properties

@@ -4,7 +4,7 @@ pluginGroup = com.koxudaxi.ruff
 pluginName = Ruff
 pluginRepositoryUrl = https://github.com/koxudaxi/ruff-pycharm-plugin
 # SemVer format -> https://semver.org
-pluginVersion = 0.0.40
+pluginVersion = 0.0.41
 
 # Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 pluginSinceBuild = 242.20224.89

resources/META-INF/plugin.xml

@@ -16,8 +16,7 @@
                          enabledByDefault="true" level="WARNING"
                          implementationClass="com.koxudaxi.ruff.RuffInspection"/>
         <externalAnnotator language="Python" implementationClass="com.koxudaxi.ruff.RuffExternalAnnotator"/>
-        <formattingService implementation="com.koxudaxi.ruff.RuffAsyncFixFormatter"/>
-        <formattingService implementation="com.koxudaxi.ruff.RuffAsyncFormatFormatter" order="last"/>
+        <formattingService implementation="com.koxudaxi.ruff.RuffAsyncFormatter"/>
         <platform.backend.documentation.targetProvider
                 implementation="com.koxudaxi.ruff.RuffNoqaDocumentationTargetProvider"/>
         <actionOnSave id="BlackFormatterActionOnSave" implementation="com.koxudaxi.ruff.RuffActionOnSave" order="last"/>

src/com/koxudaxi/ruff/Ruff.kt

@@ -268,9 +268,9 @@ fun isInspectionEnabled(project: Project): Boolean {
     return inspectionProfileManager.currentProfile.isToolEnabled(toolWrapper.displayKey)
 }
 fun runCommand(
-    commandArgs: CommandArgs
+    commandArgs: CommandArgs, stdin: ByteArray? = null
 ): String? = runCommand(
-    commandArgs.executable, commandArgs.project, commandArgs.stdin, *commandArgs.args.toTypedArray()
+    commandArgs.executable, commandArgs.project,  if (stdin is ByteArray) stdin else commandArgs.stdin, *commandArgs.args.toTypedArray()
 )
 
 private fun getGeneralCommandLine(command: List<String>, projectPath: String?): GeneralCommandLine =
@@ -430,9 +430,9 @@ enum class NewArgument(val argument: String) {
 open class UnexpectedArgumentException(argument: String) : ExecutionException("Unexpected argument: $argument")
 class UnexpectedNewArgumentException(newArgument: NewArgument) : UnexpectedArgumentException(newArgument.argument)
 
-fun runRuff(commandArgs: CommandArgs): String? {
+fun runRuff(commandArgs: CommandArgs, stdin: ByteArray? = null): String? {
     return try {
-        runCommand(commandArgs)
+        runCommand(commandArgs, stdin)
     } catch (_: RunCanceledByUserException) {
         null
     } catch (_: TOMLParseException) {

src/com/koxudaxi/ruff/RuffApplyService.kt

@@ -35,7 +35,7 @@ class RuffApplyService(val project: Project) {
             }
         }
     }
-
+    val actionName = "Formatting with Ruff"
     fun apply(document: Document, sourceFile: SourceFile, withFormat: Boolean) {
         val checkedFixed = runReadActionOnPooledThread(null) {
             val fixed = runRuff(sourceFile, project.FIX_ARGS)

src/com/koxudaxi/ruff/RuffAsyncFixFormatter.kt

@@ -1,22 +1,15 @@
 package com.koxudaxi.ruff
 
-import com.intellij.execution.ExecutionException
-import com.intellij.execution.process.CapturingProcessAdapter
-import com.intellij.execution.process.OSProcessHandler
-import com.intellij.execution.process.ProcessEvent
 import com.intellij.formatting.FormattingContext
 import com.intellij.formatting.service.AsyncDocumentFormattingService
 import com.intellij.formatting.service.AsyncFormattingRequest
 import com.intellij.formatting.service.FormattingService
-import com.intellij.openapi.project.Project
+import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.psi.PsiFile
-import java.nio.charset.StandardCharsets
 import java.util.*
 
 
-abstract class RuffAsyncFormatterBase : AsyncDocumentFormattingService() {
-    abstract fun isEnabled(project: Project): Boolean
-    abstract fun getArgs(project: Project): List<String>
+class RuffAsyncFormatter : AsyncDocumentFormattingService() {
     private val FEATURES: MutableSet<FormattingService.Feature> = EnumSet.noneOf(
         FormattingService.Feature::class.java
     )
@@ -26,54 +19,66 @@ abstract class RuffAsyncFormatterBase : AsyncDocumentFormattingService() {
     }
 
     override fun canFormat(file: PsiFile): Boolean {
-        return isEnabled(file.project) && file.isApplicableTo
+        return RuffConfigService.getInstance(file.project).runRuffOnReformatCode && file.isApplicableTo
     }
-
     override fun createFormattingTask(request: AsyncFormattingRequest): FormattingTask? {
         val formattingContext: FormattingContext = request.context
         val ioFile = request.ioFile ?: return null
-        val sourceFile = formattingContext.containingFile.sourceFile
-        val commandArgs = generateCommandArgs(sourceFile, getArgs(formattingContext.project)) ?: return null
-        try {
-            val commandLine =
-                getGeneralCommandLine(commandArgs.executable, commandArgs.project, *commandArgs.args.toTypedArray())
-                    ?: return null
-            val handler = OSProcessHandler(commandLine.withCharset(StandardCharsets.UTF_8))
-            with(handler) {
-                processInput.write(ioFile.readText().toByteArray())
-                processInput.close()
-            }
-            return object : FormattingTask {
-                override fun run() {
-                    handler.addProcessListener(object : CapturingProcessAdapter() {
-                        override fun processTerminated(event: ProcessEvent) {
-                            val exitCode = event.exitCode
-                            if (exitCode == 0) {
-                                request.onTextReady(output.stdout)
-                            } else {
-                                request.onError("Ruff Error", output.stderr)
-                            }
-                        }
-                    })
-                    handler.startNotify()
+        return object : FormattingTask {
+            private fun updateText(currentText: String, text: String?) {
+                when {
+                    text == null -> request.onTextReady(null)
+                    currentText == text -> request.onTextReady(null)
+                    else -> request.onTextReady(text)
                 }
+            }
+            override fun run() {
+                runCatching {
+                    val sourceFile = formattingContext.containingFile.sourceFile
+                    val fixCommandArgs =
+                        generateCommandArgs(sourceFile, formattingContext.project.FIX_ARGS) ?: return@runCatching
+                    val currentText = ioFile.readText()
+                    val fixCommandStdout = runRuff(fixCommandArgs, currentText.toByteArray())
+                    if (fixCommandStdout == null) {
+                        request.onTextReady(null)
+                        return@runCatching
+                    }
+                    if (!RuffConfigService.getInstance(formattingContext.project).useRuffFormat) {
+                        updateText(currentText, fixCommandStdout)
+                        return@runCatching
+                    }
+                    val formatCommandArgs = generateCommandArgs(sourceFile, FORMAT_ARGS)
+                    if (formatCommandArgs == null) {
+                        updateText(currentText, fixCommandStdout)
+                        return@runCatching
+                    }
+                    val formatCommandStdout = runRuff(formatCommandArgs, fixCommandStdout.toByteArray())
+                    updateText(currentText, formatCommandStdout)
 
-                override fun cancel(): Boolean {
-                    handler.destroyProcess()
-                    return true
+                }.onFailure { exception ->
+                    when (exception) {
+                        is ProcessCanceledException -> { /* ignore */ }
+                        else -> {
+                            request.onError("Ruff Error", exception.localizedMessage)
+                        }
+                    }
                 }
+            }
+            override fun cancel(): Boolean {
+                return true
+            }
 
-                override fun isRunUnderProgress(): Boolean {
-                    return true
-                }
+            override fun isRunUnderProgress(): Boolean {
+                return true
             }
-        } catch (e: ExecutionException) {
-            e.message?.let { request.onError("Ruff Error", it) }
-            return null
         }
     }
 
     override fun getNotificationGroupId(): String {
         return "Ruff"
     }
+
+    override fun getName(): String {
+        return "Ruff Formatter"
+    }
 }