Apply formatting

Author: MaciejG604

modules/build/src/main/scala/scala/build/Build.scala

@@ -43,17 +43,17 @@ trait Build {
 object Build {
 
   final case class Successful(
-                               inputs: Module,
-                               options: BuildOptions,
-                               scalaParams: Option[ScalaParameters],
-                               scope: Scope,
-                               sources: Sources,
-                               artifacts: Artifacts,
-                               project: Project,
-                               output: os.Path,
-                               diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]],
-                               generatedSources: Seq[GeneratedSource],
-                               isPartial: Boolean
+    inputs: Module,
+    options: BuildOptions,
+    scalaParams: Option[ScalaParameters],
+    scope: Scope,
+    sources: Sources,
+    artifacts: Artifacts,
+    project: Project,
+    output: os.Path,
+    diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]],
+    generatedSources: Seq[GeneratedSource],
+    isPartial: Boolean
   ) extends Build {
     def success: Boolean                  = true
     def successfulOpt: Some[this.type]    = Some(this)
@@ -166,24 +166,24 @@ object Build {
   }
 
   final case class Failed(
-                           inputs: Module,
-                           options: BuildOptions,
-                           scope: Scope,
-                           sources: Sources,
-                           artifacts: Artifacts,
-                           project: Project,
-                           diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]]
+    inputs: Module,
+    options: BuildOptions,
+    scope: Scope,
+    sources: Sources,
+    artifacts: Artifacts,
+    project: Project,
+    diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]]
   ) extends Build {
     def success: Boolean         = false
     def successfulOpt: None.type = None
     def outputOpt: None.type     = None
   }
 
   final case class Cancelled(
-                              inputs: Module,
-                              options: BuildOptions,
-                              scope: Scope,
-                              reason: String
+    inputs: Module,
+    options: BuildOptions,
+    scope: Scope,
+    reason: String
   ) extends Build {
     def success: Boolean         = false
     def successfulOpt: None.type = None
@@ -195,9 +195,9 @@ object Build {
     * Using only the command-line options not the ones from the sources.
     */
   def updateInputs(
-                    inputs: Module,
-                    options: BuildOptions,
-                    testOptions: Option[BuildOptions] = None
+    inputs: Module,
+    options: BuildOptions,
+    testOptions: Option[BuildOptions] = None
   ): Module = {
 
     // If some options are manually overridden, append a hash of the options to the project name
@@ -229,9 +229,7 @@ object Build {
       logger,
       options.suppressWarningOptions,
       options.internal.exclude
-    )
-
-  private def build(
+    )private def build(
     inputs: Module,
     crossSources: CrossSources,options: BuildOptions,
     logger: Logger,
@@ -424,17 +422,17 @@ object Build {
   }
 
   private def build(
-                     inputs: Module,
-                     sources: Sources,
-                     generatedSources: Seq[GeneratedSource],
-                     options: BuildOptions,
-                     scope: Scope,
-                     logger: Logger,
-                     buildClient: BloopBuildClient,
-                     compiler: ScalaCompiler,
-                     buildTests: Boolean,
-                     partial: Option[Boolean],
-                     actionableDiagnostics: Option[Boolean]
+    inputs: Module,
+    sources: Sources,
+    generatedSources: Seq[GeneratedSource],
+    options: BuildOptions,
+    scope: Scope,
+    logger: Logger,
+    buildClient: BloopBuildClient,
+    compiler: ScalaCompiler,
+    buildTests: Boolean,
+    partial: Option[Boolean],
+    actionableDiagnostics: Option[Boolean]
   )(using ScalaCliInvokeData): Either[BuildException, Build] = either {
 
     val build0 = value {
@@ -496,9 +494,9 @@ object Build {
     root / Constants.workspaceDirName / projectName.name / s"resources-${scope.name}"
 
   def scalaNativeSupported(
-                            options: BuildOptions,
-                            inputs: Module,
-                            logger: Logger
+    options: BuildOptions,
+    inputs: Module,
+    logger: Logger
   ): Either[BuildException, Option[ScalaNativeCompatibilityError]] =
     either {
       val scalaParamsOpt = value(options.scalaParams)
@@ -635,16 +633,16 @@ object Build {
   }
 
   def watch(
-             inputs: Module,
-             options: BuildOptions,
-             compilerMaker: ScalaCompilerMaker,
-             docCompilerMakerOpt: Option[ScalaCompilerMaker],
-             logger: Logger,
-             crossBuilds: Boolean,
-             buildTests: Boolean,
-             partial: Option[Boolean],
-             actionableDiagnostics: Option[Boolean],
-             postAction: () => Unit = () => ()
+    inputs: Module,
+    options: BuildOptions,
+    compilerMaker: ScalaCompilerMaker,
+    docCompilerMakerOpt: Option[ScalaCompilerMaker],
+    logger: Logger,
+    crossBuilds: Boolean,
+    buildTests: Boolean,
+    partial: Option[Boolean],
+    actionableDiagnostics: Option[Boolean],
+    postAction: () => Unit = () => ()
   )(action: Either[BuildException, Builds] => Unit)(using ScalaCliInvokeData): Watcher = {
 
     val buildClient = BloopBuildClient.create(
@@ -839,15 +837,15 @@ object Build {
     *   a bloop [[Project]]
     */
   def buildProject(
-                    inputs: Module,
-                    sources: Sources,
-                    generatedSources: Seq[GeneratedSource],
-                    options: BuildOptions,
-                    compilerJvmVersionOpt: Option[Positioned[Int]],
-                    scope: Scope,
-                    logger: Logger,
-                    artifacts: Artifacts,
-                    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
+    inputs: Module,
+    sources: Sources,
+    generatedSources: Seq[GeneratedSource],
+    options: BuildOptions,
+    compilerJvmVersionOpt: Option[Positioned[Int]],
+    scope: Scope,
+    logger: Logger,
+    artifacts: Artifacts,
+    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
   ): Either[BuildException, Project] = either {
 
     val allSources = sources.paths.map(_._1) ++ generatedSources.map(_.generated)
@@ -1031,16 +1029,16 @@ object Build {
   }
 
   def prepareBuild(
-                    inputs: Module,
-                    sources: Sources,
-                    generatedSources: Seq[GeneratedSource],
-                    options: BuildOptions,
-                    compilerJvmVersionOpt: Option[Positioned[Int]],
-                    scope: Scope,
-                    compiler: ScalaCompiler,
-                    logger: Logger,
-                    buildClient: BloopBuildClient,
-                    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
+    inputs: Module,
+    sources: Sources,
+    generatedSources: Seq[GeneratedSource],
+    options: BuildOptions,
+    compilerJvmVersionOpt: Option[Positioned[Int]],
+    scope: Scope,
+    compiler: ScalaCompiler,
+    logger: Logger,
+    buildClient: BloopBuildClient,
+    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
   ): Either[BuildException, (os.Path, Option[ScalaParameters], Artifacts, Project, Boolean)] =
     either {
 
@@ -1112,15 +1110,15 @@ object Build {
     }
 
   def buildOnce(
-                 inputs: Module,
-                 sources: Sources,
-                 generatedSources: Seq[GeneratedSource],
-                 options: BuildOptions,
-                 scope: Scope,
-                 logger: Logger,
-                 buildClient: BloopBuildClient,
-                 compiler: ScalaCompiler,
-                 partialOpt: Option[Boolean]
+    inputs: Module,
+    sources: Sources,
+    generatedSources: Seq[GeneratedSource],
+    options: BuildOptions,
+    scope: Scope,
+    logger: Logger,
+    buildClient: BloopBuildClient,
+    compiler: ScalaCompiler,
+    partialOpt: Option[Boolean]
   ): Either[BuildException, Build] = either {
 
     if (options.platform.value == Platform.Native)
@@ -1282,14 +1280,14 @@ object Build {
     else path.toString
 
   private def jmhBuild(
-                        inputs: Module,
-                        build: Build.Successful,
-                        logger: Logger,
-                        javaCommand: String,
-                        buildClient: BloopBuildClient,
-                        compiler: ScalaCompiler,
-                        buildTests: Boolean,
-                        actionableDiagnostics: Option[Boolean]
+    inputs: Module,
+    build: Build.Successful,
+    logger: Logger,
+    javaCommand: String,
+    buildClient: BloopBuildClient,
+    compiler: ScalaCompiler,
+    buildTests: Boolean,
+    actionableDiagnostics: Option[Boolean]
   )(using ScalaCliInvokeData): Either[BuildException, Option[Build]] = either {
     val jmhProjectName = inputs.projectName.name + "_jmh"
     val jmhOutputDir   = inputs.workspace / Constants.workspaceDirName / jmhProjectName

modules/build/src/main/scala/scala/build/CrossSources.scala

@@ -156,12 +156,12 @@ object CrossSources {
     *   a CrossSources and Inputs which contains element processed from using directives
     */
   def forModuleInputs(
-                       inputs: Module,
-                       preprocessors: Seq[Preprocessor],
-                       logger: Logger,
-                       suppressWarningOptions: SuppressWarningOptions,
-                       exclude: Seq[Positioned[String]] = Nil,
-                       maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
+    inputs: Module,
+    preprocessors: Seq[Preprocessor],
+    logger: Logger,
+    suppressWarningOptions: SuppressWarningOptions,
+    exclude: Seq[Positioned[String]] = Nil,
+    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
   )(using ScalaCliInvokeData): Either[BuildException, (CrossSources, Module)] = either {
 
     def preprocessSources(elems: Seq[SingleElement])
@@ -379,8 +379,8 @@ object CrossSources {
     *   the resource directories that should be added to the classpath
     */
   private def resolveResourceDirs(
-                                   allInputs: Module,
-                                   preprocessedSources: Seq[PreprocessedSource]
+    allInputs: Module,
+    preprocessedSources: Seq[PreprocessedSource]
   ): Seq[WithBuildRequirements[os.Path]] = {
     val fromInputs = allInputs.elements
       .collect { case r: ResourceDirectory => WithBuildRequirements(BuildRequirements(), r.path) }

modules/build/src/main/scala/scala/build/bsp/BspImpl.scala

@@ -240,9 +240,9 @@ final class BspImpl(
     reloadableOptions: BspReloadableOptions
   ): Either[(BuildException, ProjectName), Unit] = {
     def doBuildOnce(
-                     moduleInputs: Module,
-                     data: PreBuildData,
-                     scope: Scope
+      moduleInputs: Module,
+      data: PreBuildData,
+      scope: Scope
     ): Either[(BuildException, ProjectName), Build] =
       Build.buildOnce(
         inputs = moduleInputs,
@@ -788,9 +788,9 @@ object BspImpl {
   private final case class PreBuildProject(prebuildModules: Seq[PreBuildModule])
 
   private final case class PreBuildModule(
-                                           inputs: Module,
-                                           mainScope: PreBuildData,
-                                           testScope: PreBuildData,
-                                           diagnostics: Seq[Diagnostic]
+    inputs: Module,
+    mainScope: PreBuildData,
+    testScope: PreBuildData,
+    diagnostics: Seq[Diagnostic]
   )
 }

modules/build/src/main/scala/scala/build/input/Module.scala

@@ -430,21 +430,21 @@ object Module {
   }
 
   def apply(
-             args: Seq[String],
-             cwd: os.Path,
-             defaultInputs: () => Option[Module] = () => None,
-             download: String => Either[String, Array[Byte]] = _ => Left("URL not supported"),
-             stdinOpt: => Option[Array[Byte]] = None,
-             scriptSnippetList: List[String] = List.empty,
-             scalaSnippetList: List[String] = List.empty,
-             javaSnippetList: List[String] = List.empty,
-             markdownSnippetList: List[String] = List.empty,
-             acceptFds: Boolean = false,
-             forcedWorkspace: Option[os.Path] = None,
-             enableMarkdown: Boolean = false,
-             allowRestrictedFeatures: Boolean,
-             extraClasspathWasPassed: Boolean,
-             forcedProjectName: Option[ProjectName] = None
+    args: Seq[String],
+    cwd: os.Path,
+    defaultInputs: () => Option[Module] = () => None,
+    download: String => Either[String, Array[Byte]] = _ => Left("URL not supported"),
+    stdinOpt: => Option[Array[Byte]] = None,
+    scriptSnippetList: List[String] = List.empty,
+    scalaSnippetList: List[String] = List.empty,
+    javaSnippetList: List[String] = List.empty,
+    markdownSnippetList: List[String] = List.empty,
+    acceptFds: Boolean = false,
+    forcedWorkspace: Option[os.Path] = None,
+    enableMarkdown: Boolean = false,
+    allowRestrictedFeatures: Boolean,
+    extraClasspathWasPassed: Boolean,
+    forcedProjectName: Option[ProjectName] = None
   )(using ScalaCliInvokeData): Either[BuildException, Module] =
     if (
       args.isEmpty && scriptSnippetList.isEmpty && scalaSnippetList.isEmpty && javaSnippetList.isEmpty &&

modules/build/src/main/scala/scala/build/input/compose/InputsComposer.scala

@@ -112,25 +112,25 @@ object InputsComposer {
       case _ => Left(ModuleConfigurationError(s"${Keys.modules}.$key must be a table"))
 }
 
-/** Creates [[Module]] given the initial arguments passed to the command, Looks for module
-  * config .toml file and if found composes module inputs according to the defined config, otherwise
-  * if module config is not found or if [[allowForbiddenFeatures]] is not set, returns only one
-  * basic module created from initial args (see [[simpleInputs]])
+/** Creates [[Module]] given the initial arguments passed to the command, Looks for module config
+  * .toml file and if found composes module inputs according to the defined config, otherwise if
+  * module config is not found or if [[allowForbiddenFeatures]] is not set, returns only one basic
+  * module created from initial args (see [[simpleInputs]])
   *
   * @param args
-  * initial args passed to command
+  *   initial args passed to command
   * @param cwd
-  * working directory
+  *   working directory
   * @param inputsFromArgs
-  * function that proceeds with the whole [[Module]] creation flow (validating elements,
-  * etc.) this takes into account options passed from CLI like in SharedOptions
+  *   function that proceeds with the whole [[Module]] creation flow (validating elements, etc.)
+  *   this takes into account options passed from CLI like in SharedOptions
   * @param allowForbiddenFeatures
   */
 final case class InputsComposer(
-                                 args: Seq[String],
-                                 cwd: os.Path,
-                                 inputsFromArgs: (Seq[String], Option[ProjectName]) => Either[BuildException, Module],
-                                 allowForbiddenFeatures: Boolean
+  args: Seq[String],
+  cwd: os.Path,
+  inputsFromArgs: (Seq[String], Option[ProjectName]) => Either[BuildException, Module],
+  allowForbiddenFeatures: Boolean
 ) {
   import InputsComposer.*