ScalafixArguments

```
public interface ScalafixArguments
```
Wrapper around arguments for invoking the Scalafix command-line interface main method.
To obtain an instance of ScalafixArguments, use Scalafix.newArguments(). Instances of ScalafixArguments are immutable and thread safe. It is safe to re-use the same ScalafixArguments instance for multiple Scalafix invocations. Re-using the same instance is particularly encouraged when a custom toolClasspath is provided, in order to amortize the cost/time of fetching artifacts, classloading them & warming up the JIT code cache.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`java.util.List<ScalafixRule>`	`availableRules()` The rules that are valid arguments for `withRules(List)`.
`ScalafixEvaluation`	`evaluate()` Similar to `run()`, but without any side effects on the source files.
`java.util.List<ScalafixRule>`	`rulesThatWillRun()` The rules that would run when calling `run()`
`ScalafixError[]`	`run()` Run the Scalafix commmand-line interface `main` function.
`java.util.Optional<ScalafixException>`	`validate()` Validates that the passed arguments are valid.
`ScalafixArguments`	`withCharset(java.nio.charset.Charset charset)`
`ScalafixArguments`	`withClasspath(java.util.List<java.nio.file.Path> classpath)`
`ScalafixArguments`	`withConfig(java.util.Optional<java.nio.file.Path> config)`
`ScalafixArguments`	`withExcludedPaths(java.util.List<java.nio.file.PathMatcher> matchers)`
`ScalafixArguments`	`withMainCallback(ScalafixMainCallback callback)`
`ScalafixArguments`	`withMode(ScalafixMainMode mode)`
`ScalafixArguments`	`withParsedArguments(java.util.List<java.lang.String> args)`
`ScalafixArguments`	`withPaths(java.util.List<java.nio.file.Path> paths)`
`ScalafixArguments`	`withPrintStream(java.io.PrintStream out)`
`ScalafixArguments`	`withRules(java.util.List<java.lang.String> rules)`
`ScalafixArguments`	`withScalacOptions(java.util.List<java.lang.String> options)`
`ScalafixArguments`	`withScalaVersion(java.lang.String version)`
`ScalafixArguments`	`withSourceroot(java.nio.file.Path path)`
`ScalafixArguments`	`withToolClasspath(java.util.List<java.net.URL> customURLs)`
`ScalafixArguments`	`withToolClasspath(java.util.List<java.net.URL> customURLs, java.util.List<java.lang.String> customDependenciesCoordinates)`
`ScalafixArguments`	`withToolClasspath(java.util.List<java.net.URL> customURLs, java.util.List<java.lang.String> customDependenciesCoordinates, java.util.List<coursierapi.Repository> repositories)`
`ScalafixArguments`	`withToolClasspath(java.net.URLClassLoader toolClasspath)`
`ScalafixArguments`	`withWorkingDirectory(java.nio.file.Path path)`

- Method Detail
  - withRules
```
ScalafixArguments withRules(java.util.List<java.lang.String> rules)
```
    Parameters:
    
    rules - The rules passed via the --rules flag matching the syntax provided in rules = [ "... " ] in .scalafix.conf files.
  - withToolClasspath
```
ScalafixArguments withToolClasspath(java.util.List<java.net.URL> customURLs)
```
    Parameters:
    
    customURLs - Extra URLs for classloading and compiling external rules.
  - withToolClasspath
```
ScalafixArguments withToolClasspath(java.util.List<java.net.URL> customURLs,
                                    java.util.List<java.lang.String> customDependenciesCoordinates)
                             throws ScalafixException
```
    Parameters:
    
    customURLs - Extra URLs for classloading and compiling external rules.
    
    customDependenciesCoordinates - Extra dependencies for classloading and compiling external rules. For example "com.nequissimus::sort-imports:0.5.2". Artifacts will be resolved against the Scala version in the classloader of the parent Scalafix instance and fetched using Coursier.
    
    Throws:
    
    ScalafixException - in case of errors during artifact resolution/fetching.
  - withToolClasspath
```
ScalafixArguments withToolClasspath(java.util.List<java.net.URL> customURLs,
                                    java.util.List<java.lang.String> customDependenciesCoordinates,
                                    java.util.List<coursierapi.Repository> repositories)
                             throws ScalafixException
```
    Parameters:
    
    customURLs - Extra URLs for classloading and compiling external rules.
    
    customDependenciesCoordinates - Extra dependencies for classloading and compiling external rules. For example "com.nequissimus::sort-imports:0.5.2". Artifacts will be resolved against the Scala version in the classloader of the parent Scalafix instance and fetched using Coursier.
    
    repositories - Maven/Ivy repositories to fetch the artifacts from.
    
    Throws:
    
    ScalafixException - in case of errors during artifact resolution/fetching.
  - withToolClasspath
```
ScalafixArguments withToolClasspath(java.net.URLClassLoader toolClasspath)
```
    Parameters:
    
    toolClasspath - Custom classpath for classloading and compiling external rules. Must be a URLClassLoader (not regular ClassLoader) to support compiling sources. This classloader must have as ancestor the classloader of the Scalafix instance that returned this ScalafixArguments instance. Unless you have an advanced use-case, prefer the high-level overloads that cannot cause runtime errors due to an invalid classloader hierarchy.
  - withPaths
```
ScalafixArguments withPaths(java.util.List<java.nio.file.Path> paths)
```
    Parameters:
    
    paths - Files and directories to run Scalafix on. The ability to pass in directories is primarily supported to make it ergonomic to invoke the command-line interface. It's recommended to only pass in files with this API. Directories are recursively expanded for files matching the patterns *.scala and *.sbt and files that do not match the path matchers provided in withExcludedPaths(List).
  - withExcludedPaths
```
ScalafixArguments withExcludedPaths(java.util.List<java.nio.file.PathMatcher> matchers)
```
    Parameters:
    
    matchers - Optional list of path matchers to exclude files when expanding directories in withPaths(List).
  - withWorkingDirectory
```
ScalafixArguments withWorkingDirectory(java.nio.file.Path path)
```
    Parameters:
    
    path - The working directory of where to invoke the command-line interface. Primarily used to absolutize relative directories passed via withPaths(List) and also to auto-detect the location of .scalafix.conf.
  - withConfig
```
ScalafixArguments withConfig(java.util.Optional<java.nio.file.Path> config)
```
    Parameters:
    
    config - Optional path to a .scalafix.conf. If empty, Scalafix will infer such a file from the working directory or fallback to the default configuration.
  - withMode
```
ScalafixArguments withMode(ScalafixMainMode mode)
```
    Parameters:
    
    mode - The mode to run via --check or --stdout or --auto-suppress-linter-errors
  - withParsedArguments
```
ScalafixArguments withParsedArguments(java.util.List<java.lang.String> args)
                               throws ScalafixException
```
    Parameters:
    
    args - Unparsed command-line arguments that are fed directly to main(Array[String])
    
    Throws:
    
    ScalafixException - In case of an error parsing the provided arguments.
  - withPrintStream
```
ScalafixArguments withPrintStream(java.io.PrintStream out)
```
    Parameters:
    
    out - The output stream to use for reporting diagnostics while running Scalafix. Defaults to System.out.
  - withClasspath
```
ScalafixArguments withClasspath(java.util.List<java.nio.file.Path> classpath)
```
    Parameters:
    
    classpath - Full Java classpath of the module being fixed. Required for running semantic rewrites such as ExpliticResultTypes. Source files that are to be fixed must be compiled with the semanticdb-scalac compiler plugin and must have corresponding META-INF/semanticdb/../*.semanticdb payloads. The dependency classpath must be included as well but dependency sources do not have to be compiled with semanticdb-scalac.
  - withSourceroot
```
ScalafixArguments withSourceroot(java.nio.file.Path path)
```
    Parameters:
    
    path - The SemanticDB sources path passed via --sourceroot. Must match path in -Xplugin:semanticdb:sourceroot:{path} if used. Defaults to the current working directory.
  - withMainCallback
```
ScalafixArguments withMainCallback(ScalafixMainCallback callback)
```
    Parameters:
    
    callback - Handler for reported linter messages. If not provided, defaults to printing linter messages to the Stdout.
  - withCharset
```
ScalafixArguments withCharset(java.nio.charset.Charset charset)
```
    Parameters:
    
    charset - Charset for reading source files from disk. Defaults to UTF-8.
  - withScalaVersion
```
ScalafixArguments withScalaVersion(java.lang.String version)
```
    Parameters:
    
    version - The Scala compiler version used to compile this classpath. For example "2.12.8". To be able to run advanced semantic rules using the Scala Presentation Compiler (such as ExplicitResultTypes), this must match the binary version available in the classloader of this instance, as requested/provided in the static factory methods of Scalafix.
  - withScalacOptions
```
ScalafixArguments withScalacOptions(java.util.List<java.lang.String> options)
```
    Parameters:
    
    options - The Scala compiler flags used to compile this classpath. For example List(-Ywarn-unused-import).
  - availableRules
```
java.util.List<ScalafixRule> availableRules()
```
    The rules that are valid arguments for withRules(List).
    Takes into account built-in rules as well as the tool classpath provided via withToolClasspath(URLClassLoader).
  - rulesThatWillRun
```
java.util.List<ScalafixRule> rulesThatWillRun()
                                       throws ScalafixException
```
    The rules that would run when calling run()
    Takes into account rules that are configured in .scalafix.conf.
    
    Throws:
    
    ScalafixException - In case of an error loading the configured rules.
  - validate
```
java.util.Optional<ScalafixException> validate()
```
    Validates that the passed arguments are valid.
    Takes into account provided rules, .scalafix.conf configuration, scala version, scalac options and other potential problems. The primary purpose of this method is to validate the arguments before starting compilation to populate withClasspath(List).
    
    Returns:
    
    Optional.empty in case the arguments are valid. Optional.of an exception in case of an error loading the arguments.
  - run
```
ScalafixError[] run()
```
    Run the Scalafix commmand-line interface main function.
  - evaluate
```
ScalafixEvaluation evaluate()
```
    Similar to run(), but without any side effects on the source files. Via the returned ScalafixEvaluation, for each file, diagnostics can be inspected, and patches can be previewed and applied.
    Incompatible with withMainCallback(scalafix.interfaces.ScalafixMainCallback) and withMode(scalafix.interfaces.ScalafixMainMode).

Interface ScalafixArguments

Method Summary

Method Detail

withRules

withToolClasspath

withToolClasspath

withToolClasspath

withToolClasspath

withPaths

withExcludedPaths

withWorkingDirectory

withConfig

withMode

withParsedArguments

withPrintStream

withClasspath

withSourceroot

withMainCallback

withCharset

withScalaVersion

withScalacOptions

availableRules

rulesThatWillRun

validate

run

evaluate