Add docs for Gradle plugin

Author: blutorange

plugin-gradle/README.md

@@ -75,6 +75,7 @@ Spotless supports all of Gradle's built-in performance features (incremental bui
       - c, c++, c#, objective-c, protobuf, javascript, java
     - [eclipse web tools platform](#eclipse-web-tools-platform)
       - css, html, js, json, xml
+    - [Rome](#rome) ([binary detection](#rome-binary), [config file](#rome-configuration-file), [input language](#rome-input-language))
 - **Language independent**
   - [Generic steps](#generic-steps)
   - [License header](#license-header) ([slurp year from git](#retroactively-slurp-years-from-git-history))
@@ -613,7 +614,8 @@ spotless {
 
     tsfmt()    // has its own section below
     prettier() // has its own section below
-    eslint() // has its own section below
+    eslint()   // has its own section below
+    rome()     // has its own section below
 
     licenseHeader '/* (C) $YEAR */', '(import|const|declare|export|var) ' // or licenseHeaderFile
     // note the '(import|const|...' argument - this is a regex which identifies the top
@@ -705,7 +707,8 @@ spotless {
     target 'src/**/*.js' // you have to set the target manually
 
     prettier() // has its own section below
-    eslint() // has its own section below
+    eslint()   // has its own section below
+    rome()     // has its own section below
 
     licenseHeader '/* (C) $YEAR */', 'REGEX_TO_DEFINE_TOP_OF_FILE' // or licenseHeaderFile
   }
@@ -772,6 +775,7 @@ spotless {
     eclipseWtp('json')                    // see Eclipse web tools platform section
     gson()                                // has its own section below
     jackson()                             // has its own section below
+    rome()                                // has its own section below
   }
 }
 ```
@@ -1064,6 +1068,171 @@ Unlike Eclipse, Spotless WTP ignores per default external URIs in schema locatio
 external entities. To allow the access of external URIs, set the property `resolveExternalURI`
 to true.
 
+## Rome
+
+[homepage](https://rome.tools/). [changelog](https://github.com/rome/tools/blob/main/CHANGELOG.md). Rome is a formatter that for the Frontend written in Rust, which has a native binary,
+does not require Node.js and as such, is pretty fast. It can currently format
+JavaScript, TypeScript, JSX, and JSON, and may support
+[more frontend languages](https://docs.rome.tools/internals/language_support/)
+such as CSS in the future.
+
+You can use rome in any language-specific format for supported languages, but
+usually you will be creating a generic format.
+
+```gradle
+spotless {
+  format 'styling', {
+    // you have to set the target manually
+    target 'src/*/webapp/**/*.js'
+
+    // Download Rome from the network if not already downloaded, see below for more info
+    rome('12.0.0')
+
+    // (optional) Path to the directory with the rome.json conig file
+    rome('12.0.0').configPath("path/config/dir")
+
+    // (optional) Rome will auto detect the language based on the file extension.
+    // See below for possible values.
+    rome('12.0.0').language("js")
+  }
+}
+```
+
+**Limitations:**
+- The auto-discovery of config files (up the file tree) will not work when using
+  Rome within spotless.
+
+To apply Rome to more kinds of files with a different configuration, just add
+more formats:
+
+```gradle
+spotless {
+  format 'rome-js', {
+    target '**/*.js'
+    rome('12.0.0')
+  }
+  format 'rome-ts', {
+    target '**/*.ts'
+    rome('12.0.0')
+  }
+  format 'rome-json', {
+    target '**/*.json'
+    rome('12.0.0')
+  }
+}
+```
+
+### Rome binary
+
+To format with Rome, spotless needs to find the Rome binary. By default,
+spotless downloads the binary for the given version from the network. This
+should be fine in most cases, but may not work e.g. when there is not connection
+to the internet.
+
+To download the Rome binary from the network, just specify a version:
+
+```gradle
+spotless {
+  format 'rome', {
+    target '**/*.js','**/*.ts','**/*.json'
+    rome('12.0.0')
+  }
+}
+```
+
+Spotless uses a default version when you do not specfiy a version, but this
+may change at any time, so we recommend that you always set the Rome version
+you want to use. Optionally, you can also specify a directory for the downloaded
+Rome binaries (defaults to `~/.m2/repository/com/diffplug/spotless/spotless-data/rome`):
+
+```gradle
+spotless {
+  format 'rome', {
+    target '**/*.js','**/*.ts','**/*.json'
+     // Relative paths are resolved against the project's base directory
+    rome('12.0.0').downloadDir("${project.gradle.gradleUserHomeDir}/rome")
+  }
+}
+```
+
+To use a fixed binary, omit the `version` and specify a `pathToExe`:
+
+```gradle
+spotless {
+  format 'rome', {
+    target '**/*.js','**/*.ts','**/*.json'
+    rome('12.0.0').pathToExe("${project.buildDir.absolutePath}/bin/rome")
+  }
+}
+```
+
+Absolute paths are used as-is. Relative paths are resolved against the project's
+base directory. To use a pre-installed Rome binary on the user's path, specify
+just a name without any slashes / backslashes:
+
+```gradle
+spotless {
+  format 'rome', {
+    target '**/*.js','**/*.ts','**/*.json'
+    // Uses the "rome" command, which must be on the user's path. -->
+    rome('12.0.0').pathToExe('rome')
+  }
+}
+```
+
+### Rome configuration file
+
+Rome is a biased formatter and linter without many options, but there are a few
+basic options. Rome uses a file named [rome.json](https://docs.rome.tools/configuration/)
+for its configuration. When none is specified, the default configuration from
+Rome is used. To use a custom configuration:
+
+```gradle
+spotless {
+  format 'rome', {
+    target '**/*.js','**/*.ts','**/*.json'
+    // Must point to the directory with the "rome.json" config file -->
+    // Relative paths are resolved against the project's base directory -->
+    rome('12.0.0').configPath('./config')
+  }
+}
+```
+
+### Rome input language
+
+By default, Rome detects the language / syntax of the files to format
+automatically from the file extension. This may fail if your source code files
+have unusual extensions for some reason. If you are using the generic format,
+you can force a certain language like this:
+
+```xml
+<configuration>
+  <formats>
+    <format>
+      <includes>
+        <include>src/**/typescript/**/*.mjson</include>
+      </includes>
+
+      <rome>
+        <version>12.0.0</version>
+        <language>json</language>
+      </prettier>
+    </rome>
+
+  </formats>
+</configuration>
+```
+
+The following languages are currently recognized:
+
+* `js` -- JavaScript
+* `jsx` -- JavaScript + JSX (React)
+* `js?` -- JavaScript, with or without JSX, depending on the file extension
+* `ts` -- TypeScript
+* `tsx` -- TypeScript + JSX (React)
+* `ts?` -- TypeScript, with or without JSX, depending on the file extension
+* `json` -- JSON
+
 ## Generic steps
 
 [Prettier](#prettier), [eclipse wtp](#eclipse-web-tools-platform), and [license header](#license-header) are available in every format, and they each have their own section. As mentioned in the [quickstart](#quickstart), there are a variety of simple generic steps which are also available in every format, here are examples of these:

plugin-maven/README.md

@@ -1250,7 +1250,7 @@ usually you will be creating a generic format.
         <!-- (optional) Path to the directory with the rome.json conig file -->
         <configPath>${project.basedir}/path/to/config/dir</configPath>
 
-        <!-- Optional, Rome will auto detect the language based on the file extension. -->
+        <!-- (optional) Rome will auto detect the language based on the file extension. -->
         <!-- See below for possible values. -->
         <language>ts</language>
       </prettier>
@@ -1264,13 +1264,15 @@ usually you will be creating a generic format.
 - The auto-discovery of config files (up the file tree) will not work when using
   Rome within spotless.
 
-To apply Rome to more kinds of files, just add more formats
+To apply Rome to more kinds of files with a different configuration, just add
+more formats
 
 ```xml
 <configuration>
   <formats>
     <format><includes>src/**/*.ts</includes><rome/></format>
     <format><includes>src/**/*.js</includes><rome/></format>
+</configuration>
 ```
 
 ### Rome binary
@@ -1336,7 +1338,7 @@ Rome is used. To use a custom configuration:
 </rome>
 ```
 
-### Rome input Language
+### Rome input language
 
 By default, Rome detects the language / syntax of the files to format
 automatically from the file extension. This may fail if your source code files