├── .git-blame-ignore-revs ├── .github ├── ISSUE_TEMPLATE │ └── no-new-issues.md └── workflows │ ├── ci.yml │ ├── cla.yml │ └── format.yml ├── .gitignore ├── .java-version ├── .scalafmt.conf ├── LICENSE ├── README.md ├── bin └── fixpreloaded.sh ├── build.sbt ├── core ├── NOTICE └── src │ ├── main │ ├── contraband-scala │ │ └── sbt │ │ │ ├── internal │ │ │ └── librarymanagement │ │ │ │ ├── ConfigurationReportLite.scala │ │ │ │ ├── SemComparator.scala │ │ │ │ ├── SemSelAndChunk.scala │ │ │ │ └── UpdateReportLite.scala │ │ │ └── librarymanagement │ │ │ ├── Artifact.scala │ │ │ ├── ArtifactFormats.scala │ │ │ ├── ArtifactTypeFilter.scala │ │ │ ├── ArtifactTypeFilterFormats.scala │ │ │ ├── Caller.scala │ │ │ ├── CallerFormats.scala │ │ │ ├── ChainedResolver.scala │ │ │ ├── ChainedResolverFormats.scala │ │ │ ├── Checksum.scala │ │ │ ├── ChecksumFormats.scala │ │ │ ├── ConfigurationReport.scala │ │ │ ├── ConfigurationReportFormats.scala │ │ │ ├── ConfigurationReportLiteFormats.scala │ │ │ ├── ConflictManager.scala │ │ │ ├── ConflictManagerFormats.scala │ │ │ ├── Developer.scala │ │ │ ├── DeveloperFormats.scala │ │ │ ├── FileConfiguration.scala │ │ │ ├── FileConfigurationFormats.scala │ │ │ ├── FileRepository.scala │ │ │ ├── FileRepositoryFormats.scala │ │ │ ├── GetClassifiersConfiguration.scala │ │ │ ├── GetClassifiersConfigurationFormats.scala │ │ │ ├── GetClassifiersModule.scala │ │ │ ├── GetClassifiersModuleFormats.scala │ │ │ ├── InclExclRule.scala │ │ │ ├── InclExclRuleFormats.scala │ │ │ ├── IvyFileConfiguration.scala │ │ │ ├── IvyFileConfigurationFormats.scala │ │ │ ├── KeyFileAuthentication.scala │ │ │ ├── KeyFileAuthenticationFormats.scala │ │ │ ├── LibraryManagementCodec.scala │ │ │ ├── MakePomConfiguration.scala │ │ │ ├── MavenCache.scala │ │ │ ├── MavenCacheFormats.scala │ │ │ ├── MavenRepo.scala │ │ │ ├── MavenRepoFormats.scala │ │ │ ├── MavenRepository.scala │ │ │ ├── MavenRepositoryFormats.scala │ │ │ ├── ModuleConfiguration.scala │ │ │ ├── ModuleConfigurationFormats.scala │ │ │ ├── ModuleDescriptorConfiguration.scala │ │ │ ├── ModuleDescriptorConfigurationFormats.scala │ │ │ ├── ModuleID.scala │ │ │ ├── ModuleIDFormats.scala │ │ │ ├── ModuleInfo.scala │ │ │ ├── ModuleInfoFormats.scala │ │ │ ├── ModuleReport.scala │ │ │ ├── ModuleReportFormats.scala │ │ │ ├── ModuleSettings.scala │ │ │ ├── ModuleSettingsFormats.scala │ │ │ ├── OrganizationArtifactReport.scala │ │ │ ├── OrganizationArtifactReportFormats.scala │ │ │ ├── PasswordAuthentication.scala │ │ │ ├── PasswordAuthenticationFormats.scala │ │ │ ├── Patterns.scala │ │ │ ├── PatternsBasedRepository.scala │ │ │ ├── PatternsBasedRepositoryFormats.scala │ │ │ ├── PatternsFormats.scala │ │ │ ├── PomConfiguration.scala │ │ │ ├── PomConfigurationFormats.scala │ │ │ ├── PublishConfiguration.scala │ │ │ ├── PublishConfigurationFormats.scala │ │ │ ├── Resolver.scala │ │ │ ├── ResolverFormats.scala │ │ │ ├── RetrieveConfiguration.scala │ │ │ ├── RetrieveConfigurationFormats.scala │ │ │ ├── ScalaModuleInfo.scala │ │ │ ├── ScalaModuleInfoFormats.scala │ │ │ ├── ScmInfo.scala │ │ │ ├── ScmInfoFormats.scala │ │ │ ├── SemanticSelector.scala │ │ │ ├── SftpRepository.scala │ │ │ ├── SftpRepositoryFormats.scala │ │ │ ├── SshAuthentication.scala │ │ │ ├── SshAuthenticationFormats.scala │ │ │ ├── SshBasedRepository.scala │ │ │ ├── SshBasedRepositoryFormats.scala │ │ │ ├── SshConnection.scala │ │ │ ├── SshConnectionFormats.scala │ │ │ ├── SshRepository.scala │ │ │ ├── SshRepositoryFormats.scala │ │ │ ├── URLRepository.scala │ │ │ ├── URLRepositoryFormats.scala │ │ │ ├── UpdateConfiguration.scala │ │ │ ├── UpdateConfigurationFormats.scala │ │ │ ├── UpdateLogging.scala │ │ │ ├── UpdateLoggingFormats.scala │ │ │ ├── UpdateReport.scala │ │ │ ├── UpdateReportFormats.scala │ │ │ ├── UpdateReportLiteFormats.scala │ │ │ ├── UpdateStats.scala │ │ │ └── UpdateStatsFormats.scala │ ├── contraband │ │ ├── librarymanagement.json │ │ └── librarymanagement2.json │ ├── java │ │ └── sbt │ │ │ └── internal │ │ │ └── librarymanagement │ │ │ └── mavenint │ │ │ └── SbtPomExtraProperties.java │ └── scala │ │ └── sbt │ │ ├── internal │ │ └── librarymanagement │ │ │ ├── CompatibilityWarning.scala │ │ │ ├── InternalDefaults.scala │ │ │ ├── IvyConfigurations.scala │ │ │ ├── JsonUtil.scala │ │ │ ├── LMSysProp.scala │ │ │ ├── SemSelOperator.scala │ │ │ ├── SemanticSelectorExtra.scala │ │ │ ├── StringUtilities.scala │ │ │ ├── UpdateClassifiersUtil.scala │ │ │ ├── VersionRange.scala │ │ │ ├── VersionSchemes.scala │ │ │ ├── cross │ │ │ └── CrossVersionUtil.scala │ │ │ └── formats │ │ │ ├── GlobalLockFormat.scala │ │ │ ├── LoggerFormat.scala │ │ │ ├── LogicalClockFormats.scala │ │ │ └── NodeSeqFormat.scala │ │ └── librarymanagement │ │ ├── ArtifactExtra.scala │ │ ├── ConfigRef.scala │ │ ├── ConfigRefFormats.scala │ │ ├── Configuration.scala │ │ ├── ConfigurationExtra.scala │ │ ├── ConfigurationFormats.scala │ │ ├── ConflictWarning.scala │ │ ├── CrossVersion.scala │ │ ├── CrossVersionExtra.scala │ │ ├── DependencyBuilders.scala │ │ ├── DependencyFilter.scala │ │ ├── DependencyResolution.scala │ │ ├── EvictionError.scala │ │ ├── EvictionWarning.scala │ │ ├── Extra.scala │ │ ├── Http.scala │ │ ├── LibraryManagementInterface.scala │ │ ├── LibraryManagementSyntax.scala │ │ ├── License.scala │ │ ├── LogicalClock.scala │ │ ├── MakePomConfigurationExtra.scala │ │ ├── ModuleIDExtra.scala │ │ ├── Publisher.scala │ │ ├── ResolverExtra.scala │ │ ├── RichUpdateReport.scala │ │ ├── ScalaArtifacts.scala │ │ ├── TrackLevel.scala │ │ ├── UnresolvedWarning.scala │ │ ├── UpdateReportExtra.scala │ │ └── VersionNumber.scala │ └── test │ └── scala │ ├── ConfigMacroSpec.scala │ ├── UpdateReportSpec.scala │ ├── example │ └── tests │ │ └── CrossVersionCompatTest.scala │ └── sbt │ ├── internal │ └── librarymanagement │ │ └── UnitSpec.scala │ └── librarymanagement │ ├── ConfigMacroTest.scala │ ├── CrossVersionTest.scala │ ├── ModuleIdTest.scala │ ├── ResolverExtraTest.scala │ ├── ResolverTest.scala │ ├── SemanticSelectorSpec.scala │ ├── VersionNumberSpec.scala │ └── VersionRangeSpec.scala ├── ivy └── src │ ├── main │ ├── contraband-scala │ │ └── sbt │ │ │ └── librarymanagement │ │ │ └── ivy │ │ │ ├── ExternalIvyConfiguration.scala │ │ │ ├── ExternalIvyConfigurationFormats.scala │ │ │ ├── InlineIvyConfiguration.scala │ │ │ ├── InlineIvyConfigurationFormats.scala │ │ │ ├── IvyConfiguration.scala │ │ │ ├── IvyConfigurationFormats.scala │ │ │ ├── IvyPaths.scala │ │ │ └── IvyPathsFormats.scala │ ├── contraband │ │ └── lm-ivy.json │ ├── java │ │ └── internal │ │ │ └── librarymanagement │ │ │ └── ResolverAdapter.java │ └── scala │ │ ├── org │ │ └── apache │ │ │ └── ivy │ │ │ └── plugins │ │ │ └── parser │ │ │ └── m2 │ │ │ └── ReplaceMavenConfigurationMappings.scala │ │ └── sbt │ │ ├── internal │ │ └── librarymanagement │ │ │ ├── ComponentManager.scala │ │ │ ├── ConvertResolver.scala │ │ │ ├── CustomPomParser.scala │ │ │ ├── CustomXmlParser.scala │ │ │ ├── FakeResolver.scala │ │ │ ├── Ivy.scala │ │ │ ├── IvyActions.scala │ │ │ ├── IvyCache.scala │ │ │ ├── IvyInternalDefaults.scala │ │ │ ├── IvyLogger.scala │ │ │ ├── IvyRetrieve.scala │ │ │ ├── IvyScalaUtil.scala │ │ │ ├── IvyUtil.scala │ │ │ ├── MakePom.scala │ │ │ ├── ProjectResolver.scala │ │ │ ├── ResolutionCache.scala │ │ │ ├── ivyint │ │ │ ├── CachedResolutionResolveEngine.scala │ │ │ ├── CustomMavenResolver.scala │ │ │ ├── ErrorMessageAuthenticator.scala │ │ │ ├── IvyCredentialsLookup.scala │ │ │ ├── MergeDescriptors.scala │ │ │ ├── ParallelResolveEngine.scala │ │ │ ├── SbtChainResolver.scala │ │ │ └── SbtDefaultDependencyDescriptor.scala │ │ │ └── mavenint │ │ │ └── PomExtraDependencyAttributes.scala │ │ └── librarymanagement │ │ └── ivy │ │ ├── CircularDependencyLevel.scala │ │ ├── Credentials.scala │ │ ├── IvyDefaults.scala │ │ ├── IvyDependencyResolution.scala │ │ ├── IvyLibraryManagementCodec.scala │ │ ├── IvyPublisher.scala │ │ ├── UpdateOptions.scala │ │ └── formats │ │ └── UpdateOptionsFormat.scala │ └── test │ ├── resources │ ├── artifact1.jar │ ├── artifact2.txt │ ├── test-ivy-repo │ │ └── com.test │ │ │ └── module-with-srcs │ │ │ └── 0.1.00 │ │ │ ├── ivys │ │ │ └── ivy.xml │ │ │ ├── jars │ │ │ └── libmodule.jar │ │ │ └── srcs │ │ │ └── libmodule-source.jar │ └── test-maven-repo │ │ └── com │ │ └── test │ │ └── test-artifact │ │ └── 1.0.0-SNAPSHOT │ │ ├── test-artifact-1.0.0-SNAPSHOT.jar │ │ └── test-artifact-1.0.0-SNAPSHOT.pom │ └── scala │ └── sbt │ └── internal │ └── librarymanagement │ ├── AbstractEngineSpec.scala │ ├── BaseCachedResolutionSpec.scala │ ├── BaseIvySpecification.scala │ ├── CachedResolutionSpec.scala │ ├── ComponentManagerTest.scala │ ├── ConflictWarningSpec.scala │ ├── CredentialsSpec.scala │ ├── CustomPomParserTest.scala │ ├── DMSerializationSpec.scala │ ├── EvictionErrorSpec.scala │ ├── EvictionWarningSpec.scala │ ├── FakeResolverSpecification.scala │ ├── FrozenModeSpec.scala │ ├── InclExclSpec.scala │ ├── InconsistentDuplicateSpec.scala │ ├── IvyModuleSpec.scala │ ├── IvyRepoSpec.scala │ ├── IvyResolutionSpec.scala │ ├── IvyUtilSpec.scala │ ├── MakePomSpec.scala │ ├── ManagedChecksumsSpec.scala │ ├── MergeDescriptorSpec.scala │ ├── OfflineModeSpec.scala │ ├── ResolutionSpec.scala │ ├── ResolverSpec.scala │ ├── ScalaOverrideTest.scala │ ├── SftpRepoSpec.scala │ ├── TestLogger.scala │ └── UpdateOptionsSpec.scala ├── notes └── 1.0.0.markdown ├── project ├── DatatypeConfig.scala ├── Dependencies.scala ├── HouseRulesPlugin.scala ├── SbtScriptedIT.scala ├── Util.scala ├── build.properties └── plugins.sbt ├── sbt-allsources.sh └── scripted-test └── src └── sbt-test └── lmScriptedTest ├── multi-project ├── build.sbt ├── child │ └── src │ │ └── main │ │ └── scala │ │ └── Bar.scala ├── parent │ └── src │ │ └── main │ │ └── scala │ │ └── Foo.scala └── test ├── sbt-plugins ├── Main.scala ├── build.sbt └── test ├── simple ├── Main.scala ├── build.sbt └── test ├── use-sbt-in-meta ├── build.sbt ├── project │ └── Dependencies.scala └── test └── with-trasnsitive ├── Main.scala ├── build.sbt └── test /.git-blame-ignore-revs: -------------------------------------------------------------------------------- 1 | # Scala Steward: Reformat with scalafmt 3.8.6 2 | 790a3b46c54d6b6563c18615c436f9696adc3614 3 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/no-new-issues.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: No new issues 3 | about: Use https://github.com/sbt/sbt/issues/new/choose instead 4 | 5 | --- 6 | 7 | No new issues should be opened against this repo. 8 | 9 | Please use https://github.com/sbt/sbt/issues/new/choose to file an issue against sbt. 10 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | on: 3 | pull_request: 4 | push: 5 | 6 | jobs: 7 | test: 8 | strategy: 9 | matrix: 10 | include: 11 | - os: ubuntu-latest 12 | java: 8 13 | distribution: zulu 14 | jobtype: 1 15 | - os: ubuntu-latest 16 | java: 11 17 | distribution: temurin 18 | jobtype: 1 19 | - os: macos-latest 20 | java: 17 21 | distribution: temurin 22 | jobtype: 1 23 | runs-on: ${{ matrix.os }} 24 | env: 25 | # define Java options for both official sbt and sbt-extras 26 | JAVA_OPTS: -Xms2048M -Xmx2048M -Xss6M -XX:ReservedCodeCacheSize=256M 27 | JVM_OPTS: -Xms2048M -Xmx2048M -Xss6M -XX:ReservedCodeCacheSize=256M 28 | steps: 29 | - name: Checkout 30 | uses: actions/checkout@v4 31 | - name: Setup JDK 32 | uses: actions/setup-java@v4 33 | with: 34 | distribution: "${{ matrix.distribution }}" 35 | java-version: "${{ matrix.java }}" 36 | cache: sbt 37 | - name: Setup sbt 38 | uses: sbt/setup-sbt@v1 39 | - name: Build and test (1) 40 | if: ${{ matrix.jobtype == 1 }} 41 | shell: bash 42 | run: | 43 | sbt -v -Dfile.encoding=UTF8 +test +packagedArtifacts 44 | -------------------------------------------------------------------------------- /.github/workflows/cla.yml: -------------------------------------------------------------------------------- 1 | name: Scala CLA 2 | on: [pull_request] 3 | jobs: 4 | check: 5 | runs-on: ubuntu-latest 6 | steps: 7 | - name: Check CLA 8 | uses: scala/cla-checker@v1 9 | with: 10 | author: ${{ github.event.pull_request.user.login }} 11 | -------------------------------------------------------------------------------- /.github/workflows/format.yml: -------------------------------------------------------------------------------- 1 | name: Scalafmt 2 | 3 | permissions: {} 4 | 5 | on: 6 | pull_request: 7 | branches: ['**'] 8 | 9 | jobs: 10 | build: 11 | name: Code is formatted 12 | runs-on: ubuntu-latest 13 | steps: 14 | - name: Checkout current branch (full) 15 | uses: actions/checkout@v4 16 | with: 17 | fetch-depth: 0 18 | persist-credentials: false 19 | 20 | - name: Check project is formatted 21 | uses: jrouly/scalafmt-native-action@v3 22 | with: 23 | arguments: '--list' 24 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | tmp/ 2 | target/ 3 | __pycache__ 4 | 5 | scripted-test/src/sbt-test/*/*/project/build.properties 6 | scripted-test/src/sbt-test/*/*/project/plugins.sbt 7 | 8 | .idea 9 | .bloop 10 | .metals 11 | .bsp/ 12 | metals.sbt 13 | -------------------------------------------------------------------------------- /.java-version: -------------------------------------------------------------------------------- 1 | 1.8 2 | -------------------------------------------------------------------------------- /.scalafmt.conf: -------------------------------------------------------------------------------- 1 | version = 3.9.6 2 | maxColumn = 100 3 | project.git = true 4 | project.excludeFilters = [ /sbt-test/, /input_sources/, /contraband-scala/ ] 5 | 6 | # http://docs.scala-lang.org/style/scaladoc.html recommends the JavaDoc style. 7 | # scala/scala is written that way too https://github.com/scala/scala/blob/v2.12.2/src/library/scala/Predef.scala 8 | docstrings.style = Asterisk 9 | docstrings.wrap = no 10 | 11 | # This also seems more idiomatic to include whitespace in import x.{ yyy } 12 | spaces.inImportCurlyBraces = true 13 | 14 | # This is more idiomatic Scala. 15 | # http://docs.scala-lang.org/style/indentation.html#methods-with-numerous-arguments 16 | align.openParenCallSite = false 17 | align.openParenDefnSite = false 18 | 19 | # For better code clarity 20 | danglingParentheses.preset = true 21 | 22 | trailingCommas = preserve 23 | 24 | runner.dialect = Scala212Source3 25 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | librarymanagement module for sbt 2 | ================================ 3 | 4 | ```scala 5 | scala> import java.io.File 6 | import java.io.File 7 | 8 | scala> import sbt.librarymanagement._, syntax._ 9 | import sbt.librarymanagement._ 10 | import syntax._ 11 | 12 | scala> val log = sbt.util.LogExchange.logger("test") 13 | log: sbt.internal.util.ManagedLogger = sbt.internal.util.ManagedLogger@c439b0f 14 | 15 | scala> val lm = { 16 | import sbt.librarymanagement.ivy._ 17 | val ivyConfig = InlineIvyConfiguration().withLog(log) 18 | IvyDependencyResolution(ivyConfig) 19 | } 20 | lm: sbt.librarymanagement.DependencyResolution = sbt.librarymanagement.DependencyResolution@6a9b40f8 21 | 22 | scala> val module = "commons-io" % "commons-io" % "2.5" 23 | module: sbt.librarymanagement.ModuleID = commons-io:commons-io:2.5 24 | 25 | scala> lm.retrieve(module, scalaModuleInfo = None, new File("target"), log) 26 | res0: Either[sbt.librarymanagement.UnresolvedWarning,Vector[java.io.File]] = Right(Vector(target/jars/commons-io/commons-io/commons-io-2.5.jar, target/jars/commons-io/commons-io/commons-io-2.5.jar, target/jars/commons-io/commons-io/commons-io-2.5.jar)) 27 | ``` 28 | -------------------------------------------------------------------------------- /bin/fixpreloaded.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/org.scala-lang.modules/scala-parser-combinators_2.12/1.0.4 4 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/org.scala-lang.modules/scala-parser-combinators_2.12/1.0.5 5 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/org.scala-lang.modules/scala-xml_2.12/1.0.6 6 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/com.typesafe/config/1.2.0 7 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/com.typesafe/ssl-config-core_2.12/0.2.2 8 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/com.google.protobuf/protobuf-java/3.3.1 9 | rm -rf $HOME/.sdkman/candidates/sbt/current/lib/local-preloaded/org.scala-lang/scala-compiler/2.12.6 10 | 11 | rm -rf $HOME/.sbt/preloaded/org.scala-lang.modules/scala-parser-combinators_2.12/1.0.4 12 | rm -rf $HOME/.sbt/preloaded/org.scala-lang.modules/scala-parser-combinators_2.12/1.0.5 13 | rm -rf $HOME/.sbt/preloaded/org.scala-lang.modules/scala-xml_2.12/1.0.6 14 | rm -rf $HOME/.sbt/preloaded/com.typesafe/config/1.2.0 15 | rm -rf $HOME/.sbt/preloaded/com.typesafe/ssl-config-core_2.12/0.2.2 16 | rm -rf $HOME/.sbt/preloaded/com.google.protobuf/protobuf-java/3.3.1 17 | rm -rf $HOME/.sbt/preloaded/org.scala-lang/scala-compiler/2.12.6 18 | -------------------------------------------------------------------------------- /core/NOTICE: -------------------------------------------------------------------------------- 1 | Simple Build Tool: Ivy Interface Component 2 | Copyright 2008, 2009, 2010 Mark Harrah 3 | Licensed under BSD-style license (see LICENSE) 4 | 5 | Portions based on Apache Ivy, 6 | licensed under the Apache License, Version 2.0 (see licenses/LICENSE_Apache) 7 | 8 | It requires the following notice: 9 | 10 | This product includes software developed by 11 | The Apache Software Foundation (http://www.apache.org/). 12 | 13 | Portions of Ivy were originally developed by 14 | Jayasoft SARL (http://www.jayasoft.fr/) 15 | and are licensed to the Apache Software Foundation under the 16 | "Software Grant License Agreement" 17 | 18 | 19 | THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 20 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.internal.librarymanagement 7 | final class ConfigurationReportLite private ( 8 | val configuration: String, 9 | val details: Vector[sbt.librarymanagement.OrganizationArtifactReport]) extends Serializable { 10 | 11 | 12 | 13 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 14 | case x: ConfigurationReportLite => (this.configuration == x.configuration) && (this.details == x.details) 15 | case _ => false 16 | }) 17 | override def hashCode: Int = { 18 | 37 * (37 * (37 * (17 + "sbt.internal.librarymanagement.ConfigurationReportLite".##) + configuration.##) + details.##) 19 | } 20 | override def toString: String = { 21 | "ConfigurationReportLite(" + configuration + ", " + details + ")" 22 | } 23 | private def copy(configuration: String = configuration, details: Vector[sbt.librarymanagement.OrganizationArtifactReport] = details): ConfigurationReportLite = { 24 | new ConfigurationReportLite(configuration, details) 25 | } 26 | def withConfiguration(configuration: String): ConfigurationReportLite = { 27 | copy(configuration = configuration) 28 | } 29 | def withDetails(details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReportLite = { 30 | copy(details = details) 31 | } 32 | } 33 | object ConfigurationReportLite { 34 | 35 | def apply(configuration: String, details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReportLite = new ConfigurationReportLite(configuration, details) 36 | } 37 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/internal/librarymanagement/SemSelAndChunk.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.internal.librarymanagement 7 | final class SemSelAndChunk private ( 8 | val comparators: Seq[sbt.internal.librarymanagement.SemComparator]) extends Serializable { 9 | def matches(version: sbt.librarymanagement.VersionNumber): Boolean = comparators.forall(_.matches(version)) 10 | 11 | 12 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 13 | case x: SemSelAndChunk => (this.comparators == x.comparators) 14 | case _ => false 15 | }) 16 | override def hashCode: Int = { 17 | 37 * (37 * (17 + "sbt.internal.librarymanagement.SemSelAndChunk".##) + comparators.##) 18 | } 19 | override def toString: String = { 20 | comparators.map(_.toString).mkString(" ") 21 | } 22 | private def copy(comparators: Seq[sbt.internal.librarymanagement.SemComparator] = comparators): SemSelAndChunk = { 23 | new SemSelAndChunk(comparators) 24 | } 25 | def withComparators(comparators: Seq[sbt.internal.librarymanagement.SemComparator]): SemSelAndChunk = { 26 | copy(comparators = comparators) 27 | } 28 | } 29 | object SemSelAndChunk extends sbt.internal.librarymanagement.SemSelAndChunkFunctions { 30 | def apply(andClauseToken: String): SemSelAndChunk = parse(andClauseToken) 31 | def apply(comparators: Seq[sbt.internal.librarymanagement.SemComparator]): SemSelAndChunk = new SemSelAndChunk(comparators) 32 | } 33 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.internal.librarymanagement 7 | final class UpdateReportLite private ( 8 | val configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]) extends Serializable { 9 | 10 | 11 | 12 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 13 | case x: UpdateReportLite => (this.configurations == x.configurations) 14 | case _ => false 15 | }) 16 | override def hashCode: Int = { 17 | 37 * (37 * (17 + "sbt.internal.librarymanagement.UpdateReportLite".##) + configurations.##) 18 | } 19 | override def toString: String = { 20 | "UpdateReportLite(" + configurations + ")" 21 | } 22 | private def copy(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite] = configurations): UpdateReportLite = { 23 | new UpdateReportLite(configurations) 24 | } 25 | def withConfigurations(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]): UpdateReportLite = { 26 | copy(configurations = configurations) 27 | } 28 | } 29 | object UpdateReportLite { 30 | 31 | def apply(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]): UpdateReportLite = new UpdateReportLite(configurations) 32 | } 33 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ArtifactFormats { self: sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ArtifactFormat: JsonFormat[sbt.librarymanagement.Artifact] = new JsonFormat[sbt.librarymanagement.Artifact] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Artifact = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val `type` = unbuilder.readField[String]("type") 16 | val extension = unbuilder.readField[String]("extension") 17 | val classifier = unbuilder.readField[Option[String]]("classifier") 18 | val configurations = unbuilder.readField[Vector[sbt.librarymanagement.ConfigRef]]("configurations") 19 | val url = unbuilder.readField[Option[java.net.URL]]("url") 20 | val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes") 21 | val checksum = unbuilder.readField[Option[sbt.librarymanagement.Checksum]]("checksum") 22 | val allowInsecureProtocol = unbuilder.readField[Boolean]("allowInsecureProtocol") 23 | unbuilder.endObject() 24 | sbt.librarymanagement.Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum, allowInsecureProtocol) 25 | case None => 26 | deserializationError("Expected JsObject but found None") 27 | } 28 | } 29 | override def write[J](obj: sbt.librarymanagement.Artifact, builder: Builder[J]): Unit = { 30 | builder.beginObject() 31 | builder.addField("name", obj.name) 32 | builder.addField("type", obj.`type`) 33 | builder.addField("extension", obj.extension) 34 | builder.addField("classifier", obj.classifier) 35 | builder.addField("configurations", obj.configurations) 36 | builder.addField("url", obj.url) 37 | builder.addField("extraAttributes", obj.extraAttributes) 38 | builder.addField("checksum", obj.checksum) 39 | builder.addField("allowInsecureProtocol", obj.allowInsecureProtocol) 40 | builder.endObject() 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** 8 | * Work around the inadequacy of Ivy's ArtifactTypeFilter (that it cannot reverse a filter) 9 | * @param types Represents the artifact types that we should try to resolve for (as in the allowed values of 10 | `artifact[type]` from a dependency `` section). One can use this to filter 11 | source / doc artifacts. 12 | * @param inverted Whether to invert the types filter (i.e. allow only types NOT in the set) 13 | */ 14 | final class ArtifactTypeFilter private ( 15 | val types: Set[String], 16 | val inverted: Boolean) extends sbt.librarymanagement.ArtifactTypeFilterExtra with Serializable { 17 | 18 | 19 | 20 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 21 | case x: ArtifactTypeFilter => (this.types == x.types) && (this.inverted == x.inverted) 22 | case _ => false 23 | }) 24 | override def hashCode: Int = { 25 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.ArtifactTypeFilter".##) + types.##) + inverted.##) 26 | } 27 | override def toString: String = { 28 | "ArtifactTypeFilter(" + types + ", " + inverted + ")" 29 | } 30 | private def copy(types: Set[String] = types, inverted: Boolean = inverted): ArtifactTypeFilter = { 31 | new ArtifactTypeFilter(types, inverted) 32 | } 33 | def withTypes(types: Set[String]): ArtifactTypeFilter = { 34 | copy(types = types) 35 | } 36 | def withInverted(inverted: Boolean): ArtifactTypeFilter = { 37 | copy(inverted = inverted) 38 | } 39 | } 40 | object ArtifactTypeFilter extends sbt.librarymanagement.ArtifactTypeFilterFunctions { 41 | 42 | def apply(types: Set[String], inverted: Boolean): ArtifactTypeFilter = new ArtifactTypeFilter(types, inverted) 43 | } 44 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ArtifactTypeFilterFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ArtifactTypeFilterFormat: JsonFormat[sbt.librarymanagement.ArtifactTypeFilter] = new JsonFormat[sbt.librarymanagement.ArtifactTypeFilter] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ArtifactTypeFilter = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val types = unbuilder.readField[Set[String]]("types") 15 | val inverted = unbuilder.readField[Boolean]("inverted") 16 | unbuilder.endObject() 17 | sbt.librarymanagement.ArtifactTypeFilter(types, inverted) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.librarymanagement.ArtifactTypeFilter, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("types", obj.types) 25 | builder.addField("inverted", obj.inverted) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class ChainedResolver private ( 8 | name: String, 9 | val resolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.librarymanagement.Resolver(name) with Serializable { 10 | private[sbt] override def validateProtocol(logger: sbt.util.Logger): Boolean = !resolvers.forall(!_.validateProtocol(logger)) 11 | 12 | 13 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 14 | case x: ChainedResolver => (this.name == x.name) && (this.resolvers == x.resolvers) 15 | case _ => false 16 | }) 17 | override def hashCode: Int = { 18 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.ChainedResolver".##) + name.##) + resolvers.##) 19 | } 20 | override def toString: String = { 21 | "ChainedResolver(" + name + ", " + resolvers + ")" 22 | } 23 | private def copy(name: String = name, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers): ChainedResolver = { 24 | new ChainedResolver(name, resolvers) 25 | } 26 | def withName(name: String): ChainedResolver = { 27 | copy(name = name) 28 | } 29 | def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): ChainedResolver = { 30 | copy(resolvers = resolvers) 31 | } 32 | } 33 | object ChainedResolver { 34 | 35 | def apply(name: String, resolvers: Vector[sbt.librarymanagement.Resolver]): ChainedResolver = new ChainedResolver(name, resolvers) 36 | } 37 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ChainedResolverFormats { self: sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ChainedResolverFormat: JsonFormat[sbt.librarymanagement.ChainedResolver] = new JsonFormat[sbt.librarymanagement.ChainedResolver] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ChainedResolver = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val resolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("resolvers") 16 | unbuilder.endObject() 17 | sbt.librarymanagement.ChainedResolver(name, resolvers) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.librarymanagement.ChainedResolver, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("name", obj.name) 25 | builder.addField("resolvers", obj.resolvers) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class Checksum private ( 8 | val digest: String, 9 | val `type`: String) extends Serializable { 10 | 11 | 12 | 13 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 14 | case x: Checksum => (this.digest == x.digest) && (this.`type` == x.`type`) 15 | case _ => false 16 | }) 17 | override def hashCode: Int = { 18 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.Checksum".##) + digest.##) + `type`.##) 19 | } 20 | override def toString: String = { 21 | "Checksum(" + digest + ", " + `type` + ")" 22 | } 23 | private def copy(digest: String = digest, `type`: String = `type`): Checksum = { 24 | new Checksum(digest, `type`) 25 | } 26 | def withDigest(digest: String): Checksum = { 27 | copy(digest = digest) 28 | } 29 | def withType(`type`: String): Checksum = { 30 | copy(`type` = `type`) 31 | } 32 | } 33 | object Checksum { 34 | 35 | def apply(digest: String, `type`: String): Checksum = new Checksum(digest, `type`) 36 | } 37 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ChecksumFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ChecksumFormat: JsonFormat[sbt.librarymanagement.Checksum] = new JsonFormat[sbt.librarymanagement.Checksum] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Checksum = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val digest = unbuilder.readField[String]("digest") 15 | val `type` = unbuilder.readField[String]("type") 16 | unbuilder.endObject() 17 | sbt.librarymanagement.Checksum(digest, `type`) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.librarymanagement.Checksum, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("digest", obj.digest) 25 | builder.addField("type", obj.`type`) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ConfigurationReportFormats { self: sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sbt.librarymanagement.CallerFormats with sbt.librarymanagement.OrganizationArtifactReportFormats => 9 | implicit lazy val ConfigurationReportFormat: JsonFormat[sbt.librarymanagement.ConfigurationReport] = new JsonFormat[sbt.librarymanagement.ConfigurationReport] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ConfigurationReport = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val configuration = unbuilder.readField[sbt.librarymanagement.ConfigRef]("configuration") 15 | val modules = unbuilder.readField[Vector[sbt.librarymanagement.ModuleReport]]("modules") 16 | val details = unbuilder.readField[Vector[sbt.librarymanagement.OrganizationArtifactReport]]("details") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.ConfigurationReport(configuration, modules, details) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.ConfigurationReport, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("configuration", obj.configuration) 26 | builder.addField("modules", obj.modules) 27 | builder.addField("details", obj.details) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ConfigurationReportLiteFormats { self: sbt.librarymanagement.OrganizationArtifactReportFormats with sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sbt.librarymanagement.CallerFormats => 9 | implicit lazy val ConfigurationReportLiteFormat: JsonFormat[sbt.internal.librarymanagement.ConfigurationReportLite] = new JsonFormat[sbt.internal.librarymanagement.ConfigurationReportLite] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ConfigurationReportLite = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val configuration = unbuilder.readField[String]("configuration") 15 | val details = unbuilder.readField[Vector[sbt.librarymanagement.OrganizationArtifactReport]]("details") 16 | unbuilder.endObject() 17 | sbt.internal.librarymanagement.ConfigurationReportLite(configuration, details) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.internal.librarymanagement.ConfigurationReportLite, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("configuration", obj.configuration) 25 | builder.addField("details", obj.details) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** See http://ant.apache.org/ivy/history/latest-milestone/settings/conflict-managers.html for details of the different conflict managers. */ 8 | final class ConflictManager private ( 9 | val name: String, 10 | val organization: String, 11 | val module: String) extends Serializable { 12 | 13 | private def this(name: String) = this(name, "*", "*") 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: ConflictManager => (this.name == x.name) && (this.organization == x.organization) && (this.module == x.module) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ConflictManager".##) + name.##) + organization.##) + module.##) 21 | } 22 | override def toString: String = { 23 | "ConflictManager(" + name + ", " + organization + ", " + module + ")" 24 | } 25 | private def copy(name: String = name, organization: String = organization, module: String = module): ConflictManager = { 26 | new ConflictManager(name, organization, module) 27 | } 28 | def withName(name: String): ConflictManager = { 29 | copy(name = name) 30 | } 31 | def withOrganization(organization: String): ConflictManager = { 32 | copy(organization = organization) 33 | } 34 | def withModule(module: String): ConflictManager = { 35 | copy(module = module) 36 | } 37 | } 38 | object ConflictManager extends sbt.librarymanagement.ConflictManagerFunctions { 39 | 40 | def apply(name: String): ConflictManager = new ConflictManager(name) 41 | def apply(name: String, organization: String, module: String): ConflictManager = new ConflictManager(name, organization, module) 42 | } 43 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ConflictManagerFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ConflictManagerFormat: JsonFormat[sbt.librarymanagement.ConflictManager] = new JsonFormat[sbt.librarymanagement.ConflictManager] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ConflictManager = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val organization = unbuilder.readField[String]("organization") 16 | val module = unbuilder.readField[String]("module") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.ConflictManager(name, organization, module) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.ConflictManager, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("name", obj.name) 26 | builder.addField("organization", obj.organization) 27 | builder.addField("module", obj.module) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/Developer.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class Developer private ( 8 | val id: String, 9 | val name: String, 10 | val email: String, 11 | val url: java.net.URL) extends Serializable { 12 | 13 | 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: Developer => (this.id == x.id) && (this.name == x.name) && (this.email == x.email) && (this.url == x.url) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.Developer".##) + id.##) + name.##) + email.##) + url.##) 21 | } 22 | override def toString: String = { 23 | "Developer(" + id + ", " + name + ", " + email + ", " + url + ")" 24 | } 25 | private def copy(id: String = id, name: String = name, email: String = email, url: java.net.URL = url): Developer = { 26 | new Developer(id, name, email, url) 27 | } 28 | def withId(id: String): Developer = { 29 | copy(id = id) 30 | } 31 | def withName(name: String): Developer = { 32 | copy(name = name) 33 | } 34 | def withEmail(email: String): Developer = { 35 | copy(email = email) 36 | } 37 | def withUrl(url: java.net.URL): Developer = { 38 | copy(url = url) 39 | } 40 | } 41 | object Developer { 42 | 43 | def apply(id: String, name: String, email: String, url: java.net.URL): Developer = new Developer(id, name, email, url) 44 | } 45 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait DeveloperFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val DeveloperFormat: JsonFormat[sbt.librarymanagement.Developer] = new JsonFormat[sbt.librarymanagement.Developer] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Developer = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val id = unbuilder.readField[String]("id") 15 | val name = unbuilder.readField[String]("name") 16 | val email = unbuilder.readField[String]("email") 17 | val url = unbuilder.readField[java.net.URL]("url") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.Developer(id, name, email, url) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.Developer, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("id", obj.id) 27 | builder.addField("name", obj.name) 28 | builder.addField("email", obj.email) 29 | builder.addField("url", obj.url) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** Configuration specific to an Ivy filesystem resolver. */ 8 | final class FileConfiguration private ( 9 | val isLocal: Boolean, 10 | val isTransactional: Option[Boolean]) extends Serializable { 11 | 12 | 13 | 14 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 15 | case x: FileConfiguration => (this.isLocal == x.isLocal) && (this.isTransactional == x.isTransactional) 16 | case _ => false 17 | }) 18 | override def hashCode: Int = { 19 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.FileConfiguration".##) + isLocal.##) + isTransactional.##) 20 | } 21 | override def toString: String = { 22 | "FileConfiguration(" + isLocal + ", " + isTransactional + ")" 23 | } 24 | private def copy(isLocal: Boolean = isLocal, isTransactional: Option[Boolean] = isTransactional): FileConfiguration = { 25 | new FileConfiguration(isLocal, isTransactional) 26 | } 27 | def withIsLocal(isLocal: Boolean): FileConfiguration = { 28 | copy(isLocal = isLocal) 29 | } 30 | def withIsTransactional(isTransactional: Option[Boolean]): FileConfiguration = { 31 | copy(isTransactional = isTransactional) 32 | } 33 | def withIsTransactional(isTransactional: Boolean): FileConfiguration = { 34 | copy(isTransactional = Option(isTransactional)) 35 | } 36 | } 37 | object FileConfiguration { 38 | 39 | def apply(isLocal: Boolean, isTransactional: Option[Boolean]): FileConfiguration = new FileConfiguration(isLocal, isTransactional) 40 | def apply(isLocal: Boolean, isTransactional: Boolean): FileConfiguration = new FileConfiguration(isLocal, Option(isTransactional)) 41 | } 42 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait FileConfigurationFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val FileConfigurationFormat: JsonFormat[sbt.librarymanagement.FileConfiguration] = new JsonFormat[sbt.librarymanagement.FileConfiguration] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.FileConfiguration = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val isLocal = unbuilder.readField[Boolean]("isLocal") 15 | val isTransactional = unbuilder.readField[Option[Boolean]]("isTransactional") 16 | unbuilder.endObject() 17 | sbt.librarymanagement.FileConfiguration(isLocal, isTransactional) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.librarymanagement.FileConfiguration, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("isLocal", obj.isLocal) 25 | builder.addField("isTransactional", obj.isTransactional) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** sbt interface for an Ivy filesystem repository. More convenient construction is done using Resolver.file. */ 8 | final class FileRepository private ( 9 | name: String, 10 | patterns: sbt.librarymanagement.Patterns, 11 | val configuration: sbt.librarymanagement.FileConfiguration) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with Serializable { 12 | def this(name: String, configuration: sbt.librarymanagement.FileConfiguration, patterns: sbt.librarymanagement.Patterns) = 13 | this(name, patterns, configuration) 14 | 15 | 16 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 17 | case x: FileRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.configuration == x.configuration) 18 | case _ => false 19 | }) 20 | override def hashCode: Int = { 21 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.FileRepository".##) + name.##) + patterns.##) + configuration.##) 22 | } 23 | override def toString: String = { 24 | "FileRepository(" + name + ", " + patterns + ", " + configuration + ")" 25 | } 26 | private def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, configuration: sbt.librarymanagement.FileConfiguration = configuration): FileRepository = { 27 | new FileRepository(name, patterns, configuration) 28 | } 29 | def withName(name: String): FileRepository = { 30 | copy(name = name) 31 | } 32 | def withPatterns(patterns: sbt.librarymanagement.Patterns): FileRepository = { 33 | copy(patterns = patterns) 34 | } 35 | def withConfiguration(configuration: sbt.librarymanagement.FileConfiguration): FileRepository = { 36 | copy(configuration = configuration) 37 | } 38 | } 39 | object FileRepository { 40 | def apply(name: String, configuration: sbt.librarymanagement.FileConfiguration, patterns: sbt.librarymanagement.Patterns) = 41 | new FileRepository(name, patterns, configuration) 42 | def apply(name: String, patterns: sbt.librarymanagement.Patterns, configuration: sbt.librarymanagement.FileConfiguration): FileRepository = new FileRepository(name, patterns, configuration) 43 | } 44 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait FileRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.FileConfigurationFormats => 9 | implicit lazy val FileRepositoryFormat: JsonFormat[sbt.librarymanagement.FileRepository] = new JsonFormat[sbt.librarymanagement.FileRepository] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.FileRepository = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") 16 | val configuration = unbuilder.readField[sbt.librarymanagement.FileConfiguration]("configuration") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.FileRepository(name, patterns, configuration) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.FileRepository, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("name", obj.name) 26 | builder.addField("patterns", obj.patterns) 27 | builder.addField("configuration", obj.configuration) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait InclExclRuleFormats { self: sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val InclExclRuleFormat: JsonFormat[sbt.librarymanagement.InclExclRule] = new JsonFormat[sbt.librarymanagement.InclExclRule] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.InclExclRule = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val organization = unbuilder.readField[String]("organization") 15 | val name = unbuilder.readField[String]("name") 16 | val artifact = unbuilder.readField[String]("artifact") 17 | val configurations = unbuilder.readField[Vector[sbt.librarymanagement.ConfigRef]]("configurations") 18 | val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion") 19 | unbuilder.endObject() 20 | sbt.librarymanagement.InclExclRule(organization, name, artifact, configurations, crossVersion) 21 | case None => 22 | deserializationError("Expected JsObject but found None") 23 | } 24 | } 25 | override def write[J](obj: sbt.librarymanagement.InclExclRule, builder: Builder[J]): Unit = { 26 | builder.beginObject() 27 | builder.addField("organization", obj.organization) 28 | builder.addField("name", obj.name) 29 | builder.addField("artifact", obj.artifact) 30 | builder.addField("configurations", obj.configurations) 31 | builder.addField("crossVersion", obj.crossVersion) 32 | builder.endObject() 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait IvyFileConfigurationFormats { self: sbt.librarymanagement.ScalaModuleInfoFormats with sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val IvyFileConfigurationFormat: JsonFormat[sbt.librarymanagement.IvyFileConfiguration] = new JsonFormat[sbt.librarymanagement.IvyFileConfiguration] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.IvyFileConfiguration = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val validate = unbuilder.readField[Boolean]("validate") 15 | val scalaModuleInfo = unbuilder.readField[Option[sbt.librarymanagement.ScalaModuleInfo]]("scalaModuleInfo") 16 | val file = unbuilder.readField[java.io.File]("file") 17 | val autoScalaTools = unbuilder.readField[Boolean]("autoScalaTools") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.IvyFileConfiguration(validate, scalaModuleInfo, file, autoScalaTools) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.IvyFileConfiguration, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("validate", obj.validate) 27 | builder.addField("scalaModuleInfo", obj.scalaModuleInfo) 28 | builder.addField("file", obj.file) 29 | builder.addField("autoScalaTools", obj.autoScalaTools) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class KeyFileAuthentication private ( 8 | val user: String, 9 | val keyfile: java.io.File, 10 | val password: Option[String]) extends sbt.librarymanagement.SshAuthentication() with Serializable { 11 | 12 | 13 | 14 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 15 | case x: KeyFileAuthentication => (this.user == x.user) && (this.keyfile == x.keyfile) && (this.password == x.password) 16 | case _ => false 17 | }) 18 | override def hashCode: Int = { 19 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.KeyFileAuthentication".##) + user.##) + keyfile.##) + password.##) 20 | } 21 | override def toString: String = { 22 | "KeyFileAuthentication(" + user + ", " + keyfile + ", " + password + ")" 23 | } 24 | private def copy(user: String = user, keyfile: java.io.File = keyfile, password: Option[String] = password): KeyFileAuthentication = { 25 | new KeyFileAuthentication(user, keyfile, password) 26 | } 27 | def withUser(user: String): KeyFileAuthentication = { 28 | copy(user = user) 29 | } 30 | def withKeyfile(keyfile: java.io.File): KeyFileAuthentication = { 31 | copy(keyfile = keyfile) 32 | } 33 | def withPassword(password: Option[String]): KeyFileAuthentication = { 34 | copy(password = password) 35 | } 36 | def withPassword(password: String): KeyFileAuthentication = { 37 | copy(password = Option(password)) 38 | } 39 | } 40 | object KeyFileAuthentication { 41 | 42 | def apply(user: String, keyfile: java.io.File, password: Option[String]): KeyFileAuthentication = new KeyFileAuthentication(user, keyfile, password) 43 | def apply(user: String, keyfile: java.io.File, password: String): KeyFileAuthentication = new KeyFileAuthentication(user, keyfile, Option(password)) 44 | } 45 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait KeyFileAuthenticationFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val KeyFileAuthenticationFormat: JsonFormat[sbt.librarymanagement.KeyFileAuthentication] = new JsonFormat[sbt.librarymanagement.KeyFileAuthentication] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.KeyFileAuthentication = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val user = unbuilder.readField[String]("user") 15 | val keyfile = unbuilder.readField[java.io.File]("keyfile") 16 | val password = unbuilder.readField[Option[String]]("password") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.KeyFileAuthentication(user, keyfile, password) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.KeyFileAuthentication, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("user", obj.user) 26 | builder.addField("keyfile", obj.keyfile) 27 | builder.addField("password", obj.password) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** 8 | * An instance of maven CACHE directory. You cannot treat a cache directory the same as a a remote repository because 9 | * the metadata is different (see Aether ML discussion). 10 | */ 11 | final class MavenCache private ( 12 | name: String, 13 | root: String, 14 | localIfFile: Boolean, 15 | val rootFile: java.io.File) extends sbt.librarymanagement.MavenRepository(name, root, localIfFile) with Serializable { 16 | def this(name: String, rootFile: java.io.File) = this(name, rootFile.toURI.toURL.toString, true, rootFile) 17 | override def isCache: Boolean = true 18 | override def allowInsecureProtocol: Boolean = false 19 | private def this(name: String, root: String, rootFile: java.io.File) = this(name, root, true, rootFile) 20 | 21 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 22 | case x: MavenCache => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile) && (this.rootFile == x.rootFile) 23 | case _ => false 24 | }) 25 | override def hashCode: Int = { 26 | 37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.MavenCache".##) + name.##) + root.##) + localIfFile.##) + rootFile.##) 27 | } 28 | override def toString: String = { 29 | s"cache:$name: ${rootFile.getAbsolutePath}" 30 | } 31 | private def copy(name: String = name, root: String = root, localIfFile: Boolean = localIfFile, rootFile: java.io.File = rootFile): MavenCache = { 32 | new MavenCache(name, root, localIfFile, rootFile) 33 | } 34 | def withName(name: String): MavenCache = { 35 | copy(name = name) 36 | } 37 | def withRoot(root: String): MavenCache = { 38 | copy(root = root) 39 | } 40 | def withLocalIfFile(localIfFile: Boolean): MavenCache = { 41 | copy(localIfFile = localIfFile) 42 | } 43 | def withRootFile(rootFile: java.io.File): MavenCache = { 44 | copy(rootFile = rootFile) 45 | } 46 | } 47 | object MavenCache { 48 | def apply(name: String, rootFile: java.io.File): MavenCache = new MavenCache(name, rootFile) 49 | def apply(name: String, root: String, rootFile: java.io.File): MavenCache = new MavenCache(name, root, rootFile) 50 | def apply(name: String, root: String, localIfFile: Boolean, rootFile: java.io.File): MavenCache = new MavenCache(name, root, localIfFile, rootFile) 51 | } 52 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait MavenCacheFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val MavenCacheFormat: JsonFormat[sbt.librarymanagement.MavenCache] = new JsonFormat[sbt.librarymanagement.MavenCache] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.MavenCache = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val root = unbuilder.readField[String]("root") 16 | val localIfFile = unbuilder.readField[Boolean]("localIfFile") 17 | val rootFile = unbuilder.readField[java.io.File]("rootFile") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.MavenCache(name, root, localIfFile, rootFile) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.MavenCache, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("name", obj.name) 27 | builder.addField("root", obj.root) 28 | builder.addField("localIfFile", obj.localIfFile) 29 | builder.addField("rootFile", obj.rootFile) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait MavenRepoFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val MavenRepoFormat: JsonFormat[sbt.librarymanagement.MavenRepo] = new JsonFormat[sbt.librarymanagement.MavenRepo] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.MavenRepo = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val root = unbuilder.readField[String]("root") 16 | val localIfFile = unbuilder.readField[Boolean]("localIfFile") 17 | val _allowInsecureProtocol = unbuilder.readField[Boolean]("_allowInsecureProtocol") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.MavenRepo(name, root, localIfFile, _allowInsecureProtocol) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.MavenRepo, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("name", obj.name) 27 | builder.addField("root", obj.root) 28 | builder.addField("localIfFile", obj.localIfFile) 29 | builder.addField("_allowInsecureProtocol", obj._allowInsecureProtocol) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** An instance of a remote maven repository. Note: This will use Aether/Maven to resolve artifacts. */ 8 | abstract class MavenRepository( 9 | name: String, 10 | val root: String, 11 | val localIfFile: Boolean) extends sbt.librarymanagement.Resolver(name) with Serializable { 12 | def isCache: Boolean 13 | def allowInsecureProtocol: Boolean 14 | def withAllowInsecureProtocol(allowInsecureProtocol: Boolean): MavenRepository = 15 | this match { 16 | case x: MavenRepo => x.with_allowInsecureProtocol(allowInsecureProtocol) 17 | case x: MavenCache => x 18 | } 19 | def this(name: String, root: String) = this(name, root, true) 20 | 21 | 22 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 23 | case x: MavenRepository => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile) 24 | case _ => false 25 | }) 26 | override def hashCode: Int = { 27 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.MavenRepository".##) + name.##) + root.##) + localIfFile.##) 28 | } 29 | override def toString: String = { 30 | "MavenRepository(" + name + ", " + root + ", " + localIfFile + ")" 31 | } 32 | } 33 | object MavenRepository extends sbt.librarymanagement.MavenRepositoryFunctions { 34 | 35 | } 36 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | trait MavenRepositoryFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.MavenRepoFormats with sbt.librarymanagement.MavenCacheFormats => 10 | implicit lazy val MavenRepositoryFormat: JsonFormat[sbt.librarymanagement.MavenRepository] = flatUnionFormat2[sbt.librarymanagement.MavenRepository, sbt.librarymanagement.MavenRepo, sbt.librarymanagement.MavenCache]("type") 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class ModuleConfiguration private ( 8 | val organization: String, 9 | val name: String, 10 | val revision: String, 11 | val resolver: sbt.librarymanagement.Resolver) extends Serializable { 12 | 13 | 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: ModuleConfiguration => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.resolver == x.resolver) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ModuleConfiguration".##) + organization.##) + name.##) + revision.##) + resolver.##) 21 | } 22 | override def toString: String = { 23 | "ModuleConfiguration(" + organization + ", " + name + ", " + revision + ", " + resolver + ")" 24 | } 25 | private def copy(organization: String = organization, name: String = name, revision: String = revision, resolver: sbt.librarymanagement.Resolver = resolver): ModuleConfiguration = { 26 | new ModuleConfiguration(organization, name, revision, resolver) 27 | } 28 | def withOrganization(organization: String): ModuleConfiguration = { 29 | copy(organization = organization) 30 | } 31 | def withName(name: String): ModuleConfiguration = { 32 | copy(name = name) 33 | } 34 | def withRevision(revision: String): ModuleConfiguration = { 35 | copy(revision = revision) 36 | } 37 | def withResolver(resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = { 38 | copy(resolver = resolver) 39 | } 40 | } 41 | object ModuleConfiguration { 42 | def apply(org: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = apply(org, "*", "*", resolver) 43 | def apply(org: String, name: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = ModuleConfiguration(org, name, "*", resolver) 44 | def apply(organization: String, name: String, revision: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = new ModuleConfiguration(organization, name, revision, resolver) 45 | } 46 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ModuleConfigurationFormats { self: sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ModuleConfigurationFormat: JsonFormat[sbt.librarymanagement.ModuleConfiguration] = new JsonFormat[sbt.librarymanagement.ModuleConfiguration] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleConfiguration = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val organization = unbuilder.readField[String]("organization") 15 | val name = unbuilder.readField[String]("name") 16 | val revision = unbuilder.readField[String]("revision") 17 | val resolver = unbuilder.readField[sbt.librarymanagement.Resolver]("resolver") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.ModuleConfiguration(organization, name, revision, resolver) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.ModuleConfiguration, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("organization", obj.organization) 27 | builder.addField("name", obj.name) 28 | builder.addField("revision", obj.revision) 29 | builder.addField("resolver", obj.resolver) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ModuleInfoFormats { self: sbt.librarymanagement.ScmInfoFormats with sbt.librarymanagement.DeveloperFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ModuleInfoFormat: JsonFormat[sbt.librarymanagement.ModuleInfo] = new JsonFormat[sbt.librarymanagement.ModuleInfo] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleInfo = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val nameFormal = unbuilder.readField[String]("nameFormal") 15 | val description = unbuilder.readField[String]("description") 16 | val homepage = unbuilder.readField[Option[java.net.URL]]("homepage") 17 | val startYear = unbuilder.readField[Option[Int]]("startYear") 18 | val licenses = unbuilder.readField[Vector[scala.Tuple2[String, java.net.URL]]]("licenses") 19 | val organizationName = unbuilder.readField[String]("organizationName") 20 | val organizationHomepage = unbuilder.readField[Option[java.net.URL]]("organizationHomepage") 21 | val scmInfo = unbuilder.readField[Option[sbt.librarymanagement.ScmInfo]]("scmInfo") 22 | val developers = unbuilder.readField[Vector[sbt.librarymanagement.Developer]]("developers") 23 | unbuilder.endObject() 24 | sbt.librarymanagement.ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers) 25 | case None => 26 | deserializationError("Expected JsObject but found None") 27 | } 28 | } 29 | override def write[J](obj: sbt.librarymanagement.ModuleInfo, builder: Builder[J]): Unit = { 30 | builder.beginObject() 31 | builder.addField("nameFormal", obj.nameFormal) 32 | builder.addField("description", obj.description) 33 | builder.addField("homepage", obj.homepage) 34 | builder.addField("startYear", obj.startYear) 35 | builder.addField("licenses", obj.licenses) 36 | builder.addField("organizationName", obj.organizationName) 37 | builder.addField("organizationHomepage", obj.organizationHomepage) 38 | builder.addField("scmInfo", obj.scmInfo) 39 | builder.addField("developers", obj.developers) 40 | builder.endObject() 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | abstract class ModuleSettings( 8 | val validate: Boolean, 9 | val scalaModuleInfo: Option[sbt.librarymanagement.ScalaModuleInfo]) extends Serializable { 10 | 11 | def this() = this(false, None) 12 | 13 | 14 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 15 | case x: ModuleSettings => (this.validate == x.validate) && (this.scalaModuleInfo == x.scalaModuleInfo) 16 | case _ => false 17 | }) 18 | override def hashCode: Int = { 19 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.ModuleSettings".##) + validate.##) + scalaModuleInfo.##) 20 | } 21 | override def toString: String = { 22 | "ModuleSettings(" + validate + ", " + scalaModuleInfo + ")" 23 | } 24 | } 25 | object ModuleSettings { 26 | 27 | } 28 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | trait ModuleSettingsFormats { self: sbt.librarymanagement.ScalaModuleInfoFormats with sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.IvyFileConfigurationFormats with sbt.librarymanagement.PomConfigurationFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ChecksumFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sbt.librarymanagement.ModuleInfoFormats with sbt.librarymanagement.ScmInfoFormats with sbt.librarymanagement.DeveloperFormats with sbt.internal.librarymanagement.formats.NodeSeqFormat with sbt.librarymanagement.ConflictManagerFormats with sbt.librarymanagement.ModuleDescriptorConfigurationFormats => 10 | implicit lazy val ModuleSettingsFormat: JsonFormat[sbt.librarymanagement.ModuleSettings] = flatUnionFormat3[sbt.librarymanagement.ModuleSettings, sbt.librarymanagement.IvyFileConfiguration, sbt.librarymanagement.PomConfiguration, sbt.librarymanagement.ModuleDescriptorConfiguration]("type") 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait OrganizationArtifactReportFormats { self: sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sbt.librarymanagement.CallerFormats => 9 | implicit lazy val OrganizationArtifactReportFormat: JsonFormat[sbt.librarymanagement.OrganizationArtifactReport] = new JsonFormat[sbt.librarymanagement.OrganizationArtifactReport] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.OrganizationArtifactReport = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val organization = unbuilder.readField[String]("organization") 15 | val name = unbuilder.readField[String]("name") 16 | val modules = unbuilder.readField[Vector[sbt.librarymanagement.ModuleReport]]("modules") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.OrganizationArtifactReport(organization, name, modules) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.OrganizationArtifactReport, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("organization", obj.organization) 26 | builder.addField("name", obj.name) 27 | builder.addField("modules", obj.modules) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class PasswordAuthentication private ( 8 | val user: String, 9 | val password: Option[String]) extends sbt.librarymanagement.SshAuthentication() with Serializable { 10 | 11 | 12 | 13 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 14 | case x: PasswordAuthentication => (this.user == x.user) && (this.password == x.password) 15 | case _ => false 16 | }) 17 | override def hashCode: Int = { 18 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.PasswordAuthentication".##) + user.##) + password.##) 19 | } 20 | override def toString: String = { 21 | "PasswordAuthentication(" + user + ", " + password + ")" 22 | } 23 | private def copy(user: String = user, password: Option[String] = password): PasswordAuthentication = { 24 | new PasswordAuthentication(user, password) 25 | } 26 | def withUser(user: String): PasswordAuthentication = { 27 | copy(user = user) 28 | } 29 | def withPassword(password: Option[String]): PasswordAuthentication = { 30 | copy(password = password) 31 | } 32 | def withPassword(password: String): PasswordAuthentication = { 33 | copy(password = Option(password)) 34 | } 35 | } 36 | object PasswordAuthentication { 37 | 38 | def apply(user: String, password: Option[String]): PasswordAuthentication = new PasswordAuthentication(user, password) 39 | def apply(user: String, password: String): PasswordAuthentication = new PasswordAuthentication(user, Option(password)) 40 | } 41 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait PasswordAuthenticationFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val PasswordAuthenticationFormat: JsonFormat[sbt.librarymanagement.PasswordAuthentication] = new JsonFormat[sbt.librarymanagement.PasswordAuthentication] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.PasswordAuthentication = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val user = unbuilder.readField[String]("user") 15 | val password = unbuilder.readField[Option[String]]("password") 16 | unbuilder.endObject() 17 | sbt.librarymanagement.PasswordAuthentication(user, password) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.librarymanagement.PasswordAuthentication, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("user", obj.user) 25 | builder.addField("password", obj.password) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** sbt interface to an Ivy repository based on patterns, which is most Ivy repositories. */ 8 | abstract class PatternsBasedRepository( 9 | name: String, 10 | val patterns: sbt.librarymanagement.Patterns) extends sbt.librarymanagement.Resolver(name) with Serializable { 11 | 12 | 13 | 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: PatternsBasedRepository => (this.name == x.name) && (this.patterns == x.patterns) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.PatternsBasedRepository".##) + name.##) + patterns.##) 21 | } 22 | override def toString: String = { 23 | "PatternsBasedRepository(" + name + ", " + patterns + ")" 24 | } 25 | } 26 | object PatternsBasedRepository { 27 | 28 | } 29 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | trait PatternsBasedRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.FileConfigurationFormats with sbt.librarymanagement.FileRepositoryFormats with sbt.librarymanagement.URLRepositoryFormats with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshAuthenticationFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats => 10 | 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") 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait PatternsFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val PatternsFormat: JsonFormat[sbt.librarymanagement.Patterns] = new JsonFormat[sbt.librarymanagement.Patterns] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Patterns = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val ivyPatterns = unbuilder.readField[Vector[String]]("ivyPatterns") 15 | val artifactPatterns = unbuilder.readField[Vector[String]]("artifactPatterns") 16 | val isMavenCompatible = unbuilder.readField[Boolean]("isMavenCompatible") 17 | val descriptorOptional = unbuilder.readField[Boolean]("descriptorOptional") 18 | val skipConsistencyCheck = unbuilder.readField[Boolean]("skipConsistencyCheck") 19 | unbuilder.endObject() 20 | sbt.librarymanagement.Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck) 21 | case None => 22 | deserializationError("Expected JsObject but found None") 23 | } 24 | } 25 | override def write[J](obj: sbt.librarymanagement.Patterns, builder: Builder[J]): Unit = { 26 | builder.beginObject() 27 | builder.addField("ivyPatterns", obj.ivyPatterns) 28 | builder.addField("artifactPatterns", obj.artifactPatterns) 29 | builder.addField("isMavenCompatible", obj.isMavenCompatible) 30 | builder.addField("descriptorOptional", obj.descriptorOptional) 31 | builder.addField("skipConsistencyCheck", obj.skipConsistencyCheck) 32 | builder.endObject() 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait PomConfigurationFormats { self: sbt.librarymanagement.ScalaModuleInfoFormats with sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val PomConfigurationFormat: JsonFormat[sbt.librarymanagement.PomConfiguration] = new JsonFormat[sbt.librarymanagement.PomConfiguration] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.PomConfiguration = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val validate = unbuilder.readField[Boolean]("validate") 15 | val scalaModuleInfo = unbuilder.readField[Option[sbt.librarymanagement.ScalaModuleInfo]]("scalaModuleInfo") 16 | val file = unbuilder.readField[java.io.File]("file") 17 | val autoScalaTools = unbuilder.readField[Boolean]("autoScalaTools") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.PomConfiguration(validate, scalaModuleInfo, file, autoScalaTools) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.PomConfiguration, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("validate", obj.validate) 27 | builder.addField("scalaModuleInfo", obj.scalaModuleInfo) 28 | builder.addField("file", obj.file) 29 | builder.addField("autoScalaTools", obj.autoScalaTools) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | abstract class Resolver( 8 | val name: String) extends Serializable { 9 | /** check for HTTP */ 10 | private[sbt] def validateProtocol(logger: sbt.util.Logger): Boolean = false 11 | 12 | 13 | 14 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 15 | case x: Resolver => (this.name == x.name) 16 | case _ => false 17 | }) 18 | override def hashCode: Int = { 19 | 37 * (37 * (17 + "sbt.librarymanagement.Resolver".##) + name.##) 20 | } 21 | override def toString: String = { 22 | "Resolver(" + name + ")" 23 | } 24 | } 25 | object Resolver extends sbt.librarymanagement.ResolverFunctions { 26 | 27 | } 28 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | 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.SshAuthenticationFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats => 10 | 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") 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait RetrieveConfigurationFormats { self: sbt.librarymanagement.ConfigRefFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val RetrieveConfigurationFormat: JsonFormat[sbt.librarymanagement.RetrieveConfiguration] = new JsonFormat[sbt.librarymanagement.RetrieveConfiguration] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.RetrieveConfiguration = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val retrieveDirectory = unbuilder.readField[Option[java.io.File]]("retrieveDirectory") 15 | val outputPattern = unbuilder.readField[Option[String]]("outputPattern") 16 | val sync = unbuilder.readField[Boolean]("sync") 17 | val configurationsToRetrieve = unbuilder.readField[Option[scala.Vector[sbt.librarymanagement.ConfigRef]]]("configurationsToRetrieve") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.RetrieveConfiguration, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("retrieveDirectory", obj.retrieveDirectory) 27 | builder.addField("outputPattern", obj.outputPattern) 28 | builder.addField("sync", obj.sync) 29 | builder.addField("configurationsToRetrieve", obj.configurationsToRetrieve) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ScalaModuleInfoFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ScalaModuleInfoFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ScalaModuleInfoFormat: JsonFormat[sbt.librarymanagement.ScalaModuleInfo] = new JsonFormat[sbt.librarymanagement.ScalaModuleInfo] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ScalaModuleInfo = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val scalaFullVersion = unbuilder.readField[String]("scalaFullVersion") 15 | val scalaBinaryVersion = unbuilder.readField[String]("scalaBinaryVersion") 16 | val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations") 17 | val checkExplicit = unbuilder.readField[Boolean]("checkExplicit") 18 | val filterImplicit = unbuilder.readField[Boolean]("filterImplicit") 19 | val overrideScalaVersion = unbuilder.readField[Boolean]("overrideScalaVersion") 20 | val scalaOrganization = unbuilder.readField[String]("scalaOrganization") 21 | val scalaArtifacts = unbuilder.readField[scala.Vector[String]]("scalaArtifacts") 22 | unbuilder.endObject() 23 | sbt.librarymanagement.ScalaModuleInfo(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts) 24 | case None => 25 | deserializationError("Expected JsObject but found None") 26 | } 27 | } 28 | override def write[J](obj: sbt.librarymanagement.ScalaModuleInfo, builder: Builder[J]): Unit = { 29 | builder.beginObject() 30 | builder.addField("scalaFullVersion", obj.scalaFullVersion) 31 | builder.addField("scalaBinaryVersion", obj.scalaBinaryVersion) 32 | builder.addField("configurations", obj.configurations) 33 | builder.addField("checkExplicit", obj.checkExplicit) 34 | builder.addField("filterImplicit", obj.filterImplicit) 35 | builder.addField("overrideScalaVersion", obj.overrideScalaVersion) 36 | builder.addField("scalaOrganization", obj.scalaOrganization) 37 | builder.addField("scalaArtifacts", obj.scalaArtifacts) 38 | builder.endObject() 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** Basic SCM information for a project module */ 8 | final class ScmInfo private ( 9 | val browseUrl: java.net.URL, 10 | val connection: String, 11 | val devConnection: Option[String]) extends Serializable { 12 | 13 | private def this(browseUrl: java.net.URL, connection: String) = this(browseUrl, connection, None) 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: ScmInfo => (this.browseUrl == x.browseUrl) && (this.connection == x.connection) && (this.devConnection == x.devConnection) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ScmInfo".##) + browseUrl.##) + connection.##) + devConnection.##) 21 | } 22 | override def toString: String = { 23 | "ScmInfo(" + browseUrl + ", " + connection + ", " + devConnection + ")" 24 | } 25 | private def copy(browseUrl: java.net.URL = browseUrl, connection: String = connection, devConnection: Option[String] = devConnection): ScmInfo = { 26 | new ScmInfo(browseUrl, connection, devConnection) 27 | } 28 | def withBrowseUrl(browseUrl: java.net.URL): ScmInfo = { 29 | copy(browseUrl = browseUrl) 30 | } 31 | def withConnection(connection: String): ScmInfo = { 32 | copy(connection = connection) 33 | } 34 | def withDevConnection(devConnection: Option[String]): ScmInfo = { 35 | copy(devConnection = devConnection) 36 | } 37 | def withDevConnection(devConnection: String): ScmInfo = { 38 | copy(devConnection = Option(devConnection)) 39 | } 40 | } 41 | object ScmInfo { 42 | 43 | def apply(browseUrl: java.net.URL, connection: String): ScmInfo = new ScmInfo(browseUrl, connection) 44 | def apply(browseUrl: java.net.URL, connection: String, devConnection: Option[String]): ScmInfo = new ScmInfo(browseUrl, connection, devConnection) 45 | def apply(browseUrl: java.net.URL, connection: String, devConnection: String): ScmInfo = new ScmInfo(browseUrl, connection, Option(devConnection)) 46 | } 47 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ScmInfoFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ScmInfoFormat: JsonFormat[sbt.librarymanagement.ScmInfo] = new JsonFormat[sbt.librarymanagement.ScmInfo] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ScmInfo = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val browseUrl = unbuilder.readField[java.net.URL]("browseUrl") 15 | val connection = unbuilder.readField[String]("connection") 16 | val devConnection = unbuilder.readField[Option[String]]("devConnection") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.ScmInfo(browseUrl, connection, devConnection) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.ScmInfo, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("browseUrl", obj.browseUrl) 26 | builder.addField("connection", obj.connection) 27 | builder.addField("devConnection", obj.devConnection) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** sbt interface for an Ivy repository over sftp. More convenient construction is done using Resolver.sftp. */ 8 | final class SftpRepository private ( 9 | name: String, 10 | patterns: sbt.librarymanagement.Patterns, 11 | connection: sbt.librarymanagement.SshConnection) extends sbt.librarymanagement.SshBasedRepository(name, patterns, connection) with sbt.librarymanagement.SftpRepositoryExtra with Serializable { 12 | def this(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns) = 13 | this(name, patterns, connection) 14 | 15 | 16 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 17 | case x: SftpRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection) 18 | case _ => false 19 | }) 20 | override def hashCode: Int = { 21 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.SftpRepository".##) + name.##) + patterns.##) + connection.##) 22 | } 23 | override def toString: String = { 24 | "SftpRepository(" + name + ", " + patterns + ", " + connection + ")" 25 | } 26 | private def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, connection: sbt.librarymanagement.SshConnection = connection): SftpRepository = { 27 | new SftpRepository(name, patterns, connection) 28 | } 29 | def withName(name: String): SftpRepository = { 30 | copy(name = name) 31 | } 32 | def withPatterns(patterns: sbt.librarymanagement.Patterns): SftpRepository = { 33 | copy(patterns = patterns) 34 | } 35 | def withConnection(connection: sbt.librarymanagement.SshConnection): SftpRepository = { 36 | copy(connection = connection) 37 | } 38 | } 39 | object SftpRepository { 40 | def apply(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns) = 41 | new SftpRepository(name, patterns, connection) 42 | def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection): SftpRepository = new SftpRepository(name, patterns, connection) 43 | } 44 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait SftpRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshAuthenticationFormats => 9 | implicit lazy val SftpRepositoryFormat: JsonFormat[sbt.librarymanagement.SftpRepository] = new JsonFormat[sbt.librarymanagement.SftpRepository] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SftpRepository = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") 16 | val connection = unbuilder.readField[sbt.librarymanagement.SshConnection]("connection") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.SftpRepository(name, patterns, connection) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.SftpRepository, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("name", obj.name) 26 | builder.addField("patterns", obj.patterns) 27 | builder.addField("connection", obj.connection) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | abstract class SshAuthentication() extends Serializable { 8 | 9 | 10 | 11 | 12 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 13 | case _: SshAuthentication => true 14 | case _ => false 15 | }) 16 | override def hashCode: Int = { 17 | 37 * (17 + "sbt.librarymanagement.SshAuthentication".##) 18 | } 19 | override def toString: String = { 20 | "SshAuthentication()" 21 | } 22 | } 23 | object SshAuthentication { 24 | 25 | } 26 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | trait SshAuthenticationFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.PasswordAuthenticationFormats with sbt.librarymanagement.KeyFileAuthenticationFormats => 10 | implicit lazy val SshAuthenticationFormat: JsonFormat[sbt.librarymanagement.SshAuthentication] = flatUnionFormat2[sbt.librarymanagement.SshAuthentication, sbt.librarymanagement.PasswordAuthentication, sbt.librarymanagement.KeyFileAuthentication]("type") 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** sbt interface for an Ivy ssh-based repository (ssh and sftp). Requires the Jsch library.. */ 8 | abstract class SshBasedRepository( 9 | name: String, 10 | patterns: sbt.librarymanagement.Patterns, 11 | val connection: sbt.librarymanagement.SshConnection) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with sbt.librarymanagement.SshBasedRepositoryExtra with Serializable { 12 | 13 | 14 | 15 | 16 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 17 | case x: SshBasedRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection) 18 | case _ => false 19 | }) 20 | override def hashCode: Int = { 21 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.SshBasedRepository".##) + name.##) + patterns.##) + connection.##) 22 | } 23 | override def toString: String = { 24 | "SshBasedRepository(" + name + ", " + patterns + ", " + connection + ")" 25 | } 26 | } 27 | object SshBasedRepository { 28 | 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | trait SshBasedRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshAuthenticationFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats => 10 | implicit lazy val SshBasedRepositoryFormat: JsonFormat[sbt.librarymanagement.SshBasedRepository] = flatUnionFormat2[sbt.librarymanagement.SshBasedRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type") 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class SshConnection private ( 8 | val authentication: Option[sbt.librarymanagement.SshAuthentication], 9 | val hostname: Option[String], 10 | val port: Option[Int]) extends Serializable { 11 | 12 | 13 | 14 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 15 | case x: SshConnection => (this.authentication == x.authentication) && (this.hostname == x.hostname) && (this.port == x.port) 16 | case _ => false 17 | }) 18 | override def hashCode: Int = { 19 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.SshConnection".##) + authentication.##) + hostname.##) + port.##) 20 | } 21 | override def toString: String = { 22 | "SshConnection(" + authentication + ", " + hostname + ", " + port + ")" 23 | } 24 | private def copy(authentication: Option[sbt.librarymanagement.SshAuthentication] = authentication, hostname: Option[String] = hostname, port: Option[Int] = port): SshConnection = { 25 | new SshConnection(authentication, hostname, port) 26 | } 27 | def withAuthentication(authentication: Option[sbt.librarymanagement.SshAuthentication]): SshConnection = { 28 | copy(authentication = authentication) 29 | } 30 | def withAuthentication(authentication: sbt.librarymanagement.SshAuthentication): SshConnection = { 31 | copy(authentication = Option(authentication)) 32 | } 33 | def withHostname(hostname: Option[String]): SshConnection = { 34 | copy(hostname = hostname) 35 | } 36 | def withHostname(hostname: String): SshConnection = { 37 | copy(hostname = Option(hostname)) 38 | } 39 | def withPort(port: Option[Int]): SshConnection = { 40 | copy(port = port) 41 | } 42 | def withPort(port: Int): SshConnection = { 43 | copy(port = Option(port)) 44 | } 45 | } 46 | object SshConnection { 47 | 48 | def apply(authentication: Option[sbt.librarymanagement.SshAuthentication], hostname: Option[String], port: Option[Int]): SshConnection = new SshConnection(authentication, hostname, port) 49 | def apply(authentication: sbt.librarymanagement.SshAuthentication, hostname: String, port: Int): SshConnection = new SshConnection(Option(authentication), Option(hostname), Option(port)) 50 | } 51 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait SshConnectionFormats { self: sbt.librarymanagement.SshAuthenticationFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val SshConnectionFormat: JsonFormat[sbt.librarymanagement.SshConnection] = new JsonFormat[sbt.librarymanagement.SshConnection] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SshConnection = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val authentication = unbuilder.readField[Option[sbt.librarymanagement.SshAuthentication]]("authentication") 15 | val hostname = unbuilder.readField[Option[String]]("hostname") 16 | val port = unbuilder.readField[Option[Int]]("port") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.SshConnection(authentication, hostname, port) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.SshConnection, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("authentication", obj.authentication) 26 | builder.addField("hostname", obj.hostname) 27 | builder.addField("port", obj.port) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait SshRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshAuthenticationFormats => 9 | implicit lazy val SshRepositoryFormat: JsonFormat[sbt.librarymanagement.SshRepository] = new JsonFormat[sbt.librarymanagement.SshRepository] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SshRepository = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") 16 | val connection = unbuilder.readField[sbt.librarymanagement.SshConnection]("connection") 17 | val publishPermissions = unbuilder.readField[Option[String]]("publishPermissions") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.SshRepository(name, patterns, connection, publishPermissions) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.SshRepository, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("name", obj.name) 27 | builder.addField("patterns", obj.patterns) 28 | builder.addField("connection", obj.connection) 29 | builder.addField("publishPermissions", obj.publishPermissions) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class URLRepository private ( 8 | name: String, 9 | patterns: sbt.librarymanagement.Patterns, 10 | val allowInsecureProtocol: Boolean) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with Serializable { 11 | private[sbt] override def validateProtocol(logger: sbt.util.Logger): Boolean = Resolver.validateURLRepository(this, logger) 12 | private def this(name: String, patterns: sbt.librarymanagement.Patterns) = this(name, patterns, false) 13 | 14 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 15 | case x: URLRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.allowInsecureProtocol == x.allowInsecureProtocol) 16 | case _ => false 17 | }) 18 | override def hashCode: Int = { 19 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.URLRepository".##) + name.##) + patterns.##) + allowInsecureProtocol.##) 20 | } 21 | override def toString: String = { 22 | "URLRepository(" + name + ", " + patterns + ", " + allowInsecureProtocol + ")" 23 | } 24 | private def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, allowInsecureProtocol: Boolean = allowInsecureProtocol): URLRepository = { 25 | new URLRepository(name, patterns, allowInsecureProtocol) 26 | } 27 | def withName(name: String): URLRepository = { 28 | copy(name = name) 29 | } 30 | def withPatterns(patterns: sbt.librarymanagement.Patterns): URLRepository = { 31 | copy(patterns = patterns) 32 | } 33 | def withAllowInsecureProtocol(allowInsecureProtocol: Boolean): URLRepository = { 34 | copy(allowInsecureProtocol = allowInsecureProtocol) 35 | } 36 | } 37 | object URLRepository { 38 | 39 | def apply(name: String, patterns: sbt.librarymanagement.Patterns): URLRepository = new URLRepository(name, patterns) 40 | def apply(name: String, patterns: sbt.librarymanagement.Patterns, allowInsecureProtocol: Boolean): URLRepository = new URLRepository(name, patterns, allowInsecureProtocol) 41 | } 42 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/URLRepositoryFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait URLRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val URLRepositoryFormat: JsonFormat[sbt.librarymanagement.URLRepository] = new JsonFormat[sbt.librarymanagement.URLRepository] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.URLRepository = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val name = unbuilder.readField[String]("name") 15 | val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns") 16 | val allowInsecureProtocol = unbuilder.readField[Boolean]("allowInsecureProtocol") 17 | unbuilder.endObject() 18 | sbt.librarymanagement.URLRepository(name, patterns, allowInsecureProtocol) 19 | case None => 20 | deserializationError("Expected JsObject but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.URLRepository, builder: Builder[J]): Unit = { 24 | builder.beginObject() 25 | builder.addField("name", obj.name) 26 | builder.addField("patterns", obj.patterns) 27 | builder.addField("allowInsecureProtocol", obj.allowInsecureProtocol) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/UpdateLogging.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | /** 8 | * Configures logging during an 'update'. `level` determines the amount of other information logged. 9 | * `Full` is the default and logs the most. 10 | * `DownloadOnly` only logs what is downloaded. 11 | * `Quiet` only displays errors. 12 | * `Default` uses the current log level of `update` task. 13 | */ 14 | sealed abstract class UpdateLogging extends Serializable 15 | object UpdateLogging { 16 | 17 | 18 | case object Full extends UpdateLogging 19 | case object DownloadOnly extends UpdateLogging 20 | case object Quiet extends UpdateLogging 21 | case object Default extends UpdateLogging 22 | } 23 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/UpdateLoggingFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait UpdateLoggingFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val UpdateLoggingFormat: JsonFormat[sbt.librarymanagement.UpdateLogging] = new JsonFormat[sbt.librarymanagement.UpdateLogging] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateLogging = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.readString(__js) match { 14 | case "Full" => sbt.librarymanagement.UpdateLogging.Full 15 | case "DownloadOnly" => sbt.librarymanagement.UpdateLogging.DownloadOnly 16 | case "Quiet" => sbt.librarymanagement.UpdateLogging.Quiet 17 | case "Default" => sbt.librarymanagement.UpdateLogging.Default 18 | } 19 | case None => 20 | deserializationError("Expected JsString but found None") 21 | } 22 | } 23 | override def write[J](obj: sbt.librarymanagement.UpdateLogging, builder: Builder[J]): Unit = { 24 | val str = obj match { 25 | case sbt.librarymanagement.UpdateLogging.Full => "Full" 26 | case sbt.librarymanagement.UpdateLogging.DownloadOnly => "DownloadOnly" 27 | case sbt.librarymanagement.UpdateLogging.Quiet => "Quiet" 28 | case sbt.librarymanagement.UpdateLogging.Default => "Default" 29 | } 30 | builder.writeString(str) 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/UpdateReportFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait UpdateReportFormats { self: sbt.librarymanagement.ConfigurationReportFormats with sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sbt.librarymanagement.CallerFormats with sbt.librarymanagement.OrganizationArtifactReportFormats with sbt.librarymanagement.UpdateStatsFormats => 9 | implicit lazy val UpdateReportFormat: JsonFormat[sbt.librarymanagement.UpdateReport] = new JsonFormat[sbt.librarymanagement.UpdateReport] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateReport = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val cachedDescriptor = unbuilder.readField[java.io.File]("cachedDescriptor") 15 | val configurations = unbuilder.readField[Vector[sbt.librarymanagement.ConfigurationReport]]("configurations") 16 | val stats = unbuilder.readField[sbt.librarymanagement.UpdateStats]("stats") 17 | val stamps = unbuilder.readField[Map[java.io.File, Long]]("stamps") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.UpdateReport(cachedDescriptor, configurations, stats, stamps) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.UpdateReport, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("cachedDescriptor", obj.cachedDescriptor) 27 | builder.addField("configurations", obj.configurations) 28 | builder.addField("stats", obj.stats) 29 | builder.addField("stamps", obj.stamps) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/UpdateReportLiteFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait UpdateReportLiteFormats { self: sbt.librarymanagement.ConfigurationReportLiteFormats with sbt.librarymanagement.OrganizationArtifactReportFormats with sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.ConfigRefFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats with sbt.librarymanagement.For3Use2_13Formats with sbt.librarymanagement.For2_13Use3Formats with sbt.librarymanagement.CallerFormats => 9 | implicit lazy val UpdateReportLiteFormat: JsonFormat[sbt.internal.librarymanagement.UpdateReportLite] = new JsonFormat[sbt.internal.librarymanagement.UpdateReportLite] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.UpdateReportLite = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val configurations = unbuilder.readField[Vector[sbt.internal.librarymanagement.ConfigurationReportLite]]("configurations") 15 | unbuilder.endObject() 16 | sbt.internal.librarymanagement.UpdateReportLite(configurations) 17 | case None => 18 | deserializationError("Expected JsObject but found None") 19 | } 20 | } 21 | override def write[J](obj: sbt.internal.librarymanagement.UpdateReportLite, builder: Builder[J]): Unit = { 22 | builder.beginObject() 23 | builder.addField("configurations", obj.configurations) 24 | builder.endObject() 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/UpdateStats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | final class UpdateStats private ( 8 | val resolveTime: Long, 9 | val downloadTime: Long, 10 | val downloadSize: Long, 11 | val cached: Boolean) extends Serializable { 12 | 13 | 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: UpdateStats => (this.resolveTime == x.resolveTime) && (this.downloadTime == x.downloadTime) && (this.downloadSize == x.downloadSize) && (this.cached == x.cached) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.UpdateStats".##) + resolveTime.##) + downloadTime.##) + downloadSize.##) + cached.##) 21 | } 22 | override def toString: String = { 23 | Seq("Resolve time: " + resolveTime + " ms", "Download time: " + downloadTime + " ms", "Download size: " + downloadSize + " bytes").mkString(", ") 24 | } 25 | private def copy(resolveTime: Long = resolveTime, downloadTime: Long = downloadTime, downloadSize: Long = downloadSize, cached: Boolean = cached): UpdateStats = { 26 | new UpdateStats(resolveTime, downloadTime, downloadSize, cached) 27 | } 28 | def withResolveTime(resolveTime: Long): UpdateStats = { 29 | copy(resolveTime = resolveTime) 30 | } 31 | def withDownloadTime(downloadTime: Long): UpdateStats = { 32 | copy(downloadTime = downloadTime) 33 | } 34 | def withDownloadSize(downloadSize: Long): UpdateStats = { 35 | copy(downloadSize = downloadSize) 36 | } 37 | def withCached(cached: Boolean): UpdateStats = { 38 | copy(cached = cached) 39 | } 40 | } 41 | object UpdateStats { 42 | 43 | def apply(resolveTime: Long, downloadTime: Long, downloadSize: Long, cached: Boolean): UpdateStats = new UpdateStats(resolveTime, downloadTime, downloadSize, cached) 44 | } 45 | -------------------------------------------------------------------------------- /core/src/main/contraband-scala/sbt/librarymanagement/UpdateStatsFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait UpdateStatsFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val UpdateStatsFormat: JsonFormat[sbt.librarymanagement.UpdateStats] = new JsonFormat[sbt.librarymanagement.UpdateStats] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.UpdateStats = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val resolveTime = unbuilder.readField[Long]("resolveTime") 15 | val downloadTime = unbuilder.readField[Long]("downloadTime") 16 | val downloadSize = unbuilder.readField[Long]("downloadSize") 17 | val cached = unbuilder.readField[Boolean]("cached") 18 | unbuilder.endObject() 19 | sbt.librarymanagement.UpdateStats(resolveTime, downloadTime, downloadSize, cached) 20 | case None => 21 | deserializationError("Expected JsObject but found None") 22 | } 23 | } 24 | override def write[J](obj: sbt.librarymanagement.UpdateStats, builder: Builder[J]): Unit = { 25 | builder.beginObject() 26 | builder.addField("resolveTime", obj.resolveTime) 27 | builder.addField("downloadTime", obj.downloadTime) 28 | builder.addField("downloadSize", obj.downloadSize) 29 | builder.addField("cached", obj.cached) 30 | builder.endObject() 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /core/src/main/java/sbt/internal/librarymanagement/mavenint/SbtPomExtraProperties.java: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement.mavenint; 2 | 3 | /** 4 | * Extra properties we dump from Aether into the properties list. 5 | */ 6 | public class SbtPomExtraProperties { 7 | 8 | public static final String MAVEN_PACKAGING_KEY = "sbt.pom.packaging"; 9 | public static final String SCALA_VERSION_KEY = "sbt.pom.scalaversion"; 10 | public static final String SBT_VERSION_KEY = "sbt.pom.sbtversion"; 11 | 12 | public static final String POM_INFO_KEY_PREFIX = "info."; 13 | public static final String POM_SCALA_VERSION = "scalaVersion"; 14 | public static final String POM_SBT_VERSION = "sbtVersion"; 15 | public static final String POM_API_KEY = "info.apiURL"; 16 | public static final String VERSION_SCHEME_KEY = "info.versionScheme"; 17 | public static final String POM_RELEASE_NOTES_KEY = "info.releaseNotesUrl"; 18 | 19 | public static final String LICENSE_COUNT_KEY = "license.count"; 20 | 21 | public static String makeLicenseName(int i) { 22 | return "license." + i + ".name"; 23 | } 24 | public static String makeLicenseUrl(int i) { 25 | return "license." + i + ".url"; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/CompatibilityWarning.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | import sbt.util.{ Level, Logger } 5 | 6 | import Configurations._ 7 | 8 | final class CompatibilityWarningOptions private[sbt] ( 9 | val configurations: Seq[Configuration], 10 | val level: Level.Value 11 | ) 12 | 13 | object CompatibilityWarningOptions { 14 | def default: CompatibilityWarningOptions = 15 | apply(configurations = List(Compile, Runtime), level = Level.Warn) 16 | def apply( 17 | configurations: List[Configuration], 18 | level: Level.Value 19 | ): CompatibilityWarningOptions = 20 | new CompatibilityWarningOptions( 21 | configurations = configurations, 22 | level = level 23 | ) 24 | } 25 | 26 | private[sbt] object CompatibilityWarning { 27 | def run( 28 | config: CompatibilityWarningOptions, 29 | module: ModuleDescriptor, 30 | mavenStyle: Boolean, 31 | log: Logger 32 | ): Unit = { 33 | if (mavenStyle) { 34 | processIntransitive(config, module, log) 35 | } 36 | } 37 | def processIntransitive( 38 | config: CompatibilityWarningOptions, 39 | module: ModuleDescriptor, 40 | log: Logger 41 | ): Unit = { 42 | val monitoredConfigsStr: Set[String] = (config.configurations map { _.name }).toSet 43 | def inMonitoredConfigs(configOpt: Option[String]): Boolean = 44 | configOpt match { 45 | case Some(c) => (c.split(",").toSet intersect monitoredConfigsStr).nonEmpty 46 | case None => monitoredConfigsStr contains "compile" 47 | } 48 | module.directDependencies foreach { m => 49 | if (!m.isTransitive && inMonitoredConfigs(m.configurations)) { 50 | log.warn( 51 | s"""Found intransitive dependency ($m) while publishMavenStyle is true, but Maven repositories 52 | | do not support intransitive dependencies. Use exclusions instead so transitive dependencies 53 | | will be correctly excluded in dependent projects. 54 | """.stripMargin 55 | ) 56 | } else () 57 | } 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/InternalDefaults.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package internal.librarymanagement 3 | 4 | import java.io.File 5 | import sbt.librarymanagement._ 6 | import sbt.io.syntax._ 7 | 8 | /** 9 | * This is a list of functions with default values. 10 | */ 11 | object InternalDefaults { 12 | val sbtOrgTemp = JsonUtil.sbtOrgTemp 13 | val modulePrefixTemp = "temp-module-" 14 | 15 | def getArtifactTypeFilter(opt: Option[ArtifactTypeFilter]): ArtifactTypeFilter = 16 | opt.getOrElse(Artifact.defaultArtifactTypeFilter) 17 | 18 | def defaultRetrieveDirectory: File = 19 | (new File(".")).getAbsoluteFile / "lib_managed" 20 | 21 | def getRetrieveDirectory(opt: Option[File]): File = 22 | opt.getOrElse(defaultRetrieveDirectory) 23 | 24 | def getRetrievePattern(opt: Option[String]): String = 25 | opt.getOrElse(Resolver.defaultRetrievePattern) 26 | 27 | def getDeliverStatus(opt: Option[String]): String = 28 | opt.getOrElse("release") 29 | } 30 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/IvyConfigurations.scala: -------------------------------------------------------------------------------- 1 | /* sbt -- Simple Build Tool 2 | * Copyright 2008, 2009, 2010 Mark Harrah 3 | */ 4 | package sbt.librarymanagement 5 | 6 | private[librarymanagement] abstract class InlineConfigurationFunctions { 7 | def configurations( 8 | explicitConfigurations: Iterable[Configuration], 9 | defaultConfiguration: Option[Configuration] 10 | ) = 11 | if (explicitConfigurations.isEmpty) { 12 | defaultConfiguration match { 13 | case Some(Configurations.DefaultIvyConfiguration) => Configurations.Default :: Nil 14 | case Some(Configurations.DefaultMavenConfiguration) => 15 | Configurations.defaultMavenConfigurations 16 | case _ => Nil 17 | } 18 | } else 19 | explicitConfigurations 20 | } 21 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/LMSysProp.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * sbt 3 | * Copyright 2011 - 2018, Lightbend, Inc. 4 | * Copyright 2008 - 2010, Mark Harrah 5 | * Licensed under Apache License 2.0 (see LICENSE) 6 | */ 7 | 8 | package sbt 9 | package internal 10 | package librarymanagement 11 | 12 | import java.util.Locale 13 | import scala.util.control.NonFatal 14 | 15 | object LMSysProp { 16 | def booleanOpt(name: String): Option[Boolean] = 17 | sys.props.get(name).flatMap { x => 18 | x.toLowerCase(Locale.ENGLISH) match { 19 | case "1" | "always" | "true" => Some(true) 20 | case "0" | "never" | "false" => Some(false) 21 | case "auto" => None 22 | case _ => None 23 | } 24 | } 25 | 26 | def getOrFalse(name: String): Boolean = booleanOpt(name).getOrElse(false) 27 | def getOrTrue(name: String): Boolean = booleanOpt(name).getOrElse(true) 28 | 29 | // System property style: 30 | // 1. use sbt. prefix 31 | // 2. prefer short nouns 32 | // 3. use dot for namespacing, and avoid making dot-separated English phrase 33 | // 4. make active/enable properties, instead of "sbt.disable." 34 | // 35 | // Good: sbt.offline 36 | // 37 | // Bad: 38 | // sbt.disable.interface.classloader.cache 39 | // sbt.task.timings.on.shutdown 40 | // sbt.skip.version.write -> sbt.genbuildprops=false 41 | 42 | val useSecureResolvers: Boolean = getOrTrue("sbt.repository.secure") 43 | 44 | lazy val modifyVersionRange: Boolean = getOrTrue("sbt.modversionrange") 45 | 46 | lazy val isJavaVersion9Plus: Boolean = javaVersion > 8 47 | lazy val javaVersion: Int = { 48 | try { 49 | // See Oracle section 1.5.3 at: 50 | // https://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html 51 | val version = sys.props("java.specification.version").split("\\.").toList.map(_.toInt) 52 | version match { 53 | case 1 :: minor :: _ => minor 54 | case major :: _ => major 55 | case _ => 0 56 | } 57 | } catch { 58 | case NonFatal(_) => 0 59 | } 60 | } 61 | 62 | lazy val useGigahorse: Boolean = getOrFalse("sbt.gigahorse") 63 | lazy val maxPublishAttempts: Int = 64 | java.lang.Integer.getInteger("sbt.repository.publish.attempts", 3) 65 | 66 | } 67 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/SemSelOperator.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | sealed abstract class SemSelOperator { 3 | override def toString: String = this match { 4 | case SemSelOperator.Lte => "<=" 5 | case SemSelOperator.Lt => "<" 6 | case SemSelOperator.Gte => ">=" 7 | case SemSelOperator.Gt => ">" 8 | case SemSelOperator.Eq => "=" 9 | } 10 | } 11 | object SemSelOperator { 12 | case object Lte extends SemSelOperator 13 | case object Lt extends SemSelOperator 14 | case object Gte extends SemSelOperator 15 | case object Gt extends SemSelOperator 16 | case object Eq extends SemSelOperator 17 | } 18 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/StringUtilities.scala: -------------------------------------------------------------------------------- 1 | /* sbt -- Simple Build Tool 2 | * Copyright 2009 Mark Harrah 3 | */ 4 | package sbt.internal.librarymanagement 5 | 6 | import java.util.Locale 7 | 8 | object StringUtilities { 9 | @deprecated( 10 | "Different use cases require different normalization. Use Project.normalizeModuleID or normalizeProjectID instead.", 11 | "0.13.0" 12 | ) 13 | def normalize(s: String) = s.toLowerCase(Locale.ENGLISH).replaceAll("""\W+""", "-") 14 | def nonEmpty(s: String, label: String): Unit = 15 | require(s.trim.length > 0, label + " cannot be empty.") 16 | def appendable(s: String) = if (s.isEmpty) "" else "_" + s 17 | } 18 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/VersionSchemes.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * sbt 3 | * Copyright 2011 - 2018, Lightbend, Inc. 4 | * Copyright 2008 - 2010, Mark Harrah 5 | * Licensed under Apache License 2.0 (see LICENSE) 6 | */ 7 | 8 | package sbt 9 | package internal 10 | package librarymanagement 11 | 12 | import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties 13 | import sbt.librarymanagement.{ EvictionWarningOptions, ModuleID, ScalaModuleInfo } 14 | 15 | // See APIMappings.scala 16 | private[sbt] object VersionSchemes { 17 | final val EarlySemVer = "early-semver" 18 | final val SemVerSpec = "semver-spec" 19 | final val PackVer = "pvp" 20 | final val Strict = "strict" 21 | final val Always = "always" 22 | 23 | def validateScheme(value: String): Unit = 24 | value match { 25 | case EarlySemVer | SemVerSpec | PackVer | Strict | Always => () 26 | case "semver" => 27 | sys.error( 28 | s"""'semver' is ambiguous. 29 | |Based on the Semantic Versioning 2.0.0, 0.y.z updates are all initial development and thus 30 | |0.6.0 and 0.6.1 would NOT maintain any compatibility, but in Scala ecosystem it is 31 | |common to start adopting binary compatibility even in 0.y.z releases. 32 | | 33 | |Specify 'early-semver' for the early variant. 34 | |Specify 'semver-spec' for the spec-correct SemVer.""".stripMargin 35 | ) 36 | case x => sys.error(s"unknown version scheme: $x") 37 | } 38 | 39 | /** 40 | * info.versionScheme property will be included into POM after sbt 1.4.0. 41 | */ 42 | def extractFromId(mid: ModuleID): Option[String] = extractFromExtraAttributes(mid.extraAttributes) 43 | 44 | def extractFromExtraAttributes(extraAttributes: Map[String, String]): Option[String] = 45 | extraAttributes.get(SbtPomExtraProperties.VERSION_SCHEME_KEY) 46 | 47 | def evalFunc( 48 | scheme: String 49 | ): Function1[(ModuleID, Option[ModuleID], Option[ScalaModuleInfo]), Boolean] = 50 | scheme match { 51 | case EarlySemVer => EvictionWarningOptions.guessEarlySemVer 52 | case SemVerSpec => EvictionWarningOptions.guessSemVer 53 | case PackVer => EvictionWarningOptions.evalPvp 54 | case Strict => EvictionWarningOptions.guessStrict 55 | case Always => EvictionWarningOptions.guessTrue 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/formats/GlobalLockFormat.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement.formats 2 | 3 | import sjsonnew._ 4 | import xsbti._ 5 | import java.io.File 6 | import java.util.concurrent.Callable 7 | 8 | /** 9 | * A fake JsonFormat for xsbti.GlobalLock. 10 | * This is mostly for making IvyConfiguration serializable to JSON. 11 | */ 12 | trait GlobalLockFormat { self: BasicJsonProtocol => 13 | import GlobalLockFormats._ 14 | 15 | implicit lazy val globalLockIsoString: IsoString[GlobalLock] = 16 | IsoString.iso(_ => "", _ => NoGlobalLock) 17 | 18 | implicit lazy val GlobalLockFormat: JsonFormat[GlobalLock] = implicitly 19 | } 20 | 21 | private[sbt] object GlobalLockFormats { 22 | object NoGlobalLock extends GlobalLock { 23 | def apply[T](lockFile: File, run: Callable[T]) = run.call() 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/formats/LoggerFormat.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement.formats 2 | 3 | import sjsonnew._ 4 | import xsbti._ 5 | import sbt.util.Logger.Null 6 | 7 | /** 8 | * A fake JsonFormat for xsbti.Logger. 9 | * This is mostly for making IvyConfiguration serializable to JSON. 10 | */ 11 | trait LoggerFormat { self: BasicJsonProtocol => 12 | implicit lazy val xsbtiLoggerIsoString: IsoString[Logger] = 13 | IsoString.iso(_ => "", _ => Null) 14 | 15 | implicit lazy val LoggerFormat: JsonFormat[Logger] = implicitly 16 | } 17 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/formats/LogicalClockFormats.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement.formats 2 | 3 | import sjsonnew._ 4 | 5 | import sbt.librarymanagement.LogicalClock 6 | 7 | trait LogicalClockFormats { self: BasicJsonProtocol => 8 | implicit lazy val LogicalClockFormat: JsonFormat[LogicalClock] = 9 | projectFormat[LogicalClock, String]( 10 | cl => cl.toString, 11 | str => LogicalClock(str) 12 | ) 13 | } 14 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/internal/librarymanagement/formats/NodeSeqFormat.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement.formats 2 | 3 | import sjsonnew._ 4 | import scala.xml._ 5 | 6 | trait NodeSeqFormat { self: BasicJsonProtocol => 7 | implicit lazy val NodeSeqFormat: JsonFormat[NodeSeq] = projectFormat[NodeSeq, String]( 8 | xml => {xml}.toString, 9 | str => XML.loadString(str).child 10 | ) 11 | } 12 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/ConfigRefFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. 3 | */ 4 | package sbt.librarymanagement 5 | 6 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 7 | 8 | trait ConfigRefFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ConfigRefFormat: JsonFormat[sbt.librarymanagement.ConfigRef] = 10 | new JsonFormat[sbt.librarymanagement.ConfigRef] { 11 | override def read[J]( 12 | __jsOpt: Option[J], 13 | unbuilder: Unbuilder[J] 14 | ): sbt.librarymanagement.ConfigRef = { 15 | __jsOpt match { 16 | case Some(__js) => 17 | unbuilder.beginObject(__js) 18 | val name = unbuilder.readField[String]("name") 19 | unbuilder.endObject() 20 | sbt.librarymanagement.ConfigRef(name) 21 | case None => 22 | deserializationError("Expected JsObject but found None") 23 | } 24 | } 25 | override def write[J](obj: sbt.librarymanagement.ConfigRef, builder: Builder[J]): Unit = { 26 | builder.beginObject() 27 | builder.addField("name", obj.name) 28 | builder.endObject() 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/ConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]]. 3 | */ 4 | package sbt 5 | package librarymanagement 6 | 7 | import _root_.sjsonnew.{ deserializationError, Builder, JsonFormat, Unbuilder } 8 | 9 | trait ConfigurationFormats { 10 | self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol => 11 | implicit lazy val ConfigurationFormat: JsonFormat[sbt.librarymanagement.Configuration] = 12 | new JsonFormat[sbt.librarymanagement.Configuration] { 13 | override def read[J]( 14 | jsOpt: Option[J], 15 | unbuilder: Unbuilder[J] 16 | ): sbt.librarymanagement.Configuration = { 17 | jsOpt match { 18 | case Some(js) => 19 | unbuilder.beginObject(js) 20 | val id = unbuilder.readField[String]("id") 21 | val name = unbuilder.readField[String]("name") 22 | val description = unbuilder.readField[String]("description") 23 | val isPublic = unbuilder.readField[Boolean]("isPublic") 24 | val extendsConfigs = 25 | unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("extendsConfigs") 26 | val transitive = unbuilder.readField[Boolean]("transitive") 27 | unbuilder.endObject() 28 | new sbt.librarymanagement.Configuration( 29 | id, 30 | name, 31 | description, 32 | isPublic, 33 | extendsConfigs, 34 | transitive 35 | ) 36 | case None => 37 | deserializationError("Expected JsObject but found None") 38 | } 39 | } 40 | override def write[J](obj: sbt.librarymanagement.Configuration, builder: Builder[J]): Unit = { 41 | builder.beginObject() 42 | builder.addField("id", obj.id) 43 | builder.addField("name", obj.name) 44 | builder.addField("description", obj.description) 45 | builder.addField("isPublic", obj.isPublic) 46 | builder.addField("extendsConfigs", obj.extendsConfigs) 47 | builder.addField("transitive", obj.transitive) 48 | builder.endObject() 49 | } 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/Extra.scala: -------------------------------------------------------------------------------- 1 | /* sbt -- Simple Build Tool 2 | * Copyright 2008, 2009, 2010 Mark Harrah 3 | */ 4 | package sbt.librarymanagement 5 | 6 | import sbt.librarymanagement.DependencyBuilders.{ Organization, OrganizationArtifactName } 7 | 8 | private[librarymanagement] abstract class InclExclRuleFunctions { 9 | def everything = InclExclRule("*", "*", "*", Vector.empty, Disabled()) 10 | 11 | def apply(organization: String, name: String): InclExclRule = 12 | InclExclRule(organization, name, "*", Vector.empty, Disabled()) 13 | 14 | def apply(organization: String): InclExclRule = apply(organization, "*") 15 | 16 | implicit def organizationToExclusionRule(organization: Organization): InclExclRule = 17 | apply(organization.organization) 18 | implicit def stringToExclusionRule(organization: String): InclExclRule = apply(organization) 19 | 20 | implicit def organizationArtifactNameToExclusionRule(oa: OrganizationArtifactName): InclExclRule = 21 | InclExclRule(oa.organization, oa.name, "*", Vector.empty, oa.crossVersion) 22 | 23 | implicit def moduleIDToExclusionRule(moduleID: ModuleID): InclExclRule = { 24 | val org = moduleID.organization 25 | val name = moduleID.name 26 | val version = moduleID.revision 27 | val crossVersion = moduleID.crossVersion 28 | InclExclRule(org, name, version, Vector.empty, crossVersion) 29 | } 30 | } 31 | 32 | private[librarymanagement] abstract class ArtifactTypeFilterExtra { 33 | def inverted: Boolean 34 | 35 | def withInverted(inverted: Boolean): ArtifactTypeFilter 36 | 37 | def invert = withInverted(!inverted) 38 | } 39 | 40 | private[librarymanagement] abstract class ArtifactTypeFilterFunctions { 41 | def allow(types: Set[String]) = ArtifactTypeFilter(types, false) 42 | def forbid(types: Set[String]) = ArtifactTypeFilter(types, true) 43 | } 44 | 45 | private[librarymanagement] abstract class ConflictManagerFunctions { 46 | // To avoid NPE (or making the val's below lazy) 47 | // For case classes refchecks rewrites apply calls to constructor calls, we have to do it manually 48 | def apply(name: String, organization: String = "*", module: String = "*"): ConflictManager 49 | def ConflictManager(name: String) = apply(name) 50 | 51 | val all = ConflictManager("all") 52 | val latestTime = ConflictManager("latest-time") 53 | val latestRevision = ConflictManager("latest-revision") 54 | val latestCompatible = ConflictManager("latest-compatible") 55 | val strict = ConflictManager("strict") 56 | val default = latestRevision 57 | } 58 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/Http.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import gigahorse._, support.apachehttp.Gigahorse 4 | import scala.concurrent.duration.DurationInt 5 | 6 | object Http { 7 | lazy val http: HttpClient = Gigahorse.http(gigahorse.Config().withReadTimeout(60.minutes)) 8 | } 9 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/LibraryManagementSyntax.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | trait LibraryManagementSyntax0 { 4 | // See http://www.scala-lang.org/news/2.12.0#traits-compile-to-interfaces 5 | // Avoid defining fields (val or var, but a constant is ok – final val without result type) 6 | // Avoid calling super 7 | // Avoid initializer statements in the body 8 | 9 | implicit def richUpdateReport(ur: UpdateReport): RichUpdateReport = new RichUpdateReport(ur) 10 | } 11 | 12 | trait LibraryManagementSyntax 13 | extends LibraryManagementSyntax0 14 | with DependencyBuilders 15 | with DependencyFilterExtra { 16 | // See http://www.scala-lang.org/news/2.12.0#traits-compile-to-interfaces 17 | // Avoid defining fields (val or var, but a constant is ok – final val without result type) 18 | // Avoid calling super 19 | // Avoid initializer statements in the body 20 | 21 | type ExclusionRule = InclExclRule 22 | final val ExclusionRule = InclExclRule 23 | 24 | type InclusionRule = InclExclRule 25 | final val InclusionRule = InclExclRule 26 | 27 | import sbt.librarymanagement.{ Configurations => C } 28 | final val Compile = C.Compile 29 | final val Test = C.Test 30 | final val Runtime = C.Runtime 31 | @deprecated("Create a separate subproject for testing instead", "1.9.0") 32 | final val IntegrationTest = C.IntegrationTest 33 | final val Default = C.Default 34 | final val Provided = C.Provided 35 | // java.lang.System is more important, so don't alias this one 36 | // final val System = C.System 37 | final val Optional = C.Optional 38 | } 39 | 40 | object syntax extends LibraryManagementSyntax 41 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/License.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import java.net.URL 4 | import java.net.URI 5 | 6 | /** 7 | * Commonly used software licenses 8 | * Names are SPDX ids: 9 | * https://raw.githubusercontent.com/spdx/license-list-data/master/json/licenses.json 10 | */ 11 | object License { 12 | lazy val Apache2: (String, URL) = 13 | ("Apache-2.0", new URI("https://www.apache.org/licenses/LICENSE-2.0.txt").toURL) 14 | 15 | lazy val MIT: (String, URL) = 16 | ("MIT", new URI("https://opensource.org/licenses/MIT").toURL) 17 | 18 | lazy val CC0: (String, URL) = 19 | ("CC0-1.0", new URI("https://creativecommons.org/publicdomain/zero/1.0/legalcode").toURL) 20 | 21 | def PublicDomain: (String, URL) = CC0 22 | 23 | lazy val GPL3_or_later: (String, URL) = 24 | ("GPL-3.0-or-later", new URI("https://spdx.org/licenses/GPL-3.0-or-later.html").toURL) 25 | } 26 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/LogicalClock.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | /** 4 | * Represents a logical time point for dependency resolution. 5 | * This is used to cache dependencies across subproject resolution which may change over time. 6 | */ 7 | trait LogicalClock { 8 | def toString: String 9 | } 10 | 11 | object LogicalClock { 12 | def apply(hashCode: Int): LogicalClock = { 13 | def intToByteArray(x: Int): Array[Byte] = 14 | Array((x >>> 24).toByte, (x >> 16 & 0xff).toByte, (x >> 8 & 0xff).toByte, (x & 0xff).toByte) 15 | apply(sbt.io.Hash.toHex(intToByteArray(hashCode))) 16 | } 17 | def apply(x: String): LogicalClock = new LogicalClock { 18 | override def toString: String = x 19 | } 20 | def unknown: LogicalClock = apply("unknown") 21 | } 22 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/MakePomConfigurationExtra.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | private[librarymanagement] abstract class MakePomConfigurationFunctions { 4 | private[sbt] lazy val constTrue: MavenRepository => Boolean = _ => true 5 | 6 | def apply(): MakePomConfiguration = 7 | MakePomConfiguration( 8 | None, 9 | None, 10 | None, 11 | None, 12 | identity(_: scala.xml.Node), 13 | constTrue, 14 | true, 15 | Set(Artifact.DefaultType, Artifact.PomType) 16 | ) 17 | } 18 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/Publisher.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import java.io.File 4 | import sbt.util.Logger 5 | 6 | /** 7 | * Library management API to publish artifacts. 8 | */ 9 | class Publisher private[sbt] (publisherEngine: PublisherInterface) { 10 | 11 | /** 12 | * Builds a ModuleDescriptor that describes a subproject with dependencies. 13 | * 14 | * @param moduleSetting It contains the information about the module including the dependencies. 15 | * @return A `ModuleDescriptor` describing a subproject and its dependencies. 16 | */ 17 | def moduleDescriptor(moduleSetting: ModuleDescriptorConfiguration): ModuleDescriptor = 18 | publisherEngine.moduleDescriptor(moduleSetting) 19 | 20 | /** 21 | * Publishes the given module. 22 | * 23 | * @param module The module to be published. 24 | * @param configuration The publish configuration. 25 | * @param log The logger. 26 | */ 27 | def publish(module: ModuleDescriptor, configuration: PublishConfiguration, log: Logger): Unit = 28 | publisherEngine.publish(module, configuration, log) 29 | 30 | /** 31 | * Makes the `pom.xml` file for the given module. 32 | * 33 | * @param module The module for which a `.pom` file is to be created. 34 | * @param configuration The makePomFile configuration. 35 | * @param log The logger. 36 | * @return The `File` containing the POM descriptor. 37 | */ 38 | def makePomFile( 39 | module: ModuleDescriptor, 40 | configuration: MakePomConfiguration, 41 | log: Logger 42 | ): File = 43 | publisherEngine.makePomFile(module, configuration, log) 44 | } 45 | 46 | object Publisher { 47 | def apply(publisherEngine: PublisherInterface): Publisher = 48 | new Publisher(publisherEngine) 49 | } 50 | -------------------------------------------------------------------------------- /core/src/main/scala/sbt/librarymanagement/TrackLevel.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | /** 4 | * An enumeration defining the tracking of dependencies. A level includes all of the levels 5 | * with id larger than its own id. For example, Warn (id=3) includes Error (id=4). 6 | */ 7 | object TrackLevel { 8 | case object NoTracking extends TrackLevel { 9 | override def id: Int = 0 10 | } 11 | case object TrackIfMissing extends TrackLevel { 12 | override def id: Int = 1 13 | } 14 | case object TrackAlways extends TrackLevel { 15 | override def id: Int = 10 16 | } 17 | 18 | private[sbt] def apply(x: Int): TrackLevel = 19 | x match { 20 | case 0 => NoTracking 21 | case 1 => TrackIfMissing 22 | case 10 => TrackAlways 23 | } 24 | 25 | def intersection(a: TrackLevel, b: TrackLevel): TrackLevel = 26 | if (a.id < b.id) a 27 | else b 28 | def intersectionAll(vs: List[TrackLevel]): TrackLevel = vs reduceLeft intersection 29 | } 30 | 31 | sealed trait TrackLevel { 32 | def id: Int 33 | } 34 | -------------------------------------------------------------------------------- /core/src/test/scala/ConfigMacroSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement.Configuration 4 | import sbt.librarymanagement.Configurations.config 5 | import scala.util.control.NonFatal 6 | import org.scalacheck._ 7 | import Prop._ 8 | 9 | class ConfigDefs { 10 | lazy val Kompile = config("kompile") 11 | val X = config("x") 12 | val Z = config("z").hide 13 | val A: Configuration = config("a") 14 | lazy val Aa: Configuration = config("aa") 15 | } 16 | 17 | object ConfigMacroSpec extends Properties("ConfigMacroSpec") { 18 | lazy val cd = new ConfigDefs 19 | import cd._ 20 | 21 | def secure(f: => Prop): Prop = 22 | try { 23 | Prop.secure(f) 24 | } catch { 25 | case NonFatal(e) => 26 | e.printStackTrace 27 | throw e 28 | } 29 | 30 | property("Explicit type on lazy val supported") = secure { 31 | check(Aa, "Aa", "aa", true) 32 | } 33 | 34 | property("Explicit type on val supported") = secure { 35 | check(A, "A", "a", true) 36 | } 37 | 38 | property("lazy vals supported") = secure { 39 | check(Kompile, "Kompile", "kompile", true) 40 | } 41 | 42 | property("plain vals supported") = secure { 43 | check(X, "X", "x", true) 44 | } 45 | 46 | property("Directory overridable") = secure { 47 | check(Z, "Z", "z", false) 48 | } 49 | 50 | def check(c: Configuration, id: String, name: String, isPublic: Boolean): Prop = { 51 | s"Expected id: $id" |: 52 | s"Expected name: $name" |: 53 | s"Expected isPublic: $isPublic" |: 54 | s"Actual id: ${c.id}" |: 55 | s"Actual name: ${c.name}" |: 56 | s"Actual isPublic: ${c.isPublic}" |: 57 | (c.id == id) && 58 | (c.name == name) && 59 | (c.isPublic == isPublic) 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /core/src/test/scala/UpdateReportSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import java.io.File 4 | 5 | import org.scalatest.flatspec.AnyFlatSpec 6 | import org.scalatest.matchers.should.Matchers 7 | 8 | class UpdateReportSpec extends AnyFlatSpec with Matchers { 9 | "UpdateReport.toString" should "have a nice toString" in { 10 | assert(updateReport.toString === s""" 11 | |Update report: 12 | | Resolve time: 0 ms, Download time: 0 ms, Download size: 0 bytes 13 | | compile: 14 | | org:name 15 | | - 1.0 16 | | publicationDate: 1970-01-01T00:00:00Z 17 | | evicted: false 18 | | 19 | |""".stripMargin.drop(1)) 20 | } 21 | 22 | lazy val updateReport = 23 | UpdateReport( 24 | new File("cachedDescriptor.data"), 25 | Vector(configurationReport), 26 | UpdateStats(0, 0, 0, false), 27 | Map.empty 28 | ) 29 | 30 | lazy val configurationReport = 31 | ConfigurationReport( 32 | ConfigRef("compile"), 33 | Vector(moduleReport), 34 | Vector(organizationArtifactReport) 35 | ) 36 | 37 | lazy val moduleReport = ( 38 | ModuleReport(ModuleID("org", "name", "1.0"), Vector.empty, Vector.empty) 39 | withPublicationDate Some(epochCalendar) 40 | ) 41 | 42 | lazy val organizationArtifactReport = 43 | OrganizationArtifactReport("org", "name", Vector(moduleReport)) 44 | 45 | val epochCalendar: java.util.Calendar = { 46 | val utc = java.util.TimeZone getTimeZone "UTC" 47 | val c = new java.util.GregorianCalendar(utc, java.util.Locale.ENGLISH) 48 | c setTimeInMillis 0L 49 | c 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /core/src/test/scala/example/tests/CrossVersionCompatTest.scala: -------------------------------------------------------------------------------- 1 | package example.tests 2 | 3 | import sbt.librarymanagement.{ CrossVersion, Disabled } 4 | import verify.BasicTestSuite 5 | import scala.annotation.nowarn 6 | 7 | @nowarn 8 | object CrossVersionCompatTest extends BasicTestSuite { 9 | test("CrossVersion.Disabled is typed to be Disabled") { 10 | assert(CrossVersion.Disabled match { 11 | case _: Disabled => true 12 | case _ => false 13 | }) 14 | } 15 | 16 | test("CrossVersion.Disabled functions as disabled") { 17 | assert(CrossVersion(CrossVersion.disabled, "1.0.0", "1.0") == None) 18 | assert(CrossVersion(CrossVersion.Disabled, "1.0.0", "1.0") == None) 19 | } 20 | 21 | test("CrossVersion.Disabled() is typed to be Disabled") { 22 | assert(CrossVersion.Disabled() match { 23 | case _: Disabled => true 24 | case _ => false 25 | }) 26 | } 27 | 28 | test("CrossVersion.Disabled() functions as disabled") { 29 | assert(CrossVersion(CrossVersion.disabled, "1.0.0", "1.0") == None) 30 | assert(CrossVersion(CrossVersion.Disabled(), "1.0.0", "1.0") == None) 31 | } 32 | 33 | test("CrossVersion.Disabled is stable") { 34 | assert(CrossVersion.Disabled match { 35 | case CrossVersion.Disabled => true 36 | case _ => false 37 | }) 38 | } 39 | 40 | test("sbt.librarymanagement.Disabled is typed to be Disabled") { 41 | assert(Disabled match { 42 | case _: Disabled => true 43 | case _ => false 44 | }) 45 | } 46 | 47 | test("sbt.librarymanagement.Disabled is stable") { 48 | assert(Disabled match { 49 | case Disabled => true 50 | case _ => false 51 | }) 52 | } 53 | 54 | test("sbt.librarymanagement.Disabled() is typed to be Disabled") { 55 | assert(Disabled() match { 56 | case _: Disabled => true 57 | case _ => false 58 | }) 59 | } 60 | 61 | test("CrossVersion.disabled is sbt.librarymanagement.Disabled") { 62 | assert(CrossVersion.disabled == Disabled) 63 | } 64 | 65 | test("CrossVersion.Disabled is sbt.librarymanagement.Disabled") { 66 | assert(CrossVersion.Disabled == Disabled) 67 | } 68 | 69 | test("CrossVersion.Disabled() is sbt.librarymanagement.Disabled") { 70 | assert(CrossVersion.Disabled() == Disabled) 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /core/src/test/scala/sbt/internal/librarymanagement/UnitSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package internal 3 | package librarymanagement 4 | 5 | import org.scalatest.flatspec.AnyFlatSpec 6 | import org.scalatest.matchers.should.Matchers 7 | 8 | abstract class UnitSpec extends AnyFlatSpec with Matchers 9 | -------------------------------------------------------------------------------- /core/src/test/scala/sbt/librarymanagement/ConfigMacroTest.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import sbt.librarymanagement.Configurations.config 4 | import org.scalatest.funspec.AnyFunSpec 5 | import org.scalatest.matchers.should.Matchers 6 | 7 | class ConfigMacroTest extends AnyFunSpec with Matchers { 8 | describe("Configurations.config") { 9 | it("should validate the ID in compile time") { 10 | """val A = config("a")""" should compile 11 | """val b = config("b")""" shouldNot compile 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /core/src/test/scala/sbt/librarymanagement/ModuleIdTest.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import sjsonnew.support.scalajson.unsafe.{ Converter, CompactPrinter, Parser } 4 | 5 | object ModuleIdTest extends verify.BasicTestSuite { 6 | test("Module Id should return cross-disabled module id as equal to a copy") { 7 | assert(ModuleID("com.acme", "foo", "1") == ModuleID("com.acme", "foo", "1")) 8 | } 9 | 10 | test("it should return cross-full module id as equal to a copy") { 11 | assert( 12 | ModuleID("com.acme", "foo", "1").cross(CrossVersion.full) == 13 | ModuleID("com.acme", "foo", "1").cross(CrossVersion.full) 14 | ) 15 | } 16 | 17 | test("it should return cross-binary module id as equal to a copy") { 18 | assert( 19 | ModuleID("com.acme", "foo", "1").cross(CrossVersion.binary) == 20 | ModuleID("com.acme", "foo", "1").cross(CrossVersion.binary) 21 | ) 22 | } 23 | 24 | test("it should format itself into JSON") { 25 | import LibraryManagementCodec._ 26 | val json = Converter.toJson(ModuleID("com.acme", "foo", "1")).get 27 | assert(CompactPrinter(json) == expectedJson) 28 | } 29 | 30 | test("it should thaw back from JSON") { 31 | import LibraryManagementCodec._ 32 | val json = Parser.parseUnsafe(expectedJson) 33 | val m = Converter.fromJsonUnsafe[ModuleID](json) 34 | assert(m == ModuleID("com.acme", "foo", "1")) 35 | } 36 | 37 | test("cross(...) should compose prefix with the existing value") { 38 | assert( 39 | ModuleID("com.acme", "foo", "1") 40 | .cross(CrossVersion.binaryWith("sjs1_", "")) 41 | .cross(CrossVersion.for3Use2_13) 42 | == 43 | ModuleID("com.acme", "foo", "1").cross(CrossVersion.for3Use2_13With("sjs1_", "")) 44 | ) 45 | } 46 | 47 | def expectedJson = 48 | """{"organization":"com.acme","name":"foo","revision":"1","isChanging":false,"isTransitive":true,"isForce":false,"explicitArtifacts":[],"inclusions":[],"exclusions":[],"extraAttributes":{},"crossVersion":{"type":"Disabled"}}""" 49 | } 50 | -------------------------------------------------------------------------------- /core/src/test/scala/sbt/librarymanagement/ResolverExtraTest.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import verify.BasicTestSuite 4 | import scala.annotation.nowarn 5 | 6 | @nowarn // Necessary because our test cases look like interpolated strings. 7 | object ResolverExtraTest extends BasicTestSuite { 8 | test("expandMavenSettings should expand existing environment variables") { 9 | assertExpansion( 10 | input = "User home: ${env.HOME}", 11 | expected = s"User home: ${env("HOME")}" 12 | ) 13 | } 14 | 15 | test("expandMavenSettings should expand existing system properties") { 16 | assertExpansion( 17 | input = "User dir: ${user.dir}", 18 | expected = s"User dir: ${prop("user.dir")}" 19 | ) 20 | } 21 | 22 | test("expandMavenSettings should expand unknown system properties to the empty string") { 23 | assertExpansion( 24 | input = "Unknown system property: ${IF_THIS_EXISTS_WE_NEED_TO_HAVE_A_CHAT}", 25 | expected = s"Unknown system property: " 26 | ) 27 | } 28 | 29 | test("expandMavenSettings should expand unknown environment variables to the empty string") { 30 | assertExpansion( 31 | input = "Unknown environment variable: ${IF_THIS_EXISTS_I_WORRY_ABOUT_YOU}", 32 | expected = s"Unknown environment variable: " 33 | ) 34 | } 35 | 36 | test("expandMavenSettings should preserve backslashes in environment variable values") { 37 | val path = """C:\foo\bar\baz""" 38 | val env = Map("SOME_PATH" -> path) 39 | 40 | assert(Resolver.expandMavenSettings("${env.SOME_PATH}", env) == path) 41 | } 42 | 43 | // - Helper functions ---------------------------------------------------------------------------- 44 | // ----------------------------------------------------------------------------------------------- 45 | def assertExpansion(input: String, expected: String) = 46 | assert(Resolver.expandMavenSettings(input) == s"$expected") 47 | 48 | def env(name: String) = sys.env.getOrElse(name, "") 49 | def prop(name: String) = sys.props.getOrElse(name, "") 50 | } 51 | -------------------------------------------------------------------------------- /core/src/test/scala/sbt/librarymanagement/ResolverTest.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | 3 | import java.net.URI 4 | 5 | import sbt.internal.librarymanagement.UnitSpec 6 | 7 | object ResolverTest extends UnitSpec { 8 | 9 | "Resolver url" should "propagate pattern descriptorOptional and skipConsistencyCheck." in { 10 | val pats = Vector("[orgPath]") 11 | val patsExpected = Vector("http://foo.com/test/[orgPath]") 12 | val patterns = Resolver 13 | .url("test", new URI("http://foo.com/test").toURL)( 14 | Patterns( 15 | pats, 16 | pats, 17 | isMavenCompatible = false, 18 | descriptorOptional = true, 19 | skipConsistencyCheck = true 20 | ) 21 | ) 22 | .patterns 23 | 24 | patterns.ivyPatterns shouldBe patsExpected 25 | patterns.artifactPatterns shouldBe patsExpected 26 | patterns.isMavenCompatible shouldBe false 27 | assert(patterns.skipConsistencyCheck) 28 | assert(patterns.descriptorOptional) 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /core/src/test/scala/sbt/librarymanagement/VersionRangeSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package internal 3 | package librarymanagement 4 | 5 | class VersionRangeSpec extends UnitSpec { 6 | "Version range" should "strip 1.0 to None" in stripTo("1.0", None) 7 | it should "strip (,1.0] to 1.0" in stripTo("(,1.0]", Some("1.0")) 8 | it should "strip (,1.0) to None" in stripTo("(,1.0)", None) 9 | it should "strip [1.0] to 1.0" in stripTo("[1.0]", Some("1.0")) 10 | it should "strip [1.0,) to 1.0" in stripTo("[1.0,)", Some("1.0")) 11 | it should "strip (1.0,) to 1.0" in stripTo("(1.0,)", Some("1.0")) 12 | it should "strip (1.0,2.0) to None" in stripTo("(1.0,2.0)", None) 13 | it should "strip [1.0,2.0] to None" in stripTo("[1.0,2.0]", None) 14 | it should "strip (,1.0],[1.2,) to 1.0" in stripTo("(,1.0],[1.2,)", Some("1.0")) 15 | it should "strip (,1.1),(1.1,) to None" in stripTo("(,1.1),(1.1,)", None) 16 | 17 | def stripTo(s: String, expected: Option[String]) = 18 | assert(VersionRange.stripMavenVersionRange(s) == expected) 19 | } 20 | -------------------------------------------------------------------------------- /ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/ExternalIvyConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement.ivy 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait ExternalIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.librarymanagement.ivy.formats.UpdateOptionsFormat with sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol => 9 | implicit lazy val ExternalIvyConfigurationFormat: JsonFormat[sbt.librarymanagement.ivy.ExternalIvyConfiguration] = new JsonFormat[sbt.librarymanagement.ivy.ExternalIvyConfiguration] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ivy.ExternalIvyConfiguration = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock") 15 | val log = unbuilder.readField[Option[xsbti.Logger]]("log") 16 | val updateOptions = unbuilder.readField[sbt.librarymanagement.ivy.UpdateOptions]("updateOptions") 17 | val baseDirectory = unbuilder.readField[Option[java.io.File]]("baseDirectory") 18 | val uri = unbuilder.readField[Option[java.net.URI]]("uri") 19 | val extraResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("extraResolvers") 20 | unbuilder.endObject() 21 | sbt.librarymanagement.ivy.ExternalIvyConfiguration(lock, log, updateOptions, baseDirectory, uri, extraResolvers) 22 | case None => 23 | deserializationError("Expected JsObject but found None") 24 | } 25 | } 26 | override def write[J](obj: sbt.librarymanagement.ivy.ExternalIvyConfiguration, builder: Builder[J]): Unit = { 27 | builder.beginObject() 28 | builder.addField("lock", obj.lock) 29 | builder.addField("log", obj.log) 30 | builder.addField("updateOptions", obj.updateOptions) 31 | builder.addField("baseDirectory", obj.baseDirectory) 32 | builder.addField("uri", obj.uri) 33 | builder.addField("extraResolvers", obj.extraResolvers) 34 | builder.endObject() 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyConfiguration.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement.ivy 7 | abstract class IvyConfiguration( 8 | val lock: Option[xsbti.GlobalLock], 9 | val log: Option[xsbti.Logger], 10 | val updateOptions: sbt.librarymanagement.ivy.UpdateOptions) extends Serializable { 11 | 12 | def this() = this(None, None, sbt.librarymanagement.ivy.UpdateOptions()) 13 | 14 | 15 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 16 | case x: IvyConfiguration => (this.lock == x.lock) && (this.log == x.log) && (this.updateOptions == x.updateOptions) 17 | case _ => false 18 | }) 19 | override def hashCode: Int = { 20 | 37 * (37 * (37 * (37 * (17 + "sbt.librarymanagement.ivy.IvyConfiguration".##) + lock.##) + log.##) + updateOptions.##) 21 | } 22 | override def toString: String = { 23 | "IvyConfiguration(" + lock + ", " + log + ", " + updateOptions + ")" 24 | } 25 | } 26 | object IvyConfiguration { 27 | 28 | } 29 | -------------------------------------------------------------------------------- /ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyConfigurationFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement.ivy 7 | 8 | import _root_.sjsonnew.JsonFormat 9 | trait IvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.librarymanagement.ivy.formats.UpdateOptionsFormat with sbt.librarymanagement.ivy.IvyPathsFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.ResolverFormats with sbt.librarymanagement.ModuleConfigurationFormats with sbt.librarymanagement.ivy.InlineIvyConfigurationFormats with sbt.librarymanagement.ivy.ExternalIvyConfigurationFormats => 10 | implicit lazy val IvyConfigurationFormat: JsonFormat[sbt.librarymanagement.ivy.IvyConfiguration] = flatUnionFormat2[sbt.librarymanagement.ivy.IvyConfiguration, sbt.librarymanagement.ivy.InlineIvyConfiguration, sbt.librarymanagement.ivy.ExternalIvyConfiguration]("type") 11 | } 12 | -------------------------------------------------------------------------------- /ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyPaths.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement.ivy 7 | final class IvyPaths private ( 8 | val baseDirectory: java.io.File, 9 | val ivyHome: Option[java.io.File]) extends Serializable { 10 | 11 | 12 | 13 | override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { 14 | case x: IvyPaths => (this.baseDirectory == x.baseDirectory) && (this.ivyHome == x.ivyHome) 15 | case _ => false 16 | }) 17 | override def hashCode: Int = { 18 | 37 * (37 * (37 * (17 + "sbt.librarymanagement.ivy.IvyPaths".##) + baseDirectory.##) + ivyHome.##) 19 | } 20 | override def toString: String = { 21 | "IvyPaths(" + baseDirectory + ", " + ivyHome + ")" 22 | } 23 | private def copy(baseDirectory: java.io.File = baseDirectory, ivyHome: Option[java.io.File] = ivyHome): IvyPaths = { 24 | new IvyPaths(baseDirectory, ivyHome) 25 | } 26 | def withBaseDirectory(baseDirectory: java.io.File): IvyPaths = { 27 | copy(baseDirectory = baseDirectory) 28 | } 29 | def withIvyHome(ivyHome: Option[java.io.File]): IvyPaths = { 30 | copy(ivyHome = ivyHome) 31 | } 32 | def withIvyHome(ivyHome: java.io.File): IvyPaths = { 33 | copy(ivyHome = Option(ivyHome)) 34 | } 35 | } 36 | object IvyPaths { 37 | 38 | def apply(baseDirectory: java.io.File, ivyHome: Option[java.io.File]): IvyPaths = new IvyPaths(baseDirectory, ivyHome) 39 | def apply(baseDirectory: java.io.File, ivyHome: java.io.File): IvyPaths = new IvyPaths(baseDirectory, Option(ivyHome)) 40 | } 41 | -------------------------------------------------------------------------------- /ivy/src/main/contraband-scala/sbt/librarymanagement/ivy/IvyPathsFormats.scala: -------------------------------------------------------------------------------- 1 | /** 2 | * This code is generated using [[https://www.scala-sbt.org/contraband]]. 3 | */ 4 | 5 | // DO NOT EDIT MANUALLY 6 | package sbt.librarymanagement.ivy 7 | import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } 8 | trait IvyPathsFormats { self: sjsonnew.BasicJsonProtocol => 9 | implicit lazy val IvyPathsFormat: JsonFormat[sbt.librarymanagement.ivy.IvyPaths] = new JsonFormat[sbt.librarymanagement.ivy.IvyPaths] { 10 | override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ivy.IvyPaths = { 11 | __jsOpt match { 12 | case Some(__js) => 13 | unbuilder.beginObject(__js) 14 | val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory") 15 | val ivyHome = unbuilder.readField[Option[java.io.File]]("ivyHome") 16 | unbuilder.endObject() 17 | sbt.librarymanagement.ivy.IvyPaths(baseDirectory, ivyHome) 18 | case None => 19 | deserializationError("Expected JsObject but found None") 20 | } 21 | } 22 | override def write[J](obj: sbt.librarymanagement.ivy.IvyPaths, builder: Builder[J]): Unit = { 23 | builder.beginObject() 24 | builder.addField("baseDirectory", obj.baseDirectory) 25 | builder.addField("ivyHome", obj.ivyHome) 26 | builder.endObject() 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /ivy/src/main/java/internal/librarymanagement/ResolverAdapter.java: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement; 2 | 3 | import java.util.Map; 4 | import org.apache.ivy.plugins.resolver.DependencyResolver; 5 | 6 | // implements the methods with raw types 7 | @SuppressWarnings("rawtypes") 8 | public abstract class ResolverAdapter implements DependencyResolver 9 | { 10 | public String[] listTokenValues(String token, Map otherTokenValues) { return new String[0]; } 11 | 12 | public Map[] listTokenValues(String[] tokens, Map criteria) { return new Map[0]; } 13 | } -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/CustomXmlParser.scala: -------------------------------------------------------------------------------- 1 | /* sbt -- Simple Build Tool 2 | * Copyright 2008, 2009, 2010 Mark Harrah 3 | */ 4 | package sbt.internal.librarymanagement 5 | 6 | import java.io.ByteArrayInputStream 7 | import java.net.URL 8 | 9 | import org.apache.ivy.core.module.descriptor.{ 10 | DefaultDependencyDescriptor, 11 | DefaultModuleDescriptor 12 | } 13 | import org.apache.ivy.core.settings.IvySettings 14 | import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser 15 | import org.apache.ivy.plugins.repository.Resource 16 | import org.apache.ivy.plugins.repository.url.URLResource 17 | 18 | /** Subclasses the default Ivy file parser in order to provide access to protected methods. */ 19 | private[sbt] object CustomXmlParser extends XmlModuleDescriptorParser { 20 | import XmlModuleDescriptorParser.Parser 21 | class CustomParser(settings: IvySettings, defaultConfig: Option[String]) 22 | extends Parser(CustomXmlParser, settings) { 23 | def setSource(url: URL) = { 24 | super.setResource(new URLResource(url)) 25 | super.setInput(url) 26 | } 27 | def setInput(bytes: Array[Byte]): Unit = setInput(new ByteArrayInputStream(bytes)) 28 | 29 | /** Overridden because the super implementation overwrites the module descriptor. */ 30 | override def setResource(res: Resource): Unit = () 31 | override def setMd(md: DefaultModuleDescriptor) = { 32 | super.setMd(md) 33 | if (defaultConfig.isDefined) setDefaultConfMapping("*->default(compile)") 34 | } 35 | override def parseDepsConfs(confs: String, dd: DefaultDependencyDescriptor) = 36 | super.parseDepsConfs(confs, dd) 37 | override def getDefaultConf = defaultConfig.getOrElse(super.getDefaultConf) 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/IvyInternalDefaults.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package internal.librarymanagement 3 | 4 | import java.io.File 5 | import sbt.librarymanagement.ivy._ 6 | import sbt.io.syntax._ 7 | import xsbti.{ Logger => XLogger } 8 | import sbt.util.Logger 9 | 10 | /** 11 | * This is a list of functions with default values. 12 | */ 13 | object IvyInternalDefaults { 14 | def defaultBaseDirectory: File = 15 | (new File(".")).getAbsoluteFile / "lib_managed" 16 | 17 | def getBaseDirectory(opt: Option[File]): File = 18 | opt.getOrElse(defaultBaseDirectory) 19 | 20 | def getLog(opt: Option[XLogger]): XLogger = 21 | opt.getOrElse(Logger.Null) 22 | 23 | def defaultIvyPaths: IvyPaths = 24 | IvyPaths(defaultBaseDirectory, None) 25 | 26 | def getIvyPaths(opt: Option[IvyPaths]): IvyPaths = 27 | opt.getOrElse(defaultIvyPaths) 28 | } 29 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/IvyLogger.scala: -------------------------------------------------------------------------------- 1 | /* sbt -- Simple Build Tool 2 | * Copyright 2008, 2009, 2010 Mark Harrah 3 | */ 4 | package sbt.internal.librarymanagement 5 | 6 | import org.apache.ivy.util.{ Message, MessageLogger, MessageLoggerEngine } 7 | import sbt.util.Logger 8 | 9 | /** Interface to Ivy logging. */ 10 | private[sbt] final class IvyLoggerInterface(logger: Logger) extends MessageLogger { 11 | def rawlog(msg: String, level: Int): Unit = log(msg, level) 12 | def log(msg: String, level: Int): Unit = { 13 | import Message.{ MSG_DEBUG, MSG_VERBOSE, MSG_INFO, MSG_WARN, MSG_ERR } 14 | level match { 15 | case MSG_DEBUG => debug(msg) 16 | case MSG_VERBOSE => verbose(msg) 17 | case MSG_INFO => info(msg) 18 | case MSG_WARN => warn(msg) 19 | case MSG_ERR => error(msg) 20 | } 21 | } 22 | // DEBUG level messages are very verbose and rarely useful to users. 23 | // TODO: provide access to this information some other way 24 | def debug(msg: String): Unit = () 25 | def verbose(msg: String): Unit = logger.verbose(msg) 26 | def deprecated(msg: String): Unit = warn(msg) 27 | def info(msg: String): Unit = if (SbtIvyLogger.acceptInfo(msg)) logger.info(msg) 28 | def rawinfo(msg: String): Unit = info(msg) 29 | def warn(msg: String): Unit = logger.warn(msg) 30 | def error(msg: String): Unit = if (SbtIvyLogger.acceptError(msg)) logger.error(msg) 31 | 32 | private def emptyList = java.util.Collections.emptyList[String] 33 | def getProblems = emptyList 34 | def getWarns = emptyList 35 | def getErrors = emptyList 36 | 37 | def clearProblems(): Unit = () 38 | def sumupProblems(): Unit = clearProblems() 39 | def progress(): Unit = () 40 | def endProgress(): Unit = () 41 | 42 | def endProgress(msg: String): Unit = info(msg) 43 | def isShowProgress = false 44 | def setShowProgress(progress: Boolean): Unit = () 45 | } 46 | private[sbt] final class SbtMessageLoggerEngine extends MessageLoggerEngine { 47 | 48 | /** This is a hack to filter error messages about 'unknown resolver ...'. */ 49 | override def error(msg: String): Unit = if (SbtIvyLogger.acceptError(msg)) super.error(msg) 50 | override def sumupProblems(): Unit = clearProblems() 51 | } 52 | private[sbt] object SbtIvyLogger { 53 | final val unknownResolver = "unknown resolver" 54 | def acceptError(msg: String) = (msg ne null) && !msg.startsWith(unknownResolver) 55 | 56 | final val loadingSettings = ":: loading settings" 57 | def acceptInfo(msg: String) = (msg ne null) && !msg.startsWith(loadingSettings) 58 | } 59 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/IvyUtil.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import java.io.IOException 4 | import java.net.{ SocketException, SocketTimeoutException } 5 | 6 | import scala.annotation.tailrec 7 | import scala.util.{ Failure, Success, Try } 8 | 9 | private[sbt] object IvyUtil { 10 | def separate[A, B](l: Seq[Either[A, B]]): (Seq[A], Seq[B]) = 11 | (l.flatMap(_.left.toOption), l.flatMap(_.toOption)) 12 | 13 | @tailrec 14 | final def retryWithBackoff[T]( 15 | f: => T, 16 | predicate: Throwable => Boolean, 17 | maxAttempts: Int, 18 | retry: Int = 0 19 | ): T = { 20 | // Using Try helps in catching NonFatal exceptions only 21 | Try { 22 | f 23 | } match { 24 | case Success(value) => value 25 | case Failure(e) if predicate(e) && retry < (maxAttempts - 1) => 26 | // max 8s backoff 27 | val backoff = math.min(math.pow(2d, retry.toDouble).toLong * 1000L, 8000L) 28 | Thread.sleep(backoff) 29 | retryWithBackoff(f, predicate, maxAttempts, retry + 1) 30 | case Failure(e) => throw e 31 | } 32 | } 33 | 34 | /** 35 | * Currently transient network errors are defined as: 36 | * - a network timeout 37 | * - all server errors (response code 5xx) 38 | * - rate limiting (response code 429) 39 | */ 40 | object TransientNetworkException { 41 | private val _r = """.*HTTP response code: (5\d{2}|408|429).*""".r 42 | 43 | @inline private def check(s: String): Boolean = { 44 | if (s == null) return false 45 | 46 | _r.pattern.matcher(s).matches() 47 | } 48 | 49 | def apply(t: Throwable): Boolean = t match { 50 | case _: SocketException | _: SocketTimeoutException => true 51 | case e: IOException if check(e.getMessage) => true 52 | case _ => false 53 | } 54 | } 55 | 56 | } 57 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/ivyint/CustomMavenResolver.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | package ivyint 3 | 4 | import org.apache.ivy.plugins.resolver.DependencyResolver 5 | import sbt.librarymanagement._ 6 | 7 | // These are placeholder traits for sbt-aether-resolver 8 | trait CustomMavenResolver extends DependencyResolver {} 9 | trait CustomRemoteMavenResolver extends CustomMavenResolver { 10 | def repo: MavenRepository 11 | } 12 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/ivyint/IvyCredentialsLookup.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | package ivyint 3 | 4 | import org.apache.ivy.util.url.CredentialsStore 5 | import collection.JavaConverters._ 6 | 7 | /** A key used to store credentials in the ivy credentials store. */ 8 | private[sbt] sealed trait CredentialKey 9 | 10 | /** Represents a key in the ivy credentials store that is only specific to a host. */ 11 | private[sbt] case class Host(name: String) extends CredentialKey 12 | 13 | /** Represents a key in the ivy credentials store that is keyed to both a host and a "realm". */ 14 | private[sbt] case class Realm(host: String, realm: String) extends CredentialKey 15 | 16 | /** 17 | * Helper mechanism to improve credential related error messages. 18 | * 19 | * This evil class exposes to us the necessary information to warn on credential failure and offer 20 | * spelling/typo suggestions. 21 | */ 22 | private[sbt] object IvyCredentialsLookup { 23 | 24 | /** Helper extractor for Ivy's key-value store of credentials. */ 25 | private object KeySplit { 26 | def unapply(key: String): Option[(String, String)] = { 27 | key.indexOf('@') match { 28 | case -1 => None 29 | case n => Some(key.take(n) -> key.drop(n + 1)) 30 | } 31 | } 32 | } 33 | 34 | /** 35 | * Here we cheat runtime private so we can look in the credentials store. 36 | * 37 | * TODO - Don't bomb at class load time... 38 | */ 39 | private val credKeyringField = { 40 | val tmp = classOf[CredentialsStore].getDeclaredField("KEYRING") 41 | tmp.setAccessible(true) 42 | tmp 43 | } 44 | 45 | /** All the keys for credentials in the ivy configuration store. */ 46 | def keyringKeys: Set[CredentialKey] = { 47 | val map = credKeyringField.get(null).asInstanceOf[java.util.HashMap[String, Any]] 48 | // make a clone of the set... 49 | (map.keySet.asScala.map { 50 | case KeySplit(realm, host) => (Realm(host, realm): CredentialKey) 51 | case host => (Host(host): CredentialKey) 52 | }).toSet 53 | } 54 | 55 | /** 56 | * A mapping of host -> realms in the ivy credentials store. 57 | */ 58 | def realmsForHost: Map[String, Set[String]] = 59 | (keyringKeys collect { case x: Realm => 60 | x 61 | } groupBy { realm => 62 | realm.host 63 | } mapValues { realms => 64 | realms map (_.realm) 65 | }).toMap 66 | } 67 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/internal/librarymanagement/ivyint/SbtDefaultDependencyDescriptor.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | package ivyint 3 | 4 | import org.apache.ivy.core 5 | import core.module.descriptor.DefaultDependencyDescriptor 6 | import sbt.librarymanagement._ 7 | 8 | trait SbtDefaultDependencyDescriptor { self: DefaultDependencyDescriptor => 9 | def dependencyModuleId: ModuleID 10 | } 11 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/librarymanagement/ivy/CircularDependencyLevel.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | package ivy 3 | 4 | import org.apache.ivy.plugins.circular.{ 5 | CircularDependencyStrategy, 6 | WarnCircularDependencyStrategy, 7 | IgnoreCircularDependencyStrategy, 8 | ErrorCircularDependencyStrategy 9 | } 10 | 11 | /** 12 | * Wrapper around circular dependency strategy. 13 | */ 14 | sealed trait CircularDependencyLevel { 15 | private[sbt] def ivyStrategy: CircularDependencyStrategy 16 | private[sbt] def name: String 17 | override def toString: String = name 18 | } 19 | 20 | object CircularDependencyLevel { 21 | val Warn: CircularDependencyLevel = new CircularDependencyLevel { 22 | def ivyStrategy: CircularDependencyStrategy = WarnCircularDependencyStrategy.getInstance 23 | def name: String = "warn" 24 | } 25 | val Ignore: CircularDependencyLevel = new CircularDependencyLevel { 26 | def ivyStrategy: CircularDependencyStrategy = IgnoreCircularDependencyStrategy.getInstance 27 | def name: String = "ignore" 28 | } 29 | val Error: CircularDependencyLevel = new CircularDependencyLevel { 30 | def ivyStrategy: CircularDependencyStrategy = ErrorCircularDependencyStrategy.getInstance 31 | def name: String = "error" 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/librarymanagement/ivy/IvyDefaults.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package librarymanagement.ivy 3 | 4 | /** 5 | * This is a list of functions with default values. 6 | */ 7 | object IvyDefaults { 8 | val defaultChecksums: Vector[String] = Vector("sha1", "md5") 9 | } 10 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/librarymanagement/ivy/IvyDependencyResolution.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package librarymanagement 3 | package ivy 4 | 5 | import sbt.internal.librarymanagement._ 6 | import sbt.util.Logger 7 | 8 | class IvyDependencyResolution private[sbt] (val ivySbt: IvySbt) 9 | extends DependencyResolutionInterface { 10 | type Module = ivySbt.Module 11 | 12 | override def moduleDescriptor(moduleSetting: ModuleDescriptorConfiguration): ModuleDescriptor = { 13 | new Module(moduleSetting) 14 | } 15 | 16 | override def update( 17 | module: ModuleDescriptor, 18 | configuration: UpdateConfiguration, 19 | uwconfig: UnresolvedWarningConfiguration, 20 | log: Logger 21 | ): Either[UnresolvedWarning, UpdateReport] = 22 | IvyActions.updateEither(toModule(module), configuration, uwconfig, log) 23 | 24 | private[sbt] def toModule(module: ModuleDescriptor): Module = 25 | module match { 26 | case m: Module @unchecked => m 27 | } 28 | } 29 | 30 | object IvyDependencyResolution { 31 | def apply(ivyConfiguration: IvyConfiguration): DependencyResolution = 32 | DependencyResolution(new IvyDependencyResolution(new IvySbt(ivyConfiguration))) 33 | } 34 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/librarymanagement/ivy/IvyLibraryManagementCodec.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement 2 | package ivy 3 | 4 | trait IvyLibraryManagementCodec 5 | extends sjsonnew.BasicJsonProtocol 6 | with LibraryManagementCodec 7 | with sbt.internal.librarymanagement.formats.GlobalLockFormat 8 | with sbt.internal.librarymanagement.formats.LoggerFormat 9 | with sbt.librarymanagement.ivy.formats.UpdateOptionsFormat 10 | with IvyPathsFormats 11 | with ResolverFormats 12 | with ModuleConfigurationFormats 13 | with InlineIvyConfigurationFormats 14 | with ExternalIvyConfigurationFormats 15 | with IvyConfigurationFormats 16 | 17 | object IvyLibraryManagementCodec extends IvyLibraryManagementCodec 18 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/librarymanagement/ivy/IvyPublisher.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package librarymanagement 3 | package ivy 4 | 5 | import sbt.internal.librarymanagement._ 6 | import sbt.util.Logger 7 | import java.io.File 8 | 9 | class IvyPublisher private[sbt] (val ivySbt: IvySbt) extends PublisherInterface { 10 | type Module = ivySbt.Module 11 | 12 | override def moduleDescriptor(moduleSetting: ModuleDescriptorConfiguration): ModuleDescriptor = { 13 | new Module(moduleSetting) 14 | } 15 | 16 | override def makePomFile( 17 | module: ModuleDescriptor, 18 | configuration: MakePomConfiguration, 19 | log: Logger 20 | ): File = 21 | IvyActions.makePomFile(toModule(module), configuration, log) 22 | 23 | override def publish( 24 | module: ModuleDescriptor, 25 | configuration: PublishConfiguration, 26 | log: Logger 27 | ): Unit = 28 | IvyActions.publish(toModule(module), configuration, log) 29 | 30 | private[sbt] def toModule(module: ModuleDescriptor): Module = 31 | module match { 32 | case m: Module @unchecked => m 33 | } 34 | } 35 | 36 | object IvyPublisher { 37 | def apply(ivyConfiguration: IvyConfiguration): Publisher = 38 | Publisher(new IvyPublisher(new IvySbt(ivyConfiguration))) 39 | } 40 | -------------------------------------------------------------------------------- /ivy/src/main/scala/sbt/librarymanagement/ivy/formats/UpdateOptionsFormat.scala: -------------------------------------------------------------------------------- 1 | package sbt.librarymanagement.ivy 2 | package formats 3 | 4 | import sjsonnew._ 5 | import sbt.librarymanagement._ 6 | 7 | trait UpdateOptionsFormat { self: BasicJsonProtocol with ModuleIDFormats with ResolverFormats => 8 | /* This is necessary to serialize/deserialize `directResolvers`. */ 9 | private implicit val moduleIdJsonKeyFormat: sjsonnew.JsonKeyFormat[ModuleID] = { 10 | new sjsonnew.JsonKeyFormat[ModuleID] { 11 | import sjsonnew.support.scalajson.unsafe._ 12 | val moduleIdFormat: JsonFormat[ModuleID] = implicitly[JsonFormat[ModuleID]] 13 | def write(key: ModuleID): String = 14 | CompactPrinter(Converter.toJsonUnsafe(key)(moduleIdFormat)) 15 | def read(key: String): ModuleID = 16 | Converter.fromJsonUnsafe[ModuleID](Parser.parseUnsafe(key))(moduleIdFormat) 17 | } 18 | } 19 | 20 | implicit lazy val UpdateOptionsFormat: JsonFormat[UpdateOptions] = 21 | projectFormat( 22 | (uo: UpdateOptions) => 23 | ( 24 | uo.circularDependencyLevel.name, 25 | uo.interProjectFirst, 26 | uo.latestSnapshots, 27 | uo.cachedResolution, 28 | uo.gigahorse, 29 | uo.moduleResolvers 30 | ), 31 | (xs: (String, Boolean, Boolean, Boolean, Boolean, Map[ModuleID, Resolver])) => 32 | new UpdateOptions( 33 | levels(xs._1), 34 | xs._2, 35 | xs._3, 36 | xs._4, 37 | xs._5, 38 | PartialFunction.empty, 39 | xs._6 40 | ) 41 | ) 42 | 43 | private val levels: Map[String, CircularDependencyLevel] = Map( 44 | "warn" -> CircularDependencyLevel.Warn, 45 | "ignore" -> CircularDependencyLevel.Ignore, 46 | "error" -> CircularDependencyLevel.Error 47 | ) 48 | } 49 | -------------------------------------------------------------------------------- /ivy/src/test/resources/artifact1.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sbt/librarymanagement/99f2b1c22273383c016e2539fc0ebf7d86824162/ivy/src/test/resources/artifact1.jar -------------------------------------------------------------------------------- /ivy/src/test/resources/artifact2.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sbt/librarymanagement/99f2b1c22273383c016e2539fc0ebf7d86824162/ivy/src/test/resources/artifact2.txt -------------------------------------------------------------------------------- /ivy/src/test/resources/test-ivy-repo/com.test/module-with-srcs/0.1.00/ivys/ivy.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Just a test module that publishes both a binary jar and a src jar in the 'compile' configuration. 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /ivy/src/test/resources/test-ivy-repo/com.test/module-with-srcs/0.1.00/jars/libmodule.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sbt/librarymanagement/99f2b1c22273383c016e2539fc0ebf7d86824162/ivy/src/test/resources/test-ivy-repo/com.test/module-with-srcs/0.1.00/jars/libmodule.jar -------------------------------------------------------------------------------- /ivy/src/test/resources/test-ivy-repo/com.test/module-with-srcs/0.1.00/srcs/libmodule-source.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sbt/librarymanagement/99f2b1c22273383c016e2539fc0ebf7d86824162/ivy/src/test/resources/test-ivy-repo/com.test/module-with-srcs/0.1.00/srcs/libmodule-source.jar -------------------------------------------------------------------------------- /ivy/src/test/resources/test-maven-repo/com/test/test-artifact/1.0.0-SNAPSHOT/test-artifact-1.0.0-SNAPSHOT.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sbt/librarymanagement/99f2b1c22273383c016e2539fc0ebf7d86824162/ivy/src/test/resources/test-maven-repo/com/test/test-artifact/1.0.0-SNAPSHOT/test-artifact-1.0.0-SNAPSHOT.jar -------------------------------------------------------------------------------- /ivy/src/test/resources/test-maven-repo/com/test/test-artifact/1.0.0-SNAPSHOT/test-artifact-1.0.0-SNAPSHOT.pom: -------------------------------------------------------------------------------- 1 | 2 | 4 | 4.0.0 5 | 6 | com.test 7 | test-artifact 8 | 1.0.0-SNAPSHOT 9 | scala-jar 10 | 11 | 12 | UTF-8 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/AbstractEngineSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | import verify.BasicTestSuite 5 | 6 | abstract class AbstractEngineSpec extends BasicTestSuite { 7 | def cleanCache(): Unit 8 | 9 | def module( 10 | moduleId: ModuleID, 11 | deps: Vector[ModuleID], 12 | scalaFullVersion: Option[String] 13 | ): ModuleDescriptor 14 | 15 | def updateEither(module: ModuleDescriptor): Either[UnresolvedWarning, UpdateReport] 16 | 17 | def update(module: ModuleDescriptor) = 18 | updateEither(module) match { 19 | case Right(r) => r 20 | case Left(w) => throw w.resolveException 21 | } 22 | 23 | def cleanCachedResolutionCache(@deprecated("unused", "") module: ModuleDescriptor): Unit = () 24 | } 25 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/BaseCachedResolutionSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | import sbt.librarymanagement.ivy._ 5 | 6 | trait BaseCachedResolutionSpec extends BaseIvySpecification { 7 | override def module( 8 | moduleId: ModuleID, 9 | deps: Vector[ModuleID], 10 | scalaFullVersion: Option[String] 11 | ): ModuleDescriptor = { 12 | val uo: UpdateOptions = UpdateOptions() 13 | .withCachedResolution(true) 14 | module(moduleId, deps, scalaFullVersion, uo, true) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/CachedResolutionSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | 5 | class CachedResolutionSpec extends ResolutionSpec with BaseCachedResolutionSpec { 6 | override val resolvers = Vector( 7 | Resolver.mavenCentral, 8 | Resolver.sbtPluginRepo("releases") 9 | ) 10 | } 11 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/ConflictWarningSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | import sbt.librarymanagement.syntax._ 5 | 6 | object ConflictWarningSpec extends BaseIvySpecification { 7 | 8 | test("it should print out message about the cross-Scala conflict") { 9 | var found = false 10 | val deps = Vector( 11 | `scala2.13.6`, 12 | `cats-effect3.1.1`, 13 | `cats-core2.6.1`.cross(CrossVersion.for3Use2_13), 14 | ) 15 | val m = module(defaultModuleId, deps, Some("3.0.1-RC2")) 16 | val report = ivyUpdate(m) 17 | val w = ConflictWarning.default("foo") 18 | 19 | try { 20 | ConflictWarning(w, report, log) 21 | } catch { 22 | case e: Throwable => 23 | found = true 24 | assert( 25 | e.getMessage.linesIterator.toList.head 26 | .startsWith("Conflicting cross-version suffixes in") 27 | ) 28 | } 29 | if (!found) { 30 | sys.error("conflict warning was expected, but didn't happen sbt/sbt#6578") 31 | } 32 | } 33 | 34 | lazy val `scala2.13.6` = 35 | ModuleID("org.scala-lang", "scala-library", "2.13.6").withConfigurations(Some("compile")) 36 | lazy val `cats-effect3.1.1` = 37 | ("org.typelevel" %% "cats-effect" % "3.1.1").withConfigurations(Some("compile")) 38 | lazy val `cats-core2.6.1` = 39 | ("org.typelevel" %% "cats-core" % "2.6.1").withConfigurations(Some("compile")) 40 | } 41 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/CredentialsSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement.ivy.Credentials 4 | 5 | import java.io.File 6 | import java.nio.file.Files 7 | 8 | import org.scalatest.funsuite.AnyFunSuite 9 | 10 | class CredentialsSpec extends AnyFunSuite { 11 | 12 | test("load credential file without authentication") { 13 | val credentialsFile = File.createTempFile("credentials", "tmp") 14 | 15 | val content = 16 | """|host=example.org 17 | |user=username 18 | |password=password""".stripMargin 19 | 20 | Files.write(credentialsFile.toPath(), content.getBytes()) 21 | 22 | val Right(credentials) = Credentials.loadCredentials(credentialsFile) 23 | 24 | assert(credentials.realm == null) 25 | 26 | credentialsFile.delete() 27 | } 28 | 29 | test("DirectCredentials.toString") { 30 | assert( 31 | Credentials( 32 | realm = null, 33 | host = "example.org", 34 | userName = "username", 35 | passwd = "password" 36 | ).toString == 37 | """DirectCredentials(null, "example.org", "username", ****)""" 38 | ) 39 | 40 | assert( 41 | Credentials( 42 | realm = "realm", 43 | host = "example.org", 44 | userName = "username", 45 | passwd = "password" 46 | ).toString == 47 | """DirectCredentials("realm", "example.org", "username", ****)""" 48 | ) 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/CustomPomParserTest.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import java.io.File 4 | import org.apache.ivy.core.module.descriptor.{ Artifact => IvyArtifact } 5 | import org.apache.ivy.core.module.id.ModuleRevisionId 6 | import org.apache.ivy.core.resolve.ResolveOptions 7 | import sbt.librarymanagement._ 8 | import sbt.librarymanagement.ivy.{ InlineIvyConfiguration, IvyPaths } 9 | import sbt.io.IO.withTemporaryDirectory 10 | import sbt.internal.util.ConsoleLogger 11 | import verify.BasicTestSuite 12 | 13 | object CustomPomParserTest extends BasicTestSuite { 14 | test( 15 | "CustomPomParser should resolve an artifact with packaging 'scala-jar' as a regular jar file." 16 | ) { 17 | val log = ConsoleLogger() 18 | withTemporaryDirectory { cacheDir => 19 | val repoUrl = getClass.getResource("/test-maven-repo") 20 | val local = MavenRepository("Test Repo", repoUrl.toExternalForm) 21 | val paths = IvyPaths(new File("."), Some(cacheDir)) 22 | val conf = InlineIvyConfiguration() 23 | .withPaths(paths) 24 | .withResolvers(Vector(local)) 25 | .withLog(log) 26 | val ivySbt = new IvySbt(conf) 27 | val resolveOpts = new ResolveOptions().setConfs(Array("default")) 28 | val mrid = ModuleRevisionId.newInstance("com.test", "test-artifact", "1.0.0-SNAPSHOT") 29 | 30 | val resolveReport = ivySbt.withIvy(log) { ivy => 31 | ivy.resolve(mrid, resolveOpts, true) 32 | } 33 | 34 | assert(!resolveReport.hasError) 35 | assert(resolveReport.getArtifacts.size() == 1) 36 | val artifact: IvyArtifact = 37 | resolveReport.getArtifacts.asInstanceOf[java.util.List[IvyArtifact]].get(0) 38 | assert(artifact.getModuleRevisionId == mrid) 39 | assert(artifact.getExt == "jar") 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/InconsistentDuplicateSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | import verify.BasicTestSuite 5 | 6 | // This is a specification to check the inconsistent duplicate warnings 7 | object InconsistentDuplicateSpec extends BasicTestSuite { 8 | test("Duplicate with different version should be warned") { 9 | assert( 10 | IvySbt.inconsistentDuplicateWarning(Seq(akkaActor214, akkaActor230)) == 11 | List( 12 | "Multiple dependencies with the same organization/name but different versions. To avoid conflict, pick one version:", 13 | " * com.typesafe.akka:akka-actor:(2.1.4, 2.3.0)" 14 | ) 15 | ) 16 | } 17 | 18 | test("it should not be warned if in different configurations") { 19 | assert(IvySbt.inconsistentDuplicateWarning(Seq(akkaActor214, akkaActor230Test)) == Nil) 20 | } 21 | 22 | test("Duplicate with same version should not be warned") { 23 | assert(IvySbt.inconsistentDuplicateWarning(Seq(akkaActor230Test, akkaActor230)) == Nil) 24 | } 25 | 26 | def akkaActor214 = 27 | ModuleID("com.typesafe.akka", "akka-actor", "2.1.4").withConfigurations( 28 | Some("compile") 29 | ) cross CrossVersion.binary 30 | def akkaActor230 = 31 | ModuleID("com.typesafe.akka", "akka-actor", "2.3.0").withConfigurations( 32 | Some("compile") 33 | ) cross CrossVersion.binary 34 | def akkaActor230Test = 35 | ModuleID("com.typesafe.akka", "akka-actor", "2.3.0").withConfigurations( 36 | Some("test") 37 | ) cross CrossVersion.binary 38 | } 39 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/IvyModuleSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.internal.librarymanagement.mavenint.PomExtraDependencyAttributes.{ 4 | SbtVersionKey, 5 | ScalaVersionKey 6 | } 7 | import sbt.librarymanagement.{ CrossVersion, ModuleDescriptorConfiguration } 8 | 9 | object IvyModuleSpec extends BaseIvySpecification { 10 | 11 | test("The Scala binary version of a Scala module should be appended to its name") { 12 | val m = module( 13 | defaultModuleId.withCrossVersion(CrossVersion.Binary()), 14 | Vector.empty, 15 | Some("2.13.10") 16 | ) 17 | m.moduleSettings match { 18 | case configuration: ModuleDescriptorConfiguration => 19 | assert(configuration.module.name == "foo_2.13") 20 | case _ => fail() 21 | } 22 | } 23 | 24 | test("The sbt cross-version should be appended to the name of an sbt plugin") { 25 | val m = module( 26 | defaultModuleId.extra(SbtVersionKey -> "1.0", ScalaVersionKey -> "2.12"), 27 | Vector.empty, 28 | Some("2.12.17"), 29 | appendSbtCrossVersion = true 30 | ) 31 | m.moduleSettings match { 32 | case configuration: ModuleDescriptorConfiguration => 33 | assert(configuration.module.name == "foo_2.12_1.0") 34 | case _ => fail() 35 | } 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/IvyResolutionSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement._ 4 | 5 | class IvyResolutionSpec extends ResolutionSpec with BaseIvySpecification { 6 | override val resolvers = Vector( 7 | Resolver.mavenCentral, 8 | Resolver.sbtPluginRepo("releases") 9 | ) 10 | } 11 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/IvyUtilSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import java.io.IOException 4 | 5 | import org.scalatest.funsuite.AnyFunSuite 6 | import sbt.internal.librarymanagement.IvyUtil._ 7 | 8 | class IvyUtilSpec extends AnyFunSuite { 9 | test("503 should be a TransientNetworkException") { 10 | val statusCode503Exception = 11 | new IOException("Server returned HTTP response code: 503 for URL:") 12 | assert(TransientNetworkException(statusCode503Exception)) 13 | } 14 | 15 | test("500 should be a TransientNetworkException") { 16 | val statusCode500Exception = 17 | new IOException("Server returned HTTP response code: 500 for URL:") 18 | assert(TransientNetworkException(statusCode500Exception)) 19 | } 20 | 21 | test("408 should be a TransientNetworkException") { 22 | val statusCode408Exception = 23 | new IOException("Server returned HTTP response code: 408 for URL:") 24 | assert(TransientNetworkException(statusCode408Exception)) 25 | } 26 | 27 | test("429 should be a TransientNetworkException") { 28 | val statusCode429Exception = 29 | new IOException(" Server returned HTTP response code: 429 for URL:") 30 | assert(TransientNetworkException(statusCode429Exception)) 31 | } 32 | 33 | test("404 should not be a TransientNetworkException") { 34 | val statusCode404Exception = 35 | new IOException("Server returned HTTP response code: 404 for URL:") 36 | assert(!TransientNetworkException(statusCode404Exception)) 37 | } 38 | 39 | test("IllegalArgumentException should not be a TransientNetworkException") { 40 | val illegalArgumentException = new IllegalArgumentException() 41 | assert(!TransientNetworkException(illegalArgumentException)) 42 | } 43 | 44 | test("it should retry for 3 attempts") { 45 | var i = 0 46 | def f: Int = { 47 | i += 1 48 | if (i < 3) throw new RuntimeException() else i 49 | } 50 | // exception predicate retries on all exceptions for this test 51 | val result = retryWithBackoff(f, _ => true, maxAttempts = 3) 52 | assert(result == 3) 53 | } 54 | 55 | test("it should fail after maxAttempts") { 56 | var i = 0 57 | def f: Int = { 58 | i += 1 59 | throw new RuntimeException() 60 | } 61 | intercept[RuntimeException] { 62 | retryWithBackoff(f, _ => true, maxAttempts = 3) 63 | } 64 | assert(i == 3) 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/MergeDescriptorSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import org.apache.ivy.core.module.descriptor.DependencyArtifactDescriptor 4 | import sbt.librarymanagement._ 5 | import sbt.librarymanagement.ivy.UpdateOptions 6 | import sbt.internal.librarymanagement.ivyint._ 7 | 8 | object MergeDescriptorSpec extends BaseIvySpecification { 9 | test("Merging duplicate dependencies should work") { 10 | cleanIvyCache() 11 | val m = module( 12 | ModuleID("com.example", "foo", "0.1.0").withConfigurations(Some("compile")), 13 | Vector(guavaTest, guavaTestTests), 14 | None, 15 | UpdateOptions() 16 | ) 17 | m.withModule(log) { case (_, md, _) => 18 | val deps = md.getDependencies 19 | assert(deps.size == 1) 20 | deps.headOption.getOrElse(sys.error("Dependencies not found")) match { 21 | case dd @ MergedDescriptors(_, _) => 22 | val arts = dd.getAllDependencyArtifacts 23 | val a0: DependencyArtifactDescriptor = arts.toList(0) 24 | val a1: DependencyArtifactDescriptor = arts.toList(1) 25 | val configs0 = a0.getConfigurations.toList 26 | val configs1 = a1.getConfigurations.toList 27 | assert(configs0 == List("compile")) 28 | assert(configs1 == List("test")) 29 | } 30 | } 31 | } 32 | def guavaTest = 33 | ModuleID("com.google.guava", "guava-tests", "18.0").withConfigurations(Option("compile")) 34 | def guavaTestTests = 35 | ModuleID("com.google.guava", "guava-tests", "18.0") 36 | .withConfigurations(Option("test")) 37 | .classifier("tests") 38 | def defaultOptions = EvictionWarningOptions.default 39 | 40 | } 41 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/ResolverSpec.scala: -------------------------------------------------------------------------------- 1 | package sbttest 2 | 3 | import java.net.URI 4 | import sbt.librarymanagement._ 5 | import sbt.librarymanagement.syntax._ 6 | import verify.BasicTestSuite 7 | 8 | class ResolverSpec extends BasicTestSuite { 9 | test("Resolver.url") { 10 | Resolver.url("Test Repo", new URI("http://example.com/").toURL)(Resolver.ivyStylePatterns) 11 | () 12 | } 13 | 14 | test("at") { 15 | "something" at "http://example.com" 16 | () 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/SftpRepoSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.io._ 4 | import sbt.io.syntax._ 5 | import sbt.util.Level 6 | import sbt.librarymanagement._ 7 | import sbt.librarymanagement.syntax._ 8 | import java.nio.file.Paths 9 | 10 | //by default this test is ignored 11 | //to run this you need to change "repo" to point to some sftp repository which contains a dependency referring a dependency in same repo 12 | //it will then attempt to authenticate via key file and fetch the dependency specified via "org" and "module" 13 | object SftpRepoSpec extends BaseIvySpecification { 14 | val repo: Option[String] = None 15 | // val repo: Option[String] = Some("some repo") 16 | // a dependency which depends on another in the repo 17 | def org(repo: String) = s"com.${repo}" 18 | def module(org: String) = org % "some-lib" % "version" 19 | 20 | override def resolvers = { 21 | implicit val patterns = Resolver.defaultIvyPatterns 22 | repo.map { repo => 23 | val privateKeyFile = Paths.get(sys.env("HOME"), ".ssh", s"id_${repo}").toFile 24 | Resolver.sftp(repo, s"repo.${repo}.com", 2222).as(repo, privateKeyFile) 25 | }.toVector ++ super.resolvers 26 | } 27 | 28 | test("resolving multiple deps from sftp repo should not hang or fail") { 29 | repo match { 30 | case Some(repo) => 31 | IO.delete(currentTarget / "cache" / org(repo)) 32 | // log.setLevel(Level.Debug) 33 | lmEngine().retrieve(module(org(repo)), scalaModuleInfo = None, currentTarget, log) match { 34 | case Right(v) => log.debug(v.toString()) 35 | case Left(e) => 36 | log.log(Level.Error, e.failedPaths.toString()) 37 | throw e.resolveException 38 | } 39 | case None => log.info(s"skipped ${getClass}") 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/TestLogger.scala: -------------------------------------------------------------------------------- 1 | package sbt 2 | package internal 3 | package librarymanagement 4 | 5 | import sbt.util._ 6 | import sbt.internal.util._ 7 | 8 | object TestLogger { 9 | def apply[T](f: Logger => T): T = { 10 | val log = new BufferedLogger(ConsoleLogger()) 11 | log.setLevel(Level.Debug) 12 | log.bufferQuietly(f(log)) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /ivy/src/test/scala/sbt/internal/librarymanagement/UpdateOptionsSpec.scala: -------------------------------------------------------------------------------- 1 | package sbt.internal.librarymanagement 2 | 3 | import sbt.librarymanagement.ivy._ 4 | import verify.BasicTestSuite 5 | 6 | class UpdateOptionsSpec extends BasicTestSuite { 7 | test("UpdateOptions should have proper toString defined") { 8 | assert(UpdateOptions().toString() == """|UpdateOptions( 9 | | circularDependencyLevel = warn, 10 | | latestSnapshots = true, 11 | | cachedResolution = false 12 | |)""".stripMargin) 13 | 14 | assert( 15 | UpdateOptions() 16 | .withCircularDependencyLevel(CircularDependencyLevel.Error) 17 | .withCachedResolution(true) 18 | .withLatestSnapshots(false) 19 | .toString() == """|UpdateOptions( 20 | | circularDependencyLevel = error, 21 | | latestSnapshots = false, 22 | | cachedResolution = true 23 | |)""".stripMargin 24 | ) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /notes/1.0.0.markdown: -------------------------------------------------------------------------------- 1 | - InlineConfiguration is renamed to ModuleConfiguration 2 | - IvyScala is renamed to ScalaModuleInfo 3 | - UpdateConfiguration, RetrieveConfiguration, PublishConfiguration are refactored to use builder pattern. 4 | - Adds ConfigRef for referencing Configuration 5 | - Moves syntax related things into `sbt.librarymagement.syntax` 6 | -------------------------------------------------------------------------------- /project/HouseRulesPlugin.scala: -------------------------------------------------------------------------------- 1 | package lmbuild 2 | 3 | import sbt._ 4 | import Keys._ 5 | 6 | object HouseRulesPlugin extends AutoPlugin { 7 | override def requires = plugins.JvmPlugin 8 | override def trigger = allRequirements 9 | 10 | override def projectSettings: Seq[Def.Setting[_]] = baseSettings 11 | 12 | lazy val baseSettings: Seq[Def.Setting[_]] = Seq( 13 | scalacOptions ++= Seq("-encoding", "utf8"), 14 | scalacOptions ++= Seq("-deprecation", "-feature", "-unchecked", "-Xlint"), 15 | scalacOptions += "-language:higherKinds", 16 | scalacOptions += "-language:implicitConversions", 17 | scalacOptions ++= "-Xfuture".ifScala213OrMinus.value.toList, 18 | scalacOptions += "-Xlint", 19 | scalacOptions ++= "-Xfatal-warnings" 20 | .ifScala(v => { 21 | sys.props.get("sbt.build.fatal") match { 22 | case Some(_) => java.lang.Boolean.getBoolean("sbt.build.fatal") 23 | case _ => v == 12 24 | } 25 | }) 26 | .value 27 | .toList, 28 | scalacOptions ++= "-Yinline-warnings".ifScala211OrMinus.value.toList, 29 | scalacOptions ++= "-Yno-adapted-args".ifScala212OrMinus.value.toList, 30 | scalacOptions += "-Ywarn-dead-code", 31 | scalacOptions += "-Ywarn-numeric-widen", 32 | scalacOptions += "-Ywarn-value-discard", 33 | scalacOptions ++= "-Ywarn-unused-import".ifScala(v => 11 <= v && v <= 12).value.toList 34 | ) ++ Seq(Compile, Test).flatMap(c => 35 | (c / console / scalacOptions) --= Seq("-Ywarn-unused-import", "-Xlint") 36 | ) 37 | 38 | private def scalaPartV = Def setting (CrossVersion partialVersion scalaVersion.value) 39 | 40 | private implicit final class AnyWithIfScala[A](val __x: A) { 41 | def ifScala(p: Long => Boolean) = 42 | Def setting (scalaPartV.value collect { case (2, y) if p(y) => __x }) 43 | def ifScalaLte(v: Long) = ifScala(_ <= v) 44 | def ifScalaGte(v: Long) = ifScala(_ >= v) 45 | def ifScala211OrMinus = ifScalaLte(11) 46 | def ifScala211OrPlus = ifScalaGte(11) 47 | def ifScala212OrMinus = ifScalaLte(12) 48 | def ifScala213OrMinus = ifScalaLte(13) 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /project/Util.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | import Keys._ 3 | import sbt.IO 4 | 5 | import java.io.File 6 | import xsbti.compile.CompileAnalysis 7 | 8 | object Util { 9 | 10 | def versionLine(version: String): String = "version=" + version 11 | def containsVersion(propFile: File, version: String): Boolean = 12 | IO.read(propFile).contains(versionLine(version)) 13 | def lastCompilationTime(analysis0: CompileAnalysis): Long = { 14 | val analysis = analysis0 match { case a: sbt.internal.inc.Analysis => a } 15 | val lastCompilation = analysis.compilations.allCompilations.lastOption 16 | lastCompilation.map(_.getStartTime) getOrElse 0L 17 | } 18 | 19 | def generateVersionFile( 20 | version: String, 21 | dir: File, 22 | s: TaskStreams, 23 | analysis: CompileAnalysis 24 | ): Seq[File] = { 25 | import java.util.{ Date, TimeZone } 26 | val formatter = new java.text.SimpleDateFormat("yyyyMMdd'T'HHmmss") 27 | formatter.setTimeZone(TimeZone.getTimeZone("GMT")) 28 | val timestamp = formatter.format(new Date) 29 | val content = versionLine(version) + "\ntimestamp=" + timestamp 30 | val f = dir / "xsbt.version.properties" 31 | // TODO: replace lastModified() with sbt.io.IO.getModifiedTimeOrZero(), once the build 32 | // has been upgraded to a version of sbt that includes that call. 33 | if ( 34 | !f.exists || f.lastModified < lastCompilationTime(analysis) || !containsVersion(f, version) 35 | ) { 36 | s.log.info("Writing version information to " + f + " :\n" + content) 37 | IO.write(f, content) 38 | } 39 | f :: Nil 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version=1.11.0 2 | -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | addSbtPlugin("com.github.sbt" % "sbt-dynver" % "5.1.0") 2 | addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.3.1") 3 | addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "1.1.4") 4 | addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.4") 5 | addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.7.0") 6 | 7 | scalacOptions += "-language:postfixOps" 8 | -------------------------------------------------------------------------------- /sbt-allsources.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | sbt -Dsbtio.path=../io -Dsbtutil.path=../util "$@" 4 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/multi-project/build.sbt: -------------------------------------------------------------------------------- 1 | lazy val root = (project in file(".")).aggregate(parent, child) 2 | lazy val parent = project 3 | lazy val child = project.dependsOn(parent) 4 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/multi-project/child/src/main/scala/Bar.scala: -------------------------------------------------------------------------------- 1 | class Bar extends Foo 2 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/multi-project/parent/src/main/scala/Foo.scala: -------------------------------------------------------------------------------- 1 | class Foo 2 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/multi-project/test: -------------------------------------------------------------------------------- 1 | > compile 2 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/sbt-plugins/Main.scala: -------------------------------------------------------------------------------- 1 | 2 | object Main { 3 | 4 | println("hello, world!") 5 | 6 | } 7 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/sbt-plugins/build.sbt: -------------------------------------------------------------------------------- 1 | 2 | { 3 | def writePluginsSbt(str: String) = { 4 | val pluginsSbt = file(".") / "project" / "plugins.sbt" 5 | if (!pluginsSbt.exists) 6 | IO.write( 7 | pluginsSbt, 8 | s"""$str 9 | |addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.8") 10 | |""".stripMargin 11 | ) 12 | } 13 | val dr = sys.props.get("dependency.resolution") match { 14 | case Some("ivy") => 15 | """dependencyResolution := sbt.librarymanagement.ivy.IvyDependencyResolution(ivyConfiguration.value)""" 16 | case Some("coursier") => 17 | """dependencyResolution := sbt.librarymanagement.coursier.CoursierDependencyResolution(sbt.librarymanagement.coursier.CoursierConfiguration())""" 18 | case _ => sys.error("""|The system property 'dependency.resolution' is not defined. 19 | |Specify this property using the scriptedLaunchOpts -D.""".stripMargin) 20 | } 21 | 22 | writePluginsSbt(dr) 23 | addCommandAlias( 24 | "setDependencyResolution", 25 | s"""set $dr""" 26 | ) 27 | } 28 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/sbt-plugins/test: -------------------------------------------------------------------------------- 1 | > reload 2 | > assembly 3 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/simple/Main.scala: -------------------------------------------------------------------------------- 1 | 2 | object Main { 3 | 4 | import com.typesafe.config.ConfigFactory 5 | 6 | val x = ConfigFactory.load() 7 | 8 | } 9 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/simple/build.sbt: -------------------------------------------------------------------------------- 1 | 2 | sys.props.get("dependency.resolution") match { 3 | case Some("ivy") => 4 | addCommandAlias( 5 | "setDependencyResolution", 6 | """set dependencyResolution := sbt.librarymanagement.ivy.IvyDependencyResolution(ivyConfiguration.value)""" 7 | ) 8 | case Some("coursier") => 9 | addCommandAlias( 10 | "setDependencyResolution", 11 | """set dependencyResolution := sbt.librarymanagement.coursier.CoursierDependencyResolution(sbt.librarymanagement.coursier.CoursierConfiguration())""" 12 | ) 13 | case _ => sys.error("""|The system property 'dependency.resolution' is not defined. 14 | |Specify this property using the scriptedLaunchOpts -D.""".stripMargin) 15 | } 16 | 17 | libraryDependencies ++= Seq( 18 | "com.typesafe" % "config" % "1.3.3" 19 | ) 20 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/simple/test: -------------------------------------------------------------------------------- 1 | > compile 2 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/use-sbt-in-meta/build.sbt: -------------------------------------------------------------------------------- 1 | 2 | { 3 | def writePluginsSbt(str: String) = { 4 | val pluginsSbt = file(".") / "project" / "plugins.sbt" 5 | if (!pluginsSbt.exists) 6 | IO.write( 7 | pluginsSbt, 8 | str 9 | ) 10 | } 11 | val dr = sys.props.get("dependency.resolution") match { 12 | case Some("ivy") => 13 | """dependencyResolution := sbt.librarymanagement.ivy.IvyDependencyResolution(ivyConfiguration.value)""" 14 | case Some("coursier") => 15 | """dependencyResolution := sbt.librarymanagement.coursier.CoursierDependencyResolution(sbt.librarymanagement.coursier.CoursierConfiguration())""" 16 | case _ => sys.error("""|The system property 'dependency.resolution' is not defined. 17 | |Specify this property using the scriptedLaunchOpts -D.""".stripMargin) 18 | } 19 | 20 | writePluginsSbt(dr) 21 | addCommandAlias( 22 | "setDependencyResolution", 23 | s"""set $dr""" 24 | ) 25 | } 26 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/use-sbt-in-meta/project/Dependencies.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | import Keys._ 3 | 4 | object Dependencies { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/use-sbt-in-meta/test: -------------------------------------------------------------------------------- 1 | > reload 2 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/with-trasnsitive/Main.scala: -------------------------------------------------------------------------------- 1 | 2 | object Main { 3 | 4 | import akka.actor._ 5 | 6 | val system = ActorSystem() 7 | 8 | system.terminate() 9 | 10 | import com.typesafe.config.ConfigFactory 11 | 12 | val x = ConfigFactory.load() 13 | 14 | } 15 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/with-trasnsitive/build.sbt: -------------------------------------------------------------------------------- 1 | 2 | sys.props.get("dependency.resolution") match { 3 | case Some("ivy") => 4 | addCommandAlias( 5 | "setDependencyResolution", 6 | """set dependencyResolution := sbt.librarymanagement.ivy.IvyDependencyResolution(ivyConfiguration.value)""" 7 | ) 8 | case Some("coursier") => 9 | addCommandAlias( 10 | "setDependencyResolution", 11 | """set dependencyResolution := sbt.librarymanagement.coursier.CoursierDependencyResolution(sbt.librarymanagement.coursier.CoursierConfiguration())""" 12 | ) 13 | case _ => sys.error("""|The system property 'dependency.resolution' is not defined. 14 | |Specify this property using the scriptedLaunchOpts -D.""".stripMargin) 15 | } 16 | 17 | libraryDependencies ++= Seq( 18 | "com.typesafe.akka" %% "akka-actor" % "2.5.17" 19 | ) 20 | -------------------------------------------------------------------------------- /scripted-test/src/sbt-test/lmScriptedTest/with-trasnsitive/test: -------------------------------------------------------------------------------- 1 | > compile 2 | --------------------------------------------------------------------------------