feat: --enable-editorconfig flag and .editorconfig support (#570)

Summary:
closes #45

Pull Request resolved: #570

Reviewed By: cortinico

Differential Revision: D88870046

Pulled By: hick209

fbshipit-source-id: 1365a914e49c325bc72146739a35e796e7d7052a

Author: tKe

CHANGELOG.md

@@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Added
 - Support for `else if` guard conditions (https://github.com/facebook/ktfmt/pull/563)
 - Explicit Kotlin import layout for the default and Google specific editorconfig files to match ktfmt's style. The same layout was already applied to the Kotlin Lang editorconfig (https://github.com/facebook/ktfmt/pull/571)
+- ktfmt cli can pull formatting configs from editor config files (https://github.com/facebook/ktfmt/pull/570)
 
 
 ## [0.59]

README.md

@@ -78,10 +78,20 @@ $ java -jar /path/to/ktfmt-<VERSION>-with-dependencies.jar [--kotlinlang-style |
 `--kotlinlang-style` makes `ktfmt` use a block indent of 4 spaces instead of 2.
 See below for details.
 
+`--enable-editorconfig` makes `ktfmt` enables limited support to override the style's configuration based on the
+following subset of editorconfig properties:
+
+| EditorConfig Property                                     | Description                                                                                      |
+|:----------------------------------------------------------|--------------------------------------------------------------------------------------------------|
+| `max_line_length`                                         | will override the max line width                                                                 |
+| `indent_size`<br/>*or `tab_width` if `indent_size = tab`* | will override the block indent                                                                   |
+| `ij_continuation_indent_size`                             | will override the continuation indent                                                            |
+| `ktfmt_trailing_comma_management_strategy`                | one of `none`, `only_add` or `complete`<br/>will override the trailing comma management strategy |
+
 ***Note:***
-*There is no configurability as to the formatter's algorithm for formatting (apart from the
-different styles). This is a deliberate design decision to unify our code formatting on a single
-format.*
+*There is no configurability as to the formatter's algorithm for formatting (apart from the different styles
+or limited `.editorconfig` support). This is a deliberate design decision to unify our code formatting on a
+single format.*
 
 ### using Gradle
 
@@ -138,6 +148,8 @@ Two reasons -
 However, we do offer an alternative style for projects that absolutely cannot make the move to
 `ktfmt` because of 2-space: the style `--kotlinlang-style` changes block indents to 4-space.
 
+Alternatively, the `ktfmt` command-line supports a limited subset of `.editorconfig` properties; see above.
+
 ## Developer's Guide
 
 ### Setup

core/build.gradle.kts

@@ -38,6 +38,7 @@ dependencies {
   api(libs.kotlin.stdlib)
   api(libs.kotlin.test)
   api(libs.kotlin.compilerEmbeddable)
+  implementation(libs.ec4j)
   testImplementation(libs.googleTruth)
   testImplementation(libs.junit)
 }

core/src/main/java/com/facebook/ktfmt/cli/EditorConfigResolver.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.facebook.ktfmt.cli
+
+import com.facebook.ktfmt.format.FormattingOptions
+import com.facebook.ktfmt.format.TrailingCommaManagementStrategy
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import org.ec4j.core.EditorConfigLoader
+import org.ec4j.core.PropertyTypeRegistry
+import org.ec4j.core.Resource
+import org.ec4j.core.ResourceProperties
+import org.ec4j.core.ResourcePropertiesService
+import org.ec4j.core.model.EditorConfig
+import org.ec4j.core.model.PropertyType
+import org.ec4j.core.model.Version.CURRENT
+
+object EditorConfigResolver {
+
+  private val ijContinuationIndentSize: PropertyType<Int> =
+      PropertyType.LowerCasingPropertyType(
+          "ij_continuation_indent_size",
+          "Denotes the continuation indent size. Useful to distinguish code blocks versus continuation lines",
+          PropertyType.PropertyValueParser.POSITIVE_INT_VALUE_PARSER,
+      )
+
+  private val commaManagementStrategy: PropertyType<TrailingCommaManagementStrategy> =
+      PropertyType.LowerCasingPropertyType(
+          "ktfmt_trailing_comma_management_strategy",
+          "Ktfmt Trailing Comma Management Strategy",
+          { _: String, value: String ->
+            TrailingCommaManagementStrategy.entries
+                .find { it.name.lowercase() == value }
+                ?.let { PropertyType.PropertyValue.valid(value, it) }
+                ?: PropertyType.PropertyValue.invalid(
+                    value,
+                    "Unknown ktfmt_trailing_comma_management_strategy value '$value'",
+                )
+          },
+          TrailingCommaManagementStrategy.entries.map { it.name.lowercase() }.toSet(),
+      )
+
+  private val propertyTypeRegistry by
+      lazy(LazyThreadSafetyMode.NONE) {
+        PropertyTypeRegistry.builder()
+            .defaults()
+            .type(PropertyType.max_line_length) // missing from defaults?
+            .type(ijContinuationIndentSize)
+            .type(commaManagementStrategy)
+            .build()
+      }
+
+  private object Cache : org.ec4j.core.Cache {
+    val cached = ConcurrentHashMap<Resource, EditorConfig>()
+
+    override fun get(
+        editorConfigFile: Resource,
+        loader: EditorConfigLoader,
+    ): EditorConfig = cached.computeIfAbsent(editorConfigFile, loader::load)
+  }
+
+  private val resourcePropertiesService: ResourcePropertiesService by
+      lazy(LazyThreadSafetyMode.NONE) {
+        ResourcePropertiesService.builder()
+            .cache(Cache)
+            .loader(EditorConfigLoader.of(CURRENT, propertyTypeRegistry))
+            .build()
+      }
+
+  fun resolveFormattingOptions(file: File, baseOptions: FormattingOptions): FormattingOptions =
+      resourcePropertiesService
+          .queryProperties(Resource.Resources.ofPath(file.toPath(), Charsets.UTF_8))
+          .resolveFormattingOptions(baseOptions)
+
+  private fun ResourceProperties.resolveFormattingOptions(
+      baseOptions: FormattingOptions,
+  ): FormattingOptions {
+    // `max_line_length` may return null to indicate 'off', in which case we keep the base maxWidth
+    val maxWidth =
+        getValue(PropertyType.max_line_length, baseOptions.maxWidth, false) ?: baseOptions.maxWidth
+
+    // `indent_size` may return null to indicate 'tab', in which case we defer to `tab_width`
+    val blockIndent =
+        getValue(PropertyType.indent_size, baseOptions.blockIndent, false)
+            ?: getValue(PropertyType.tab_width, baseOptions.blockIndent, false)
+
+    val continuationIndent =
+        getValue(ijContinuationIndentSize, baseOptions.continuationIndent, false)
+
+    val trailingCommaStrategy =
+        getValue(commaManagementStrategy, baseOptions.trailingCommaManagementStrategy, false)
+
+    val resolved =
+        baseOptions.copy(
+            maxWidth = maxWidth,
+            blockIndent = blockIndent,
+            continuationIndent = continuationIndent,
+            trailingCommaManagementStrategy = trailingCommaStrategy,
+        )
+    return resolved
+  }
+}

core/src/main/java/com/facebook/ktfmt/cli/Main.kt

@@ -140,9 +140,12 @@ class Main(
   private fun format(file: File?, args: ParsedArgs): Boolean {
     val fileName = file?.toString() ?: args.stdinName ?: "<stdin>"
     try {
+      val formattingOptions =
+          if (file == null || !args.editorConfig) args.formattingOptions
+          else EditorConfigResolver.resolveFormattingOptions(file, args.formattingOptions)
       val bytes = if (file == null) input else FileInputStream(file)
       val code = BufferedReader(InputStreamReader(bytes, UTF_8)).readText()
-      val formattedCode = Formatter.format(args.formattingOptions, code)
+      val formattedCode = Formatter.format(formattingOptions, code)
       val alreadyFormatted = code == formattedCode
 
       // stdin

core/src/main/java/com/facebook/ktfmt/cli/ParsedArgs.kt

@@ -36,6 +36,7 @@ data class ParsedArgs(
     val setExitIfChanged: Boolean,
     /** File name to report when formating code from stdin */
     val stdinName: String?,
+    val editorConfig: Boolean,
 ) {
   companion object {
 
@@ -81,6 +82,8 @@ data class ParsedArgs(
         |  --set-exit-if-changed             Sets exit code to 1 if any input file was not 
         |                                        formatted/touched
         |  --do-not-remove-unused-imports    Leaves all imports in place, even if not used
+        |  --enable-editorconfig             Enable .editorconfig overrides for supported formatting options (limited)
+        |                                        see https://github.com/facebook/ktfmt/blob/main/README.md
         |  
         |ARGFILE:
         |  If the only argument begins with '@', the remainder of the argument is treated
@@ -106,6 +109,7 @@ data class ParsedArgs(
       var setExitIfChanged = false
       var removeUnusedImports = true
       var stdinName: String? = null
+      var editorConfig = false
 
       if ("--help" in args || "-h" in args) return ParseResult.ShowMessage(HELP_TEXT)
       if ("--version" in args || "-v" in args) {
@@ -120,6 +124,7 @@ data class ParsedArgs(
           arg == "--dry-run" || arg == "-n" -> dryRun = true
           arg == "--set-exit-if-changed" -> setExitIfChanged = true
           arg == "--do-not-remove-unused-imports" -> removeUnusedImports = false
+          arg == "--enable-editorconfig" -> editorConfig = true
           arg.startsWith("--stdin-name=") ->
               stdinName =
                   parseKeyValueArg("--stdin-name", arg)
@@ -152,6 +157,7 @@ data class ParsedArgs(
               dryRun,
               setExitIfChanged,
               stdinName,
+              editorConfig,
           )
       )
     }