From d94503446ea28507d2a59e5d4c0e632ac52f5649 Mon Sep 17 00:00:00 2001 From: Alexandre Archambault Date: Tue, 14 May 2019 11:43:04 +0200 Subject: [PATCH] Make CoursierConfiguration easier to edit --- .../lmcoursier/CoursierConfiguration.scala | 366 ++++++++++++++---- 1 file changed, 286 insertions(+), 80 deletions(-) diff --git a/modules/lm-coursier/src/main/scala/lmcoursier/CoursierConfiguration.scala b/modules/lm-coursier/src/main/scala/lmcoursier/CoursierConfiguration.scala index c7a08440c..2c24538df 100644 --- a/modules/lm-coursier/src/main/scala/lmcoursier/CoursierConfiguration.scala +++ b/modules/lm-coursier/src/main/scala/lmcoursier/CoursierConfiguration.scala @@ -1,131 +1,337 @@ /** - * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + * This code USED TO BE generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. */ -// DO NOT EDIT MANUALLY +// DO EDIT MANUALLY from now on package lmcoursier + +import java.io.File + +import lmcoursier.credentials.Credentials +import lmcoursier.definitions.{Authentication, CacheLogger, Project} +import sbt.librarymanagement.Resolver +import xsbti.Logger + final class CoursierConfiguration private ( - val log: Option[xsbti.Logger], - val resolvers: Vector[sbt.librarymanagement.Resolver], + val log: Option[Logger], + val resolvers: Vector[Resolver], val parallelDownloads: Int, val maxIterations: Int, val sbtScalaOrganization: Option[String], val sbtScalaVersion: Option[String], - val sbtScalaJars: Vector[java.io.File], - val interProjectDependencies: Vector[lmcoursier.definitions.Project], + val sbtScalaJars: Vector[File], + val interProjectDependencies: Vector[Project], val excludeDependencies: Vector[(String, String)], - val fallbackDependencies: Vector[lmcoursier.FallbackDependency], + val fallbackDependencies: Vector[FallbackDependency], val autoScalaLibrary: Boolean, val hasClassifiers: Boolean, val classifiers: Vector[String], val mavenProfiles: Vector[String], val scalaOrganization: Option[String], val scalaVersion: Option[String], - val authenticationByRepositoryId: Vector[(String, lmcoursier.definitions.Authentication)], - val credentials: Seq[lmcoursier.credentials.Credentials], - val logger: Option[lmcoursier.definitions.CacheLogger], - val cache: Option[java.io.File]) extends Serializable { + val authenticationByRepositoryId: Vector[(String, Authentication)], + val credentials: Seq[Credentials], + val logger: Option[CacheLogger], + val cache: Option[File] +) extends Serializable { - private def this() = this(None, sbt.librarymanagement.Resolver.defaults, 6, 100, None, None, Vector.empty, Vector.empty, Vector.empty, Vector.empty, true, false, Vector.empty, Vector.empty, None, None, Vector.empty, Vector.empty, None, None) + private def this() = + this( + None, + Resolver.defaults, + 6, + 100, + None, + None, + Vector.empty, + Vector.empty, + Vector.empty, + Vector.empty, + true, + false, + Vector.empty, + Vector.empty, + None, + None, + Vector.empty, + Vector.empty, + None, + None + ) - override def equals(o: Any): Boolean = o match { - case x: CoursierConfiguration => (this.log == x.log) && (this.resolvers == x.resolvers) && (this.parallelDownloads == x.parallelDownloads) && (this.maxIterations == x.maxIterations) && (this.sbtScalaOrganization == x.sbtScalaOrganization) && (this.sbtScalaVersion == x.sbtScalaVersion) && (this.sbtScalaJars == x.sbtScalaJars) && (this.interProjectDependencies == x.interProjectDependencies) && (this.excludeDependencies == x.excludeDependencies) && (this.fallbackDependencies == x.fallbackDependencies) && (this.autoScalaLibrary == x.autoScalaLibrary) && (this.hasClassifiers == x.hasClassifiers) && (this.classifiers == x.classifiers) && (this.mavenProfiles == x.mavenProfiles) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaVersion == x.scalaVersion) && (this.authenticationByRepositoryId == x.authenticationByRepositoryId) && (this.credentials == x.credentials) && (this.logger == x.logger) && (this.cache == x.cache) - case _ => false - } + override def equals(o: Any): Boolean = + o match { + case other: CoursierConfiguration => + log == other.log && + resolvers == other.resolvers && + parallelDownloads == other.parallelDownloads && + maxIterations == other.maxIterations && + sbtScalaOrganization == other.sbtScalaOrganization && + sbtScalaVersion == other.sbtScalaVersion && + sbtScalaJars == other.sbtScalaJars && + interProjectDependencies == other.interProjectDependencies && + excludeDependencies == other.excludeDependencies && + fallbackDependencies == other.fallbackDependencies && + autoScalaLibrary == other.autoScalaLibrary && + hasClassifiers == other.hasClassifiers && + classifiers == other.classifiers && + mavenProfiles == other.mavenProfiles && + scalaOrganization == other.scalaOrganization && + scalaVersion == other.scalaVersion && + authenticationByRepositoryId == other.authenticationByRepositoryId && + credentials == other.credentials && + logger == other.logger && + cache == other.cache + case _ => false + } + override def hashCode: Int = { - 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "lmcoursier.CoursierConfiguration".##) + log.##) + resolvers.##) + parallelDownloads.##) + maxIterations.##) + sbtScalaOrganization.##) + sbtScalaVersion.##) + sbtScalaJars.##) + interProjectDependencies.##) + excludeDependencies.##) + fallbackDependencies.##) + autoScalaLibrary.##) + hasClassifiers.##) + classifiers.##) + mavenProfiles.##) + scalaOrganization.##) + scalaVersion.##) + authenticationByRepositoryId.##) + credentials.##) + logger.##) + cache.##) + var code = 37 * (17 + "lmcoursier.CoursierConfiguration".##) + code = 37 * (code + log.##) + code = 37 * (code + resolvers.##) + code = 37 * (code + parallelDownloads.##) + code = 37 * (code + maxIterations.##) + code = 37 * (code + sbtScalaOrganization.##) + code = 37 * (code + sbtScalaVersion.##) + code = 37 * (code + sbtScalaJars.##) + code = 37 * (code + interProjectDependencies.##) + code = 37 * (code + excludeDependencies.##) + code = 37 * (code + fallbackDependencies.##) + code = 37 * (code + autoScalaLibrary.##) + code = 37 * (code + hasClassifiers.##) + code = 37 * (code + classifiers.##) + code = 37 * (code + mavenProfiles.##) + code = 37 * (code + scalaOrganization.##) + code = 37 * (code + scalaVersion.##) + code = 37 * (code + authenticationByRepositoryId.##) + code = 37 * (code + credentials.##) + code = 37 * (code + logger.##) + code = 37 * (code + cache.##) + code } - override def toString: String = { - "CoursierConfiguration(" + log + ", " + resolvers + ", " + parallelDownloads + ", " + maxIterations + ", " + sbtScalaOrganization + ", " + sbtScalaVersion + ", " + sbtScalaJars + ", " + interProjectDependencies + ", " + excludeDependencies + ", " + fallbackDependencies + ", " + autoScalaLibrary + ", " + hasClassifiers + ", " + classifiers + ", " + mavenProfiles + ", " + scalaOrganization + ", " + scalaVersion + ", " + authenticationByRepositoryId + ", " + credentials + ", " + logger + ", " + cache + ")" - } - private[this] def copy(log: Option[xsbti.Logger] = log, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers, parallelDownloads: Int = parallelDownloads, maxIterations: Int = maxIterations, sbtScalaOrganization: Option[String] = sbtScalaOrganization, sbtScalaVersion: Option[String] = sbtScalaVersion, sbtScalaJars: Vector[java.io.File] = sbtScalaJars, interProjectDependencies: Vector[lmcoursier.definitions.Project] = interProjectDependencies, excludeDependencies: Vector[(String, String)] = excludeDependencies, fallbackDependencies: Vector[lmcoursier.FallbackDependency] = fallbackDependencies, autoScalaLibrary: Boolean = autoScalaLibrary, hasClassifiers: Boolean = hasClassifiers, classifiers: Vector[String] = classifiers, mavenProfiles: Vector[String] = mavenProfiles, scalaOrganization: Option[String] = scalaOrganization, scalaVersion: Option[String] = scalaVersion, authenticationByRepositoryId: Vector[(String, lmcoursier.definitions.Authentication)] = authenticationByRepositoryId, credentials: Seq[lmcoursier.credentials.Credentials] = credentials, logger: Option[lmcoursier.definitions.CacheLogger] = logger, cache: Option[java.io.File] = cache): CoursierConfiguration = { - new CoursierConfiguration(log, resolvers, parallelDownloads, maxIterations, sbtScalaOrganization, sbtScalaVersion, sbtScalaJars, interProjectDependencies, excludeDependencies, fallbackDependencies, autoScalaLibrary, hasClassifiers, classifiers, mavenProfiles, scalaOrganization, scalaVersion, authenticationByRepositoryId, credentials, logger, cache) - } - def withLog(log: Option[xsbti.Logger]): CoursierConfiguration = { + + override def toString: String = + s"CoursierConfiguration($log, $resolvers, $parallelDownloads, $maxIterations, $sbtScalaOrganization, $sbtScalaVersion, $sbtScalaJars, $interProjectDependencies, $excludeDependencies, $fallbackDependencies, $autoScalaLibrary, $hasClassifiers, $classifiers, $mavenProfiles, $scalaOrganization, $scalaVersion, $authenticationByRepositoryId, $credentials, $logger, $cache)" + + private[this] def copy( + log: Option[Logger] = log, + resolvers: Vector[Resolver] = resolvers, + parallelDownloads: Int = parallelDownloads, + maxIterations: Int = maxIterations, + sbtScalaOrganization: Option[String] = sbtScalaOrganization, + sbtScalaVersion: Option[String] = sbtScalaVersion, + sbtScalaJars: Vector[File] = sbtScalaJars, + interProjectDependencies: Vector[Project] = interProjectDependencies, + excludeDependencies: Vector[(String, String)] = excludeDependencies, + fallbackDependencies: Vector[FallbackDependency] = fallbackDependencies, + autoScalaLibrary: Boolean = autoScalaLibrary, + hasClassifiers: Boolean = hasClassifiers, + classifiers: Vector[String] = classifiers, + mavenProfiles: Vector[String] = mavenProfiles, + scalaOrganization: Option[String] = scalaOrganization, + scalaVersion: Option[String] = scalaVersion, + authenticationByRepositoryId: Vector[(String, Authentication)] = authenticationByRepositoryId, + credentials: Seq[Credentials] = credentials, + logger: Option[CacheLogger] = logger, + cache: Option[File] = cache + ): CoursierConfiguration = + new CoursierConfiguration( + log, + resolvers, + parallelDownloads, + maxIterations, + sbtScalaOrganization, + sbtScalaVersion, + sbtScalaJars, + interProjectDependencies, + excludeDependencies, + fallbackDependencies, + autoScalaLibrary, + hasClassifiers, + classifiers, + mavenProfiles, + scalaOrganization, + scalaVersion, + authenticationByRepositoryId, + credentials, + logger, + cache + ) + + def withLog(log: Option[Logger]): CoursierConfiguration = copy(log = log) - } - def withLog(log: xsbti.Logger): CoursierConfiguration = { + + def withLog(log: Logger): CoursierConfiguration = copy(log = Option(log)) - } - def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): CoursierConfiguration = { + + def withResolvers(resolvers: Vector[Resolver]): CoursierConfiguration = copy(resolvers = resolvers) - } - def withParallelDownloads(parallelDownloads: Int): CoursierConfiguration = { + + def withParallelDownloads(parallelDownloads: Int): CoursierConfiguration = copy(parallelDownloads = parallelDownloads) - } - def withMaxIterations(maxIterations: Int): CoursierConfiguration = { + + def withMaxIterations(maxIterations: Int): CoursierConfiguration = copy(maxIterations = maxIterations) - } - def withSbtScalaOrganization(sbtScalaOrganization: Option[String]): CoursierConfiguration = { + + def withSbtScalaOrganization(sbtScalaOrganization: Option[String]): CoursierConfiguration = copy(sbtScalaOrganization = sbtScalaOrganization) - } - def withSbtScalaOrganization(sbtScalaOrganization: String): CoursierConfiguration = { + + def withSbtScalaOrganization(sbtScalaOrganization: String): CoursierConfiguration = copy(sbtScalaOrganization = Option(sbtScalaOrganization)) - } - def withSbtScalaVersion(sbtScalaVersion: Option[String]): CoursierConfiguration = { + + def withSbtScalaVersion(sbtScalaVersion: Option[String]): CoursierConfiguration = copy(sbtScalaVersion = sbtScalaVersion) - } - def withSbtScalaVersion(sbtScalaVersion: String): CoursierConfiguration = { + + def withSbtScalaVersion(sbtScalaVersion: String): CoursierConfiguration = copy(sbtScalaVersion = Option(sbtScalaVersion)) - } - def withSbtScalaJars(sbtScalaJars: Vector[java.io.File]): CoursierConfiguration = { + + def withSbtScalaJars(sbtScalaJars: Vector[File]): CoursierConfiguration = copy(sbtScalaJars = sbtScalaJars) - } - def withInterProjectDependencies(interProjectDependencies: Vector[lmcoursier.definitions.Project]): CoursierConfiguration = { + + def withInterProjectDependencies(interProjectDependencies: Vector[Project]): CoursierConfiguration = copy(interProjectDependencies = interProjectDependencies) - } - def withExcludeDependencies(excludeDependencies: Vector[(String, String)]): CoursierConfiguration = { + + def withExcludeDependencies(excludeDependencies: Vector[(String, String)]): CoursierConfiguration = copy(excludeDependencies = excludeDependencies) - } - def withFallbackDependencies(fallbackDependencies: Vector[lmcoursier.FallbackDependency]): CoursierConfiguration = { + + def withFallbackDependencies(fallbackDependencies: Vector[FallbackDependency]): CoursierConfiguration = copy(fallbackDependencies = fallbackDependencies) - } - def withAutoScalaLibrary(autoScalaLibrary: Boolean): CoursierConfiguration = { + + def withAutoScalaLibrary(autoScalaLibrary: Boolean): CoursierConfiguration = copy(autoScalaLibrary = autoScalaLibrary) - } - def withHasClassifiers(hasClassifiers: Boolean): CoursierConfiguration = { + + def withHasClassifiers(hasClassifiers: Boolean): CoursierConfiguration = copy(hasClassifiers = hasClassifiers) - } - def withClassifiers(classifiers: Vector[String]): CoursierConfiguration = { + + def withClassifiers(classifiers: Vector[String]): CoursierConfiguration = copy(classifiers = classifiers) - } - def withMavenProfiles(mavenProfiles: Vector[String]): CoursierConfiguration = { + + def withMavenProfiles(mavenProfiles: Vector[String]): CoursierConfiguration = copy(mavenProfiles = mavenProfiles) - } - def withScalaOrganization(scalaOrganization: Option[String]): CoursierConfiguration = { + + def withScalaOrganization(scalaOrganization: Option[String]): CoursierConfiguration = copy(scalaOrganization = scalaOrganization) - } - def withScalaOrganization(scalaOrganization: String): CoursierConfiguration = { + + def withScalaOrganization(scalaOrganization: String): CoursierConfiguration = copy(scalaOrganization = Option(scalaOrganization)) - } - def withScalaVersion(scalaVersion: Option[String]): CoursierConfiguration = { + + def withScalaVersion(scalaVersion: Option[String]): CoursierConfiguration = copy(scalaVersion = scalaVersion) - } - def withScalaVersion(scalaVersion: String): CoursierConfiguration = { + + def withScalaVersion(scalaVersion: String): CoursierConfiguration = copy(scalaVersion = Option(scalaVersion)) - } - def withAuthenticationByRepositoryId(authenticationByRepositoryId: Vector[(String, lmcoursier.definitions.Authentication)]): CoursierConfiguration = { + + def withAuthenticationByRepositoryId(authenticationByRepositoryId: Vector[(String, Authentication)]): CoursierConfiguration = copy(authenticationByRepositoryId = authenticationByRepositoryId) - } - def withCredentials(credentials: Seq[lmcoursier.credentials.Credentials]): CoursierConfiguration = { + + def withCredentials(credentials: Seq[Credentials]): CoursierConfiguration = copy(credentials = credentials) - } - def withLogger(logger: Option[lmcoursier.definitions.CacheLogger]): CoursierConfiguration = { + + def withLogger(logger: Option[CacheLogger]): CoursierConfiguration = copy(logger = logger) - } - def withLogger(logger: lmcoursier.definitions.CacheLogger): CoursierConfiguration = { + + def withLogger(logger: CacheLogger): CoursierConfiguration = copy(logger = Option(logger)) - } - def withCache(cache: Option[java.io.File]): CoursierConfiguration = { + + def withCache(cache: Option[File]): CoursierConfiguration = copy(cache = cache) - } - def withCache(cache: java.io.File): CoursierConfiguration = { + + def withCache(cache: File): CoursierConfiguration = copy(cache = Option(cache)) - } } + object CoursierConfiguration { + + def apply(): CoursierConfiguration = + new CoursierConfiguration() + + def apply( + log: Option[Logger], + resolvers: Vector[Resolver], + parallelDownloads: Int, + maxIterations: Int, + sbtScalaOrganization: Option[String], + sbtScalaVersion: Option[String], + sbtScalaJars: Vector[File], + interProjectDependencies: Vector[Project], + excludeDependencies: Vector[(String, String)], + fallbackDependencies: Vector[FallbackDependency], + autoScalaLibrary: Boolean, + hasClassifiers: Boolean, + classifiers: Vector[String], + mavenProfiles: Vector[String], + scalaOrganization: Option[String], + scalaVersion: Option[String], + authenticationByRepositoryId: Vector[(String, Authentication)], + credentials: Seq[Credentials], + logger: Option[CacheLogger], + cache: Option[File] + ): CoursierConfiguration = + new CoursierConfiguration( + log, + resolvers, + parallelDownloads, + maxIterations, + sbtScalaOrganization, + sbtScalaVersion, + sbtScalaJars, + interProjectDependencies, + excludeDependencies, + fallbackDependencies, + autoScalaLibrary, + hasClassifiers, + classifiers, + mavenProfiles, + scalaOrganization, + scalaVersion, + authenticationByRepositoryId, + credentials, + logger, + cache + ) - def apply(): CoursierConfiguration = new CoursierConfiguration() - def apply(log: Option[xsbti.Logger], resolvers: Vector[sbt.librarymanagement.Resolver], parallelDownloads: Int, maxIterations: Int, sbtScalaOrganization: Option[String], sbtScalaVersion: Option[String], sbtScalaJars: Vector[java.io.File], interProjectDependencies: Vector[lmcoursier.definitions.Project], excludeDependencies: Vector[(String, String)], fallbackDependencies: Vector[lmcoursier.FallbackDependency], autoScalaLibrary: Boolean, hasClassifiers: Boolean, classifiers: Vector[String], mavenProfiles: Vector[String], scalaOrganization: Option[String], scalaVersion: Option[String], authenticationByRepositoryId: Vector[(String, lmcoursier.definitions.Authentication)], credentials: Seq[lmcoursier.credentials.Credentials], logger: Option[lmcoursier.definitions.CacheLogger], cache: Option[java.io.File]): CoursierConfiguration = new CoursierConfiguration(log, resolvers, parallelDownloads, maxIterations, sbtScalaOrganization, sbtScalaVersion, sbtScalaJars, interProjectDependencies, excludeDependencies, fallbackDependencies, autoScalaLibrary, hasClassifiers, classifiers, mavenProfiles, scalaOrganization, scalaVersion, authenticationByRepositoryId, credentials, logger, cache) - def apply(log: xsbti.Logger, resolvers: Vector[sbt.librarymanagement.Resolver], parallelDownloads: Int, maxIterations: Int, sbtScalaOrganization: String, sbtScalaVersion: String, sbtScalaJars: Vector[java.io.File], interProjectDependencies: Vector[lmcoursier.definitions.Project], excludeDependencies: Vector[(String, String)], fallbackDependencies: Vector[lmcoursier.FallbackDependency], autoScalaLibrary: Boolean, hasClassifiers: Boolean, classifiers: Vector[String], mavenProfiles: Vector[String], scalaOrganization: String, scalaVersion: String, authenticationByRepositoryId: Vector[(String, lmcoursier.definitions.Authentication)], credentials: Seq[lmcoursier.credentials.Credentials], logger: lmcoursier.definitions.CacheLogger, cache: java.io.File): CoursierConfiguration = new CoursierConfiguration(Option(log), resolvers, parallelDownloads, maxIterations, Option(sbtScalaOrganization), Option(sbtScalaVersion), sbtScalaJars, interProjectDependencies, excludeDependencies, fallbackDependencies, autoScalaLibrary, hasClassifiers, classifiers, mavenProfiles, Option(scalaOrganization), Option(scalaVersion), authenticationByRepositoryId, credentials, Option(logger), Option(cache)) + def apply( + log: Logger, + resolvers: Vector[Resolver], + parallelDownloads: Int, + maxIterations: Int, + sbtScalaOrganization: String, + sbtScalaVersion: String, + sbtScalaJars: Vector[File], + interProjectDependencies: Vector[Project], + excludeDependencies: Vector[(String, String)], + fallbackDependencies: Vector[FallbackDependency], + autoScalaLibrary: Boolean, + hasClassifiers: Boolean, + classifiers: Vector[String], + mavenProfiles: Vector[String], + scalaOrganization: String, + scalaVersion: String, + authenticationByRepositoryId: Vector[(String, Authentication)], + credentials: Seq[Credentials], + logger: CacheLogger, + cache: File + ): CoursierConfiguration = + new CoursierConfiguration( + Option(log), + resolvers, + parallelDownloads, + maxIterations, + Option(sbtScalaOrganization), + Option(sbtScalaVersion), + sbtScalaJars, + interProjectDependencies, + excludeDependencies, + fallbackDependencies, + autoScalaLibrary, + hasClassifiers, + classifiers, + mavenProfiles, + Option(scalaOrganization), + Option(scalaVersion), + authenticationByRepositoryId, + credentials, + Option(logger), + Option(cache) + ) }