spotless {
  // optional: limit format enforcement to just the files changed by this feature branch
  ratchetFrom 'origin/main'

  format 'misc', {
    // define the files to apply `misc` to
    target '*.gradle', '.gitattributes', '.gitignore'

    // define the steps to apply to those files
    trimTrailingWhitespace()
    leadingSpacesToTabs() // or leadingTabsToSpaces. Takes an integer argument if you don't like 4
    endWithNewline()
  }
  java {
    // don't need to set target, it is inferred from java

    // apply a specific flavor of google-java-format
    googleJavaFormat('1.8').aosp().reflowLongStrings().skipJavadocFormatting()
    // fix formatting of type annotations
    formatAnnotations()
    // make sure every file has the following copyright header.
    // optionally, Spotless can set copyright years by digging
    // through git history (see "license" section below)
    licenseHeader '/* (C)$YEAR */'
  }
}

spotless {
  kotlin {
    ktlint()
    suppressLintsFor {
      step = 'ktlint'
      shortCode = 'standard:no-wildcard-imports'
    }
  }
}

spotless {
  java {
    // Use the default importOrder configuration
    importOrder()
    // optional: you can specify import groups directly
    // note: you can use an empty string for all the imports you didn't specify explicitly, '|' to join group without blank line, and '\\#` prefix for static imports
    importOrder('java|javax', 'com.acme', '', '\\#com.acme', '\\#')
    // optional: instead of specifying import groups directly you can specify a config file
    // export config file: https://github.com/diffplug/spotless/blob/main/ECLIPSE_SCREENSHOTS.md#creating-spotlessimportorder
    importOrderFile('eclipse-import-order.txt') // import order file as exported from eclipse

    removeUnusedImports()
    forbidWildcardImports() // or expandWildcardImports, see below
    forbidModuleImports()

    // Cleanthat will refactor your code, but it may break your style: apply it before your formatter
    cleanthat()          // has its own section below

    // Choose one of these formatters.
    googleJavaFormat()   // has its own section below
    eclipse()            // has its own section below
    prettier()           // has its own section below
    clangFormat()        // has its own section below
    idea()               // has its own section below

    tableTestFormatter() // has its own section below

    formatAnnotations()  // fixes formatting of type annotations, see below

    licenseHeader '/* (C) $YEAR */' // or licenseHeaderFile
  }
}

spotless {
  java {
    googleJavaFormat()
    // optional: you can specify a specific version (>= 1.8) and/or switch to AOSP style
    //   and/or reflow long strings
    //   and/or use custom group artifact (you probably don't need this)
    googleJavaFormat('1.8').aosp().reflowLongStrings().formatJavadoc(false).reorderImports(false).groupArtifact('com.google.googlejavaformat:google-java-format')

spotless {
  java {
    palantirJavaFormat()
    // optional: you can specify a specific version and/or switch to AOSP/GOOGLE style
    palantirJavaFormat('2.9.0').style("GOOGLE")
    // optional: you can also format Javadocs, requires at least Palantir 2.39.0
    palantirJavaFormat('2.39.0').formatJavadoc(true)

spotless {
  java {
    eclipse()
    // optional: you can specify a specific version and/or config file
    eclipse('4.26').configFile('eclipse-prefs.xml')
    // Or supply the configuration properties as a string
    eclipse('4.26').configProperties("""
    ...
    """)
    // Or supply the configuration XML as a string
    eclipse('4.26').configXml("""
    ...
    """)
    // if the access to the p2 repositories is restricted, mirrors can be
    // specified using a URI prefix map as follows:
    eclipse().withP2Mirrors(['https://download.eclipse.org/eclipse/updates/4.29/':'https://some.internal.mirror/4-29-updates-p2/']) 

spotless {
  java {
    eclipse()
      // Optional: Enable the Sort Members feature globally. (default: false)
      .sortMembersEnabled(true)
      // Optional: Specify the sort order of the member categories. (default: T,SF,SI,SM,F,I,C,M)
      //   SF,SI,SM,F,I,C,M,T = Static Fields, Static Initializers, Static Methods, Fields, Initializers, Constructors, Methods, (Nested) Types
      .sortMembersOrder("SF,SI,SM,F,I,C,M,T")
      // Optional: Enable the reordering of fields, enum constants, and initializers. (default: true)
      .sortMembersDoNotSortFields(false)
      // Optional: Enable reordering of members of the same category by the visibility within the category. (default: false)
      .sortMembersVisibilityOrderEnabled(true)
      // Optional: Specify the ordering of members of the same category by the visibility within the category. (default: B,V,R,D)
      //   B,R,D,V = Public, Protected, Package, Private
      .sortMembersVisibilityOrder("B,R,D,V")

spotless {
  java {
    googleJavaFormat()
    formatAnnotations()
  }
}

    formatAnnotations().addTypeAnnotation("Empty").addTypeAnnotation("NonEmpty").removeTypeAnnotation("Localized")

spotless {
  java {
    cleanthat()
    // optional: you can specify a specific version and/or config file
    cleanthat()
      .groupArtifact('io.github.solven-eu.cleanthat:java') // Optional. Default is 'io.github.solven-eu.cleanthat:java'
      .version('2.8')                                      // You may force a custom version of Cleanthat
      .sourceCompatibility('1.7')                          // default is '1.7'
      .addMutator('SafeAndConsensual')                     // Default includes the SafeAndConsensual composite mutator
      .addMutator('your.custom.MagicMutator')              // List of mutators: https://github.com/solven-eu/cleanthat/blob/master/MUTATORS.generated.MD
      .excludeMutator('UseCollectionIsEmpty')              // You may exclude some mutators (from Composite ones)
      .includeDraft(false)                                 // You may exclude draft mutators (from Composite ones)

spotless {
  java {
    tableTestFormatter()
    // optional: you can specify a specific version
    tableTestFormatter('1.0.1')

apply plugin: 'groovy'
spotless {
  groovy {
    // Use the default importOrder configuration
    importOrder()
    // optional: you can specify import groups directly
    // note: you can use an empty string for all the imports you didn't specify explicitly, and '\\#` prefix for static imports
    importOrder('java', 'javax', 'com.acme', '', '\\#com.acme', '\\#')
    // optional: instead of specifying import groups directly you can specify a config file
    // export config file: https://github.com/diffplug/spotless/blob/main/ECLIPSE_SCREENSHOTS.md#creating-spotlessimportorder
    importOrderFile('eclipse-import-order.txt') // import order file as exported from eclipse
    // removes semicolons at the end of lines
    removeSemicolons()
    // the Groovy Eclipse formatter extends the Java Eclipse formatter,
    // so it formats Java files by default (unless `excludeJava` is used).
    greclipse() // has its own section below
    
    licenseHeader('/* (C) $YEAR */') // or licenseHeaderFile

    //---- Below is for `groovy` only ----
    
    // excludes all Java sources within the Groovy source dirs from formatting
    excludeJava()
  }
  groovyGradle {
    target '*.gradle' // default target of groovyGradle
    greclipse()
  }
}

spotless {
  groovy {
    // Use the default version and Groovy-Eclipse default configuration
    greclipse()
    // optional: you can specify a specific version or config file(s), version matches the Eclipse Platform
    greclipse('4.26').configFile('spotless.eclipseformat.xml', 'org.codehaus.groovy.eclipse.ui.prefs')
    // Or supply the configuration properties as a string
    greclipse('4.26').configProperties("""
    ...
    """)
    // Or supply the configuration XML as a string
    greclipse('4.26').configXml("""
    ...
    """)

spotless { // if you are using build.gradle.kts, instead of 'spotless {' use:
           // configure<com.diffplug.gradle.spotless.SpotlessExtension> {
  kotlin {
    // by default the target is every '.kt' and '.kts` file in the java sourcesets
    ktfmt()    // has its own section below
    ktlint()   // has its own section below
    diktat()   // has its own section below
    prettier() // has its own section below
    tableTestFormatter() // has its own section below
    licenseHeader '/* (C)$YEAR */' // or licenseHeaderFile
  }
  kotlinGradle {
    target('*.gradle.kts') // default target for kotlinGradle
    ktlint() // or ktfmt() or prettier()
  }
}

spotless {
  scala {
    // by default, all `.scala` and `.sc` files in the java sourcesets will be formatted

    scalafmt() // has its own section below

    licenseHeader '/* (C) $YEAR */', 'package ' // or licenseHeaderFile
    // note the 'package ' argument - this is a regex which identifies the top
    // of the file, be careful that all of your sources have a package declaration,
    // or pick a regex which works better for your code
  }
}

spotless {
  scala {
    // version and configFile, scalaMajorVersion are all optional
    scalafmt('3.5.9').configFile('scalafmt.conf').scalaMajorVersion('2.13')

spotless {
  cpp {
    target 'src/native/**' // you have to set the target manually

    clangFormat()  // has its own section below
    eclipseCdt()   // has its own section below

    licenseHeader '/* (C) $YEAR */' // or licenseHeaderFile
  }
}

spotles {
  cpp {
    // version and configFile are both optional
    eclipseCdt('4.13.0').configFile('eclipse-cdt.xml')
    // Or supply the configuration properties as a string
    eclipseCdt('4.13.0').configProperties("""
    ...
    """)
    // Or supply the configuration XML as a string
    eclipseCdt('4.13.0').configXml("""
    ...
    """)
  }
}

spotless {
  python {
    target 'src/main/**/*.py' // have to set manually

    black()  // has its own section below

    licenseHeader '/* (C) $YEAR */', 'REGEX_TO_DEFINE_TOP_OF_FILE' // or licenseHeaderFile
  }
}

black('19.10b0') // version is optional. Explicitly allow "any found version" with '*'.

// if black is not on your path, you must specify its location manually
black().pathToExe('C:/myuser/.pyenv/versions/3.8.0/scripts/black.exe')
// Spotless always checks the version of the black it is using
// and will fail with an error if it does not match the expected version
// (whether manually specified or default). If there is a problem, Spotless
// will suggest commands to help install the correct version.
//   TODO: handle installation & packaging automatically - https://github.com/diffplug/spotless/issues/674

spotless {
  protobuf {
    // by default the target is every '.proto' file in the project
    buf()

    licenseHeader '/* (C) $YEAR */' // or licenseHeaderFile
  }
}

spotless {
  protobuf {
    buf().pathToExe(configurations.getByName(BUF_BINARY_CONFIGURATION_NAME).getSingleFile().getAbsolutePath())
  }
}

// Be sure to disable the buf-gradle-plugin's execution of `buf format`:
buf {
  enforceFormat = false
}

spotless {
  freshmark {
    target '*.md' // you have to set the target manually
    propertiesFile('gradle.properties')		// loads all the properties in the given file
    properties {
      it.put('key', 'value')				// specify other properties manually
    }
  }
}

spotless {
  flexmark {
    target '**/*.md' // you have to set the target manually
    flexmark() // or flexmark('0.64.8') // version is optional
      .emulationProfile('COMMONMARK') // optional
      .pegdownExtensions('ALL') // optional
      .extensions('YamlFrontMatter') // optional
  }
}

spotless {
  antlr4 {
    target 'src/*/antlr4/**/*.g4' // default value, you can change if you want
    antlr4Formatter() // has its own section below
    licenseHeader '/* (C) $YEAR */' // or licenseHeaderFile
  }
}

antlr4formatter('1.2.1') // version is optional

spotless {
  sql {
    target 'src/main/resources/**/*.sql' // have to set manually

    dbeaver()  // has its own section below
    prettier() // has its own section below
    idea()     // has its own section below
  }
}

spotless {
  sql {
    dbeaver().configFile('dbeaver.properties') // configFile is optional

spotless {
  pom {
    target('pom.xml') // default value, you can change if you want

    sortPom()  // has its own section below
  }
}

spotless {
  pom {
    sortPom('4.0.0')
      .encoding('UTF-8') // The encoding of the pom files
      .lineSeparator(System.getProperty('line.separator')) // line separator to use
      .expandEmptyElements(true) // Should empty elements be expanded
      .spaceBeforeCloseEmptyElement(false) // Should a space be added inside self-closing elements
      .keepBlankLines(true) // Keep empty lines
      .endWithNewline(true) // Whether sorted pom ends with a newline
      .nrOfIndentSpace(2) // Indentation
      .indentBlankLines(false) // Should empty lines be indented
      .indentSchemaLocation(false) // Should schema locations be indented
      .indentAttribute(null) // Should the xml attributes be indented
      .predefinedSortOrder('recommended_2008_06') // Sort order of elements: https://github.com/Ekryd/sortpom/wiki/PredefinedSortOrderProfiles
      .sortOrderFile(null) // Custom sort order of elements: https://raw.githubusercontent.com/Ekryd/sortpom/master/sorter/src/main/resources/custom_1.xml
      .sortDependencies(null) // Sort dependencies: https://github.com/Ekryd/sortpom/wiki/SortDependencies
      .sortDependencyManagement(null) // Sort dependency management: https://github.com/Ekryd/sortpom/wiki/SortDependencies
      .sortDependencyExclusions(null) // Sort dependency exclusions: https://github.com/Ekryd/sortpom/wiki/SortDependencies
      .sortPlugins(null) // Sort plugins: https://github.com/Ekryd/sortpom/wiki/SortPlugins
      .sortProperties(false) // Sort properties
      .sortModules(false) // Sort modules
      .sortExecutions(false) // Sort plugin executions
  }
}

spotless {
  typescript {
    target 'src/**/*.ts' // you have to set the target manually

    tsfmt()    // has its own section below
    prettier() // has its own section below
    eslint()   // has its own section below
    biome()    // 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
    // of the file, be careful that all of your sources have a suitable top-level declaration,
    // or pick a regex which works better for your code
  }
}

spotless {
  typescript {
    tsfmt('7.2.2')
      // provide config inline: https://github.com/vvakame/typescript-formatter/blob/7764258ad42ac65071399840d1b8701868510ca7/lib/utils.ts#L11L32
      .config(['indentSize': 1, 'convertTabsToSpaces': true])
      // or according to tsfmt-parameters: https://github.com/vvakame/typescript-formatter/blob/7764258ad42ac65071399840d1b8701868510ca7/lib/index.ts#L27L34
      .tsconfigFile('tsconfig.json')
      .tslintFile('tslint.json')
      .vscodeFile('vscode.json')
      .tsfmtFile('tsfmt.json')

spotless {
  typescript {
    eslint('8.30.0') // version is optional
    eslint(['my-eslint-fork': '1.2.3', 'my-eslint-plugin': '1.2.1']) // can specify exactly which npm packages to use

    eslint()
      // configuration is mandatory. Provide inline config or a config file.
      // a) inline-configuration
      .configJs('''
        {
          env: {
            browser: true,
            es2021: true
          },
          extends: 'standard-with-typescript',
          overrides: [
          ],
          parserOptions: {
            ecmaVersion: 'latest',
            sourceType: 'module',
            project: './tsconfig.json',
          },
          rules: {
          }
        }
      ''')
      // b) config file
      .configFile('.eslintrc.js')
      // recommended: provide a tsconfig.json - especially when using the styleguides
      .tsconfigFile('tsconfig.json')
  }
}

spotless {
  javascript {
    target 'src/**/*.js' // you have to set the target manually

    prettier() // has its own section below
    eslint()   // has its own section below
    biome()    // has its own section below

    licenseHeader '/* (C) $YEAR */', 'REGEX_TO_DEFINE_TOP_OF_FILE' // or licenseHeaderFile
  }
}

spotless {
  javascript {
    eslint('8.30.0') // version is optional
    eslint(['my-eslint-fork': '1.2.3', 'my-eslint-plugin': '1.2.1']) // can specify exactly which npm packages to use

    eslint()
      // configuration is mandatory. Provide inline config or a config file.
      // a) inline-configuration
      .configJs('''
        {
          env: {
            browser: true,
            es2021: true
          },
          extends: 'standard',
          overrides: [
          ],
          parserOptions: {
            ecmaVersion: 'latest',
            sourceType: 'module'
          },
          rules: {
          }
        }
      ''')
      // b) config file
      .configFile('.eslintrc.js')
  }
}

spotless {
  json {
    target 'src/**/*.json'                // you have to set the target manually
    simple()                              // has its own section below
    prettier().config(['parser': 'json']) // see Prettier section below
    eclipseWtp('json')                    // see Eclipse web tools platform section
    gson()                                // has its own section below
    jackson()                             // has its own section below
    biome()                               // has its own section below
    jsonPatch([])                         // has its own section below
  }
}

spotless {
  json {
    target 'src/**/*.json'
    simple()
    // optional: specify the number of spaces to use
    simple().indentWithSpaces(6)
  }
}

spotless {
  json {
    target 'src/**/*.json'
    gson()
      .indentWithSpaces(6) // optional: specify the number of spaces to use
      .sortByKeys()        // optional: sort JSON by its keys
      .escapeHtml()        // optional: escape HTML in values
      .version('2.8.1')    // optional: specify version
  }
}

spotless {
  json {
    target 'src/**/*.json'
    jackson()
      .spaceBeforeSeparator(false)                   // optional: add a whitespace before key separator. False by default
      .feature('INDENT_OUTPUT', true)                // optional: true by default
      .feature('ORDER_MAP_ENTRIES_BY_KEYS', true)    // optional: false by default
      .feature('ANY_OTHER_FEATURE', true|false)      // optional: any SerializationFeature can be toggled on or off
      .jsonFeature('ANY_OTHER_FEATURE', true|false)  // any JsonGenerator.Feature can be toggled on or off
  }
}

spotless {
  json {
    target 'src/**/*.json'
    jsonPatch([
      [op: 'replace', path: '/baz', value: 'boo'],
      [op: 'add', path: '/hello', value: ['world']],
      [op: 'remove', path: '/foo']
    ])
  }
}

spotless {
  yaml {
    target 'src/**/*.yaml'                // you have to set the target manually
    jackson()                             // has its own section below
    prettier()                            // has its own section below
  }
}

spotless {
  yaml {
    target 'src/**/*.yaml'
    jackson()
      .spaceBeforeSeparator(false)                   // optional: add a whitespace before key separator. False by default
      .feature('INDENT_OUTPUT', true)                // optional: true by default
      .feature('ORDER_MAP_ENTRIES_BY_KEYS', true)    // optional: false by default
      .feature('ANY_OTHER_FEATURE', true|false)      // optional: any SerializationFeature can be toggled on or off
      .yamlFeature('ANY_OTHER_FEATURE', true|false)  // any YAMLGenerator.Feature can be toggled on or off
  }
}

spotless {
  shell {
    target 'scripts/**/*.sh' // default: '**/*.sh'

    shfmt()  // has its own section below
  }
}

shfmt('3.8.0') // version is optional. Explicitly allow "any found version" with '*'.

// if shfmt is not on your path, you must specify its location manually
shfmt().pathToExe('/opt/homebrew/bin/shfmt')

// Spotless always checks the version of the shfmt it is using
// and will fail with an error if it does not match the expected version
// (whether manually specified or default). If there is a problem, Spotless
// will suggest commands to help install the correct version.
//   TODO: handle installation & packaging automatically - https://github.com/diffplug/spotless/issues/674

spotless {
  gherkin {
    target 'src/**/*.feature' // you have to set the target manually
    gherkinUtils() // has its own section below
  }
}

spotless {
  gherkin {
    target 'src/**/*.feature'     // required to be set explicitly
    gherkinUtils()
      .version('9.0.0')           // optional: custom version of 'io.cucumber:gherkin-utils'
  }
}

spotless {
  css {
    target 'css/**/*.css' // default: '**/*.css'

    biome('1.8.3')  // has its own section below
  }
}

spotless {
  format 'styling', {
    // you have to set the target manually
    target 'src/*/webapp/**/*.css', 'src/*/webapp/**/*.scss'

    prettier('2.0.4') // version is optional
    prettier(['my-prettier-fork': '1.16.4']) // can specify exactly which npm packages to use

    // by default, prettier uses the file's extension to guess a parser
    // but you can override that and specify the parser manually
    prettier().config(['parser': 'css'])

    // you can also set some style options
    // https://prettier.io/docs/en/configuration.html
    prettier().config(['tabWidth': 4])

    // you can also slurp from a file or even provide both (inline always takes precedence over file)
    prettier().config(['tabWidth': 4]).configFile('path-to/.prettierrc.yml')
  }
}

spotless {
  java {
    prettier(['prettier': '2.8.8', 'prettier-plugin-java': '2.2.0']).config(['parser': 'java', 'tabWidth': 4])
  }
  format 'php', {
    target 'src/**/*.php'
    prettier(['prettier': '2.8.8', '@prettier/plugin-php': '0.19.6']).config(['parser': 'php', 'tabWidth': 3])
  }
}

spotless {
  java {
    prettier(['prettier': '3.0.3', 'prettier-plugin-java': '2.3.0'])
      .config(['parser': 'java', 'tabWidth': 4, 'plugins': ['prettier-plugin-java']])
  }
  format 'php', {
    target 'src/**/*.php'
    prettier(['prettier': '3.0.3', '@prettier/plugin-php': '0.20.1'])
      .config(['parser': 'php', 'tabWidth': 3, 'plugins': ['@prettier/plugin-php']])
  }
}

spotless {
  format 'javascript', {
    prettier().npmExecutable('/usr/bin/npm').nodeExecutable('/usr/bin/node').config(...)

spotless {
  typescript {
    prettier().npmrc("$projectDir/config/.npmrc").config(...)

spotless {
  typescript {
    prettier().npmInstallCache() // will use the default cache directory (the build-directory of the respective module)
    prettier().npmInstallCache("${rootProject.rootDir}/.gradle/spotless-npm-cache") // will use the specified directory (creating it if not existing)

spotless {
  format 'csharp', {
    // you have to set the target manually
    target 'src/**/*.cs'

    clangFormat('10.0.1') // version is optional. Explicitly allow "any found version" with '*'.

    // can also specify a code style
    clangFormat().style('LLVM') // or Google, Chromium, Mozilla, WebKit
    // TODO: support arbitrary .clang-format

    // if clang-format is not on your path, you must specify its location manually
    clangFormat().pathToExe('/usr/local/Cellar/clang-format/10.0.1/bin/clang-format')
    // Spotless always checks the version of the clang-format it is using
    // and will fail with an error if it does not match the expected version
    // (whether manually specified or default). If there is a problem, Spotless
    // will suggest commands to help install the correct version.
    //   TODO: handle installation & packaging automatically - https://github.com/diffplug/spotless/issues/673
  }
}

spotless {
  format 'xml', {
    target 'src/**/*.xml' // must specify target
    eclipseWtp('xml')     // must specify a type (table below)
    eclipseWtp('xml', '11.0') // optional version, others at https://download.eclipse.org/tools/cdt/releases/
    // you can also specify an arbitrary number of config files
    eclipseWtp('xml').configFile('spotless.xml.prefs', 'spotless.common.properties'
  }
}

spotless {
  format 'styling', {
    // you have to set the target manually
    target 'src/*/webapp/**/*.js'

    // Download Biome from the network if not already downloaded, see below for more info
    biome('2.1.0')

    // (optional) Path to the directory with the biome.json conig file
    biome('2.1.0').configPath("path/config/dir")

    // (optional) Biome will auto detect the language based on the file extension.
    // See below for possible values.
    biome('2.1.0').language("js")
  }
}

spotless {
  format 'biome-js', {
    target '**/*.js'
    biome('2.1.0')
  }
  format 'biome-ts', {
    target '**/*.ts'
    biome('2.1.0')
  }
  format 'biome-json', {
    target '**/*.json'
    biome('2.1.0')
  }
}

spotless {
  format 'biome', {
    target '**/*.js','**/*.ts','**/*.json'
    biome('1.2.0')
  }
}

spotless {
  format 'biome', {
    target '**/*.js','**/*.ts','**/*.json'
     // Relative paths are resolved against the project's base directory
    biome('1.2.0').downloadDir("${project.gradle.gradleUserHomeDir}/biome")
  }
}

spotless {
  format 'biome', {
    target '**/*.js','**/*.ts','**/*.json'
    biome().pathToExe("${project.layout.buildDirectory.asFile.get().absolutePath}/bin/biome")
  }
}

spotless {
  format 'biome', {
    target '**/*.js','**/*.ts','**/*.json'
    // Uses the "biome" command, which must be on the user's path. -->
    biome().pathToExe('biome')
  }
}

spotless {
  format 'biome', {
    target '**/*.js','**/*.ts','**/*.json'
    // Must point to the directory with the "biome.json" config file -->
    // Relative paths are resolved against the project's base directory -->
    biome('2.1.0').configPath('./config')
  }
}

spotless {
  format 'biome', {
    biome('2.1.0').configPath('./config/biome-spotless.json')
  }
}

spotless {
  format 'myFormatter', {
    // you have to set the target manually
    target 'src/main/**/*.java','jbang/*.java'

    idea()
      .codeStyleSettingsPath('/path/to/config') // if you have custom formatting rules, see below for how to extract/reference them
      .withDefaults(false) // Disable using default code style settings when no custom code style is defined for a file type (default: true)

    // if idea is not on your path, you must specify the path to the executable
    idea().binaryPath('/path/to/idea')
  }
}

spotless {
  // run a native binary
  format 'terraform', {
    target 'src/**/*.tf', 'src/**/*.tfvars' // you have to set the target manually
    nativeCmd('terraform', '/opt/homebrew/bin/terraform', ['fmt', '-']) // name, path to binary, additional arguments
  }
}

spotless {
  ratchetFrom 'origin/main' // only format files which have changed since origin/main

spotless {
  java { // or kotlin, or c, or python, or whatever
    toggleOffOn()

spotless {
  encoding 'UTF-8' // all formats will be interpreted as UTF-8
  java {
    encoding 'Cp1252' // except java, which will be Cp1252

spotless {
  format 'misc', {
    custom 'lowercase', { str -> str.toLowerCase() }

spotless {
  format 'misc', {
    addStep(MyFormatterStep.create())

spotless { java { ... } }
spotless { format 'javaFoo', com.diffplug.gradle.spotless.JavaExtension, { ... } }
// has to be 'javaFoo' not 'java' because each format needs a unique name

spotless {
  format 'foo', com.acme.FooLanguageExtension, {

import com.diffplug.gradle.spotless.JavaExtension

spotless {
  format 'templates', {
    target 'src/templates/**/*.foo.html'
    prettier().config(['parser': 'html'])
    withinBlocks 'javascript block', '<script>', '</script>', {
      prettier().config(['parser': 'javascript'])
    }
    withinBlocksRegex 'single-line @(java-expresion)', '@\\((.*?)\\)', JavaExtension, {
      googleJavaFormat()
    }

spotless {
  enforceCheck false
}

spotless {
  java {
    custom 'my-glitchy-step', { ... }

    ignoreErrorForStep('my-glitchy-step')   // ignore errors on all files thrown by a specific step
    ignoreErrorForPath('path/to/file.java') // ignore errors by all steps on this specific file

spotless {
  ...
  predeclareDeps()
}
spotlessPredeclare {
  java { eclipse() }
  kotlin { ktfmt('0.28') }
}