spotless {
  format 'misc', {
    target '**/*.gradle', '**/*.md', '**/.gitignore'

    trimTrailingWhitespace()
    indentWithTabs() // or spaces. Takes an integer argument if you don't like 4
    endWithNewline()
  }
  format 'cpp', {
    target '**/*.hpp', '**/*.cpp'

    replace      'Not enough space after if', 'if(', 'if ('
    replaceRegex 'Too much space after if', 'if +\\(', 'if ('

    // Everything before the first #include or #pragma will
    // be replaced with whatever is in `spotless.license.cpp`
    licenseHeaderFile 'spotless.license.cpp', '#'
  }
}

apply plugin: 'java'
...

spotless {
  java {
    licenseHeader '/* Licensed under Apache-2.0 */'	// License header
    licenseHeaderFile 'spotless.license.java'		// License header file
    // Obviously, you can't specify both licenseHeader and licenseHeaderFile at the same time

    importOrder 'java', 'javax', 'org', 'com', 'com.diffplug', ''	// A sequence of package names
    importOrderFile 'spotless.importorder'				// An import ordering file, exported from Eclipse
    // As before, you can't specify both importOrder and importOrderFile at the same time
    // You probably want an empty string at the end - all of the imports you didn't specify
    // explicitly will go there.

    removeUnusedImports() // removes any unused imports

    eclipse().configFile 'spotless.eclipseformat.xml'	// XML file dumped out by the Eclipse formatter
    // If you have Eclipse preference or property files, you can use them too.
    // eclipse('4.7.1') to specify a specific version of eclipse,
    // available versions are: https://bintray.com/diffplug/opensource/spotless-ext-eclipse-jdt
  }
}

spotless {
  java {
    // ...
    target '**/*.java'
    // ...
  }
}

spotless {
  java {
    googleJavaFormat()
    // optional: you can specify a specific version and/or switch to AOSP style
    googleJavaFormat('1.1').aosp()
    // you can then layer other format steps, such as
    licenseHeaderFile 'spotless.license.java'
  }
}

apply plugin: 'groovy'
...

spotless {
  java {
    licenseHeaderFile 'spotless.license.java'
    googleJavaFormat() // use a specific formatter for Java files
  }
  groovy {
    licenseHeaderFile 'spotless.license.java'
    excludeJava() // excludes all Java sources within the Groovy source dirs from formatting
    paddedCell() // Avoid cyclic ambiguities
    // the Groovy Eclipse formatter extends the Java Eclipse formatter,
    // so it formats Java files by default (unless `excludeJava` is used).
    greclipse().configFile('greclipse.properties')
  }
  groovyGradle {
    // same as groovy, but for .gradle (defaults to '*.gradle')
    target '*.gradle', 'additionalScripts/*.gradle'
    greclipse().configFile('greclipse.properties')
  }
}

spotless {
  groovy {
    // Use the default version and Groovy-Eclipse default configuration
    greclipse()
    // optional: you can specify a specific version or config file(s)
    // available versions: https://bintray.com/diffplug/opensource/spotless-ext-greclipse
    greclipse('2.3.0').configFile('spotless.eclipseformat.xml', 'org.codehaus.groovy.eclipse.ui.prefs')
  }
}

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

spotless {
  scala {
    scalafmt()
    // optional: you can specify a specific version or config file
    scalafmt('0.5.1').configFile('scalafmt.conf')
  }
}

spotless {
  kotlin {
    // optionally takes a version
    ktlint()
    // Optional user arguments can be set as such:
    ktlint().userData(['indent_size': '2', 'continuation_indent_size' : '2'])

    // also supports license headers
    licenseHeader '/* Licensed under Apache-2.0 */'	// License header
    licenseHeaderFile 'path-to-license-file'		// License header file
  }
  kotlinGradle {
    // same as kotlin, but for .gradle.kts files (defaults to '*.gradle.kts')
    target '*.gradle.kts', 'additionalScripts/*.gradle.kts'

    ktlint()

    // Optional user arguments can be set as such:
    ktlint().userData(['indent_size': '2', 'continuation_indent_size' : '2'])

    // doesn't support licenseHeader, because scripts don't have a package statement
    // to clearly mark where the license should go
  }
}

spotless {
  sql {
    // default value for target files
    target '**/*.sql'
    // configFile is optional, arguments available here: https://github.com/diffplug/spotless/blob/master/lib/src/main/java/com/diffplug/spotless/sql/DBeaverSQLFormatterStep.java
    dbeaver().configFile('dbeaver.props')
  }
}

spotless {
  java {
    licenseHeader('Licensed under Apache-2.0 $YEAR').yearSeparator(', ')
  }
}

spotless {
  // this will create two tasks: spotlessMiscCheck and spotlessMiscApply
  format 'misc', {
    // target determines which files this format will apply to
    // - if you pass a string or a list of strings, they will be treated
    //       as 'include' parameters to a fileTree in the root directory
    // - if you pass a FileCollection, it will pass through untouched
    //       e.g. project.files('build.gradle', 'settings.gradle')
    // - if you pass anything else, it will be sent to project.files(yourArg)
    target '**/*.gradle', '**/*.md', '**/.gitignore'

    // spotless has built-in rules for the most basic formatting tasks
    trimTrailingWhitespace()
    indentWithTabs() // or spaces. Takes an integer argument if you don't like 4
    endWithNewline()

    // you can also call out to your own function
    custom 'superFormatter', {
      // when writing a custom step, it will be helpful to know
      // how the formatting process works, which is as follows:

      // 1) Load each target file, and convert it to unix-style line endings ('\n')
      // 2) Pass its content through a series of steps, feeding the output of each step to the next
      // 3) Put the correct line endings back on, then either check or apply

      // each step receives a string as input, and should output
      // a formatted string as output.  Each step can trust that its
      // input will have unix newlines, and it must promise to output
      // only unix newlines.  Other than that, anything is fair game!
    }
  }
}

spotless {
  java {
    ...
    encoding 'Cp1252' // java will have Cp1252
  }
  encoding 'US-ASCII'   // but all other formats will be interpreted as US-ASCII
}

spotless {
  enforceCheck false
}

spotless {
  java {
    googleJavaFormat()
    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
  }
}