Merge pull request #8 from tindzk/feat/resolve-full-deps

 Expose artefact version tag in TOML build file

Author: tindzk

Diff for: .gitignore

@@ -1,6 +1,5 @@
-.idea/
 .bloop/
-build/
 target/
-project/target/
-test/
+/.idea/
+/build/
+/test/

Diff for: README.md

@@ -357,6 +357,26 @@ scalaDeps = [
 ]
 ```
 
+On `scalaDeps`, you can specify a fourth parameter for the version tag. The version tag is the actual difference between a Java and Scala dependency.
+
+The Scala naming conventions stipulate that a suffix be added to the artefact name. Thus, `scalaj-http` becomes [`scalaj-http_2.12`](http://central.maven.org/maven2/org/scalaj/scalaj-http_2.12/).
+
+The previous example could be rewritten as:
+
+```toml
+scalaDeps = [
+  ["org.scalaj", "scalaj-http", "2.4.1", "platformBinary"]
+]
+```
+
+The default is `platformBinary` which will suit most libraries. However, some libraries target a specific compiler version or share one artefact with all platforms.
+
+The available options are:
+
+* `binary`: Binary Scala version (e.g. 2.12). This behaves like `full` if the Scala version is a pre-release (e.g. `2.12.8-M3`)
+* `full`: Full Scala version (e.g. `2.11.11`)
+* `platformBinary`: Platform name including the binary Scala version (`native0.3_2.11`)
+
 `scalaDeps` only works with Scala artefacts. For all other artefacts, you can use `javaDeps`:
 
 ```toml

Diff for: src/main/scala/seed/artefact/ArtefactResolution.scala

@@ -5,52 +5,51 @@ import java.nio.file.Path
 import seed.Cli.PackageConfig
 import MavenCentral.{CompilerVersion, PlatformVersion}
 import seed.cli.util.Ansi
-import seed.model.Artefact.PlatformSuffix
-import seed.model.Build.{Dep, Module}
+import seed.model.Build.{Dep, JavaDep, Module, ScalaDep}
 import seed.model.Platform.{JVM, JavaScript, Native}
 import seed.model.{Artefact, Build, Platform, Resolution}
 import seed.Log
 import seed.config.BuildConfig
 
 object ArtefactResolution {
-  def dependencyFromDep(dep: Dep,
-                        platform: Platform,
-                        platformVersion: PlatformVersion,
-                        compilerVersion: CompilerVersion,
-                        platformSuffix: PlatformSuffix = PlatformSuffix.PlatformAndCompiler
-                       ): Dep =
-    Dep(
+  def javaDepFromScalaDep(dep: ScalaDep,
+                          platform: Platform,
+                          platformVersion: PlatformVersion,
+                          compilerVersion: CompilerVersion
+                         ): JavaDep =
+    JavaDep(
       dep.organisation,
       MavenCentral.formatArtefactName(
-        Artefact(dep.organisation, dep.artefact, platformSuffix), platform,
-        platformVersion, compilerVersion
+        dep.artefact, dep.versionTag, platform, platformVersion, compilerVersion
       ), dep.version)
 
-  def dependencyFromArtefact(artefact: Artefact,
-                             version: String,
-                             platform: Platform,
-                             platformVersion: PlatformVersion,
-                             compilerVersion: CompilerVersion): Dep =
-    Dep(
+  def javaDepFromArtefact(artefact: Artefact,
+                          version: String,
+                          platform: Platform,
+                          platformVersion: PlatformVersion,
+                          compilerVersion: CompilerVersion
+                         ): JavaDep =
+    JavaDep(
       artefact.organisation,
-      MavenCentral.formatArtefactName(
-        artefact, platform, platformVersion, compilerVersion),
-      version)
+      artefact.versionTag.fold(artefact.name)(vt =>
+        MavenCentral.formatArtefactName(artefact.name, vt, platform,
+          platformVersion, compilerVersion)
+      ), version)
 
-  def jsPlatformDeps(build: Build, module: Module): Set[Dep] = {
+  def jsPlatformDeps(build: Build, module: Module): Set[JavaDep] = {
     val scalaVersion   = BuildConfig.scalaVersion(build.project, List(module))
     val scalaJsVersion = build.project.scalaJsVersion.get
 
     Set(
       Artefact.ScalaJsCompiler,
       Artefact.ScalaJsLibrary
     ).map(artefact =>
-      dependencyFromArtefact(artefact, scalaJsVersion, JavaScript,
+      javaDepFromArtefact(artefact, scalaJsVersion, JavaScript,
         scalaJsVersion, scalaVersion)
     )
   }
 
-  def nativePlatformDeps(build: Build, module: Module): Set[Dep] = {
+  def nativePlatformDeps(build: Build, module: Module): Set[JavaDep] = {
     val scalaVersion = BuildConfig.scalaVersion(build.project, List(module))
     val scalaNativeVersion = build.project.scalaNativeVersion.get
 
@@ -61,78 +60,52 @@ object ArtefactResolution {
       Artefact.ScalaNativeNativelib,
       Artefact.ScalaNativeAuxlib
     ).map(artefact =>
-      dependencyFromArtefact(artefact, scalaNativeVersion, Native,
+      javaDepFromArtefact(artefact, scalaNativeVersion, Native,
         scalaNativeVersion, scalaVersion)
     )
   }
 
-  def jvmArtefacts(stack: List[Module]): Set[(Platform, Artefact.Versioned)] =
-    stack.flatMap(_.scalaDeps).map(dep =>
-      JVM -> Artefact.Versioned(
-        Artefact(dep.organisation, dep.artefact, PlatformSuffix.PlatformAndCompiler),
-        dep.version)
-    ).toSet ++
-    stack.flatMap(_.javaDeps).map(dep =>
-      JVM -> Artefact.Versioned(
-        Artefact(dep.organisation, dep.artefact, PlatformSuffix.Regular), dep.version)
-    ).toSet
+  def jvmArtefacts(stack: List[Module]): Set[(Platform, Dep)] =
+    stack.flatMap(_.scalaDeps).map(dep => JVM -> dep).toSet ++
+    stack.flatMap(_.javaDeps).map(dep => JVM -> dep).toSet
 
-  def jvmDeps(build: Build, stack: List[Module]): Set[Dep] = {
+  def jvmDeps(build: Build, stack: List[Module]): Set[JavaDep] = {
     val scalaVersion = BuildConfig.scalaVersion(build.project, stack)
 
     stack.flatMap(_.scalaDeps).map(dep =>
-      dependencyFromArtefact(
-        Artefact(dep.organisation, dep.artefact, PlatformSuffix.PlatformAndCompiler),
-        dep.version, JVM, scalaVersion, scalaVersion)
+      javaDepFromScalaDep(dep, JVM, scalaVersion, scalaVersion)
     ).toSet ++
-    stack.flatMap(_.javaDeps).map(dep =>
-      dependencyFromArtefact(
-        Artefact(dep.organisation, dep.artefact, PlatformSuffix.Regular),
-        dep.version, JVM, scalaVersion, scalaVersion)
-    ).toSet
+    stack.flatMap(_.javaDeps).toSet
   }
 
-  def jsArtefacts(stack: List[Module]): Set[(Platform, Artefact.Versioned)] =
-    stack.flatMap(_.scalaDeps).map(dep =>
-      JavaScript ->
-        Artefact.Versioned(
-          Artefact(dep.organisation, dep.artefact, PlatformSuffix.PlatformAndCompiler),
-          dep.version)
-    ).toSet
+  def jsArtefacts(stack: List[Module]): Set[(Platform, Dep)] =
+    stack.flatMap(_.scalaDeps).map(dep => JavaScript -> dep).toSet
 
-  def jsDeps(build: Build, stack: List[Module]): Set[Dep] =
+  def jsDeps(build: Build, stack: List[Module]): Set[JavaDep] =
     build.project.scalaJsVersion match {
       case None                 => Set()
       case Some(scalaJsVersion) =>
         val scalaVersion = BuildConfig.scalaVersion(build.project, stack)
         stack.flatMap(_.scalaDeps).map(dep =>
-          dependencyFromArtefact(
-            Artefact(dep.organisation, dep.artefact, PlatformSuffix.PlatformAndCompiler),
-            dep.version, JavaScript, scalaJsVersion, scalaVersion)
+          javaDepFromScalaDep(dep, JavaScript, scalaJsVersion, scalaVersion)
         ).toSet
     }
 
-  def nativeArtefacts(stack: List[Module]): Set[(Platform, Artefact.Versioned)] =
-    stack.flatMap(_.scalaDeps).map(dep =>
-      Native -> Artefact.Versioned(
-        Artefact(dep.organisation, dep.artefact, PlatformSuffix.PlatformAndCompiler),
-        dep.version)
-    ).toSet
+  def nativeArtefacts(stack: List[Module]): Set[(Platform, Dep)] =
+    stack.flatMap(_.scalaDeps).map(dep => Native -> dep).toSet
 
-  def nativeDeps(build: Build, stack: List[Module]): Set[Dep] =
+  def nativeDeps(build: Build, stack: List[Module]): Set[JavaDep] =
     build.project.scalaNativeVersion match {
       case None                     => Set()
       case Some(scalaNativeVersion) =>
         val scalaVersion = BuildConfig.scalaVersion(build.project, stack)
         stack.flatMap(_.scalaDeps).map(dep =>
-          dependencyFromArtefact(
-            Artefact(dep.organisation, dep.artefact, PlatformSuffix.PlatformAndCompiler),
-            dep.version, Native, scalaNativeVersion, scalaVersion)
+          javaDepFromScalaDep(dep, Native, scalaNativeVersion, scalaVersion)
         ).toSet
     }
 
-  def compilerDeps(build: Build, module: Module): List[Set[Dep]] = {
-    def f(build: Build, module: Module): Set[Dep] = {
+  def compilerDeps(build: Build, module: Module): List[Set[JavaDep]] = {
+    def f(build: Build, module: Module): Set[JavaDep] = {
       import build.project.scalaOrganisation
       val scalaVersion = BuildConfig.scalaVersion(build.project, List(module))
 
@@ -141,7 +114,7 @@ object ArtefactResolution {
         Artefact.scalaLibrary(scalaOrganisation),
         Artefact.scalaReflect(scalaOrganisation)
       ).map(artefact =>
-        dependencyFromArtefact(artefact, scalaVersion, JVM, scalaVersion,
+        javaDepFromArtefact(artefact, scalaVersion, JVM, scalaVersion,
           scalaVersion))
     }
 
@@ -153,23 +126,23 @@ object ArtefactResolution {
     ).filter(_.nonEmpty)
   }
 
-  def allCompilerDeps(build: Build): List[Set[Dep]] =
+  def allCompilerDeps(build: Build): List[Set[JavaDep]] =
     build.module.values.toList.flatMap(compilerDeps(build, _)).distinct
 
-  def platformDeps(build: Build, module: Module): Set[Dep] =
+  def platformDeps(build: Build, module: Module): Set[JavaDep] =
     module.targets.toSet[Platform].flatMap { target =>
       if (target == JavaScript)
         jsPlatformDeps(build, module.js.getOrElse(Module()))
       else if (target == Native) nativePlatformDeps(build,
         module.native.getOrElse(Module()))
-      else Set[Dep]()
+      else Set[JavaDep]()
     }
 
   def libraryDeps(build: Build,
                   module: Module,
                   platforms: Set[Platform],
                   parent: Module = Module()
-                 ): Set[Dep] = {
+                 ): Set[JavaDep] = {
     val targets = if (module.targets.isEmpty) parent.targets else module.targets
     targets.toSet[Platform].intersect(platforms).flatMap { target =>
       // Shared libraries
@@ -200,7 +173,7 @@ object ArtefactResolution {
   def libraryArtefacts(build: Build,
                        module: Module,
                        parent: Module = Module()
-                      ): Set[(Platform, Artefact.Versioned)] =
+                      ): Set[(Platform, Dep)] =
     module.targets.toSet[Platform].flatMap { target =>
       if (target == JVM) jvmArtefacts(List(module, parent))
       else if (target == JavaScript) jsArtefacts(List(module, parent))
@@ -215,15 +188,15 @@ object ArtefactResolution {
         List(native, parent.native.getOrElse(Module()), module))) ++
     module.test.toSet.flatMap(libraryArtefacts(build, _, module))
 
-  def allPlatformDeps(build: Build): Set[Dep] =
+  def allPlatformDeps(build: Build): Set[JavaDep] =
     build.module.values.toSet.flatMap(platformDeps(build, _))
 
   def allLibraryDeps(build: Build,
                      platforms: Set[Platform] = Set(JVM, JavaScript, Native)
-                    ): Set[Dep] =
+                    ): Set[JavaDep] =
     build.module.values.toSet.flatMap(libraryDeps(build, _, platforms))
 
-  def allLibraryArtefacts(build: Build): Map[Platform, Set[Artefact.Versioned]] =
+  def allLibraryArtefacts(build: Build): Map[Platform, Set[Dep]] =
     build.module.values.toSet.flatMap(libraryArtefacts(build, _))
       .groupBy(_._1)
       .mapValues(_.map(_._2))
@@ -233,9 +206,9 @@ object ArtefactResolution {
                            scalaVersion: String,
                            classPath: List[Path]
                           ): Resolution.ScalaCompiler = {
-    val compilerDep = Dep(scalaOrganisation, "scala-compiler", scalaVersion)
-    val libraryDep  = Dep(scalaOrganisation, "scala-library", scalaVersion)
-    val reflectDep  = Dep(scalaOrganisation, "scala-reflect", scalaVersion)
+    val compilerDep = JavaDep(scalaOrganisation, "scala-compiler", scalaVersion)
+    val libraryDep  = JavaDep(scalaOrganisation, "scala-library", scalaVersion)
+    val reflectDep  = JavaDep(scalaOrganisation, "scala-reflect", scalaVersion)
 
     val resolution = resolutionResult.find(r =>
       Coursier.hasDep(r, compilerDep)).get
@@ -265,8 +238,8 @@ object ArtefactResolution {
                  build: Build,
                  packageConfig: PackageConfig,
                  optionalArtefacts: Boolean,
-                 platformDeps: Set[Dep],
-                 compilerDeps: List[Set[Dep]],
+                 platformDeps: Set[JavaDep],
+                 compilerDeps: List[Set[JavaDep]],
                 ) = {
     val silent = packageConfig.silent || seedConfig.resolution.silent
     if (!silent) Coursier.initLogger()
@@ -281,7 +254,7 @@ object ArtefactResolution {
     build.resolvers.ivy.foreach(ivy => Log.info("  - " + Ansi.italic(ivy.url) + " (Ivy)"))
     build.resolvers.maven.foreach(maven => Log.info("  - " + Ansi.italic(maven) + " (Maven)"))
 
-    def resolve(deps: Set[Dep]) =
+    def resolve(deps: Set[JavaDep]) =
       Coursier.resolveAndDownload(deps, build.resolvers, resolvedIvyPath,
         resolvedCachePath, optionalArtefacts)
 

Diff for: src/main/scala/seed/artefact/Coursier.scala

@@ -10,7 +10,7 @@ import coursier.ivy.IvyRepository
 import coursier.util.{Gather, Task}
 import coursier.{Artifact, Cache, CachePath, Dependency, Fetch, MavenRepository, Module, Resolution, TermDisplay}
 import seed.cli.util.Ansi
-import seed.model.Build.{Dep, Resolvers}
+import seed.model.Build.{JavaDep, Resolvers}
 import seed.model.Platform
 import seed.{Log, model}
 
@@ -37,18 +37,18 @@ object Coursier {
       logger = Some(termDisplay)
     }
 
-  def hasDep(resolutionResult: Coursier.ResolutionResult, dep: Dep): Boolean =
+  def hasDep(resolutionResult: Coursier.ResolutionResult, dep: JavaDep): Boolean =
     resolutionResult.resolution.dependencies.exists(d =>
       d.module.organization.value == dep.organisation &&
       d.module.name.value == dep.artefact &&
       d.version == dep.version)
 
-  def coursierDependencies(deps: Set[Dep]): Set[Dependency] =
+  def coursierDependencies(deps: Set[JavaDep]): Set[Dependency] =
     deps.map(r => Dependency(Module(Organization(r.organisation), ModuleName(r.artefact)), r.version))
 
   private val lock = new ReentrantLock()
 
-  def resolve(all: Set[Dep], resolvers: Resolvers, ivyPath: Path, cachePath: Path): Resolution =
+  def resolve(all: Set[JavaDep], resolvers: Resolvers, ivyPath: Path, cachePath: Path): Resolution =
     if (all.isEmpty) Resolution.empty
     else {
       val organisations = all.map(_.organisation).toList.sorted.map(Ansi.italic).mkString(", ")
@@ -113,7 +113,7 @@ object Coursier {
       }
   }
 
-  def resolveAndDownload(deps: Set[Dep],
+  def resolveAndDownload(deps: Set[JavaDep],
                          resolvers: Resolvers,
                          ivyPath: Path,
                          cachePath: Path,
@@ -131,7 +131,7 @@ object Coursier {
   }
 
   def resolveSubset(resolution: Resolution,
-                    deps: Set[Dep],
+                    deps: Set[JavaDep],
                     optionalArtefacts: Boolean): List[(Classifier, Artefact)] = {
     val result =
       resolution
@@ -157,7 +157,7 @@ object Coursier {
 
   /** Resolves requested libraries and their dependencies */
   def localArtefacts(result: ResolutionResult,
-                     all: Set[Dep],
+                     all: Set[JavaDep],
                      optionalArtefacts: Boolean = false
                     ): List[model.Resolution.Artefact] =
     resolveSubset(result.resolution, all, optionalArtefacts)
@@ -184,8 +184,10 @@ object Coursier {
                    platformVersion: MavenCentral.PlatformVersion,
                    compilerVersion: MavenCentral.CompilerVersion,
                    version: String): Option[Path] = {
-    val name = MavenCentral.formatArtefactName(artefact, platform,
-      platformVersion, compilerVersion)
+    val name =
+      artefact.versionTag.fold(artefact.name)(vt =>
+        MavenCentral.formatArtefactName(artefact.name, vt, platform,
+          platformVersion, compilerVersion))
 
     result.resolution.dependencyArtifacts().find { case (dep, attr, art) =>
       dep.module.name.value == name