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. *

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)`.
`java.util.List<ScalafixRule>`	`rulesThatWillRun()` The rules that would run when calling `run()` Takes into account rules that are configured in .scalafix.conf.
`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.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.net.URLClassLoader toolClasspath)
```
    Parameters:
    
    toolClasspath - Custom classpath for classloading and compiling external rules. Must be a URLClassLoader (not regular ClassLoader) to support compiling sources.
  - 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.7".
  - 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.

Interface ScalafixArguments

Method Summary

Method Detail

withRules

withToolClasspath

withPaths

withExcludedPaths

withWorkingDirectory

withConfig

withMode

withParsedArguments

withPrintStream

withClasspath

withSourceroot

withMainCallback

withCharset

withScalaVersion

withScalacOptions

availableRules

rulesThatWillRun

validate

run