Refined artifacts API

cli/src/main/scala/coursier/cli/Coursier.scala

@@ -149,12 +149,12 @@ case class Coursier(scope: List[String],
         (repo, deps) <- sorted
         dl = downloaders(repo)
         dep <- deps
+        (_, proj) = res.projectsCache(dep.moduleVersion)
       } yield {
-        dl.artifact(dep, cachePolicy = cachePolicy).run.map {
-          case -\/(err) =>
-            println(s"Failed to get ${repr(dep)}: $err")
-          case \/-(f) =>
-            println(s"${repr(dep)}:\n  ${fileRepr(f)}")
+        dl.artifacts(dep, proj, cachePolicy = cachePolicy).map { results =>
+          val errorCount = results.count{case -\/(_) => true; case _ => false}
+          val resultsRepr = results.map(_.map(fileRepr).merge).map("  " + _).mkString("\n")
+          println(s"${repr(dep)} (${results.length} artifact(s)${if (errorCount > 0) s", $errorCount error(s)" else ""}):\n$resultsRepr")
         }
       }
 

core-jvm/src/main/scala/coursier/core/Remote.scala

@@ -21,18 +21,14 @@ case class ArtifactDownloader(root: String, cache: File, logger: Option[Artifact
 
   def artifact(module: Module,
                version: String,
-               artifacts: Artifacts,
+               artifact: Artifacts.Artifact,
                cachePolicy: CachePolicy): EitherT[Task, String, File] = {
 
-    val (type0, classifier) = artifacts match {
-      case maven: Artifacts.Maven => (maven.`type`, maven.classifier)
-    }
-
     val relPath =
       module.organization.split('.').toSeq ++ Seq(
         module.name,
         version,
-        s"${module.name}-$version${Some(classifier).filter(_.nonEmpty).map("-"+_).mkString}.$type0"
+        s"${module.name}-$version${Some(artifact.classifier).filter(_.nonEmpty).map("-"+_).mkString}.${artifact.`type`}"
       )
 
     val file = (cache /: relPath)(new File(_, _))
@@ -95,9 +91,23 @@ case class ArtifactDownloader(root: String, cache: File, logger: Option[Artifact
     EitherT(cachePolicy(locally)(remote))
   }
 
-  def artifact(dependency: Dependency,
-               cachePolicy: CachePolicy = CachePolicy.Default): EitherT[Task, String, File] =
-    artifact(dependency.module, dependency.version, dependency.artifacts, cachePolicy = cachePolicy)
+  def artifacts(dependency: Dependency,
+                project: Project,
+                cachePolicy: CachePolicy = CachePolicy.Default): Task[Seq[String \/ File]] = {
+
+    val artifacts0 =
+      dependency.artifacts match {
+        case s: Artifacts.Sufficient => s.artifacts
+        case p: Artifacts.WithProject => p.artifacts(project)
+      }
+
+    val tasks =
+      artifacts0 .map { artifact0 =>
+        artifact(dependency.module, dependency.version, artifact0, cachePolicy = cachePolicy).run
+      }
+
+    Task.gatherUnordered(tasks)
+  }
 
 }
 

core/src/main/scala/coursier/core/Definitions.scala

@@ -41,8 +41,25 @@ case class Dependency(module: Module,
 sealed trait Artifacts
 
 object Artifacts {
+  /**
+   * May become a bit more complicated with Ivy support,
+   * but should still point at one single artifact.
+   */
+  case class Artifact(`type`: String,
+                      classifier: String)
+
+  sealed trait WithProject extends Artifacts {
+    def artifacts(project: Project): Seq[Artifact]
+  }
+
+  sealed trait Sufficient extends Artifacts {
+    def artifacts: Seq[Artifact]
+  }
+
   case class Maven(`type`: String,
-                   classifier: String) extends Artifacts
+                   classifier: String) extends Sufficient {
+    def artifacts: Seq[Artifact] = Seq(Artifact(`type`, classifier))
+  }
 }
 
 case class Project(module: Module,