From 4ac724e529b807c2b86b435439e5d831713cbcbf Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 1 Jul 2017 19:27:54 -0400 Subject: [PATCH] bump to sbt-contraband 0.3.0-M7 and latest util --- build.sbt | 5 +- .../ConfigurationReportLite.scala | 36 ++++++ .../ExternalIvyConfiguration.scala | 56 +++++++++ .../InlineConfiguration.scala | 78 +++++++++++++ .../InlineIvyConfiguration.scala | 92 +++++++++++++++ .../librarymanagement/IvyConfiguration.scala | 29 +++++ .../internal/librarymanagement/IvyPaths.scala | 40 +++++++ .../RetrieveConfiguration.scala | 45 ++++++++ .../librarymanagement/UpdateReportLite.scala | 32 ++++++ .../sbt/librarymanagement/Artifact.scala | 61 ++++++++++ .../librarymanagement/ArtifactFormats.scala | 41 +++++++ .../ArtifactTypeFilter.scala | 43 +++++++ .../ArtifactTypeFilterFormats.scala | 29 +++++ .../sbt/librarymanagement/Binary.scala | 43 +++++++ .../sbt/librarymanagement/BinaryFormats.scala | 29 +++++ .../sbt/librarymanagement/Caller.scala | 56 +++++++++ .../sbt/librarymanagement/CallerFormats.scala | 39 +++++++ .../librarymanagement/ChainedResolver.scala | 36 ++++++ .../ChainedResolverFormats.scala | 29 +++++ .../sbt/librarymanagement/Checksum.scala | 36 ++++++ .../librarymanagement/ChecksumFormats.scala | 29 +++++ .../sbt/librarymanagement/Configuration.scala | 50 +++++++++ .../ConfigurationFormats.scala | 35 ++++++ .../ConfigurationReport.scala | 46 ++++++++ .../ConfigurationReportFormats.scala | 31 +++++ .../ConfigurationReportLiteFormats.scala | 29 +++++ .../librarymanagement/ConflictManager.scala | 42 +++++++ .../ConflictManagerFormats.scala | 31 +++++ .../sbt/librarymanagement/Constant.scala | 34 ++++++ .../librarymanagement/ConstantFormats.scala | 27 +++++ .../sbt/librarymanagement/CrossVersion.scala | 26 +++++ .../CrossVersionFormats.scala | 11 ++ .../sbt/librarymanagement/Developer.scala | 44 ++++++++ .../librarymanagement/DeveloperFormats.scala | 33 ++++++ .../sbt/librarymanagement/Disabled.scala | 30 +++++ .../librarymanagement/DisabledFormats.scala | 27 +++++ .../ExternalIvyConfigurationFormats.scala | 37 ++++++ .../librarymanagement/FileConfiguration.scala | 41 +++++++ .../FileConfigurationFormats.scala | 29 +++++ .../librarymanagement/FileRepository.scala | 43 +++++++ .../FileRepositoryFormats.scala | 31 +++++ .../sbt/librarymanagement/Full.scala | 43 +++++++ .../sbt/librarymanagement/FullFormats.scala | 29 +++++ .../sbt/librarymanagement/InclExclRule.scala | 58 ++++++++++ .../InclExclRuleFormats.scala | 35 ++++++ .../InlineConfigurationFormats.scala | 47 ++++++++ .../InlineIvyConfigurationFormats.scala | 47 ++++++++ .../IvyConfigurationFormats.scala | 11 ++ .../IvyFileConfiguration.scala | 48 ++++++++ .../IvyFileConfigurationFormats.scala | 33 ++++++ .../librarymanagement/IvyPathsFormats.scala | 29 +++++ .../sbt/librarymanagement/IvyScala.scala | 61 ++++++++++ .../librarymanagement/IvyScalaFormats.scala | 41 +++++++ .../KeyFileAuthentication.scala | 44 ++++++++ .../KeyFileAuthenticationFormats.scala | 31 +++++ .../LibraryManagementCodec.scala | 66 +++++++++++ .../sbt/librarymanagement/MavenCache.scala | 50 +++++++++ .../librarymanagement/MavenCacheFormats.scala | 33 ++++++ .../sbt/librarymanagement/MavenRepo.scala | 41 +++++++ .../librarymanagement/MavenRepoFormats.scala | 31 +++++ .../librarymanagement/MavenRepository.scala | 29 +++++ .../MavenRepositoryFormats.scala | 11 ++ .../ModuleConfiguration.scala | 45 ++++++++ .../ModuleConfigurationFormats.scala | 33 ++++++ .../sbt/librarymanagement/ModuleID.scala | 81 +++++++++++++ .../librarymanagement/ModuleIDFormats.scala | 51 +++++++++ .../sbt/librarymanagement/ModuleInfo.scala | 66 +++++++++++ .../librarymanagement/ModuleInfoFormats.scala | 43 +++++++ .../sbt/librarymanagement/ModuleReport.scala | 106 ++++++++++++++++++ .../ModuleReportFormats.scala | 61 ++++++++++ .../librarymanagement/ModuleSettings.scala | 27 +++++ .../ModuleSettingsFormats.scala | 11 ++ .../OrganizationArtifactReport.scala | 51 +++++++++ .../OrganizationArtifactReportFormats.scala | 31 +++++ .../PasswordAuthentication.scala | 40 +++++++ .../PasswordAuthenticationFormats.scala | 29 +++++ .../sbt/librarymanagement/Patch.scala | 33 ++++++ .../sbt/librarymanagement/PatchFormats.scala | 27 +++++ .../sbt/librarymanagement/Patterns.scala | 50 +++++++++ .../PatternsBasedRepository.scala | 28 +++++ .../PatternsBasedRepositoryFormats.scala | 11 ++ .../librarymanagement/PatternsFormats.scala | 35 ++++++ .../librarymanagement/PomConfiguration.scala | 48 ++++++++ .../PomConfigurationFormats.scala | 33 ++++++ .../sbt/librarymanagement/Resolver.scala | 26 +++++ .../librarymanagement/ResolverFormats.scala | 11 ++ .../RetrieveConfigurationFormats.scala | 33 ++++++ .../sbt/librarymanagement/ScmInfo.scala | 46 ++++++++ .../librarymanagement/ScmInfoFormats.scala | 31 +++++ .../librarymanagement/SftpRepository.scala | 43 +++++++ .../SftpRepositoryFormats.scala | 31 +++++ .../librarymanagement/SshAuthentication.scala | 25 +++++ .../SshAuthenticationFormats.scala | 11 ++ .../SshBasedRepository.scala | 29 +++++ .../SshBasedRepositoryFormats.scala | 11 ++ .../sbt/librarymanagement/SshConnection.scala | 50 +++++++++ .../SshConnectionFormats.scala | 31 +++++ .../sbt/librarymanagement/SshRepository.scala | 51 +++++++++ .../SshRepositoryFormats.scala | 33 ++++++ .../sbt/librarymanagement/URLRepository.scala | 36 ++++++ .../URLRepositoryFormats.scala | 29 +++++ .../UpdateConfiguration.scala | 56 +++++++++ .../UpdateConfigurationFormats.scala | 37 ++++++ .../sbt/librarymanagement/UpdateLogging.scala | 22 ++++ .../UpdateLoggingFormats.scala | 33 ++++++ .../sbt/librarymanagement/UpdateReport.scala | 52 +++++++++ .../UpdateReportFormats.scala | 33 ++++++ .../UpdateReportLiteFormats.scala | 27 +++++ .../sbt/librarymanagement/UpdateStats.scala | 44 ++++++++ .../UpdateStatsFormats.scala | 33 ++++++ .../internal/librarymanagement/IvyCache.scala | 2 +- .../librarymanagement/CrossVersionExtra.scala | 1 + .../src/test/scala/DMSerializationSpec.scala | 2 +- project/Dependencies.scala | 9 +- project/plugins.sbt | 2 +- 115 files changed, 4191 insertions(+), 8 deletions(-) create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ExternalIvyConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineIvyConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyPaths.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/RetrieveConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Artifact.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Binary.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/BinaryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Caller.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CallerFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Configuration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReport.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Constant.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConstantFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersion.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersionFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Developer.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Disabled.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DisabledFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ExternalIvyConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Full.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FullFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRule.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineIvyConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScala.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScalaFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepo.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfo.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReport.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReportFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReport.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patch.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatchFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patterns.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepositoryFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfiguration.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfigurationFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLogging.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLoggingFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReport.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportLiteFormats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStats.scala create mode 100644 librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStatsFormats.scala diff --git a/build.sbt b/build.sbt index 69bd536f6..8cb4a343f 100644 --- a/build.sbt +++ b/build.sbt @@ -69,7 +69,7 @@ lazy val lm = (project in file("librarymanagement")) launcherInterface, gigahorseOkhttp, okhttpUrlconnection, - sjsonnewScalaJson % Optional), + sjsonnewScalaJson.value % Optional), libraryDependencies ++= scalaXml.value, resourceGenerators in Compile += Def .task( @@ -79,6 +79,9 @@ lazy val lm = (project in file("librarymanagement")) (compile in Compile).value)) .taskValue, // mimaBinaryIssueFilters ++= Seq(), + managedSourceDirectories in Compile += + baseDirectory.value / "src" / "main" / "contraband-scala", + sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala", contrabandFormatsForType in generateContrabands in Compile := DatatypeConfig.getFormats, // WORKAROUND sbt/sbt#2205 include managed sources in packageSrc mappings in (Compile, packageSrc) ++= { diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala new file mode 100644 index 000000000..f63313b93 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala @@ -0,0 +1,36 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class ConfigurationReportLite private ( + val configuration: String, + val details: Vector[sbt.librarymanagement.OrganizationArtifactReport]) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: ConfigurationReportLite => (this.configuration == x.configuration) && (this.details == x.details) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "ConfigurationReportLite".##) + configuration.##) + details.##) + } + override def toString: String = { + "ConfigurationReportLite(" + configuration + ", " + details + ")" + } + protected[this] def copy(configuration: String = configuration, details: Vector[sbt.librarymanagement.OrganizationArtifactReport] = details): ConfigurationReportLite = { + new ConfigurationReportLite(configuration, details) + } + def withConfiguration(configuration: String): ConfigurationReportLite = { + copy(configuration = configuration) + } + def withDetails(details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReportLite = { + copy(details = details) + } +} +object ConfigurationReportLite { + + def apply(configuration: String, details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReportLite = new ConfigurationReportLite(configuration, details) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ExternalIvyConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ExternalIvyConfiguration.scala new file mode 100644 index 000000000..b99ec9238 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ExternalIvyConfiguration.scala @@ -0,0 +1,56 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class ExternalIvyConfiguration private ( + lock: Option[xsbti.GlobalLock], + baseDirectory: java.io.File, + log: xsbti.Logger, + updateOptions: sbt.librarymanagement.UpdateOptions, + val uri: java.net.URI, + val extraResolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.internal.librarymanagement.IvyConfiguration(lock, baseDirectory, log, updateOptions) with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: ExternalIvyConfiguration => (this.lock == x.lock) && (this.baseDirectory == x.baseDirectory) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.uri == x.uri) && (this.extraResolvers == x.extraResolvers) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ExternalIvyConfiguration".##) + lock.##) + baseDirectory.##) + log.##) + updateOptions.##) + uri.##) + extraResolvers.##) + } + override def toString: String = { + "ExternalIvyConfiguration(" + lock + ", " + baseDirectory + ", " + log + ", " + updateOptions + ", " + uri + ", " + extraResolvers + ")" + } + protected[this] def copy(lock: Option[xsbti.GlobalLock] = lock, baseDirectory: java.io.File = baseDirectory, log: xsbti.Logger = log, updateOptions: sbt.librarymanagement.UpdateOptions = updateOptions, uri: java.net.URI = uri, extraResolvers: Vector[sbt.librarymanagement.Resolver] = extraResolvers): ExternalIvyConfiguration = { + new ExternalIvyConfiguration(lock, baseDirectory, log, updateOptions, uri, extraResolvers) + } + def withLock(lock: Option[xsbti.GlobalLock]): ExternalIvyConfiguration = { + copy(lock = lock) + } + def withLock(lock: xsbti.GlobalLock): ExternalIvyConfiguration = { + copy(lock = Option(lock)) + } + def withBaseDirectory(baseDirectory: java.io.File): ExternalIvyConfiguration = { + copy(baseDirectory = baseDirectory) + } + def withLog(log: xsbti.Logger): ExternalIvyConfiguration = { + copy(log = log) + } + def withUpdateOptions(updateOptions: sbt.librarymanagement.UpdateOptions): ExternalIvyConfiguration = { + copy(updateOptions = updateOptions) + } + def withUri(uri: java.net.URI): ExternalIvyConfiguration = { + copy(uri = uri) + } + def withExtraResolvers(extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = { + copy(extraResolvers = extraResolvers) + } +} +object ExternalIvyConfiguration { + + def apply(lock: Option[xsbti.GlobalLock], baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, uri: java.net.URI, extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(lock, baseDirectory, log, updateOptions, uri, extraResolvers) + def apply(lock: xsbti.GlobalLock, baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, uri: java.net.URI, extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(Option(lock), baseDirectory, log, updateOptions, uri, extraResolvers) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineConfiguration.scala new file mode 100644 index 000000000..5ddc4a153 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineConfiguration.scala @@ -0,0 +1,78 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class InlineConfiguration private ( + validate: Boolean, + ivyScala: Option[sbt.librarymanagement.IvyScala], + val module: sbt.librarymanagement.ModuleID, + val moduleInfo: sbt.librarymanagement.ModuleInfo, + val dependencies: Vector[sbt.librarymanagement.ModuleID], + val overrides: Set[sbt.librarymanagement.ModuleID], + val excludes: Vector[sbt.librarymanagement.InclExclRule], + val ivyXML: scala.xml.NodeSeq, + val configurations: Vector[sbt.librarymanagement.Configuration], + val defaultConfiguration: Option[sbt.librarymanagement.Configuration], + val conflictManager: sbt.librarymanagement.ConflictManager) extends sbt.librarymanagement.ModuleSettings(validate, ivyScala) with Serializable { + + private def this(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID]) = this(validate, ivyScala, module, moduleInfo, dependencies, Set.empty, Vector.empty, scala.xml.NodeSeq.Empty, Vector.empty, None, sbt.librarymanagement.ConflictManager.default) + + override def equals(o: Any): Boolean = o match { + case x: InlineConfiguration => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) && (this.module == x.module) && (this.moduleInfo == x.moduleInfo) && (this.dependencies == x.dependencies) && (this.overrides == x.overrides) && (this.excludes == x.excludes) && (this.ivyXML == x.ivyXML) && (this.configurations == x.configurations) && (this.defaultConfiguration == x.defaultConfiguration) && (this.conflictManager == x.conflictManager) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "InlineConfiguration".##) + validate.##) + ivyScala.##) + module.##) + moduleInfo.##) + dependencies.##) + overrides.##) + excludes.##) + ivyXML.##) + configurations.##) + defaultConfiguration.##) + conflictManager.##) + } + override def toString: String = { + "InlineConfiguration(" + validate + ", " + ivyScala + ", " + module + ", " + moduleInfo + ", " + dependencies + ", " + overrides + ", " + excludes + ", " + ivyXML + ", " + configurations + ", " + defaultConfiguration + ", " + conflictManager + ")" + } + protected[this] def copy(validate: Boolean = validate, ivyScala: Option[sbt.librarymanagement.IvyScala] = ivyScala, module: sbt.librarymanagement.ModuleID = module, moduleInfo: sbt.librarymanagement.ModuleInfo = moduleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID] = dependencies, overrides: Set[sbt.librarymanagement.ModuleID] = overrides, excludes: Vector[sbt.librarymanagement.InclExclRule] = excludes, ivyXML: scala.xml.NodeSeq = ivyXML, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, defaultConfiguration: Option[sbt.librarymanagement.Configuration] = defaultConfiguration, conflictManager: sbt.librarymanagement.ConflictManager = conflictManager): InlineConfiguration = { + new InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager) + } + def withValidate(validate: Boolean): InlineConfiguration = { + copy(validate = validate) + } + def withIvyScala(ivyScala: Option[sbt.librarymanagement.IvyScala]): InlineConfiguration = { + copy(ivyScala = ivyScala) + } + def withIvyScala(ivyScala: sbt.librarymanagement.IvyScala): InlineConfiguration = { + copy(ivyScala = Option(ivyScala)) + } + def withModule(module: sbt.librarymanagement.ModuleID): InlineConfiguration = { + copy(module = module) + } + def withModuleInfo(moduleInfo: sbt.librarymanagement.ModuleInfo): InlineConfiguration = { + copy(moduleInfo = moduleInfo) + } + def withDependencies(dependencies: Vector[sbt.librarymanagement.ModuleID]): InlineConfiguration = { + copy(dependencies = dependencies) + } + def withOverrides(overrides: Set[sbt.librarymanagement.ModuleID]): InlineConfiguration = { + copy(overrides = overrides) + } + def withExcludes(excludes: Vector[sbt.librarymanagement.InclExclRule]): InlineConfiguration = { + copy(excludes = excludes) + } + def withIvyXML(ivyXML: scala.xml.NodeSeq): InlineConfiguration = { + copy(ivyXML = ivyXML) + } + def withConfigurations(configurations: Vector[sbt.librarymanagement.Configuration]): InlineConfiguration = { + copy(configurations = configurations) + } + def withDefaultConfiguration(defaultConfiguration: Option[sbt.librarymanagement.Configuration]): InlineConfiguration = { + copy(defaultConfiguration = defaultConfiguration) + } + def withConflictManager(conflictManager: sbt.librarymanagement.ConflictManager): InlineConfiguration = { + copy(conflictManager = conflictManager) + } +} +object InlineConfiguration extends sbt.internal.librarymanagement.InlineConfigurationFunctions { + + def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID]): InlineConfiguration = new InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, Set.empty, Vector.empty, scala.xml.NodeSeq.Empty, Vector.empty, None, sbt.librarymanagement.ConflictManager.default) + def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID]): InlineConfiguration = new InlineConfiguration(validate, Option(ivyScala), module, moduleInfo, dependencies, Set.empty, Vector.empty, scala.xml.NodeSeq.Empty, Vector.empty, None, sbt.librarymanagement.ConflictManager.default) + def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID], overrides: Set[sbt.librarymanagement.ModuleID], excludes: Vector[sbt.librarymanagement.InclExclRule], ivyXML: scala.xml.NodeSeq, configurations: Vector[sbt.librarymanagement.Configuration], defaultConfiguration: Option[sbt.librarymanagement.Configuration], conflictManager: sbt.librarymanagement.ConflictManager): InlineConfiguration = new InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager) + def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID], overrides: Set[sbt.librarymanagement.ModuleID], excludes: Vector[sbt.librarymanagement.InclExclRule], ivyXML: scala.xml.NodeSeq, configurations: Vector[sbt.librarymanagement.Configuration], defaultConfiguration: Option[sbt.librarymanagement.Configuration], conflictManager: sbt.librarymanagement.ConflictManager): InlineConfiguration = new InlineConfiguration(validate, Option(ivyScala), module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineIvyConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineIvyConfiguration.scala new file mode 100644 index 000000000..0cd006bfa --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineIvyConfiguration.scala @@ -0,0 +1,92 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class InlineIvyConfiguration private ( + lock: Option[xsbti.GlobalLock], + baseDirectory: java.io.File, + log: xsbti.Logger, + updateOptions: sbt.librarymanagement.UpdateOptions, + val paths: sbt.internal.librarymanagement.IvyPaths, + val resolvers: Vector[sbt.librarymanagement.Resolver], + val otherResolvers: Vector[sbt.librarymanagement.Resolver], + val moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], + val checksums: Vector[String], + val managedChecksums: Boolean, + val resolutionCacheDir: Option[java.io.File]) extends sbt.internal.librarymanagement.IvyConfiguration(lock, baseDirectory, log, updateOptions) with Serializable { + def this( + paths: sbt.internal.librarymanagement.IvyPaths, + resolvers: Vector[sbt.librarymanagement.Resolver], + otherResolvers: Vector[sbt.librarymanagement.Resolver], + moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], + lock: Option[xsbti.GlobalLock], + checksums: Vector[String], + managedChecksums: Boolean, + resolutionCacheDir: Option[java.io.File], + updateOptions: sbt.librarymanagement.UpdateOptions, + log: xsbti.Logger + ) = + this(lock, paths.baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, + moduleConfigurations, checksums, managedChecksums, resolutionCacheDir) + + + override def equals(o: Any): Boolean = o match { + case x: InlineIvyConfiguration => (this.lock == x.lock) && (this.baseDirectory == x.baseDirectory) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.paths == x.paths) && (this.resolvers == x.resolvers) && (this.otherResolvers == x.otherResolvers) && (this.moduleConfigurations == x.moduleConfigurations) && (this.checksums == x.checksums) && (this.managedChecksums == x.managedChecksums) && (this.resolutionCacheDir == x.resolutionCacheDir) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "InlineIvyConfiguration".##) + lock.##) + baseDirectory.##) + log.##) + updateOptions.##) + paths.##) + resolvers.##) + otherResolvers.##) + moduleConfigurations.##) + checksums.##) + managedChecksums.##) + resolutionCacheDir.##) + } + override def toString: String = { + "InlineIvyConfiguration(" + lock + ", " + baseDirectory + ", " + log + ", " + updateOptions + ", " + paths + ", " + resolvers + ", " + otherResolvers + ", " + moduleConfigurations + ", " + checksums + ", " + managedChecksums + ", " + resolutionCacheDir + ")" + } + protected[this] def copy(lock: Option[xsbti.GlobalLock] = lock, baseDirectory: java.io.File = baseDirectory, log: xsbti.Logger = log, updateOptions: sbt.librarymanagement.UpdateOptions = updateOptions, paths: sbt.internal.librarymanagement.IvyPaths = paths, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers, otherResolvers: Vector[sbt.librarymanagement.Resolver] = otherResolvers, moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration] = moduleConfigurations, checksums: Vector[String] = checksums, managedChecksums: Boolean = managedChecksums, resolutionCacheDir: Option[java.io.File] = resolutionCacheDir): InlineIvyConfiguration = { + new InlineIvyConfiguration(lock, baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir) + } + def withLock(lock: Option[xsbti.GlobalLock]): InlineIvyConfiguration = { + copy(lock = lock) + } + def withLock(lock: xsbti.GlobalLock): InlineIvyConfiguration = { + copy(lock = Option(lock)) + } + def withBaseDirectory(baseDirectory: java.io.File): InlineIvyConfiguration = { + copy(baseDirectory = baseDirectory) + } + def withLog(log: xsbti.Logger): InlineIvyConfiguration = { + copy(log = log) + } + def withUpdateOptions(updateOptions: sbt.librarymanagement.UpdateOptions): InlineIvyConfiguration = { + copy(updateOptions = updateOptions) + } + def withPaths(paths: sbt.internal.librarymanagement.IvyPaths): InlineIvyConfiguration = { + copy(paths = paths) + } + def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = { + copy(resolvers = resolvers) + } + def withOtherResolvers(otherResolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = { + copy(otherResolvers = otherResolvers) + } + def withModuleConfigurations(moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration]): InlineIvyConfiguration = { + copy(moduleConfigurations = moduleConfigurations) + } + def withChecksums(checksums: Vector[String]): InlineIvyConfiguration = { + copy(checksums = checksums) + } + def withManagedChecksums(managedChecksums: Boolean): InlineIvyConfiguration = { + copy(managedChecksums = managedChecksums) + } + def withResolutionCacheDir(resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = { + copy(resolutionCacheDir = resolutionCacheDir) + } + def withResolutionCacheDir(resolutionCacheDir: java.io.File): InlineIvyConfiguration = { + copy(resolutionCacheDir = Option(resolutionCacheDir)) + } +} +object InlineIvyConfiguration { + + def apply(lock: Option[xsbti.GlobalLock], baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, paths: sbt.internal.librarymanagement.IvyPaths, resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = new InlineIvyConfiguration(lock, baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir) + def apply(lock: xsbti.GlobalLock, baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, paths: sbt.internal.librarymanagement.IvyPaths, resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: java.io.File): InlineIvyConfiguration = new InlineIvyConfiguration(Option(lock), baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, Option(resolutionCacheDir)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyConfiguration.scala new file mode 100644 index 000000000..a50adcb0a --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyConfiguration.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +abstract class IvyConfiguration( + val lock: Option[xsbti.GlobalLock], + val baseDirectory: java.io.File, + val log: xsbti.Logger, + val updateOptions: sbt.librarymanagement.UpdateOptions) extends Serializable { + + + + + override def equals(o: Any): Boolean = o match { + case x: IvyConfiguration => (this.lock == x.lock) && (this.baseDirectory == x.baseDirectory) && (this.log == x.log) && (this.updateOptions == x.updateOptions) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "IvyConfiguration".##) + lock.##) + baseDirectory.##) + log.##) + updateOptions.##) + } + override def toString: String = { + "IvyConfiguration(" + lock + ", " + baseDirectory + ", " + log + ", " + updateOptions + ")" + } +} +object IvyConfiguration { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyPaths.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyPaths.scala new file mode 100644 index 000000000..0a5fd35ae --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyPaths.scala @@ -0,0 +1,40 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class IvyPaths private ( + val baseDirectory: java.io.File, + val ivyHome: Option[java.io.File]) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: IvyPaths => (this.baseDirectory == x.baseDirectory) && (this.ivyHome == x.ivyHome) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "IvyPaths".##) + baseDirectory.##) + ivyHome.##) + } + override def toString: String = { + "IvyPaths(" + baseDirectory + ", " + ivyHome + ")" + } + protected[this] def copy(baseDirectory: java.io.File = baseDirectory, ivyHome: Option[java.io.File] = ivyHome): IvyPaths = { + new IvyPaths(baseDirectory, ivyHome) + } + def withBaseDirectory(baseDirectory: java.io.File): IvyPaths = { + copy(baseDirectory = baseDirectory) + } + def withIvyHome(ivyHome: Option[java.io.File]): IvyPaths = { + copy(ivyHome = ivyHome) + } + def withIvyHome(ivyHome: java.io.File): IvyPaths = { + copy(ivyHome = Option(ivyHome)) + } +} +object IvyPaths { + + def apply(baseDirectory: java.io.File, ivyHome: Option[java.io.File]): IvyPaths = new IvyPaths(baseDirectory, ivyHome) + def apply(baseDirectory: java.io.File, ivyHome: java.io.File): IvyPaths = new IvyPaths(baseDirectory, Option(ivyHome)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/RetrieveConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/RetrieveConfiguration.scala new file mode 100644 index 000000000..e1be8c9db --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/RetrieveConfiguration.scala @@ -0,0 +1,45 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class RetrieveConfiguration private ( + val retrieveDirectory: java.io.File, + val outputPattern: String, + val sync: Boolean, + val configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]]) extends Serializable { + + private def this(retrieveDirectory: java.io.File, outputPattern: String) = this(retrieveDirectory, outputPattern, false, None) + + override def equals(o: Any): Boolean = o match { + case x: RetrieveConfiguration => (this.retrieveDirectory == x.retrieveDirectory) && (this.outputPattern == x.outputPattern) && (this.sync == x.sync) && (this.configurationsToRetrieve == x.configurationsToRetrieve) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "RetrieveConfiguration".##) + retrieveDirectory.##) + outputPattern.##) + sync.##) + configurationsToRetrieve.##) + } + override def toString: String = { + "RetrieveConfiguration(" + retrieveDirectory + ", " + outputPattern + ", " + sync + ", " + configurationsToRetrieve + ")" + } + protected[this] def copy(retrieveDirectory: java.io.File = retrieveDirectory, outputPattern: String = outputPattern, sync: Boolean = sync, configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]] = configurationsToRetrieve): RetrieveConfiguration = { + new RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve) + } + def withRetrieveDirectory(retrieveDirectory: java.io.File): RetrieveConfiguration = { + copy(retrieveDirectory = retrieveDirectory) + } + def withOutputPattern(outputPattern: String): RetrieveConfiguration = { + copy(outputPattern = outputPattern) + } + def withSync(sync: Boolean): RetrieveConfiguration = { + copy(sync = sync) + } + def withConfigurationsToRetrieve(configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]]): RetrieveConfiguration = { + copy(configurationsToRetrieve = configurationsToRetrieve) + } +} +object RetrieveConfiguration { + + def apply(retrieveDirectory: java.io.File, outputPattern: String): RetrieveConfiguration = new RetrieveConfiguration(retrieveDirectory, outputPattern, false, None) + def apply(retrieveDirectory: java.io.File, outputPattern: String, sync: Boolean, configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]]): RetrieveConfiguration = new RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala new file mode 100644 index 000000000..4d927be08 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala @@ -0,0 +1,32 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.librarymanagement +final class UpdateReportLite private ( + val configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: UpdateReportLite => (this.configurations == x.configurations) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (17 + "UpdateReportLite".##) + configurations.##) + } + override def toString: String = { + "UpdateReportLite(" + configurations + ")" + } + protected[this] def copy(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite] = configurations): UpdateReportLite = { + new UpdateReportLite(configurations) + } + def withConfigurations(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]): UpdateReportLite = { + copy(configurations = configurations) + } +} +object UpdateReportLite { + + def apply(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]): UpdateReportLite = new UpdateReportLite(configurations) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Artifact.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Artifact.scala new file mode 100644 index 000000000..d1848b1c0 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Artifact.scala @@ -0,0 +1,61 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class Artifact private ( + val name: String, + val `type`: String, + val extension: String, + val classifier: Option[String], + val configurations: Vector[sbt.librarymanagement.Configuration], + val url: Option[java.net.URL], + val extraAttributes: Map[String, String], + val checksum: Option[sbt.librarymanagement.Checksum]) extends sbt.librarymanagement.ArtifactExtra with Serializable { + + private def this(name: String) = this(name, Artifact.DefaultType, Artifact.DefaultExtension, None, Vector.empty, None, Map.empty, None) + + override def equals(o: Any): Boolean = o match { + case x: Artifact => (this.name == x.name) && (this.`type` == x.`type`) && (this.extension == x.extension) && (this.classifier == x.classifier) && (this.configurations == x.configurations) && (this.url == x.url) && (this.extraAttributes == x.extraAttributes) && (this.checksum == x.checksum) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "Artifact".##) + name.##) + `type`.##) + extension.##) + classifier.##) + configurations.##) + url.##) + extraAttributes.##) + checksum.##) + } + override def toString: String = { + "Artifact(" + name + ", " + `type` + ", " + extension + ", " + classifier + ", " + configurations + ", " + url + ", " + extraAttributes + ", " + checksum + ")" + } + protected[this] def copy(name: String = name, `type`: String = `type`, extension: String = extension, classifier: Option[String] = classifier, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, url: Option[java.net.URL] = url, extraAttributes: Map[String, String] = extraAttributes, checksum: Option[sbt.librarymanagement.Checksum] = checksum): Artifact = { + new Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum) + } + def withName(name: String): Artifact = { + copy(name = name) + } + def withType(`type`: String): Artifact = { + copy(`type` = `type`) + } + def withExtension(extension: String): Artifact = { + copy(extension = extension) + } + def withClassifier(classifier: Option[String]): Artifact = { + copy(classifier = classifier) + } + def withConfigurations(configurations: Vector[sbt.librarymanagement.Configuration]): Artifact = { + copy(configurations = configurations) + } + def withUrl(url: Option[java.net.URL]): Artifact = { + copy(url = url) + } + def withExtraAttributes(extraAttributes: Map[String, String]): Artifact = { + copy(extraAttributes = extraAttributes) + } + def withChecksum(checksum: Option[sbt.librarymanagement.Checksum]): Artifact = { + copy(checksum = checksum) + } +} +object Artifact extends sbt.librarymanagement.ArtifactFunctions { + + def apply(name: String): Artifact = new Artifact(name, Artifact.DefaultType, Artifact.DefaultExtension, None, Vector.empty, None, Map.empty, None) + def apply(name: String, `type`: String, extension: String, classifier: Option[String], configurations: Vector[sbt.librarymanagement.Configuration], url: Option[java.net.URL], extraAttributes: Map[String, String], checksum: Option[sbt.librarymanagement.Checksum]): Artifact = new Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala new file mode 100644 index 000000000..08bd9cadb --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala @@ -0,0 +1,41 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ArtifactFormats { self: sbt.librarymanagement.ConfigurationFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ArtifactFormat: JsonFormat[sbt.librarymanagement.Artifact] = new JsonFormat[sbt.librarymanagement.Artifact] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Artifact = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val `type` = unbuilder.readField[String]("type") + val extension = unbuilder.readField[String]("extension") + val classifier = unbuilder.readField[Option[String]]("classifier") + val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations") + val url = unbuilder.readField[Option[java.net.URL]]("url") + val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes") + val checksum = unbuilder.readField[Option[sbt.librarymanagement.Checksum]]("checksum") + unbuilder.endObject() + sbt.librarymanagement.Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Artifact, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("type", obj.`type`) + builder.addField("extension", obj.extension) + builder.addField("classifier", obj.classifier) + builder.addField("configurations", obj.configurations) + builder.addField("url", obj.url) + builder.addField("extraAttributes", obj.extraAttributes) + builder.addField("checksum", obj.checksum) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala new file mode 100644 index 000000000..9b64bf71d --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala @@ -0,0 +1,43 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Work around the inadequacy of Ivy's ArtifactTypeFilter (that it cannot reverse a filter) */ +final class ArtifactTypeFilter private ( + /** + * Represents the artifact types that we should try to resolve for (as in the allowed values of + * `artifact[type]` from a dependency `` section). One can use this to filter + * source / doc artifacts. + */ + val types: Set[String], + /** Whether to invert the types filter (i.e. allow only types NOT in the set) */ + val inverted: Boolean) extends sbt.librarymanagement.ArtifactTypeFilterExtra with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: ArtifactTypeFilter => (this.types == x.types) && (this.inverted == x.inverted) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "ArtifactTypeFilter".##) + types.##) + inverted.##) + } + override def toString: String = { + "ArtifactTypeFilter(" + types + ", " + inverted + ")" + } + protected[this] def copy(types: Set[String] = types, inverted: Boolean = inverted): ArtifactTypeFilter = { + new ArtifactTypeFilter(types, inverted) + } + def withTypes(types: Set[String]): ArtifactTypeFilter = { + copy(types = types) + } + def withInverted(inverted: Boolean): ArtifactTypeFilter = { + copy(inverted = inverted) + } +} +object ArtifactTypeFilter extends sbt.librarymanagement.ArtifactTypeFilterFunctions { + + def apply(types: Set[String], inverted: Boolean): ArtifactTypeFilter = new ArtifactTypeFilter(types, inverted) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala new file mode 100644 index 000000000..ec7a3919e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ArtifactTypeFilterFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val ArtifactTypeFilterFormat: JsonFormat[sbt.librarymanagement.ArtifactTypeFilter] = new JsonFormat[sbt.librarymanagement.ArtifactTypeFilter] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ArtifactTypeFilter = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val types = unbuilder.readField[Set[String]]("types") + val inverted = unbuilder.readField[Boolean]("inverted") + unbuilder.endObject() + sbt.librarymanagement.ArtifactTypeFilter(types, inverted) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ArtifactTypeFilter, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("types", obj.types) + builder.addField("inverted", obj.inverted) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Binary.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Binary.scala new file mode 100644 index 000000000..323002dd7 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Binary.scala @@ -0,0 +1,43 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Cross-versions a module using the result of + * prepending `prefix` and appending `suffix` to the binary version. + * For example, if `prefix = "foo_"` and `suffix = "_bar"` and the binary version is "2.10", + * the module is cross-versioned with "foo_2.10_bar". + */ +final class Binary private ( + val prefix: String, + val suffix: String) extends sbt.librarymanagement.CrossVersion() with Serializable { + + private def this() = this("", "") + + override def equals(o: Any): Boolean = o match { + case x: Binary => (this.prefix == x.prefix) && (this.suffix == x.suffix) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "Binary".##) + prefix.##) + suffix.##) + } + override def toString: String = { + "Binary(" + prefix + ", " + suffix + ")" + } + protected[this] def copy(prefix: String = prefix, suffix: String = suffix): Binary = { + new Binary(prefix, suffix) + } + def withPrefix(prefix: String): Binary = { + copy(prefix = prefix) + } + def withSuffix(suffix: String): Binary = { + copy(suffix = suffix) + } +} +object Binary { + + def apply(): Binary = new Binary("", "") + def apply(prefix: String, suffix: String): Binary = new Binary(prefix, suffix) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/BinaryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/BinaryFormats.scala new file mode 100644 index 000000000..95bf74afc --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/BinaryFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait BinaryFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val BinaryFormat: JsonFormat[sbt.librarymanagement.Binary] = new JsonFormat[sbt.librarymanagement.Binary] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Binary = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val prefix = unbuilder.readField[String]("prefix") + val suffix = unbuilder.readField[String]("suffix") + unbuilder.endObject() + sbt.librarymanagement.Binary(prefix, suffix) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Binary, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("prefix", obj.prefix) + builder.addField("suffix", obj.suffix) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Caller.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Caller.scala new file mode 100644 index 000000000..0770bc9e7 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Caller.scala @@ -0,0 +1,56 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class Caller private ( + val caller: sbt.librarymanagement.ModuleID, + val callerConfigurations: Vector[String], + val callerExtraAttributes: Map[String, String], + val isForceDependency: Boolean, + val isChangingDependency: Boolean, + val isTransitiveDependency: Boolean, + val isDirectlyForceDependency: Boolean) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: Caller => (this.caller == x.caller) && (this.callerConfigurations == x.callerConfigurations) && (this.callerExtraAttributes == x.callerExtraAttributes) && (this.isForceDependency == x.isForceDependency) && (this.isChangingDependency == x.isChangingDependency) && (this.isTransitiveDependency == x.isTransitiveDependency) && (this.isDirectlyForceDependency == x.isDirectlyForceDependency) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "Caller".##) + caller.##) + callerConfigurations.##) + callerExtraAttributes.##) + isForceDependency.##) + isChangingDependency.##) + isTransitiveDependency.##) + isDirectlyForceDependency.##) + } + override def toString: String = { + s"$caller" + } + protected[this] def copy(caller: sbt.librarymanagement.ModuleID = caller, callerConfigurations: Vector[String] = callerConfigurations, callerExtraAttributes: Map[String, String] = callerExtraAttributes, isForceDependency: Boolean = isForceDependency, isChangingDependency: Boolean = isChangingDependency, isTransitiveDependency: Boolean = isTransitiveDependency, isDirectlyForceDependency: Boolean = isDirectlyForceDependency): Caller = { + new Caller(caller, callerConfigurations, callerExtraAttributes, isForceDependency, isChangingDependency, isTransitiveDependency, isDirectlyForceDependency) + } + def withCaller(caller: sbt.librarymanagement.ModuleID): Caller = { + copy(caller = caller) + } + def withCallerConfigurations(callerConfigurations: Vector[String]): Caller = { + copy(callerConfigurations = callerConfigurations) + } + def withCallerExtraAttributes(callerExtraAttributes: Map[String, String]): Caller = { + copy(callerExtraAttributes = callerExtraAttributes) + } + def withIsForceDependency(isForceDependency: Boolean): Caller = { + copy(isForceDependency = isForceDependency) + } + def withIsChangingDependency(isChangingDependency: Boolean): Caller = { + copy(isChangingDependency = isChangingDependency) + } + def withIsTransitiveDependency(isTransitiveDependency: Boolean): Caller = { + copy(isTransitiveDependency = isTransitiveDependency) + } + def withIsDirectlyForceDependency(isDirectlyForceDependency: Boolean): Caller = { + copy(isDirectlyForceDependency = isDirectlyForceDependency) + } +} +object Caller { + + def apply(caller: sbt.librarymanagement.ModuleID, callerConfigurations: Vector[String], callerExtraAttributes: Map[String, String], isForceDependency: Boolean, isChangingDependency: Boolean, isTransitiveDependency: Boolean, isDirectlyForceDependency: Boolean): Caller = new Caller(caller, callerConfigurations, callerExtraAttributes, isForceDependency, isChangingDependency, isTransitiveDependency, isDirectlyForceDependency) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CallerFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CallerFormats.scala new file mode 100644 index 000000000..f0994fef8 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CallerFormats.scala @@ -0,0 +1,39 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait CallerFormats { self: sbt.librarymanagement.ModuleIDFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val CallerFormat: JsonFormat[sbt.librarymanagement.Caller] = new JsonFormat[sbt.librarymanagement.Caller] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Caller = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val caller = unbuilder.readField[sbt.librarymanagement.ModuleID]("caller") + val callerConfigurations = unbuilder.readField[Vector[String]]("callerConfigurations") + val callerExtraAttributes = unbuilder.readField[Map[String, String]]("callerExtraAttributes") + val isForceDependency = unbuilder.readField[Boolean]("isForceDependency") + val isChangingDependency = unbuilder.readField[Boolean]("isChangingDependency") + val isTransitiveDependency = unbuilder.readField[Boolean]("isTransitiveDependency") + val isDirectlyForceDependency = unbuilder.readField[Boolean]("isDirectlyForceDependency") + unbuilder.endObject() + sbt.librarymanagement.Caller(caller, callerConfigurations, callerExtraAttributes, isForceDependency, isChangingDependency, isTransitiveDependency, isDirectlyForceDependency) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Caller, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("caller", obj.caller) + builder.addField("callerConfigurations", obj.callerConfigurations) + builder.addField("callerExtraAttributes", obj.callerExtraAttributes) + builder.addField("isForceDependency", obj.isForceDependency) + builder.addField("isChangingDependency", obj.isChangingDependency) + builder.addField("isTransitiveDependency", obj.isTransitiveDependency) + builder.addField("isDirectlyForceDependency", obj.isDirectlyForceDependency) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala new file mode 100644 index 000000000..75978cc04 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala @@ -0,0 +1,36 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class ChainedResolver private ( + name: String, + val resolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.librarymanagement.Resolver(name) with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: ChainedResolver => (this.name == x.name) && (this.resolvers == x.resolvers) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "ChainedResolver".##) + name.##) + resolvers.##) + } + override def toString: String = { + "ChainedResolver(" + name + ", " + resolvers + ")" + } + protected[this] def copy(name: String = name, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers): ChainedResolver = { + new ChainedResolver(name, resolvers) + } + def withName(name: String): ChainedResolver = { + copy(name = name) + } + def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): ChainedResolver = { + copy(resolvers = resolvers) + } +} +object ChainedResolver { + + def apply(name: String, resolvers: Vector[sbt.librarymanagement.Resolver]): ChainedResolver = new ChainedResolver(name, resolvers) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala new file mode 100644 index 000000000..3972cb500 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ChainedResolverFormats { self: sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ChainedResolverFormat: JsonFormat[sbt.librarymanagement.ChainedResolver] = new JsonFormat[sbt.librarymanagement.ChainedResolver] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ChainedResolver = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val resolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("resolvers") + unbuilder.endObject() + sbt.librarymanagement.ChainedResolver(name, resolvers) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ChainedResolver, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("resolvers", obj.resolvers) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala new file mode 100644 index 000000000..dd2db5902 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala @@ -0,0 +1,36 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class Checksum private ( + val digest: String, + val `type`: String) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: Checksum => (this.digest == x.digest) && (this.`type` == x.`type`) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "Checksum".##) + digest.##) + `type`.##) + } + override def toString: String = { + "Checksum(" + digest + ", " + `type` + ")" + } + protected[this] def copy(digest: String = digest, `type`: String = `type`): Checksum = { + new Checksum(digest, `type`) + } + def withDigest(digest: String): Checksum = { + copy(digest = digest) + } + def withType(`type`: String): Checksum = { + copy(`type` = `type`) + } +} +object Checksum { + + def apply(digest: String, `type`: String): Checksum = new Checksum(digest, `type`) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala new file mode 100644 index 000000000..7f674171e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ChecksumFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val ChecksumFormat: JsonFormat[sbt.librarymanagement.Checksum] = new JsonFormat[sbt.librarymanagement.Checksum] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Checksum = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val digest = unbuilder.readField[String]("digest") + val `type` = unbuilder.readField[String]("type") + unbuilder.endObject() + sbt.librarymanagement.Checksum(digest, `type`) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Checksum, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("digest", obj.digest) + builder.addField("type", obj.`type`) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Configuration.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Configuration.scala new file mode 100644 index 000000000..a4ab026da --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Configuration.scala @@ -0,0 +1,50 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Represents an Ivy configuration. */ +final class Configuration private ( + val name: String, + val description: String, + val isPublic: Boolean, + val extendsConfigs: Vector[sbt.librarymanagement.Configuration], + val transitive: Boolean) extends sbt.librarymanagement.ConfigurationExtra with Serializable { + + private def this(name: String) = this(name, "", true, Vector.empty, true) + + override def equals(o: Any): Boolean = o match { + case x: Configuration => (this.name == x.name) && (this.description == x.description) && (this.isPublic == x.isPublic) && (this.extendsConfigs == x.extendsConfigs) && (this.transitive == x.transitive) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (17 + "Configuration".##) + name.##) + description.##) + isPublic.##) + extendsConfigs.##) + transitive.##) + } + override def toString: String = { + name + } + protected[this] def copy(name: String = name, description: String = description, isPublic: Boolean = isPublic, extendsConfigs: Vector[sbt.librarymanagement.Configuration] = extendsConfigs, transitive: Boolean = transitive): Configuration = { + new Configuration(name, description, isPublic, extendsConfigs, transitive) + } + def withName(name: String): Configuration = { + copy(name = name) + } + def withDescription(description: String): Configuration = { + copy(description = description) + } + def withIsPublic(isPublic: Boolean): Configuration = { + copy(isPublic = isPublic) + } + def withExtendsConfigs(extendsConfigs: Vector[sbt.librarymanagement.Configuration]): Configuration = { + copy(extendsConfigs = extendsConfigs) + } + def withTransitive(transitive: Boolean): Configuration = { + copy(transitive = transitive) + } +} +object Configuration { + + def apply(name: String): Configuration = new Configuration(name, "", true, Vector.empty, true) + def apply(name: String, description: String, isPublic: Boolean, extendsConfigs: Vector[sbt.librarymanagement.Configuration], transitive: Boolean): Configuration = new Configuration(name, description, isPublic, extendsConfigs, transitive) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationFormats.scala new file mode 100644 index 000000000..70e4b21fc --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationFormats.scala @@ -0,0 +1,35 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ConfigurationFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ConfigurationFormat: JsonFormat[sbt.librarymanagement.Configuration] = new JsonFormat[sbt.librarymanagement.Configuration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Configuration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val description = unbuilder.readField[String]("description") + val isPublic = unbuilder.readField[Boolean]("isPublic") + val extendsConfigs = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("extendsConfigs") + val transitive = unbuilder.readField[Boolean]("transitive") + unbuilder.endObject() + sbt.librarymanagement.Configuration(name, description, isPublic, extendsConfigs, transitive) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Configuration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("description", obj.description) + builder.addField("isPublic", obj.isPublic) + builder.addField("extendsConfigs", obj.extendsConfigs) + builder.addField("transitive", obj.transitive) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReport.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReport.scala new file mode 100644 index 000000000..2fa190dea --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReport.scala @@ -0,0 +1,46 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Provides information about resolution of a single configuration. */ +final class ConfigurationReport private ( + /** the configuration this report is for. */ + val configuration: String, + /** a sequence containing one report for each module resolved for this configuration. */ + val modules: Vector[sbt.librarymanagement.ModuleReport], + /** a sequence containing one report for each org/name, which may or may not be part of the final resolution. */ + val details: Vector[sbt.librarymanagement.OrganizationArtifactReport]) extends sbt.librarymanagement.ConfigurationReportExtra with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: ConfigurationReport => (this.configuration == x.configuration) && (this.modules == x.modules) && (this.details == x.details) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "ConfigurationReport".##) + configuration.##) + modules.##) + details.##) + } + override def toString: String = { + s"\t$configuration:\n" + + (if (details.isEmpty) modules.mkString + details.flatMap(_.modules).filter(_.evicted).map("\t\t(EVICTED) " + _ + "\n").mkString + else details.mkString) + } + protected[this] def copy(configuration: String = configuration, modules: Vector[sbt.librarymanagement.ModuleReport] = modules, details: Vector[sbt.librarymanagement.OrganizationArtifactReport] = details): ConfigurationReport = { + new ConfigurationReport(configuration, modules, details) + } + def withConfiguration(configuration: String): ConfigurationReport = { + copy(configuration = configuration) + } + def withModules(modules: Vector[sbt.librarymanagement.ModuleReport]): ConfigurationReport = { + copy(modules = modules) + } + def withDetails(details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReport = { + copy(details = details) + } +} +object ConfigurationReport { + + def apply(configuration: String, modules: Vector[sbt.librarymanagement.ModuleReport], details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReport = new ConfigurationReport(configuration, modules, details) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala new file mode 100644 index 000000000..81a1219ad --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ConfigurationReportFormats { self: sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.OrganizationArtifactReportFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ConfigurationReportFormat: JsonFormat[sbt.librarymanagement.ConfigurationReport] = new JsonFormat[sbt.librarymanagement.ConfigurationReport] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ConfigurationReport = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val configuration = unbuilder.readField[String]("configuration") + val modules = unbuilder.readField[Vector[sbt.librarymanagement.ModuleReport]]("modules") + val details = unbuilder.readField[Vector[sbt.librarymanagement.OrganizationArtifactReport]]("details") + unbuilder.endObject() + sbt.librarymanagement.ConfigurationReport(configuration, modules, details) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ConfigurationReport, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("configuration", obj.configuration) + builder.addField("modules", obj.modules) + builder.addField("details", obj.details) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala new file mode 100644 index 000000000..be62807e4 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ConfigurationReportLiteFormats { self: sbt.librarymanagement.OrganizationArtifactReportFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ConfigurationReportLiteFormat: JsonFormat[sbt.internal.librarymanagement.ConfigurationReportLite] = new JsonFormat[sbt.internal.librarymanagement.ConfigurationReportLite] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ConfigurationReportLite = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val configuration = unbuilder.readField[String]("configuration") + val details = unbuilder.readField[Vector[sbt.librarymanagement.OrganizationArtifactReport]]("details") + unbuilder.endObject() + sbt.internal.librarymanagement.ConfigurationReportLite(configuration, details) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.ConfigurationReportLite, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("configuration", obj.configuration) + builder.addField("details", obj.details) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala new file mode 100644 index 000000000..84cfeefab --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala @@ -0,0 +1,42 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** See http://ant.apache.org/ivy/history/latest-milestone/settings/conflict-managers.html for details of the different conflict managers. */ +final class ConflictManager private ( + val name: String, + val organization: String, + val module: String) extends Serializable { + + private def this(name: String) = this(name, "*", "*") + + override def equals(o: Any): Boolean = o match { + case x: ConflictManager => (this.name == x.name) && (this.organization == x.organization) && (this.module == x.module) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "ConflictManager".##) + name.##) + organization.##) + module.##) + } + override def toString: String = { + "ConflictManager(" + name + ", " + organization + ", " + module + ")" + } + protected[this] def copy(name: String = name, organization: String = organization, module: String = module): ConflictManager = { + new ConflictManager(name, organization, module) + } + def withName(name: String): ConflictManager = { + copy(name = name) + } + def withOrganization(organization: String): ConflictManager = { + copy(organization = organization) + } + def withModule(module: String): ConflictManager = { + copy(module = module) + } +} +object ConflictManager extends sbt.librarymanagement.ConflictManagerFunctions { + + def apply(name: String): ConflictManager = new ConflictManager(name, "*", "*") + def apply(name: String, organization: String, module: String): ConflictManager = new ConflictManager(name, organization, module) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala new file mode 100644 index 000000000..40271b940 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ConflictManagerFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val ConflictManagerFormat: JsonFormat[sbt.librarymanagement.ConflictManager] = new JsonFormat[sbt.librarymanagement.ConflictManager] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ConflictManager = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val organization = unbuilder.readField[String]("organization") + val module = unbuilder.readField[String]("module") + unbuilder.endObject() + sbt.librarymanagement.ConflictManager(name, organization, module) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ConflictManager, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("organization", obj.organization) + builder.addField("module", obj.module) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Constant.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Constant.scala new file mode 100644 index 000000000..bca95bb25 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Constant.scala @@ -0,0 +1,34 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Cross-versions a module using the string `value`. */ +final class Constant private ( + val value: String) extends sbt.librarymanagement.CrossVersion() with Serializable { + + private def this() = this("") + + override def equals(o: Any): Boolean = o match { + case x: Constant => (this.value == x.value) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (17 + "Constant".##) + value.##) + } + override def toString: String = { + "Constant(" + value + ")" + } + protected[this] def copy(value: String = value): Constant = { + new Constant(value) + } + def withValue(value: String): Constant = { + copy(value = value) + } +} +object Constant { + + def apply(): Constant = new Constant("") + def apply(value: String): Constant = new Constant(value) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConstantFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConstantFormats.scala new file mode 100644 index 000000000..752adb674 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConstantFormats.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ConstantFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val ConstantFormat: JsonFormat[sbt.librarymanagement.Constant] = new JsonFormat[sbt.librarymanagement.Constant] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Constant = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val value = unbuilder.readField[String]("value") + unbuilder.endObject() + sbt.librarymanagement.Constant(value) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Constant, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("value", obj.value) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersion.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersion.scala new file mode 100644 index 000000000..c1f658229 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersion.scala @@ -0,0 +1,26 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Configures how a module will be cross-versioned. */ +abstract class CrossVersion() extends Serializable { + + + + +override def equals(o: Any): Boolean = o match { + case x: CrossVersion => true + case _ => false +} +override def hashCode: Int = { + 37 * (17 + "CrossVersion".##) +} +override def toString: String = { + "CrossVersion()" +} +} +object CrossVersion extends sbt.librarymanagement.CrossVersionFunctions { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersionFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersionFormats.scala new file mode 100644 index 000000000..b0b37e916 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersionFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait CrossVersionFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats => +implicit lazy val CrossVersionFormat: JsonFormat[sbt.librarymanagement.CrossVersion] = flatUnionFormat5[sbt.librarymanagement.CrossVersion, sbt.librarymanagement.Disabled, sbt.librarymanagement.Binary, sbt.librarymanagement.Constant, sbt.librarymanagement.Patch, sbt.librarymanagement.Full]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Developer.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Developer.scala new file mode 100644 index 000000000..0689fccf4 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Developer.scala @@ -0,0 +1,44 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class Developer private ( + val id: String, + val name: String, + val email: String, + val url: java.net.URL) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: Developer => (this.id == x.id) && (this.name == x.name) && (this.email == x.email) && (this.url == x.url) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "Developer".##) + id.##) + name.##) + email.##) + url.##) + } + override def toString: String = { + "Developer(" + id + ", " + name + ", " + email + ", " + url + ")" + } + protected[this] def copy(id: String = id, name: String = name, email: String = email, url: java.net.URL = url): Developer = { + new Developer(id, name, email, url) + } + def withId(id: String): Developer = { + copy(id = id) + } + def withName(name: String): Developer = { + copy(name = name) + } + def withEmail(email: String): Developer = { + copy(email = email) + } + def withUrl(url: java.net.URL): Developer = { + copy(url = url) + } +} +object Developer { + + def apply(id: String, name: String, email: String, url: java.net.URL): Developer = new Developer(id, name, email, url) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala new file mode 100644 index 000000000..ee1e87e45 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait DeveloperFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val DeveloperFormat: JsonFormat[sbt.librarymanagement.Developer] = new JsonFormat[sbt.librarymanagement.Developer] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Developer = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val id = unbuilder.readField[String]("id") + val name = unbuilder.readField[String]("name") + val email = unbuilder.readField[String]("email") + val url = unbuilder.readField[java.net.URL]("url") + unbuilder.endObject() + sbt.librarymanagement.Developer(id, name, email, url) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Developer, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("id", obj.id) + builder.addField("name", obj.name) + builder.addField("email", obj.email) + builder.addField("url", obj.url) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Disabled.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Disabled.scala new file mode 100644 index 000000000..c1f3339d1 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Disabled.scala @@ -0,0 +1,30 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Disables cross versioning for a module. */ +final class Disabled private () extends sbt.librarymanagement.CrossVersion() with Serializable { + + + +override def equals(o: Any): Boolean = o match { + case x: Disabled => true + case _ => false +} +override def hashCode: Int = { + 37 * (17 + "Disabled".##) +} +override def toString: String = { + "Disabled()" +} +protected[this] def copy(): Disabled = { + new Disabled() +} + +} +object Disabled { + + def apply(): Disabled = new Disabled() +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DisabledFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DisabledFormats.scala new file mode 100644 index 000000000..7c0602834 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DisabledFormats.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait DisabledFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val DisabledFormat: JsonFormat[sbt.librarymanagement.Disabled] = new JsonFormat[sbt.librarymanagement.Disabled] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Disabled = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + + unbuilder.endObject() + sbt.librarymanagement.Disabled() + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Disabled, builder: Builder[J]): Unit = { + builder.beginObject() + + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ExternalIvyConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ExternalIvyConfigurationFormats.scala new file mode 100644 index 000000000..55de96c3e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ExternalIvyConfigurationFormats.scala @@ -0,0 +1,37 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ExternalIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.internal.librarymanagement.formats.UpdateOptionsFormat with sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ExternalIvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.ExternalIvyConfiguration] = new JsonFormat[sbt.internal.librarymanagement.ExternalIvyConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ExternalIvyConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock") + val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory") + val log = unbuilder.readField[xsbti.Logger]("log") + val updateOptions = unbuilder.readField[sbt.librarymanagement.UpdateOptions]("updateOptions") + val uri = unbuilder.readField[java.net.URI]("uri") + val extraResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("extraResolvers") + unbuilder.endObject() + sbt.internal.librarymanagement.ExternalIvyConfiguration(lock, baseDirectory, log, updateOptions, uri, extraResolvers) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.ExternalIvyConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("lock", obj.lock) + builder.addField("baseDirectory", obj.baseDirectory) + builder.addField("log", obj.log) + builder.addField("updateOptions", obj.updateOptions) + builder.addField("uri", obj.uri) + builder.addField("extraResolvers", obj.extraResolvers) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala new file mode 100644 index 000000000..c74be3197 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala @@ -0,0 +1,41 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Configuration specific to an Ivy filesystem resolver. */ +final class FileConfiguration private ( + val isLocal: Boolean, + val isTransactional: Option[Boolean]) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: FileConfiguration => (this.isLocal == x.isLocal) && (this.isTransactional == x.isTransactional) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "FileConfiguration".##) + isLocal.##) + isTransactional.##) + } + override def toString: String = { + "FileConfiguration(" + isLocal + ", " + isTransactional + ")" + } + protected[this] def copy(isLocal: Boolean = isLocal, isTransactional: Option[Boolean] = isTransactional): FileConfiguration = { + new FileConfiguration(isLocal, isTransactional) + } + def withIsLocal(isLocal: Boolean): FileConfiguration = { + copy(isLocal = isLocal) + } + def withIsTransactional(isTransactional: Option[Boolean]): FileConfiguration = { + copy(isTransactional = isTransactional) + } + def withIsTransactional(isTransactional: Boolean): FileConfiguration = { + copy(isTransactional = Option(isTransactional)) + } +} +object FileConfiguration { + + def apply(isLocal: Boolean, isTransactional: Option[Boolean]): FileConfiguration = new FileConfiguration(isLocal, isTransactional) + def apply(isLocal: Boolean, isTransactional: Boolean): FileConfiguration = new FileConfiguration(isLocal, Option(isTransactional)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala new file mode 100644 index 000000000..8117d6b15 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait FileConfigurationFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val FileConfigurationFormat: JsonFormat[sbt.librarymanagement.FileConfiguration] = new JsonFormat[sbt.librarymanagement.FileConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.FileConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val isLocal = unbuilder.readField[Boolean]("isLocal") + val isTransactional = unbuilder.readField[Option[Boolean]]("isTransactional") + unbuilder.endObject() + sbt.librarymanagement.FileConfiguration(isLocal, isTransactional) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.FileConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("isLocal", obj.isLocal) + builder.addField("isTransactional", obj.isTransactional) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala new file mode 100644 index 000000000..77d2d3068 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala @@ -0,0 +1,43 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** sbt interface for an Ivy filesystem repository. More convenient construction is done using Resolver.file. */ +final class FileRepository private ( + name: String, + patterns: sbt.librarymanagement.Patterns, + val configuration: sbt.librarymanagement.FileConfiguration) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with Serializable { + def this(name: String, configuration: sbt.librarymanagement.FileConfiguration, patterns: sbt.librarymanagement.Patterns) = + this(name, patterns, configuration) + + + override def equals(o: Any): Boolean = o match { + case x: FileRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.configuration == x.configuration) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "FileRepository".##) + name.##) + patterns.##) + configuration.##) + } + override def toString: String = { + "FileRepository(" + name + ", " + patterns + ", " + configuration + ")" + } + protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, configuration: sbt.librarymanagement.FileConfiguration = configuration): FileRepository = { + new FileRepository(name, patterns, configuration) + } + def withName(name: String): FileRepository = { + copy(name = name) + } + def withPatterns(patterns: sbt.librarymanagement.Patterns): FileRepository = { + copy(patterns = patterns) + } + def withConfiguration(configuration: sbt.librarymanagement.FileConfiguration): FileRepository = { + copy(configuration = configuration) + } +} +object FileRepository { + def apply(name: String, configuration: sbt.librarymanagement.FileConfiguration, patterns: sbt.librarymanagement.Patterns) = + new FileRepository(name, patterns, configuration) + def apply(name: String, patterns: sbt.librarymanagement.Patterns, configuration: sbt.librarymanagement.FileConfiguration): FileRepository = new FileRepository(name, patterns, configuration) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala new file mode 100644 index 000000000..31a282b3b --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait FileRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.FileConfigurationFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val FileRepositoryFormat: JsonFormat[sbt.librarymanagement.FileRepository] = new JsonFormat[sbt.librarymanagement.FileRepository] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.FileRepository = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") + val configuration = unbuilder.readField[sbt.librarymanagement.FileConfiguration]("configuration") + unbuilder.endObject() + sbt.librarymanagement.FileRepository(name, patterns, configuration) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.FileRepository, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("patterns", obj.patterns) + builder.addField("configuration", obj.configuration) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Full.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Full.scala new file mode 100644 index 000000000..3ad99a43e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Full.scala @@ -0,0 +1,43 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Cross-versions a module with the result of + * prepending `prefix` and appending `suffix` to the full version. + * For example, if `prefix = "foo_"` and `suffix = "_bar"` and the full version is "2.12.1", + * the module is cross-versioned with "foo_2.12.1_bar". + */ +final class Full private ( + val prefix: String, + val suffix: String) extends sbt.librarymanagement.CrossVersion() with Serializable { + + private def this() = this("", "") + + override def equals(o: Any): Boolean = o match { + case x: Full => (this.prefix == x.prefix) && (this.suffix == x.suffix) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "Full".##) + prefix.##) + suffix.##) + } + override def toString: String = { + "Full(" + prefix + ", " + suffix + ")" + } + protected[this] def copy(prefix: String = prefix, suffix: String = suffix): Full = { + new Full(prefix, suffix) + } + def withPrefix(prefix: String): Full = { + copy(prefix = prefix) + } + def withSuffix(suffix: String): Full = { + copy(suffix = suffix) + } +} +object Full { + + def apply(): Full = new Full("", "") + def apply(prefix: String, suffix: String): Full = new Full(prefix, suffix) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FullFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FullFormats.scala new file mode 100644 index 000000000..c44b95ef3 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FullFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait FullFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val FullFormat: JsonFormat[sbt.librarymanagement.Full] = new JsonFormat[sbt.librarymanagement.Full] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Full = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val prefix = unbuilder.readField[String]("prefix") + val suffix = unbuilder.readField[String]("suffix") + unbuilder.endObject() + sbt.librarymanagement.Full(prefix, suffix) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Full, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("prefix", obj.prefix) + builder.addField("suffix", obj.suffix) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRule.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRule.scala new file mode 100644 index 000000000..cd2032c80 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRule.scala @@ -0,0 +1,58 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Defines a rule to either: + * + * The use case that is applied depends on the parameter name which it is passed to, but the + * filter has the same fields in both cases. + */ +final class InclExclRule private ( + val organization: String, + val name: String, + val artifact: String, + val configurations: Vector[String], + val crossVersion: sbt.librarymanagement.CrossVersion) extends Serializable { + + private def this() = this("*", "*", "*", Vector.empty, sbt.librarymanagement.Disabled()) + + override def equals(o: Any): Boolean = o match { + case x: InclExclRule => (this.organization == x.organization) && (this.name == x.name) && (this.artifact == x.artifact) && (this.configurations == x.configurations) && (this.crossVersion == x.crossVersion) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (17 + "InclExclRule".##) + organization.##) + name.##) + artifact.##) + configurations.##) + crossVersion.##) + } + override def toString: String = { + "InclExclRule(" + organization + ", " + name + ", " + artifact + ", " + configurations + ", " + crossVersion + ")" + } + protected[this] def copy(organization: String = organization, name: String = name, artifact: String = artifact, configurations: Vector[String] = configurations, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion): InclExclRule = { + new InclExclRule(organization, name, artifact, configurations, crossVersion) + } + def withOrganization(organization: String): InclExclRule = { + copy(organization = organization) + } + def withName(name: String): InclExclRule = { + copy(name = name) + } + def withArtifact(artifact: String): InclExclRule = { + copy(artifact = artifact) + } + def withConfigurations(configurations: Vector[String]): InclExclRule = { + copy(configurations = configurations) + } + def withCrossVersion(crossVersion: sbt.librarymanagement.CrossVersion): InclExclRule = { + copy(crossVersion = crossVersion) + } +} +object InclExclRule extends sbt.librarymanagement.InclExclRuleFunctions { + + def apply(): InclExclRule = new InclExclRule("*", "*", "*", Vector.empty, sbt.librarymanagement.Disabled()) + def apply(organization: String, name: String, artifact: String, configurations: Vector[String], crossVersion: sbt.librarymanagement.CrossVersion): InclExclRule = new InclExclRule(organization, name, artifact, configurations, crossVersion) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala new file mode 100644 index 000000000..76a3c49b8 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala @@ -0,0 +1,35 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait InclExclRuleFormats { self: sbt.librarymanagement.CrossVersionFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val InclExclRuleFormat: JsonFormat[sbt.librarymanagement.InclExclRule] = new JsonFormat[sbt.librarymanagement.InclExclRule] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.InclExclRule = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val organization = unbuilder.readField[String]("organization") + val name = unbuilder.readField[String]("name") + val artifact = unbuilder.readField[String]("artifact") + val configurations = unbuilder.readField[Vector[String]]("configurations") + val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion") + unbuilder.endObject() + sbt.librarymanagement.InclExclRule(organization, name, artifact, configurations, crossVersion) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.InclExclRule, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("organization", obj.organization) + builder.addField("name", obj.name) + builder.addField("artifact", obj.artifact) + builder.addField("configurations", obj.configurations) + builder.addField("crossVersion", obj.crossVersion) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineConfigurationFormats.scala new file mode 100644 index 000000000..13cc67247 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineConfigurationFormats.scala @@ -0,0 +1,47 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait InlineConfigurationFormats { self: sbt.librarymanagement.IvyScalaFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ModuleInfoFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.internal.librarymanagement.formats.NodeSeqFormat with sbt.librarymanagement.ConfigurationFormats with sbt.librarymanagement.ConflictManagerFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val InlineConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.InlineConfiguration] = new JsonFormat[sbt.internal.librarymanagement.InlineConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.InlineConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val validate = unbuilder.readField[Boolean]("validate") + val ivyScala = unbuilder.readField[Option[sbt.librarymanagement.IvyScala]]("ivyScala") + val module = unbuilder.readField[sbt.librarymanagement.ModuleID]("module") + val moduleInfo = unbuilder.readField[sbt.librarymanagement.ModuleInfo]("moduleInfo") + val dependencies = unbuilder.readField[Vector[sbt.librarymanagement.ModuleID]]("dependencies") + val overrides = unbuilder.readField[Set[sbt.librarymanagement.ModuleID]]("overrides") + val excludes = unbuilder.readField[Vector[sbt.librarymanagement.InclExclRule]]("excludes") + val ivyXML = unbuilder.readField[scala.xml.NodeSeq]("ivyXML") + val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations") + val defaultConfiguration = unbuilder.readField[Option[sbt.librarymanagement.Configuration]]("defaultConfiguration") + val conflictManager = unbuilder.readField[sbt.librarymanagement.ConflictManager]("conflictManager") + unbuilder.endObject() + sbt.internal.librarymanagement.InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.InlineConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("validate", obj.validate) + builder.addField("ivyScala", obj.ivyScala) + builder.addField("module", obj.module) + builder.addField("moduleInfo", obj.moduleInfo) + builder.addField("dependencies", obj.dependencies) + builder.addField("overrides", obj.overrides) + builder.addField("excludes", obj.excludes) + builder.addField("ivyXML", obj.ivyXML) + builder.addField("configurations", obj.configurations) + builder.addField("defaultConfiguration", obj.defaultConfiguration) + builder.addField("conflictManager", obj.conflictManager) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineIvyConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineIvyConfigurationFormats.scala new file mode 100644 index 000000000..8adfd3620 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineIvyConfigurationFormats.scala @@ -0,0 +1,47 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait InlineIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.internal.librarymanagement.formats.UpdateOptionsFormat with sbt.librarymanagement.IvyPathsFormats with sbt.librarymanagement.ResolverFormats with sbt.librarymanagement.ModuleConfigurationFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val InlineIvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.InlineIvyConfiguration] = new JsonFormat[sbt.internal.librarymanagement.InlineIvyConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.InlineIvyConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock") + val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory") + val log = unbuilder.readField[xsbti.Logger]("log") + val updateOptions = unbuilder.readField[sbt.librarymanagement.UpdateOptions]("updateOptions") + val paths = unbuilder.readField[sbt.internal.librarymanagement.IvyPaths]("paths") + val resolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("resolvers") + val otherResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("otherResolvers") + val moduleConfigurations = unbuilder.readField[Vector[sbt.librarymanagement.ModuleConfiguration]]("moduleConfigurations") + val checksums = unbuilder.readField[Vector[String]]("checksums") + val managedChecksums = unbuilder.readField[Boolean]("managedChecksums") + val resolutionCacheDir = unbuilder.readField[Option[java.io.File]]("resolutionCacheDir") + unbuilder.endObject() + sbt.internal.librarymanagement.InlineIvyConfiguration(lock, baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.InlineIvyConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("lock", obj.lock) + builder.addField("baseDirectory", obj.baseDirectory) + builder.addField("log", obj.log) + builder.addField("updateOptions", obj.updateOptions) + builder.addField("paths", obj.paths) + builder.addField("resolvers", obj.resolvers) + builder.addField("otherResolvers", obj.otherResolvers) + builder.addField("moduleConfigurations", obj.moduleConfigurations) + builder.addField("checksums", obj.checksums) + builder.addField("managedChecksums", obj.managedChecksums) + builder.addField("resolutionCacheDir", obj.resolutionCacheDir) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyConfigurationFormats.scala new file mode 100644 index 000000000..405edbbad --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyConfigurationFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait IvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.internal.librarymanagement.formats.UpdateOptionsFormat with sbt.librarymanagement.IvyPathsFormats with sbt.librarymanagement.ResolverFormats with sbt.librarymanagement.ModuleConfigurationFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InlineIvyConfigurationFormats with sbt.librarymanagement.ExternalIvyConfigurationFormats => +implicit lazy val IvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.IvyConfiguration] = flatUnionFormat2[sbt.internal.librarymanagement.IvyConfiguration, sbt.internal.librarymanagement.InlineIvyConfiguration, sbt.internal.librarymanagement.ExternalIvyConfiguration]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfiguration.scala new file mode 100644 index 000000000..2939baaa8 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfiguration.scala @@ -0,0 +1,48 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class IvyFileConfiguration private ( + validate: Boolean, + ivyScala: Option[sbt.librarymanagement.IvyScala], + val file: java.io.File, + val autoScalaTools: Boolean) extends sbt.librarymanagement.ModuleSettings(validate, ivyScala) with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: IvyFileConfiguration => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) && (this.file == x.file) && (this.autoScalaTools == x.autoScalaTools) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "IvyFileConfiguration".##) + validate.##) + ivyScala.##) + file.##) + autoScalaTools.##) + } + override def toString: String = { + "IvyFileConfiguration(" + validate + ", " + ivyScala + ", " + file + ", " + autoScalaTools + ")" + } + protected[this] def copy(validate: Boolean = validate, ivyScala: Option[sbt.librarymanagement.IvyScala] = ivyScala, file: java.io.File = file, autoScalaTools: Boolean = autoScalaTools): IvyFileConfiguration = { + new IvyFileConfiguration(validate, ivyScala, file, autoScalaTools) + } + def withValidate(validate: Boolean): IvyFileConfiguration = { + copy(validate = validate) + } + def withIvyScala(ivyScala: Option[sbt.librarymanagement.IvyScala]): IvyFileConfiguration = { + copy(ivyScala = ivyScala) + } + def withIvyScala(ivyScala: sbt.librarymanagement.IvyScala): IvyFileConfiguration = { + copy(ivyScala = Option(ivyScala)) + } + def withFile(file: java.io.File): IvyFileConfiguration = { + copy(file = file) + } + def withAutoScalaTools(autoScalaTools: Boolean): IvyFileConfiguration = { + copy(autoScalaTools = autoScalaTools) + } +} +object IvyFileConfiguration { + + def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], file: java.io.File, autoScalaTools: Boolean): IvyFileConfiguration = new IvyFileConfiguration(validate, ivyScala, file, autoScalaTools) + def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, file: java.io.File, autoScalaTools: Boolean): IvyFileConfiguration = new IvyFileConfiguration(validate, Option(ivyScala), file, autoScalaTools) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala new file mode 100644 index 000000000..c675f4427 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait IvyFileConfigurationFormats { self: sbt.librarymanagement.IvyScalaFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val IvyFileConfigurationFormat: JsonFormat[sbt.librarymanagement.IvyFileConfiguration] = new JsonFormat[sbt.librarymanagement.IvyFileConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.IvyFileConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val validate = unbuilder.readField[Boolean]("validate") + val ivyScala = unbuilder.readField[Option[sbt.librarymanagement.IvyScala]]("ivyScala") + val file = unbuilder.readField[java.io.File]("file") + val autoScalaTools = unbuilder.readField[Boolean]("autoScalaTools") + unbuilder.endObject() + sbt.librarymanagement.IvyFileConfiguration(validate, ivyScala, file, autoScalaTools) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.IvyFileConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("validate", obj.validate) + builder.addField("ivyScala", obj.ivyScala) + builder.addField("file", obj.file) + builder.addField("autoScalaTools", obj.autoScalaTools) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala new file mode 100644 index 000000000..506047e1e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait IvyPathsFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val IvyPathsFormat: JsonFormat[sbt.internal.librarymanagement.IvyPaths] = new JsonFormat[sbt.internal.librarymanagement.IvyPaths] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.IvyPaths = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory") + val ivyHome = unbuilder.readField[Option[java.io.File]]("ivyHome") + unbuilder.endObject() + sbt.internal.librarymanagement.IvyPaths(baseDirectory, ivyHome) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.IvyPaths, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("baseDirectory", obj.baseDirectory) + builder.addField("ivyHome", obj.ivyHome) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScala.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScala.scala new file mode 100644 index 000000000..4bbde0dee --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScala.scala @@ -0,0 +1,61 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class IvyScala private ( + val scalaFullVersion: String, + val scalaBinaryVersion: String, + val configurations: Vector[sbt.librarymanagement.Configuration], + val checkExplicit: Boolean, + val filterImplicit: Boolean, + val overrideScalaVersion: Boolean, + val scalaOrganization: String, + val scalaArtifacts: scala.Vector[String]) extends Serializable { + + private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts) + + override def equals(o: Any): Boolean = o match { + case x: IvyScala => (this.scalaFullVersion == x.scalaFullVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.configurations == x.configurations) && (this.checkExplicit == x.checkExplicit) && (this.filterImplicit == x.filterImplicit) && (this.overrideScalaVersion == x.overrideScalaVersion) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaArtifacts == x.scalaArtifacts) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "IvyScala".##) + scalaFullVersion.##) + scalaBinaryVersion.##) + configurations.##) + checkExplicit.##) + filterImplicit.##) + overrideScalaVersion.##) + scalaOrganization.##) + scalaArtifacts.##) + } + override def toString: String = { + "IvyScala(" + scalaFullVersion + ", " + scalaBinaryVersion + ", " + configurations + ", " + checkExplicit + ", " + filterImplicit + ", " + overrideScalaVersion + ", " + scalaOrganization + ", " + scalaArtifacts + ")" + } + protected[this] def copy(scalaFullVersion: String = scalaFullVersion, scalaBinaryVersion: String = scalaBinaryVersion, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, checkExplicit: Boolean = checkExplicit, filterImplicit: Boolean = filterImplicit, overrideScalaVersion: Boolean = overrideScalaVersion, scalaOrganization: String = scalaOrganization, scalaArtifacts: scala.Vector[String] = scalaArtifacts): IvyScala = { + new IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) + } + def withScalaFullVersion(scalaFullVersion: String): IvyScala = { + copy(scalaFullVersion = scalaFullVersion) + } + def withScalaBinaryVersion(scalaBinaryVersion: String): IvyScala = { + copy(scalaBinaryVersion = scalaBinaryVersion) + } + def withConfigurations(configurations: Vector[sbt.librarymanagement.Configuration]): IvyScala = { + copy(configurations = configurations) + } + def withCheckExplicit(checkExplicit: Boolean): IvyScala = { + copy(checkExplicit = checkExplicit) + } + def withFilterImplicit(filterImplicit: Boolean): IvyScala = { + copy(filterImplicit = filterImplicit) + } + def withOverrideScalaVersion(overrideScalaVersion: Boolean): IvyScala = { + copy(overrideScalaVersion = overrideScalaVersion) + } + def withScalaOrganization(scalaOrganization: String): IvyScala = { + copy(scalaOrganization = scalaOrganization) + } + def withScalaArtifacts(scalaArtifacts: scala.Vector[String]): IvyScala = { + copy(scalaArtifacts = scalaArtifacts) + } +} +object IvyScala extends sbt.librarymanagement.IvyScalaFunctions { + + def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean): IvyScala = new IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts) + def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String]): IvyScala = new IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScalaFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScalaFormats.scala new file mode 100644 index 000000000..b12207105 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScalaFormats.scala @@ -0,0 +1,41 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait IvyScalaFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val IvyScalaFormat: JsonFormat[sbt.librarymanagement.IvyScala] = new JsonFormat[sbt.librarymanagement.IvyScala] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.IvyScala = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val scalaFullVersion = unbuilder.readField[String]("scalaFullVersion") + val scalaBinaryVersion = unbuilder.readField[String]("scalaBinaryVersion") + val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations") + val checkExplicit = unbuilder.readField[Boolean]("checkExplicit") + val filterImplicit = unbuilder.readField[Boolean]("filterImplicit") + val overrideScalaVersion = unbuilder.readField[Boolean]("overrideScalaVersion") + val scalaOrganization = unbuilder.readField[String]("scalaOrganization") + val scalaArtifacts = unbuilder.readField[scala.Vector[String]]("scalaArtifacts") + unbuilder.endObject() + sbt.librarymanagement.IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.IvyScala, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("scalaFullVersion", obj.scalaFullVersion) + builder.addField("scalaBinaryVersion", obj.scalaBinaryVersion) + builder.addField("configurations", obj.configurations) + builder.addField("checkExplicit", obj.checkExplicit) + builder.addField("filterImplicit", obj.filterImplicit) + builder.addField("overrideScalaVersion", obj.overrideScalaVersion) + builder.addField("scalaOrganization", obj.scalaOrganization) + builder.addField("scalaArtifacts", obj.scalaArtifacts) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala new file mode 100644 index 000000000..33742d372 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala @@ -0,0 +1,44 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class KeyFileAuthentication private ( + val user: String, + val keyfile: java.io.File, + val password: Option[String]) extends sbt.librarymanagement.SshAuthentication() with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: KeyFileAuthentication => (this.user == x.user) && (this.keyfile == x.keyfile) && (this.password == x.password) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "KeyFileAuthentication".##) + user.##) + keyfile.##) + password.##) + } + override def toString: String = { + "KeyFileAuthentication(" + user + ", " + keyfile + ", " + password + ")" + } + protected[this] def copy(user: String = user, keyfile: java.io.File = keyfile, password: Option[String] = password): KeyFileAuthentication = { + new KeyFileAuthentication(user, keyfile, password) + } + def withUser(user: String): KeyFileAuthentication = { + copy(user = user) + } + def withKeyfile(keyfile: java.io.File): KeyFileAuthentication = { + copy(keyfile = keyfile) + } + def withPassword(password: Option[String]): KeyFileAuthentication = { + copy(password = password) + } + def withPassword(password: String): KeyFileAuthentication = { + copy(password = Option(password)) + } +} +object KeyFileAuthentication { + + def apply(user: String, keyfile: java.io.File, password: Option[String]): KeyFileAuthentication = new KeyFileAuthentication(user, keyfile, password) + def apply(user: String, keyfile: java.io.File, password: String): KeyFileAuthentication = new KeyFileAuthentication(user, keyfile, Option(password)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala new file mode 100644 index 000000000..965c48625 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait KeyFileAuthenticationFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val KeyFileAuthenticationFormat: JsonFormat[sbt.librarymanagement.KeyFileAuthentication] = new JsonFormat[sbt.librarymanagement.KeyFileAuthentication] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.KeyFileAuthentication = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val user = unbuilder.readField[String]("user") + val keyfile = unbuilder.readField[java.io.File]("keyfile") + val password = unbuilder.readField[Option[String]]("password") + unbuilder.endObject() + sbt.librarymanagement.KeyFileAuthentication(user, keyfile, password) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.KeyFileAuthentication, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("user", obj.user) + builder.addField("keyfile", obj.keyfile) + builder.addField("password", obj.password) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala new file mode 100644 index 000000000..9745a4d1a --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala @@ -0,0 +1,66 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +trait LibraryManagementCodec extends sjsonnew.BasicJsonProtocol + with sbt.librarymanagement.ConfigurationFormats + with sbt.librarymanagement.ChecksumFormats + with sbt.librarymanagement.ArtifactFormats + with sbt.librarymanagement.ArtifactTypeFilterFormats + with sbt.librarymanagement.DisabledFormats + with sbt.librarymanagement.BinaryFormats + with sbt.librarymanagement.ConstantFormats + with sbt.librarymanagement.PatchFormats + with sbt.librarymanagement.FullFormats + with sbt.librarymanagement.CrossVersionFormats + with sbt.librarymanagement.InclExclRuleFormats + with sbt.librarymanagement.ModuleIDFormats + with sbt.librarymanagement.CallerFormats + with sbt.librarymanagement.ModuleReportFormats + with sbt.librarymanagement.OrganizationArtifactReportFormats + with sbt.librarymanagement.ConfigurationReportFormats + with sbt.librarymanagement.ConflictManagerFormats + with sbt.librarymanagement.DeveloperFormats + with sbt.librarymanagement.FileConfigurationFormats + with sbt.librarymanagement.IvyScalaFormats + with sbt.librarymanagement.ChainedResolverFormats + with sbt.librarymanagement.MavenRepoFormats + with sbt.librarymanagement.MavenCacheFormats + with sbt.librarymanagement.PatternsFormats + with sbt.librarymanagement.FileRepositoryFormats + with sbt.librarymanagement.URLRepositoryFormats + with sbt.librarymanagement.PasswordAuthenticationFormats + with sbt.librarymanagement.KeyFileAuthenticationFormats + with sbt.librarymanagement.SshAuthenticationFormats + with sbt.librarymanagement.SshConnectionFormats + with sbt.librarymanagement.SshRepositoryFormats + with sbt.librarymanagement.SftpRepositoryFormats + with sbt.librarymanagement.ResolverFormats + with sbt.librarymanagement.ModuleConfigurationFormats + with sbt.librarymanagement.ScmInfoFormats + with sbt.librarymanagement.ModuleInfoFormats + with sbt.librarymanagement.IvyFileConfigurationFormats + with sbt.librarymanagement.PomConfigurationFormats + with sbt.internal.librarymanagement.formats.NodeSeqFormat + with sbt.librarymanagement.InlineConfigurationFormats + with sbt.librarymanagement.ModuleSettingsFormats + with sbt.librarymanagement.MavenRepositoryFormats + with sbt.librarymanagement.PatternsBasedRepositoryFormats + with sbt.librarymanagement.SshBasedRepositoryFormats + with sbt.librarymanagement.RetrieveConfigurationFormats + with sbt.librarymanagement.UpdateLoggingFormats + with sbt.librarymanagement.UpdateConfigurationFormats + with sbt.librarymanagement.UpdateStatsFormats + with sbt.librarymanagement.UpdateReportFormats + with sbt.librarymanagement.ConfigurationReportLiteFormats + with sbt.internal.librarymanagement.formats.GlobalLockFormat + with sbt.internal.librarymanagement.formats.LoggerFormat + with sbt.internal.librarymanagement.formats.UpdateOptionsFormat + with sbt.librarymanagement.IvyPathsFormats + with sbt.librarymanagement.InlineIvyConfigurationFormats + with sbt.librarymanagement.ExternalIvyConfigurationFormats + with sbt.librarymanagement.IvyConfigurationFormats + with sbt.librarymanagement.UpdateReportLiteFormats +object LibraryManagementCodec extends LibraryManagementCodec \ No newline at end of file diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala new file mode 100644 index 000000000..5ecbb9173 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala @@ -0,0 +1,50 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * An instance of maven CACHE directory. You cannot treat a cache directory the same as a a remote repository because + * the metadata is different (see Aether ML discussion). + */ +final class MavenCache private ( + name: String, + root: String, + localIfFile: Boolean, + val rootFile: java.io.File) extends sbt.librarymanagement.MavenRepository(name, root, localIfFile) with Serializable { + def this(name: String, rootFile: java.io.File) = this(name, rootFile.toURI.toURL.toString, true, rootFile) + def isCache: Boolean = true + private def this(name: String, root: String, rootFile: java.io.File) = this(name, root, true, rootFile) + + override def equals(o: Any): Boolean = o match { + case x: MavenCache => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile) && (this.rootFile == x.rootFile) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "MavenCache".##) + name.##) + root.##) + localIfFile.##) + rootFile.##) + } + override def toString: String = { + s"cache:$name: ${rootFile.getAbsolutePath}" + } + protected[this] def copy(name: String = name, root: String = root, localIfFile: Boolean = localIfFile, rootFile: java.io.File = rootFile): MavenCache = { + new MavenCache(name, root, localIfFile, rootFile) + } + def withName(name: String): MavenCache = { + copy(name = name) + } + def withRoot(root: String): MavenCache = { + copy(root = root) + } + def withLocalIfFile(localIfFile: Boolean): MavenCache = { + copy(localIfFile = localIfFile) + } + def withRootFile(rootFile: java.io.File): MavenCache = { + copy(rootFile = rootFile) + } +} +object MavenCache { + def apply(name: String, rootFile: java.io.File): MavenCache = new MavenCache(name, rootFile) + def apply(name: String, root: String, rootFile: java.io.File): MavenCache = new MavenCache(name, root, true, rootFile) + def apply(name: String, root: String, localIfFile: Boolean, rootFile: java.io.File): MavenCache = new MavenCache(name, root, localIfFile, rootFile) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala new file mode 100644 index 000000000..4079ded96 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait MavenCacheFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val MavenCacheFormat: JsonFormat[sbt.librarymanagement.MavenCache] = new JsonFormat[sbt.librarymanagement.MavenCache] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.MavenCache = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val root = unbuilder.readField[String]("root") + val localIfFile = unbuilder.readField[Boolean]("localIfFile") + val rootFile = unbuilder.readField[java.io.File]("rootFile") + unbuilder.endObject() + sbt.librarymanagement.MavenCache(name, root, localIfFile, rootFile) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.MavenCache, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("root", obj.root) + builder.addField("localIfFile", obj.localIfFile) + builder.addField("rootFile", obj.rootFile) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepo.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepo.scala new file mode 100644 index 000000000..1374e2d0b --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepo.scala @@ -0,0 +1,41 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class MavenRepo private ( + name: String, + root: String, + localIfFile: Boolean) extends sbt.librarymanagement.MavenRepository(name, root, localIfFile) with Serializable { + def isCache: Boolean = false + private def this(name: String, root: String) = this(name, root, true) + + override def equals(o: Any): Boolean = o match { + case x: MavenRepo => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "MavenRepo".##) + name.##) + root.##) + localIfFile.##) + } + override def toString: String = { + s"$name: $root" + } + protected[this] def copy(name: String = name, root: String = root, localIfFile: Boolean = localIfFile): MavenRepo = { + new MavenRepo(name, root, localIfFile) + } + def withName(name: String): MavenRepo = { + copy(name = name) + } + def withRoot(root: String): MavenRepo = { + copy(root = root) + } + def withLocalIfFile(localIfFile: Boolean): MavenRepo = { + copy(localIfFile = localIfFile) + } +} +object MavenRepo { + + def apply(name: String, root: String): MavenRepo = new MavenRepo(name, root, true) + def apply(name: String, root: String, localIfFile: Boolean): MavenRepo = new MavenRepo(name, root, localIfFile) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala new file mode 100644 index 000000000..235de9643 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait MavenRepoFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val MavenRepoFormat: JsonFormat[sbt.librarymanagement.MavenRepo] = new JsonFormat[sbt.librarymanagement.MavenRepo] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.MavenRepo = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val root = unbuilder.readField[String]("root") + val localIfFile = unbuilder.readField[Boolean]("localIfFile") + unbuilder.endObject() + sbt.librarymanagement.MavenRepo(name, root, localIfFile) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.MavenRepo, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("root", obj.root) + builder.addField("localIfFile", obj.localIfFile) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala new file mode 100644 index 000000000..b3487a7d4 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** An instance of a remote maven repository. Note: This will use Aether/Maven to resolve artifacts. */ +abstract class MavenRepository( + name: String, + val root: String, + val localIfFile: Boolean) extends sbt.librarymanagement.Resolver(name) with Serializable { + def isCache: Boolean + def this(name: String, root: String) = this(name, root, true) + + + override def equals(o: Any): Boolean = o match { + case x: MavenRepository => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "MavenRepository".##) + name.##) + root.##) + localIfFile.##) + } + override def toString: String = { + "MavenRepository(" + name + ", " + root + ", " + localIfFile + ")" + } +} +object MavenRepository extends sbt.librarymanagement.MavenRepositoryFunctions { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala new file mode 100644 index 000000000..6e8a14d3c --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait MavenRepositoryFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.MavenRepoFormats with sbt.librarymanagement.MavenCacheFormats => +implicit lazy val MavenRepositoryFormat: JsonFormat[sbt.librarymanagement.MavenRepository] = flatUnionFormat2[sbt.librarymanagement.MavenRepository, sbt.librarymanagement.MavenRepo, sbt.librarymanagement.MavenCache]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala new file mode 100644 index 000000000..7198727a9 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala @@ -0,0 +1,45 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class ModuleConfiguration private ( + val organization: String, + val name: String, + val revision: String, + val resolver: sbt.librarymanagement.Resolver) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: ModuleConfiguration => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.resolver == x.resolver) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "ModuleConfiguration".##) + organization.##) + name.##) + revision.##) + resolver.##) + } + override def toString: String = { + "ModuleConfiguration(" + organization + ", " + name + ", " + revision + ", " + resolver + ")" + } + protected[this] def copy(organization: String = organization, name: String = name, revision: String = revision, resolver: sbt.librarymanagement.Resolver = resolver): ModuleConfiguration = { + new ModuleConfiguration(organization, name, revision, resolver) + } + def withOrganization(organization: String): ModuleConfiguration = { + copy(organization = organization) + } + def withName(name: String): ModuleConfiguration = { + copy(name = name) + } + def withRevision(revision: String): ModuleConfiguration = { + copy(revision = revision) + } + def withResolver(resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = { + copy(resolver = resolver) + } +} +object ModuleConfiguration { + def apply(org: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = apply(org, "*", "*", resolver) + def apply(org: String, name: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = ModuleConfiguration(org, name, "*", resolver) + def apply(organization: String, name: String, revision: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = new ModuleConfiguration(organization, name, revision, resolver) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala new file mode 100644 index 000000000..8ac48ea5c --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ModuleConfigurationFormats { self: sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ModuleConfigurationFormat: JsonFormat[sbt.librarymanagement.ModuleConfiguration] = new JsonFormat[sbt.librarymanagement.ModuleConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val organization = unbuilder.readField[String]("organization") + val name = unbuilder.readField[String]("name") + val revision = unbuilder.readField[String]("revision") + val resolver = unbuilder.readField[sbt.librarymanagement.Resolver]("resolver") + unbuilder.endObject() + sbt.librarymanagement.ModuleConfiguration(organization, name, revision, resolver) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ModuleConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("organization", obj.organization) + builder.addField("name", obj.name) + builder.addField("revision", obj.revision) + builder.addField("resolver", obj.resolver) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala new file mode 100644 index 000000000..4e117921e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala @@ -0,0 +1,81 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class ModuleID private ( + val organization: String, + val name: String, + val revision: String, + val configurations: Option[String], + val isChanging: Boolean, + val isTransitive: Boolean, + val isForce: Boolean, + val explicitArtifacts: Vector[sbt.librarymanagement.Artifact], + val inclusions: Vector[sbt.librarymanagement.InclExclRule], + val exclusions: Vector[sbt.librarymanagement.InclExclRule], + val extraAttributes: Map[String, String], + val crossVersion: sbt.librarymanagement.CrossVersion, + val branchName: Option[String]) extends sbt.librarymanagement.ModuleIDExtra with Serializable { + + private def this(organization: String, name: String, revision: String) = this(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None) + + override def equals(o: Any): Boolean = o match { + case x: ModuleID => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.configurations == x.configurations) && (this.isChanging == x.isChanging) && (this.isTransitive == x.isTransitive) && (this.isForce == x.isForce) && (this.explicitArtifacts == x.explicitArtifacts) && (this.inclusions == x.inclusions) && (this.exclusions == x.exclusions) && (this.extraAttributes == x.extraAttributes) && (this.crossVersion == x.crossVersion) && (this.branchName == x.branchName) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ModuleID".##) + organization.##) + name.##) + revision.##) + configurations.##) + isChanging.##) + isTransitive.##) + isForce.##) + explicitArtifacts.##) + inclusions.##) + exclusions.##) + extraAttributes.##) + crossVersion.##) + branchName.##) + } + override def toString: String = { + this.toStringImpl + } + protected[this] def copy(organization: String = organization, name: String = name, revision: String = revision, configurations: Option[String] = configurations, isChanging: Boolean = isChanging, isTransitive: Boolean = isTransitive, isForce: Boolean = isForce, explicitArtifacts: Vector[sbt.librarymanagement.Artifact] = explicitArtifacts, inclusions: Vector[sbt.librarymanagement.InclExclRule] = inclusions, exclusions: Vector[sbt.librarymanagement.InclExclRule] = exclusions, extraAttributes: Map[String, String] = extraAttributes, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion, branchName: Option[String] = branchName): ModuleID = { + new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName) + } + def withOrganization(organization: String): ModuleID = { + copy(organization = organization) + } + def withName(name: String): ModuleID = { + copy(name = name) + } + def withRevision(revision: String): ModuleID = { + copy(revision = revision) + } + def withConfigurations(configurations: Option[String]): ModuleID = { + copy(configurations = configurations) + } + def withIsChanging(isChanging: Boolean): ModuleID = { + copy(isChanging = isChanging) + } + def withIsTransitive(isTransitive: Boolean): ModuleID = { + copy(isTransitive = isTransitive) + } + def withIsForce(isForce: Boolean): ModuleID = { + copy(isForce = isForce) + } + def withExplicitArtifacts(explicitArtifacts: Vector[sbt.librarymanagement.Artifact]): ModuleID = { + copy(explicitArtifacts = explicitArtifacts) + } + def withInclusions(inclusions: Vector[sbt.librarymanagement.InclExclRule]): ModuleID = { + copy(inclusions = inclusions) + } + def withExclusions(exclusions: Vector[sbt.librarymanagement.InclExclRule]): ModuleID = { + copy(exclusions = exclusions) + } + def withExtraAttributes(extraAttributes: Map[String, String]): ModuleID = { + copy(extraAttributes = extraAttributes) + } + def withCrossVersion(crossVersion: sbt.librarymanagement.CrossVersion): ModuleID = { + copy(crossVersion = crossVersion) + } + def withBranchName(branchName: Option[String]): ModuleID = { + copy(branchName = branchName) + } +} +object ModuleID extends sbt.librarymanagement.ModuleIDFunctions { + + def apply(organization: String, name: String, revision: String): ModuleID = new ModuleID(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None) + def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String]): ModuleID = new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala new file mode 100644 index 000000000..55d0d2fc4 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala @@ -0,0 +1,51 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ModuleIDFormats { self: sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ModuleIDFormat: JsonFormat[sbt.librarymanagement.ModuleID] = new JsonFormat[sbt.librarymanagement.ModuleID] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleID = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val organization = unbuilder.readField[String]("organization") + val name = unbuilder.readField[String]("name") + val revision = unbuilder.readField[String]("revision") + val configurations = unbuilder.readField[Option[String]]("configurations") + val isChanging = unbuilder.readField[Boolean]("isChanging") + val isTransitive = unbuilder.readField[Boolean]("isTransitive") + val isForce = unbuilder.readField[Boolean]("isForce") + val explicitArtifacts = unbuilder.readField[Vector[sbt.librarymanagement.Artifact]]("explicitArtifacts") + val inclusions = unbuilder.readField[Vector[sbt.librarymanagement.InclExclRule]]("inclusions") + val exclusions = unbuilder.readField[Vector[sbt.librarymanagement.InclExclRule]]("exclusions") + val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes") + val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion") + val branchName = unbuilder.readField[Option[String]]("branchName") + unbuilder.endObject() + sbt.librarymanagement.ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ModuleID, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("organization", obj.organization) + builder.addField("name", obj.name) + builder.addField("revision", obj.revision) + builder.addField("configurations", obj.configurations) + builder.addField("isChanging", obj.isChanging) + builder.addField("isTransitive", obj.isTransitive) + builder.addField("isForce", obj.isForce) + builder.addField("explicitArtifacts", obj.explicitArtifacts) + builder.addField("inclusions", obj.inclusions) + builder.addField("exclusions", obj.exclusions) + builder.addField("extraAttributes", obj.extraAttributes) + builder.addField("crossVersion", obj.crossVersion) + builder.addField("branchName", obj.branchName) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfo.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfo.scala new file mode 100644 index 000000000..ef9dc5ac1 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfo.scala @@ -0,0 +1,66 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Additional information about a project module */ +final class ModuleInfo private ( + val nameFormal: String, + val description: String, + val homepage: Option[java.net.URL], + val startYear: Option[Int], + val licenses: Vector[scala.Tuple2[String, java.net.URL]], + val organizationName: String, + val organizationHomepage: Option[java.net.URL], + val scmInfo: Option[sbt.librarymanagement.ScmInfo], + val developers: Vector[sbt.librarymanagement.Developer]) extends Serializable { + + private def this(nameFormal: String) = this(nameFormal, "", None, None, Vector.empty, "", None, None, Vector.empty) + + override def equals(o: Any): Boolean = o match { + case x: ModuleInfo => (this.nameFormal == x.nameFormal) && (this.description == x.description) && (this.homepage == x.homepage) && (this.startYear == x.startYear) && (this.licenses == x.licenses) && (this.organizationName == x.organizationName) && (this.organizationHomepage == x.organizationHomepage) && (this.scmInfo == x.scmInfo) && (this.developers == x.developers) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ModuleInfo".##) + nameFormal.##) + description.##) + homepage.##) + startYear.##) + licenses.##) + organizationName.##) + organizationHomepage.##) + scmInfo.##) + developers.##) + } + override def toString: String = { + "ModuleInfo(" + nameFormal + ", " + description + ", " + homepage + ", " + startYear + ", " + licenses + ", " + organizationName + ", " + organizationHomepage + ", " + scmInfo + ", " + developers + ")" + } + protected[this] def copy(nameFormal: String = nameFormal, description: String = description, homepage: Option[java.net.URL] = homepage, startYear: Option[Int] = startYear, licenses: Vector[scala.Tuple2[String, java.net.URL]] = licenses, organizationName: String = organizationName, organizationHomepage: Option[java.net.URL] = organizationHomepage, scmInfo: Option[sbt.librarymanagement.ScmInfo] = scmInfo, developers: Vector[sbt.librarymanagement.Developer] = developers): ModuleInfo = { + new ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers) + } + def withNameFormal(nameFormal: String): ModuleInfo = { + copy(nameFormal = nameFormal) + } + def withDescription(description: String): ModuleInfo = { + copy(description = description) + } + def withHomepage(homepage: Option[java.net.URL]): ModuleInfo = { + copy(homepage = homepage) + } + def withStartYear(startYear: Option[Int]): ModuleInfo = { + copy(startYear = startYear) + } + def withLicenses(licenses: Vector[scala.Tuple2[String, java.net.URL]]): ModuleInfo = { + copy(licenses = licenses) + } + def withOrganizationName(organizationName: String): ModuleInfo = { + copy(organizationName = organizationName) + } + def withOrganizationHomepage(organizationHomepage: Option[java.net.URL]): ModuleInfo = { + copy(organizationHomepage = organizationHomepage) + } + def withScmInfo(scmInfo: Option[sbt.librarymanagement.ScmInfo]): ModuleInfo = { + copy(scmInfo = scmInfo) + } + def withDevelopers(developers: Vector[sbt.librarymanagement.Developer]): ModuleInfo = { + copy(developers = developers) + } +} +object ModuleInfo { + + def apply(nameFormal: String): ModuleInfo = new ModuleInfo(nameFormal, "", None, None, Vector.empty, "", None, None, Vector.empty) + def apply(nameFormal: String, description: String, homepage: Option[java.net.URL], startYear: Option[Int], licenses: Vector[scala.Tuple2[String, java.net.URL]], organizationName: String, organizationHomepage: Option[java.net.URL], scmInfo: Option[sbt.librarymanagement.ScmInfo], developers: Vector[sbt.librarymanagement.Developer]): ModuleInfo = new ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala new file mode 100644 index 000000000..8d9c1c8b0 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala @@ -0,0 +1,43 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ModuleInfoFormats { self: sbt.librarymanagement.ScmInfoFormats with sbt.librarymanagement.DeveloperFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ModuleInfoFormat: JsonFormat[sbt.librarymanagement.ModuleInfo] = new JsonFormat[sbt.librarymanagement.ModuleInfo] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleInfo = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val nameFormal = unbuilder.readField[String]("nameFormal") + val description = unbuilder.readField[String]("description") + val homepage = unbuilder.readField[Option[java.net.URL]]("homepage") + val startYear = unbuilder.readField[Option[Int]]("startYear") + val licenses = unbuilder.readField[Vector[scala.Tuple2[String, java.net.URL]]]("licenses") + val organizationName = unbuilder.readField[String]("organizationName") + val organizationHomepage = unbuilder.readField[Option[java.net.URL]]("organizationHomepage") + val scmInfo = unbuilder.readField[Option[sbt.librarymanagement.ScmInfo]]("scmInfo") + val developers = unbuilder.readField[Vector[sbt.librarymanagement.Developer]]("developers") + unbuilder.endObject() + sbt.librarymanagement.ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ModuleInfo, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("nameFormal", obj.nameFormal) + builder.addField("description", obj.description) + builder.addField("homepage", obj.homepage) + builder.addField("startYear", obj.startYear) + builder.addField("licenses", obj.licenses) + builder.addField("organizationName", obj.organizationName) + builder.addField("organizationHomepage", obj.organizationHomepage) + builder.addField("scmInfo", obj.scmInfo) + builder.addField("developers", obj.developers) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReport.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReport.scala new file mode 100644 index 000000000..625b142f2 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReport.scala @@ -0,0 +1,106 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Provides information about the resolution of a module. + * This information is in the context of a specific configuration. + */ +final class ModuleReport private ( + val module: sbt.librarymanagement.ModuleID, + val artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], + val missingArtifacts: Vector[sbt.librarymanagement.Artifact], + val status: Option[String], + val publicationDate: Option[java.util.Calendar], + val resolver: Option[String], + val artifactResolver: Option[String], + val evicted: Boolean, + val evictedData: Option[String], + val evictedReason: Option[String], + val problem: Option[String], + val homepage: Option[String], + val extraAttributes: Map[String, String], + val isDefault: Option[Boolean], + val branch: Option[String], + val configurations: Vector[String], + val licenses: Vector[scala.Tuple2[String, Option[String]]], + val callers: Vector[sbt.librarymanagement.Caller]) extends sbt.librarymanagement.ModuleReportExtra with Serializable { + + private def this(module: sbt.librarymanagement.ModuleID, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], missingArtifacts: Vector[sbt.librarymanagement.Artifact]) = this(module, artifacts, missingArtifacts, None, None, None, None, false, None, None, None, None, Map.empty, None, None, Vector.empty, Vector.empty, Vector.empty) + + override def equals(o: Any): Boolean = o match { + case x: ModuleReport => (this.module == x.module) && (this.artifacts == x.artifacts) && (this.missingArtifacts == x.missingArtifacts) && (this.status == x.status) && (this.publicationDate == x.publicationDate) && (this.resolver == x.resolver) && (this.artifactResolver == x.artifactResolver) && (this.evicted == x.evicted) && (this.evictedData == x.evictedData) && (this.evictedReason == x.evictedReason) && (this.problem == x.problem) && (this.homepage == x.homepage) && (this.extraAttributes == x.extraAttributes) && (this.isDefault == x.isDefault) && (this.branch == x.branch) && (this.configurations == x.configurations) && (this.licenses == x.licenses) && (this.callers == x.callers) + 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 * (17 + "ModuleReport".##) + module.##) + artifacts.##) + missingArtifacts.##) + status.##) + publicationDate.##) + resolver.##) + artifactResolver.##) + evicted.##) + evictedData.##) + evictedReason.##) + problem.##) + homepage.##) + extraAttributes.##) + isDefault.##) + branch.##) + configurations.##) + licenses.##) + callers.##) + } + override def toString: String = { + s"\t\t$module: " + + (if (arts.size <= 1) "" else "\n\t\t\t") + arts.mkString("\n\t\t\t") + "\n" + } + protected[this] def copy(module: sbt.librarymanagement.ModuleID = module, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]] = artifacts, missingArtifacts: Vector[sbt.librarymanagement.Artifact] = missingArtifacts, status: Option[String] = status, publicationDate: Option[java.util.Calendar] = publicationDate, resolver: Option[String] = resolver, artifactResolver: Option[String] = artifactResolver, evicted: Boolean = evicted, evictedData: Option[String] = evictedData, evictedReason: Option[String] = evictedReason, problem: Option[String] = problem, homepage: Option[String] = homepage, extraAttributes: Map[String, String] = extraAttributes, isDefault: Option[Boolean] = isDefault, branch: Option[String] = branch, configurations: Vector[String] = configurations, licenses: Vector[scala.Tuple2[String, Option[String]]] = licenses, callers: Vector[sbt.librarymanagement.Caller] = callers): ModuleReport = { + new ModuleReport(module, artifacts, missingArtifacts, status, publicationDate, resolver, artifactResolver, evicted, evictedData, evictedReason, problem, homepage, extraAttributes, isDefault, branch, configurations, licenses, callers) + } + def withModule(module: sbt.librarymanagement.ModuleID): ModuleReport = { + copy(module = module) + } + def withArtifacts(artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]]): ModuleReport = { + copy(artifacts = artifacts) + } + def withMissingArtifacts(missingArtifacts: Vector[sbt.librarymanagement.Artifact]): ModuleReport = { + copy(missingArtifacts = missingArtifacts) + } + def withStatus(status: Option[String]): ModuleReport = { + copy(status = status) + } + def withPublicationDate(publicationDate: Option[java.util.Calendar]): ModuleReport = { + copy(publicationDate = publicationDate) + } + def withResolver(resolver: Option[String]): ModuleReport = { + copy(resolver = resolver) + } + def withArtifactResolver(artifactResolver: Option[String]): ModuleReport = { + copy(artifactResolver = artifactResolver) + } + def withEvicted(evicted: Boolean): ModuleReport = { + copy(evicted = evicted) + } + def withEvictedData(evictedData: Option[String]): ModuleReport = { + copy(evictedData = evictedData) + } + def withEvictedReason(evictedReason: Option[String]): ModuleReport = { + copy(evictedReason = evictedReason) + } + def withProblem(problem: Option[String]): ModuleReport = { + copy(problem = problem) + } + def withHomepage(homepage: Option[String]): ModuleReport = { + copy(homepage = homepage) + } + def withExtraAttributes(extraAttributes: Map[String, String]): ModuleReport = { + copy(extraAttributes = extraAttributes) + } + def withIsDefault(isDefault: Option[Boolean]): ModuleReport = { + copy(isDefault = isDefault) + } + def withBranch(branch: Option[String]): ModuleReport = { + copy(branch = branch) + } + def withConfigurations(configurations: Vector[String]): ModuleReport = { + copy(configurations = configurations) + } + def withLicenses(licenses: Vector[scala.Tuple2[String, Option[String]]]): ModuleReport = { + copy(licenses = licenses) + } + def withCallers(callers: Vector[sbt.librarymanagement.Caller]): ModuleReport = { + copy(callers = callers) + } +} +object ModuleReport { + + def apply(module: sbt.librarymanagement.ModuleID, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], missingArtifacts: Vector[sbt.librarymanagement.Artifact]): ModuleReport = new ModuleReport(module, artifacts, missingArtifacts, None, None, None, None, false, None, None, None, None, Map.empty, None, None, Vector.empty, Vector.empty, Vector.empty) + def apply(module: sbt.librarymanagement.ModuleID, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], missingArtifacts: Vector[sbt.librarymanagement.Artifact], status: Option[String], publicationDate: Option[java.util.Calendar], resolver: Option[String], artifactResolver: Option[String], evicted: Boolean, evictedData: Option[String], evictedReason: Option[String], problem: Option[String], homepage: Option[String], extraAttributes: Map[String, String], isDefault: Option[Boolean], branch: Option[String], configurations: Vector[String], licenses: Vector[scala.Tuple2[String, Option[String]]], callers: Vector[sbt.librarymanagement.Caller]): ModuleReport = new ModuleReport(module, artifacts, missingArtifacts, status, publicationDate, resolver, artifactResolver, evicted, evictedData, evictedReason, problem, homepage, extraAttributes, isDefault, branch, configurations, licenses, callers) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReportFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReportFormats.scala new file mode 100644 index 000000000..fedf5b263 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReportFormats.scala @@ -0,0 +1,61 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ModuleReportFormats { self: sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.CallerFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val ModuleReportFormat: JsonFormat[sbt.librarymanagement.ModuleReport] = new JsonFormat[sbt.librarymanagement.ModuleReport] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleReport = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val module = unbuilder.readField[sbt.librarymanagement.ModuleID]("module") + val artifacts = unbuilder.readField[Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]]]("artifacts") + val missingArtifacts = unbuilder.readField[Vector[sbt.librarymanagement.Artifact]]("missingArtifacts") + val status = unbuilder.readField[Option[String]]("status") + val publicationDate = unbuilder.readField[Option[java.util.Calendar]]("publicationDate") + val resolver = unbuilder.readField[Option[String]]("resolver") + val artifactResolver = unbuilder.readField[Option[String]]("artifactResolver") + val evicted = unbuilder.readField[Boolean]("evicted") + val evictedData = unbuilder.readField[Option[String]]("evictedData") + val evictedReason = unbuilder.readField[Option[String]]("evictedReason") + val problem = unbuilder.readField[Option[String]]("problem") + val homepage = unbuilder.readField[Option[String]]("homepage") + val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes") + val isDefault = unbuilder.readField[Option[Boolean]]("isDefault") + val branch = unbuilder.readField[Option[String]]("branch") + val configurations = unbuilder.readField[Vector[String]]("configurations") + val licenses = unbuilder.readField[Vector[scala.Tuple2[String, Option[String]]]]("licenses") + val callers = unbuilder.readField[Vector[sbt.librarymanagement.Caller]]("callers") + unbuilder.endObject() + sbt.librarymanagement.ModuleReport(module, artifacts, missingArtifacts, status, publicationDate, resolver, artifactResolver, evicted, evictedData, evictedReason, problem, homepage, extraAttributes, isDefault, branch, configurations, licenses, callers) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ModuleReport, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("module", obj.module) + builder.addField("artifacts", obj.artifacts) + builder.addField("missingArtifacts", obj.missingArtifacts) + builder.addField("status", obj.status) + builder.addField("publicationDate", obj.publicationDate) + builder.addField("resolver", obj.resolver) + builder.addField("artifactResolver", obj.artifactResolver) + builder.addField("evicted", obj.evicted) + builder.addField("evictedData", obj.evictedData) + builder.addField("evictedReason", obj.evictedReason) + builder.addField("problem", obj.problem) + builder.addField("homepage", obj.homepage) + builder.addField("extraAttributes", obj.extraAttributes) + builder.addField("isDefault", obj.isDefault) + builder.addField("branch", obj.branch) + builder.addField("configurations", obj.configurations) + builder.addField("licenses", obj.licenses) + builder.addField("callers", obj.callers) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala new file mode 100644 index 000000000..e70a3b1f7 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +abstract class ModuleSettings( + val validate: Boolean, + val ivyScala: Option[sbt.librarymanagement.IvyScala]) extends Serializable { + + + + + override def equals(o: Any): Boolean = o match { + case x: ModuleSettings => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "ModuleSettings".##) + validate.##) + ivyScala.##) + } + override def toString: String = { + "ModuleSettings(" + validate + ", " + ivyScala + ")" + } +} +object ModuleSettings { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala new file mode 100644 index 000000000..66ae6c37f --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait ModuleSettingsFormats { self: sbt.librarymanagement.IvyScalaFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.IvyFileConfigurationFormats with sbt.librarymanagement.PomConfigurationFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ModuleInfoFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.internal.librarymanagement.formats.NodeSeqFormat with sbt.librarymanagement.ConfigurationFormats with sbt.librarymanagement.ConflictManagerFormats with sbt.librarymanagement.InlineConfigurationFormats => +implicit lazy val ModuleSettingsFormat: JsonFormat[sbt.librarymanagement.ModuleSettings] = flatUnionFormat3[sbt.librarymanagement.ModuleSettings, sbt.librarymanagement.IvyFileConfiguration, sbt.librarymanagement.PomConfiguration, sbt.internal.librarymanagement.InlineConfiguration]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReport.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReport.scala new file mode 100644 index 000000000..daceb5658 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReport.scala @@ -0,0 +1,51 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * OrganizationArtifactReport represents an organization+name entry in Ivy resolution report. + * In sbt's terminology, "module" consists of organization, name, and version. + * In Ivy's, "module" means just organization and name, and the one including version numbers + * are called revisions. + * + * A sequence of OrganizationArtifactReport called details is newly added to ConfigurationReport, replacing evicted. + * (Note old evicted was just a seq of ModuleIDs). + * OrganizationArtifactReport groups the ModuleReport of both winners and evicted reports by their organization and name, + * which can be used to calculate detailed eviction warning etc. + */ +final class OrganizationArtifactReport private ( + val organization: String, + val name: String, + val modules: Vector[sbt.librarymanagement.ModuleReport]) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: OrganizationArtifactReport => (this.organization == x.organization) && (this.name == x.name) && (this.modules == x.modules) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "OrganizationArtifactReport".##) + organization.##) + name.##) + modules.##) + } + override def toString: String = { + "OrganizationArtifactReport(" + organization + ", " + name + ", " + modules + ")" + } + protected[this] def copy(organization: String = organization, name: String = name, modules: Vector[sbt.librarymanagement.ModuleReport] = modules): OrganizationArtifactReport = { + new OrganizationArtifactReport(organization, name, modules) + } + def withOrganization(organization: String): OrganizationArtifactReport = { + copy(organization = organization) + } + def withName(name: String): OrganizationArtifactReport = { + copy(name = name) + } + def withModules(modules: Vector[sbt.librarymanagement.ModuleReport]): OrganizationArtifactReport = { + copy(modules = modules) + } +} +object OrganizationArtifactReport { + + def apply(organization: String, name: String, modules: Vector[sbt.librarymanagement.ModuleReport]): OrganizationArtifactReport = new OrganizationArtifactReport(organization, name, modules) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala new file mode 100644 index 000000000..eacd8605c --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait OrganizationArtifactReportFormats { self: sbt.librarymanagement.ModuleReportFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val OrganizationArtifactReportFormat: JsonFormat[sbt.librarymanagement.OrganizationArtifactReport] = new JsonFormat[sbt.librarymanagement.OrganizationArtifactReport] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.OrganizationArtifactReport = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val organization = unbuilder.readField[String]("organization") + val name = unbuilder.readField[String]("name") + val modules = unbuilder.readField[Vector[sbt.librarymanagement.ModuleReport]]("modules") + unbuilder.endObject() + sbt.librarymanagement.OrganizationArtifactReport(organization, name, modules) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.OrganizationArtifactReport, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("organization", obj.organization) + builder.addField("name", obj.name) + builder.addField("modules", obj.modules) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala new file mode 100644 index 000000000..ff71e1e0a --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala @@ -0,0 +1,40 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class PasswordAuthentication private ( + val user: String, + val password: Option[String]) extends sbt.librarymanagement.SshAuthentication() with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: PasswordAuthentication => (this.user == x.user) && (this.password == x.password) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "PasswordAuthentication".##) + user.##) + password.##) + } + override def toString: String = { + "PasswordAuthentication(" + user + ", " + password + ")" + } + protected[this] def copy(user: String = user, password: Option[String] = password): PasswordAuthentication = { + new PasswordAuthentication(user, password) + } + def withUser(user: String): PasswordAuthentication = { + copy(user = user) + } + def withPassword(password: Option[String]): PasswordAuthentication = { + copy(password = password) + } + def withPassword(password: String): PasswordAuthentication = { + copy(password = Option(password)) + } +} +object PasswordAuthentication { + + def apply(user: String, password: Option[String]): PasswordAuthentication = new PasswordAuthentication(user, password) + def apply(user: String, password: String): PasswordAuthentication = new PasswordAuthentication(user, Option(password)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala new file mode 100644 index 000000000..0ece82e2a --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait PasswordAuthenticationFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val PasswordAuthenticationFormat: JsonFormat[sbt.librarymanagement.PasswordAuthentication] = new JsonFormat[sbt.librarymanagement.PasswordAuthentication] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.PasswordAuthentication = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val user = unbuilder.readField[String]("user") + val password = unbuilder.readField[Option[String]]("password") + unbuilder.endObject() + sbt.librarymanagement.PasswordAuthentication(user, password) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.PasswordAuthentication, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("user", obj.user) + builder.addField("password", obj.password) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patch.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patch.scala new file mode 100644 index 000000000..f6cefff42 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patch.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Cross-versions a module by stripping off -bin-suffix. + * This is intended for patch-version compatible alternative replacements. + */ +final class Patch private () extends sbt.librarymanagement.CrossVersion() with Serializable { + + + +override def equals(o: Any): Boolean = o match { + case x: Patch => true + case _ => false +} +override def hashCode: Int = { + 37 * (17 + "Patch".##) +} +override def toString: String = { + "Patch()" +} +protected[this] def copy(): Patch = { + new Patch() +} + +} +object Patch { + + def apply(): Patch = new Patch() +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatchFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatchFormats.scala new file mode 100644 index 000000000..c419fcb6a --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatchFormats.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait PatchFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val PatchFormat: JsonFormat[sbt.librarymanagement.Patch] = new JsonFormat[sbt.librarymanagement.Patch] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Patch = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + + unbuilder.endObject() + sbt.librarymanagement.Patch() + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Patch, builder: Builder[J]): Unit = { + builder.beginObject() + + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patterns.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patterns.scala new file mode 100644 index 000000000..5457c8a4a --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patterns.scala @@ -0,0 +1,50 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class Patterns private ( + val ivyPatterns: Vector[String], + val artifactPatterns: Vector[String], + val isMavenCompatible: Boolean, + val descriptorOptional: Boolean, + val skipConsistencyCheck: Boolean) extends Serializable { + + private def this() = this(Vector.empty, Vector.empty, true, false, false) + + override def equals(o: Any): Boolean = o match { + case x: Patterns => (this.ivyPatterns == x.ivyPatterns) && (this.artifactPatterns == x.artifactPatterns) && (this.isMavenCompatible == x.isMavenCompatible) && (this.descriptorOptional == x.descriptorOptional) && (this.skipConsistencyCheck == x.skipConsistencyCheck) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (17 + "Patterns".##) + ivyPatterns.##) + artifactPatterns.##) + isMavenCompatible.##) + descriptorOptional.##) + skipConsistencyCheck.##) + } + override def toString: String = { + "Patterns(ivyPatterns=%s, artifactPatterns=%s, isMavenCompatible=%s, descriptorOptional=%s, skipConsistencyCheck=%s)".format( + ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck) + } + protected[this] def copy(ivyPatterns: Vector[String] = ivyPatterns, artifactPatterns: Vector[String] = artifactPatterns, isMavenCompatible: Boolean = isMavenCompatible, descriptorOptional: Boolean = descriptorOptional, skipConsistencyCheck: Boolean = skipConsistencyCheck): Patterns = { + new Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck) + } + def withIvyPatterns(ivyPatterns: Vector[String]): Patterns = { + copy(ivyPatterns = ivyPatterns) + } + def withArtifactPatterns(artifactPatterns: Vector[String]): Patterns = { + copy(artifactPatterns = artifactPatterns) + } + def withIsMavenCompatible(isMavenCompatible: Boolean): Patterns = { + copy(isMavenCompatible = isMavenCompatible) + } + def withDescriptorOptional(descriptorOptional: Boolean): Patterns = { + copy(descriptorOptional = descriptorOptional) + } + def withSkipConsistencyCheck(skipConsistencyCheck: Boolean): Patterns = { + copy(skipConsistencyCheck = skipConsistencyCheck) + } +} +object Patterns extends sbt.librarymanagement.PatternsFunctions { + + def apply(): Patterns = new Patterns(Vector.empty, Vector.empty, true, false, false) + def apply(ivyPatterns: Vector[String], artifactPatterns: Vector[String], isMavenCompatible: Boolean, descriptorOptional: Boolean, skipConsistencyCheck: Boolean): Patterns = new Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala new file mode 100644 index 000000000..8354c6b44 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala @@ -0,0 +1,28 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** sbt interface to an Ivy repository based on patterns, which is most Ivy repositories. */ +abstract class PatternsBasedRepository( + name: String, + val patterns: sbt.librarymanagement.Patterns) extends sbt.librarymanagement.Resolver(name) with Serializable { + + + + + override def equals(o: Any): Boolean = o match { + case x: PatternsBasedRepository => (this.name == x.name) && (this.patterns == x.patterns) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "PatternsBasedRepository".##) + name.##) + patterns.##) + } + override def toString: String = { + "PatternsBasedRepository(" + name + ", " + patterns + ")" + } +} +object PatternsBasedRepository { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala new file mode 100644 index 000000000..a63b8da50 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait PatternsBasedRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.FileConfigurationFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.FileRepositoryFormats with sbt.librarymanagement.URLRepositoryFormats with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats => +implicit lazy val PatternsBasedRepositoryFormat: JsonFormat[sbt.librarymanagement.PatternsBasedRepository] = flatUnionFormat4[sbt.librarymanagement.PatternsBasedRepository, sbt.librarymanagement.FileRepository, sbt.librarymanagement.URLRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala new file mode 100644 index 000000000..b530299c2 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala @@ -0,0 +1,35 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait PatternsFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val PatternsFormat: JsonFormat[sbt.librarymanagement.Patterns] = new JsonFormat[sbt.librarymanagement.Patterns] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Patterns = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val ivyPatterns = unbuilder.readField[Vector[String]]("ivyPatterns") + val artifactPatterns = unbuilder.readField[Vector[String]]("artifactPatterns") + val isMavenCompatible = unbuilder.readField[Boolean]("isMavenCompatible") + val descriptorOptional = unbuilder.readField[Boolean]("descriptorOptional") + val skipConsistencyCheck = unbuilder.readField[Boolean]("skipConsistencyCheck") + unbuilder.endObject() + sbt.librarymanagement.Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.Patterns, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("ivyPatterns", obj.ivyPatterns) + builder.addField("artifactPatterns", obj.artifactPatterns) + builder.addField("isMavenCompatible", obj.isMavenCompatible) + builder.addField("descriptorOptional", obj.descriptorOptional) + builder.addField("skipConsistencyCheck", obj.skipConsistencyCheck) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfiguration.scala new file mode 100644 index 000000000..ff9b16137 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfiguration.scala @@ -0,0 +1,48 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class PomConfiguration private ( + validate: Boolean, + ivyScala: Option[sbt.librarymanagement.IvyScala], + val file: java.io.File, + val autoScalaTools: Boolean) extends sbt.librarymanagement.ModuleSettings(validate, ivyScala) with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: PomConfiguration => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) && (this.file == x.file) && (this.autoScalaTools == x.autoScalaTools) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "PomConfiguration".##) + validate.##) + ivyScala.##) + file.##) + autoScalaTools.##) + } + override def toString: String = { + "PomConfiguration(" + validate + ", " + ivyScala + ", " + file + ", " + autoScalaTools + ")" + } + protected[this] def copy(validate: Boolean = validate, ivyScala: Option[sbt.librarymanagement.IvyScala] = ivyScala, file: java.io.File = file, autoScalaTools: Boolean = autoScalaTools): PomConfiguration = { + new PomConfiguration(validate, ivyScala, file, autoScalaTools) + } + def withValidate(validate: Boolean): PomConfiguration = { + copy(validate = validate) + } + def withIvyScala(ivyScala: Option[sbt.librarymanagement.IvyScala]): PomConfiguration = { + copy(ivyScala = ivyScala) + } + def withIvyScala(ivyScala: sbt.librarymanagement.IvyScala): PomConfiguration = { + copy(ivyScala = Option(ivyScala)) + } + def withFile(file: java.io.File): PomConfiguration = { + copy(file = file) + } + def withAutoScalaTools(autoScalaTools: Boolean): PomConfiguration = { + copy(autoScalaTools = autoScalaTools) + } +} +object PomConfiguration { + + def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], file: java.io.File, autoScalaTools: Boolean): PomConfiguration = new PomConfiguration(validate, ivyScala, file, autoScalaTools) + def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, file: java.io.File, autoScalaTools: Boolean): PomConfiguration = new PomConfiguration(validate, Option(ivyScala), file, autoScalaTools) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala new file mode 100644 index 000000000..e8a2a787d --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait PomConfigurationFormats { self: sbt.librarymanagement.IvyScalaFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val PomConfigurationFormat: JsonFormat[sbt.librarymanagement.PomConfiguration] = new JsonFormat[sbt.librarymanagement.PomConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.PomConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val validate = unbuilder.readField[Boolean]("validate") + val ivyScala = unbuilder.readField[Option[sbt.librarymanagement.IvyScala]]("ivyScala") + val file = unbuilder.readField[java.io.File]("file") + val autoScalaTools = unbuilder.readField[Boolean]("autoScalaTools") + unbuilder.endObject() + sbt.librarymanagement.PomConfiguration(validate, ivyScala, file, autoScalaTools) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.PomConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("validate", obj.validate) + builder.addField("ivyScala", obj.ivyScala) + builder.addField("file", obj.file) + builder.addField("autoScalaTools", obj.autoScalaTools) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala new file mode 100644 index 000000000..792d0daa6 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala @@ -0,0 +1,26 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +abstract class Resolver( + val name: String) extends Serializable { + + + + + override def equals(o: Any): Boolean = o match { + case x: Resolver => (this.name == x.name) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (17 + "Resolver".##) + name.##) + } + override def toString: String = { + "Resolver(" + name + ")" + } +} +object Resolver extends sbt.librarymanagement.ResolverFunctions { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala new file mode 100644 index 000000000..dc1daceea --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait ResolverFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.ChainedResolverFormats with sbt.librarymanagement.MavenRepoFormats with sbt.librarymanagement.MavenCacheFormats with sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.FileConfigurationFormats with sbt.librarymanagement.FileRepositoryFormats with sbt.librarymanagement.URLRepositoryFormats with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats => +implicit lazy val ResolverFormat: JsonFormat[sbt.librarymanagement.Resolver] = flatUnionFormat7[sbt.librarymanagement.Resolver, sbt.librarymanagement.ChainedResolver, sbt.librarymanagement.MavenRepo, sbt.librarymanagement.MavenCache, sbt.librarymanagement.FileRepository, sbt.librarymanagement.URLRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala new file mode 100644 index 000000000..9fbb51b2d --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait RetrieveConfigurationFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val RetrieveConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.RetrieveConfiguration] = new JsonFormat[sbt.internal.librarymanagement.RetrieveConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.RetrieveConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val retrieveDirectory = unbuilder.readField[java.io.File]("retrieveDirectory") + val outputPattern = unbuilder.readField[String]("outputPattern") + val sync = unbuilder.readField[Boolean]("sync") + val configurationsToRetrieve = unbuilder.readField[Option[Set[sbt.librarymanagement.Configuration]]]("configurationsToRetrieve") + unbuilder.endObject() + sbt.internal.librarymanagement.RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.RetrieveConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("retrieveDirectory", obj.retrieveDirectory) + builder.addField("outputPattern", obj.outputPattern) + builder.addField("sync", obj.sync) + builder.addField("configurationsToRetrieve", obj.configurationsToRetrieve) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala new file mode 100644 index 000000000..701bfc4b1 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala @@ -0,0 +1,46 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** Basic SCM information for a project module */ +final class ScmInfo private ( + val browseUrl: java.net.URL, + val connection: String, + val devConnection: Option[String]) extends Serializable { + + private def this(browseUrl: java.net.URL, connection: String) = this(browseUrl, connection, None) + + override def equals(o: Any): Boolean = o match { + case x: ScmInfo => (this.browseUrl == x.browseUrl) && (this.connection == x.connection) && (this.devConnection == x.devConnection) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "ScmInfo".##) + browseUrl.##) + connection.##) + devConnection.##) + } + override def toString: String = { + "ScmInfo(" + browseUrl + ", " + connection + ", " + devConnection + ")" + } + protected[this] def copy(browseUrl: java.net.URL = browseUrl, connection: String = connection, devConnection: Option[String] = devConnection): ScmInfo = { + new ScmInfo(browseUrl, connection, devConnection) + } + def withBrowseUrl(browseUrl: java.net.URL): ScmInfo = { + copy(browseUrl = browseUrl) + } + def withConnection(connection: String): ScmInfo = { + copy(connection = connection) + } + def withDevConnection(devConnection: Option[String]): ScmInfo = { + copy(devConnection = devConnection) + } + def withDevConnection(devConnection: String): ScmInfo = { + copy(devConnection = Option(devConnection)) + } +} +object ScmInfo { + + def apply(browseUrl: java.net.URL, connection: String): ScmInfo = new ScmInfo(browseUrl, connection, None) + def apply(browseUrl: java.net.URL, connection: String, devConnection: Option[String]): ScmInfo = new ScmInfo(browseUrl, connection, devConnection) + def apply(browseUrl: java.net.URL, connection: String, devConnection: String): ScmInfo = new ScmInfo(browseUrl, connection, Option(devConnection)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala new file mode 100644 index 000000000..38e04f37d --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait ScmInfoFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val ScmInfoFormat: JsonFormat[sbt.librarymanagement.ScmInfo] = new JsonFormat[sbt.librarymanagement.ScmInfo] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ScmInfo = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val browseUrl = unbuilder.readField[java.net.URL]("browseUrl") + val connection = unbuilder.readField[String]("connection") + val devConnection = unbuilder.readField[Option[String]]("devConnection") + unbuilder.endObject() + sbt.librarymanagement.ScmInfo(browseUrl, connection, devConnection) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.ScmInfo, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("browseUrl", obj.browseUrl) + builder.addField("connection", obj.connection) + builder.addField("devConnection", obj.devConnection) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala new file mode 100644 index 000000000..b2a4fe6fc --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala @@ -0,0 +1,43 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** sbt interface for an Ivy repository over sftp. More convenient construction is done using Resolver.sftp. */ +final class SftpRepository private ( + name: String, + patterns: sbt.librarymanagement.Patterns, + connection: sbt.librarymanagement.SshConnection) extends sbt.librarymanagement.SshBasedRepository(name, patterns, connection) with sbt.librarymanagement.SftpRepositoryExtra with Serializable { + def this(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns) = + this(name, patterns, connection) + + + override def equals(o: Any): Boolean = o match { + case x: SftpRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "SftpRepository".##) + name.##) + patterns.##) + connection.##) + } + override def toString: String = { + "SftpRepository(" + name + ", " + patterns + ", " + connection + ")" + } + protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, connection: sbt.librarymanagement.SshConnection = connection): SftpRepository = { + new SftpRepository(name, patterns, connection) + } + def withName(name: String): SftpRepository = { + copy(name = name) + } + def withPatterns(patterns: sbt.librarymanagement.Patterns): SftpRepository = { + copy(patterns = patterns) + } + def withConnection(connection: sbt.librarymanagement.SshConnection): SftpRepository = { + copy(connection = connection) + } +} +object SftpRepository { + def apply(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns) = + new SftpRepository(name, patterns, connection) + def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection): SftpRepository = new SftpRepository(name, patterns, connection) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala new file mode 100644 index 000000000..43932f61e --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait SftpRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.SshConnectionFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val SftpRepositoryFormat: JsonFormat[sbt.librarymanagement.SftpRepository] = new JsonFormat[sbt.librarymanagement.SftpRepository] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SftpRepository = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") + val connection = unbuilder.readField[sbt.librarymanagement.SshConnection]("connection") + unbuilder.endObject() + sbt.librarymanagement.SftpRepository(name, patterns, connection) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.SftpRepository, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("patterns", obj.patterns) + builder.addField("connection", obj.connection) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala new file mode 100644 index 000000000..96b0ec553 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala @@ -0,0 +1,25 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +abstract class SshAuthentication() extends Serializable { + + + + +override def equals(o: Any): Boolean = o match { + case x: SshAuthentication => true + case _ => false +} +override def hashCode: Int = { + 37 * (17 + "SshAuthentication".##) +} +override def toString: String = { + "SshAuthentication()" +} +} +object SshAuthentication { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala new file mode 100644 index 000000000..4539a2598 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait SshAuthenticationFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.PasswordAuthenticationFormats with sbt.librarymanagement.KeyFileAuthenticationFormats => +implicit lazy val SshAuthenticationFormat: JsonFormat[sbt.librarymanagement.SshAuthentication] = flatUnionFormat2[sbt.librarymanagement.SshAuthentication, sbt.librarymanagement.PasswordAuthentication, sbt.librarymanagement.KeyFileAuthentication]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala new file mode 100644 index 000000000..484b74778 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** sbt interface for an Ivy ssh-based repository (ssh and sftp). Requires the Jsch library.. */ +abstract class SshBasedRepository( + name: String, + patterns: sbt.librarymanagement.Patterns, + val connection: sbt.librarymanagement.SshConnection) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with sbt.librarymanagement.SshBasedRepositoryExtra with Serializable { + + + + + override def equals(o: Any): Boolean = o match { + case x: SshBasedRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "SshBasedRepository".##) + name.##) + patterns.##) + connection.##) + } + override def toString: String = { + "SshBasedRepository(" + name + ", " + patterns + ", " + connection + ")" + } +} +object SshBasedRepository { + +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala new file mode 100644 index 000000000..c7f0bff21 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala @@ -0,0 +1,11 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement + +import _root_.sjsonnew.JsonFormat +trait SshBasedRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.SshConnectionFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats => +implicit lazy val SshBasedRepositoryFormat: JsonFormat[sbt.librarymanagement.SshBasedRepository] = flatUnionFormat2[sbt.librarymanagement.SshBasedRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type") +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala new file mode 100644 index 000000000..185d9b8f5 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala @@ -0,0 +1,50 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class SshConnection private ( + val authentication: Option[sbt.librarymanagement.SshAuthentication], + val hostname: Option[String], + val port: Option[Int]) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: SshConnection => (this.authentication == x.authentication) && (this.hostname == x.hostname) && (this.port == x.port) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (17 + "SshConnection".##) + authentication.##) + hostname.##) + port.##) + } + override def toString: String = { + "SshConnection(" + authentication + ", " + hostname + ", " + port + ")" + } + protected[this] def copy(authentication: Option[sbt.librarymanagement.SshAuthentication] = authentication, hostname: Option[String] = hostname, port: Option[Int] = port): SshConnection = { + new SshConnection(authentication, hostname, port) + } + def withAuthentication(authentication: Option[sbt.librarymanagement.SshAuthentication]): SshConnection = { + copy(authentication = authentication) + } + def withAuthentication(authentication: sbt.librarymanagement.SshAuthentication): SshConnection = { + copy(authentication = Option(authentication)) + } + def withHostname(hostname: Option[String]): SshConnection = { + copy(hostname = hostname) + } + def withHostname(hostname: String): SshConnection = { + copy(hostname = Option(hostname)) + } + def withPort(port: Option[Int]): SshConnection = { + copy(port = port) + } + def withPort(port: Int): SshConnection = { + copy(port = Option(port)) + } +} +object SshConnection { + + def apply(authentication: Option[sbt.librarymanagement.SshAuthentication], hostname: Option[String], port: Option[Int]): SshConnection = new SshConnection(authentication, hostname, port) + def apply(authentication: sbt.librarymanagement.SshAuthentication, hostname: String, port: Int): SshConnection = new SshConnection(Option(authentication), Option(hostname), Option(port)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala new file mode 100644 index 000000000..ec0e4cb74 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala @@ -0,0 +1,31 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait SshConnectionFormats { self: sbt.librarymanagement.SshAuthenticationFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val SshConnectionFormat: JsonFormat[sbt.librarymanagement.SshConnection] = new JsonFormat[sbt.librarymanagement.SshConnection] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SshConnection = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val authentication = unbuilder.readField[Option[sbt.librarymanagement.SshAuthentication]]("authentication") + val hostname = unbuilder.readField[Option[String]]("hostname") + val port = unbuilder.readField[Option[Int]]("port") + unbuilder.endObject() + sbt.librarymanagement.SshConnection(authentication, hostname, port) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.SshConnection, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("authentication", obj.authentication) + builder.addField("hostname", obj.hostname) + builder.addField("port", obj.port) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepository.scala new file mode 100644 index 000000000..9a65cfeae --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepository.scala @@ -0,0 +1,51 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** sbt interface for an Ivy repository over ssh. More convenient construction is done using Resolver.ssh. */ +final class SshRepository private ( + name: String, + patterns: sbt.librarymanagement.Patterns, + connection: sbt.librarymanagement.SshConnection, + val publishPermissions: Option[String]) extends sbt.librarymanagement.SshBasedRepository(name, patterns, connection) with sbt.librarymanagement.SshRepositoryExtra with Serializable { + def this(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns, publishPermissions: Option[String]) = + this(name, patterns, connection, publishPermissions) + + + override def equals(o: Any): Boolean = o match { + case x: SshRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection) && (this.publishPermissions == x.publishPermissions) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "SshRepository".##) + name.##) + patterns.##) + connection.##) + publishPermissions.##) + } + override def toString: String = { + "SshRepository(" + name + ", " + patterns + ", " + connection + ", " + publishPermissions + ")" + } + protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, connection: sbt.librarymanagement.SshConnection = connection, publishPermissions: Option[String] = publishPermissions): SshRepository = { + new SshRepository(name, patterns, connection, publishPermissions) + } + def withName(name: String): SshRepository = { + copy(name = name) + } + def withPatterns(patterns: sbt.librarymanagement.Patterns): SshRepository = { + copy(patterns = patterns) + } + def withConnection(connection: sbt.librarymanagement.SshConnection): SshRepository = { + copy(connection = connection) + } + def withPublishPermissions(publishPermissions: Option[String]): SshRepository = { + copy(publishPermissions = publishPermissions) + } + def withPublishPermissions(publishPermissions: String): SshRepository = { + copy(publishPermissions = Option(publishPermissions)) + } +} +object SshRepository { + def apply(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns, publishPermissions: Option[String]) = + new SshRepository(name, patterns, connection, publishPermissions) + def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection, publishPermissions: Option[String]): SshRepository = new SshRepository(name, patterns, connection, publishPermissions) + def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection, publishPermissions: String): SshRepository = new SshRepository(name, patterns, connection, Option(publishPermissions)) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala new file mode 100644 index 000000000..3f6284b2f --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait SshRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.SshConnectionFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val SshRepositoryFormat: JsonFormat[sbt.librarymanagement.SshRepository] = new JsonFormat[sbt.librarymanagement.SshRepository] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SshRepository = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") + val connection = unbuilder.readField[sbt.librarymanagement.SshConnection]("connection") + val publishPermissions = unbuilder.readField[Option[String]]("publishPermissions") + unbuilder.endObject() + sbt.librarymanagement.SshRepository(name, patterns, connection, publishPermissions) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.SshRepository, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("patterns", obj.patterns) + builder.addField("connection", obj.connection) + builder.addField("publishPermissions", obj.publishPermissions) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala new file mode 100644 index 000000000..2120a339b --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala @@ -0,0 +1,36 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class URLRepository private ( + name: String, + patterns: sbt.librarymanagement.Patterns) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: URLRepository => (this.name == x.name) && (this.patterns == x.patterns) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (17 + "URLRepository".##) + name.##) + patterns.##) + } + override def toString: String = { + "URLRepository(" + name + ", " + patterns + ")" + } + protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns): URLRepository = { + new URLRepository(name, patterns) + } + def withName(name: String): URLRepository = { + copy(name = name) + } + def withPatterns(patterns: sbt.librarymanagement.Patterns): URLRepository = { + copy(patterns = patterns) + } +} +object URLRepository { + + def apply(name: String, patterns: sbt.librarymanagement.Patterns): URLRepository = new URLRepository(name, patterns) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepositoryFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepositoryFormats.scala new file mode 100644 index 000000000..dbf9e9cfa --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepositoryFormats.scala @@ -0,0 +1,29 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait URLRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val URLRepositoryFormat: JsonFormat[sbt.librarymanagement.URLRepository] = new JsonFormat[sbt.librarymanagement.URLRepository] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.URLRepository = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val name = unbuilder.readField[String]("name") + val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") + unbuilder.endObject() + sbt.librarymanagement.URLRepository(name, patterns) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.URLRepository, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("name", obj.name) + builder.addField("patterns", obj.patterns) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfiguration.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfiguration.scala new file mode 100644 index 000000000..de5773eed --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfiguration.scala @@ -0,0 +1,56 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class UpdateConfiguration private ( + val retrieve: Option[sbt.internal.librarymanagement.RetrieveConfiguration], + val missingOk: Boolean, + val logging: sbt.librarymanagement.UpdateLogging, + val artifactFilter: sbt.librarymanagement.ArtifactTypeFilter, + val offline: Boolean, + val frozen: Boolean) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: UpdateConfiguration => (this.retrieve == x.retrieve) && (this.missingOk == x.missingOk) && (this.logging == x.logging) && (this.artifactFilter == x.artifactFilter) && (this.offline == x.offline) && (this.frozen == x.frozen) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "UpdateConfiguration".##) + retrieve.##) + missingOk.##) + logging.##) + artifactFilter.##) + offline.##) + frozen.##) + } + override def toString: String = { + "UpdateConfiguration(" + retrieve + ", " + missingOk + ", " + logging + ", " + artifactFilter + ", " + offline + ", " + frozen + ")" + } + protected[this] def copy(retrieve: Option[sbt.internal.librarymanagement.RetrieveConfiguration] = retrieve, missingOk: Boolean = missingOk, logging: sbt.librarymanagement.UpdateLogging = logging, artifactFilter: sbt.librarymanagement.ArtifactTypeFilter = artifactFilter, offline: Boolean = offline, frozen: Boolean = frozen): UpdateConfiguration = { + new UpdateConfiguration(retrieve, missingOk, logging, artifactFilter, offline, frozen) + } + def withRetrieve(retrieve: Option[sbt.internal.librarymanagement.RetrieveConfiguration]): UpdateConfiguration = { + copy(retrieve = retrieve) + } + def withRetrieve(retrieve: sbt.internal.librarymanagement.RetrieveConfiguration): UpdateConfiguration = { + copy(retrieve = Option(retrieve)) + } + def withMissingOk(missingOk: Boolean): UpdateConfiguration = { + copy(missingOk = missingOk) + } + def withLogging(logging: sbt.librarymanagement.UpdateLogging): UpdateConfiguration = { + copy(logging = logging) + } + def withArtifactFilter(artifactFilter: sbt.librarymanagement.ArtifactTypeFilter): UpdateConfiguration = { + copy(artifactFilter = artifactFilter) + } + def withOffline(offline: Boolean): UpdateConfiguration = { + copy(offline = offline) + } + def withFrozen(frozen: Boolean): UpdateConfiguration = { + copy(frozen = frozen) + } +} +object UpdateConfiguration { + + def apply(retrieve: Option[sbt.internal.librarymanagement.RetrieveConfiguration], missingOk: Boolean, logging: sbt.librarymanagement.UpdateLogging, artifactFilter: sbt.librarymanagement.ArtifactTypeFilter, offline: Boolean, frozen: Boolean): UpdateConfiguration = new UpdateConfiguration(retrieve, missingOk, logging, artifactFilter, offline, frozen) + def apply(retrieve: sbt.internal.librarymanagement.RetrieveConfiguration, missingOk: Boolean, logging: sbt.librarymanagement.UpdateLogging, artifactFilter: sbt.librarymanagement.ArtifactTypeFilter, offline: Boolean, frozen: Boolean): UpdateConfiguration = new UpdateConfiguration(Option(retrieve), missingOk, logging, artifactFilter, offline, frozen) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfigurationFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfigurationFormats.scala new file mode 100644 index 000000000..fe2d47956 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateConfigurationFormats.scala @@ -0,0 +1,37 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait UpdateConfigurationFormats { self: sbt.librarymanagement.RetrieveConfigurationFormats with sbt.librarymanagement.UpdateLoggingFormats with sbt.librarymanagement.ArtifactTypeFilterFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val UpdateConfigurationFormat: JsonFormat[sbt.librarymanagement.UpdateConfiguration] = new JsonFormat[sbt.librarymanagement.UpdateConfiguration] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateConfiguration = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val retrieve = unbuilder.readField[Option[sbt.internal.librarymanagement.RetrieveConfiguration]]("retrieve") + val missingOk = unbuilder.readField[Boolean]("missingOk") + val logging = unbuilder.readField[sbt.librarymanagement.UpdateLogging]("logging") + val artifactFilter = unbuilder.readField[sbt.librarymanagement.ArtifactTypeFilter]("artifactFilter") + val offline = unbuilder.readField[Boolean]("offline") + val frozen = unbuilder.readField[Boolean]("frozen") + unbuilder.endObject() + sbt.librarymanagement.UpdateConfiguration(retrieve, missingOk, logging, artifactFilter, offline, frozen) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.UpdateConfiguration, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("retrieve", obj.retrieve) + builder.addField("missingOk", obj.missingOk) + builder.addField("logging", obj.logging) + builder.addField("artifactFilter", obj.artifactFilter) + builder.addField("offline", obj.offline) + builder.addField("frozen", obj.frozen) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLogging.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLogging.scala new file mode 100644 index 000000000..f749ef9d5 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLogging.scala @@ -0,0 +1,22 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Configures logging during an 'update'. `level` determines the amount of other information logged. + * `Full` is the default and logs the most. + * `DownloadOnly` only logs what is downloaded. + * `Quiet` only displays errors. + * `Default` uses the current log level of `update` task. + */ +sealed abstract class UpdateLogging extends Serializable +object UpdateLogging { + + + case object Full extends UpdateLogging + case object DownloadOnly extends UpdateLogging + case object Quiet extends UpdateLogging + case object Default extends UpdateLogging +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLoggingFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLoggingFormats.scala new file mode 100644 index 000000000..77e18d19c --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateLoggingFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait UpdateLoggingFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val UpdateLoggingFormat: JsonFormat[sbt.librarymanagement.UpdateLogging] = new JsonFormat[sbt.librarymanagement.UpdateLogging] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateLogging = { + jsOpt match { + case Some(js) => + unbuilder.readString(js) match { + case "Full" => sbt.librarymanagement.UpdateLogging.Full + case "DownloadOnly" => sbt.librarymanagement.UpdateLogging.DownloadOnly + case "Quiet" => sbt.librarymanagement.UpdateLogging.Quiet + case "Default" => sbt.librarymanagement.UpdateLogging.Default + } + case None => + deserializationError("Expected JsString but found None") + } + } + override def write[J](obj: sbt.librarymanagement.UpdateLogging, builder: Builder[J]): Unit = { + val str = obj match { + case sbt.librarymanagement.UpdateLogging.Full => "Full" + case sbt.librarymanagement.UpdateLogging.DownloadOnly => "DownloadOnly" + case sbt.librarymanagement.UpdateLogging.Quiet => "Quiet" + case sbt.librarymanagement.UpdateLogging.Default => "Default" + } + builder.writeString(str) + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReport.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReport.scala new file mode 100644 index 000000000..00b9e8225 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReport.scala @@ -0,0 +1,52 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +/** + * Provides information about dependency resolution. + * It does not include information about evicted modules, only about the modules ultimately selected by the conflict manager. + * This means that for a given configuration, there should only be one revision for a given organization and module name. + */ +final class UpdateReport private ( + /** the location of the resolved module descriptor in the cache */ + val cachedDescriptor: java.io.File, + /** a sequence containing one report for each configuration resolved. */ + val configurations: Vector[sbt.librarymanagement.ConfigurationReport], + /** stats information about the update that produced this report */ + val stats: sbt.librarymanagement.UpdateStats, + val stamps: Map[java.io.File, Long]) extends sbt.librarymanagement.UpdateReportExtra with Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: UpdateReport => (this.cachedDescriptor == x.cachedDescriptor) && (this.configurations == x.configurations) && (this.stats == x.stats) && (this.stamps == x.stamps) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "UpdateReport".##) + cachedDescriptor.##) + configurations.##) + stats.##) + stamps.##) + } + override def toString: String = { + "Update report:\n\t" + stats + "\n" + configurations.mkString + } + protected[this] def copy(cachedDescriptor: java.io.File = cachedDescriptor, configurations: Vector[sbt.librarymanagement.ConfigurationReport] = configurations, stats: sbt.librarymanagement.UpdateStats = stats, stamps: Map[java.io.File, Long] = stamps): UpdateReport = { + new UpdateReport(cachedDescriptor, configurations, stats, stamps) + } + def withCachedDescriptor(cachedDescriptor: java.io.File): UpdateReport = { + copy(cachedDescriptor = cachedDescriptor) + } + def withConfigurations(configurations: Vector[sbt.librarymanagement.ConfigurationReport]): UpdateReport = { + copy(configurations = configurations) + } + def withStats(stats: sbt.librarymanagement.UpdateStats): UpdateReport = { + copy(stats = stats) + } + def withStamps(stamps: Map[java.io.File, Long]): UpdateReport = { + copy(stamps = stamps) + } +} +object UpdateReport { + + def apply(cachedDescriptor: java.io.File, configurations: Vector[sbt.librarymanagement.ConfigurationReport], stats: sbt.librarymanagement.UpdateStats, stamps: Map[java.io.File, Long]): UpdateReport = new UpdateReport(cachedDescriptor, configurations, stats, stamps) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportFormats.scala new file mode 100644 index 000000000..54e858000 --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait UpdateReportFormats { self: sbt.librarymanagement.ConfigurationReportFormats with sbt.librarymanagement.UpdateStatsFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val UpdateReportFormat: JsonFormat[sbt.librarymanagement.UpdateReport] = new JsonFormat[sbt.librarymanagement.UpdateReport] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateReport = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val cachedDescriptor = unbuilder.readField[java.io.File]("cachedDescriptor") + val configurations = unbuilder.readField[Vector[sbt.librarymanagement.ConfigurationReport]]("configurations") + val stats = unbuilder.readField[sbt.librarymanagement.UpdateStats]("stats") + val stamps = unbuilder.readField[Map[java.io.File, Long]]("stamps") + unbuilder.endObject() + sbt.librarymanagement.UpdateReport(cachedDescriptor, configurations, stats, stamps) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.UpdateReport, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("cachedDescriptor", obj.cachedDescriptor) + builder.addField("configurations", obj.configurations) + builder.addField("stats", obj.stats) + builder.addField("stamps", obj.stamps) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportLiteFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportLiteFormats.scala new file mode 100644 index 000000000..9736e62ca --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateReportLiteFormats.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait UpdateReportLiteFormats { self: sbt.librarymanagement.ConfigurationReportLiteFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val UpdateReportLiteFormat: JsonFormat[sbt.internal.librarymanagement.UpdateReportLite] = new JsonFormat[sbt.internal.librarymanagement.UpdateReportLite] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.UpdateReportLite = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val configurations = unbuilder.readField[Vector[sbt.internal.librarymanagement.ConfigurationReportLite]]("configurations") + unbuilder.endObject() + sbt.internal.librarymanagement.UpdateReportLite(configurations) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.librarymanagement.UpdateReportLite, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("configurations", obj.configurations) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStats.scala new file mode 100644 index 000000000..6b33803da --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStats.scala @@ -0,0 +1,44 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +final class UpdateStats private ( + val resolveTime: Long, + val downloadTime: Long, + val downloadSize: Long, + val cached: Boolean) extends Serializable { + + + + override def equals(o: Any): Boolean = o match { + case x: UpdateStats => (this.resolveTime == x.resolveTime) && (this.downloadTime == x.downloadTime) && (this.downloadSize == x.downloadSize) && (this.cached == x.cached) + case _ => false + } + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "UpdateStats".##) + resolveTime.##) + downloadTime.##) + downloadSize.##) + cached.##) + } + override def toString: String = { + Seq("Resolve time: " + resolveTime + " ms", "Download time: " + downloadTime + " ms", "Download size: " + downloadSize + " bytes").mkString(", ") + } + protected[this] def copy(resolveTime: Long = resolveTime, downloadTime: Long = downloadTime, downloadSize: Long = downloadSize, cached: Boolean = cached): UpdateStats = { + new UpdateStats(resolveTime, downloadTime, downloadSize, cached) + } + def withResolveTime(resolveTime: Long): UpdateStats = { + copy(resolveTime = resolveTime) + } + def withDownloadTime(downloadTime: Long): UpdateStats = { + copy(downloadTime = downloadTime) + } + def withDownloadSize(downloadSize: Long): UpdateStats = { + copy(downloadSize = downloadSize) + } + def withCached(cached: Boolean): UpdateStats = { + copy(cached = cached) + } +} +object UpdateStats { + + def apply(resolveTime: Long, downloadTime: Long, downloadSize: Long, cached: Boolean): UpdateStats = new UpdateStats(resolveTime, downloadTime, downloadSize, cached) +} diff --git a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStatsFormats.scala b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStatsFormats.scala new file mode 100644 index 000000000..21de1bf5c --- /dev/null +++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/UpdateStatsFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.librarymanagement +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait UpdateStatsFormats { self: sjsonnew.BasicJsonProtocol => +implicit lazy val UpdateStatsFormat: JsonFormat[sbt.librarymanagement.UpdateStats] = new JsonFormat[sbt.librarymanagement.UpdateStats] { + override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateStats = { + jsOpt match { + case Some(js) => + unbuilder.beginObject(js) + val resolveTime = unbuilder.readField[Long]("resolveTime") + val downloadTime = unbuilder.readField[Long]("downloadTime") + val downloadSize = unbuilder.readField[Long]("downloadSize") + val cached = unbuilder.readField[Boolean]("cached") + unbuilder.endObject() + sbt.librarymanagement.UpdateStats(resolveTime, downloadTime, downloadSize, cached) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.librarymanagement.UpdateStats, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("resolveTime", obj.resolveTime) + builder.addField("downloadTime", obj.downloadTime) + builder.addField("downloadSize", obj.downloadSize) + builder.addField("cached", obj.cached) + builder.endObject() + } +} +} diff --git a/librarymanagement/src/main/scala/sbt/internal/librarymanagement/IvyCache.scala b/librarymanagement/src/main/scala/sbt/internal/librarymanagement/IvyCache.scala index 5a17a2d82..9a0044aca 100644 --- a/librarymanagement/src/main/scala/sbt/internal/librarymanagement/IvyCache.scala +++ b/librarymanagement/src/main/scala/sbt/internal/librarymanagement/IvyCache.scala @@ -19,7 +19,7 @@ import sbt.io.Path import sbt.librarymanagement._ import sbt.util.Logger -import scala.json.ast.unsafe._ +import scalajson.ast.unsafe._ import scala.collection.mutable import jawn.{ SupportParser, MutableFacade } diff --git a/librarymanagement/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala b/librarymanagement/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala index 0273a2930..0ce279c27 100644 --- a/librarymanagement/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala +++ b/librarymanagement/src/main/scala/sbt/librarymanagement/CrossVersionExtra.scala @@ -5,6 +5,7 @@ import sbt.internal.librarymanagement.cross.CrossVersionUtil final case class ScalaVersion(full: String, binary: String) abstract class CrossVersionFunctions { + /** Compatibility with 0.13 */ final val Disabled = sbt.librarymanagement.Disabled final val Binary = sbt.librarymanagement.Binary diff --git a/librarymanagement/src/test/scala/DMSerializationSpec.scala b/librarymanagement/src/test/scala/DMSerializationSpec.scala index 3fb9ae8e2..06c178d8e 100644 --- a/librarymanagement/src/test/scala/DMSerializationSpec.scala +++ b/librarymanagement/src/test/scala/DMSerializationSpec.scala @@ -4,7 +4,7 @@ import java.net.URL import java.io.File import sbt.internal._, librarymanagement._, util.UnitSpec -import scala.json.ast.unsafe._ +import scalajson.ast.unsafe._ import sjsonnew._, support.scalajson.unsafe._ import org.scalatest.Assertion diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 6c618249f..8567c1012 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -1,12 +1,13 @@ import sbt._ import Keys._ +import sbt.contraband.ContrabandPlugin.autoImport._ object Dependencies { val scala211 = "2.11.11" val scala212 = "2.12.2" - private val ioVersion = "1.0.0-M11" - private val utilVersion = "1.0.0-M23" + private val ioVersion = "1.0.0-M12" + private val utilVersion = "1.0.0-M25" private val sbtIO = "org.scala-sbt" %% "io" % ioVersion @@ -55,8 +56,8 @@ object Dependencies { val jsch = "com.jcraft" % "jsch" % "0.1.46" intransitive () val scalaReflect = Def.setting { "org.scala-lang" % "scala-reflect" % scalaVersion.value } val scalaXml = scala211Module("scala-xml", "1.0.5") - val sjsonnewVersion = "0.8.0-M1" - val sjsonnewScalaJson = "com.eed3si9n" %% "sjson-new-scalajson" % sjsonnewVersion + val sjsonnew = Def.setting { "com.eed3si9n" %% "sjson-new-core" % contrabandSjsonNewVersion.value } + val sjsonnewScalaJson = Def.setting { "com.eed3si9n" %% "sjson-new-scalajson" % contrabandSjsonNewVersion.value } val gigahorseOkhttp = "com.eed3si9n" %% "gigahorse-okhttp" % "0.3.0" val okhttpUrlconnection = "com.squareup.okhttp3" % "okhttp-urlconnection" % "3.7.0" diff --git a/project/plugins.sbt b/project/plugins.sbt index 64f6761ab..ae33ece34 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -1,5 +1,5 @@ addSbtPlugin("org.scala-sbt" % "sbt-houserules" % "0.3.3") -addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.3.0-M5") +addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.3.0-M7") addSbtPlugin("org.foundweekends" % "sbt-bintray" % "0.4.0") addSbtPlugin("com.lucidchart" % "sbt-scalafmt" % "1.3")