Import the jsDependencies plugin from the Scala.js core repository.

.travis.yml

@@ -0,0 +1,43 @@
+sudo: false
+language: scala
+scala:
+  - 2.10.6
+  - 2.11.11
+  - 2.12.2
+jdk:
+  - oraclejdk8
+install:
+  - if [[ "${TRAVIS_SCALA_VERSION}" == "2.10.6" ]]; then TEST_SBT_PLUGIN=true; else TEST_SBT_PLUGIN=false; fi
+  # The default ivy resolution takes way too much time, and times out Travis builds.
+  # We use coursier instead.
+  - mkdir -p $HOME/.sbt/0.13/plugins/
+  - echo 'addSbtPlugin("io.get-coursier" % "sbt-coursier" % "1.0.0-RC3")' > $HOME/.sbt/0.13/plugins/coursier.sbt
+  # While there is no published version of Scala.js 1.x, we have to locally build a snapshot.
+  - git clone https://github.com/scala-js/scala-js.git
+  - cd scala-js
+  - git checkout cc6610bf35332b5a52276b8fda69dee5ea72300f
+  - sbt ++$TRAVIS_SCALA_VERSION ir/publishLocal tools/publishLocal
+  - |
+      if [[ "${TEST_SBT_PLUGIN}" == "true" ]]; then
+        sbt ++$TRAVIS_SCALA_VERSION jsEnvs/publishLocal testAdapter/publishLocal sbtPlugin/publishLocal &&
+        sbt ++2.11.11 compiler/publishLocal library/publishLocal testInterface/publishLocal
+      fi
+  - cd ..
+script:
+  - sbt ++$TRAVIS_SCALA_VERSION jsdependencies-core/test jsdependencies-core/doc
+  - |
+      if [[ "${TEST_SBT_PLUGIN}" == "true" ]]; then
+        sbt jsdependencies-core/publishLocal sbt-jsdependencies/publishLocal && \
+        cd sbt-plugin-test && \
+        sbt testAll && \
+        cd ..
+      fi
+cache:
+  directories:
+    - $HOME/.ivy2/cache
+    - $HOME/.sbt
+    - $HOME/.coursier/cache
+before_cache:
+  - find $HOME/.ivy2/cache -name "ivydata-*.properties" -print -delete
+  - find $HOME/.sbt -name "*.lock" -print -delete
+  - rm $HOME/.sbt/0.13/plugins/coursier.sbt

build.sbt

@@ -0,0 +1,104 @@
+val scalaJSVersion = "1.0.0-SNAPSHOT"
+
+inThisBuild(Seq(
+  version := "0.1.0-SNAPSHOT",
+  organization := "org.scala-js",
+
+  crossScalaVersions := Seq("2.10.6", "2.11.11", "2.12.2"),
+  scalaVersion := "2.10.6",
+  scalacOptions ++= Seq("-deprecation", "-feature", "-Xfatal-warnings"),
+
+  homepage := Some(url("https://www.scala-js.org/")),
+  licenses += ("BSD New",
+      url("https://github.com/scala-js/jsdependencies/blob/master/LICENSE")),
+  scmInfo := Some(ScmInfo(
+      url("https://github.com/scala-js/jsdependencies"),
+      "scm:git:git@github.com:scala-js/jsdependencies.git",
+      Some("scm:git:git@github.com:scala-js/jsdependencies.git")))
+))
+
+val commonSettings = Def.settings(
+  // Scaladoc linking
+  apiURL := {
+    val name = moduleName.value
+    val v = version.value
+    Some(url(s"https://www.scala-js.org/api/$name/$v/"))
+  },
+  autoAPIMappings := true,
+
+  publishMavenStyle := true,
+  publishTo := {
+    val nexus = "https://oss.sonatype.org/"
+    if (isSnapshot.value)
+      Some("snapshots" at nexus + "content/repositories/snapshots")
+    else
+      Some("releases" at nexus + "service/local/staging/deploy/maven2")
+  },
+  pomExtra := (
+    <developers>
+      <developer>
+        <id>sjrd</id>
+        <name>Sébastien Doeraene</name>
+        <url>https://github.com/sjrd/</url>
+      </developer>
+      <developer>
+        <id>gzm0</id>
+        <name>Tobias Schlatter</name>
+        <url>https://github.com/gzm0/</url>
+      </developer>
+      <developer>
+        <id>nicolasstucki</id>
+        <name>Nicolas Stucki</name>
+        <url>https://github.com/nicolasstucki/</url>
+      </developer>
+    </developers>
+  ),
+  pomIncludeRepository := { _ => false }
+)
+
+lazy val root: Project = project.in(file(".")).
+  settings(
+    publishArtifact in Compile := false,
+    publish := {},
+    publishLocal := {},
+
+    clean := clean.dependsOn(
+      clean in `jsdependencies-core`,
+      clean in `sbt-jsdependencies`
+    ).value
+  )
+
+lazy val `jsdependencies-core`: Project = project.in(file("jsdependencies-core")).
+  settings(
+    commonSettings,
+
+    libraryDependencies ++= Seq(
+      "org.scala-js" %% "scalajs-tools" % scalaJSVersion,
+
+      "com.novocode" % "junit-interface" % "0.11" % "test"
+    )
+  )
+
+lazy val `sbt-jsdependencies`: Project = project.in(file("jsdependencies-sbt-plugin")).
+  settings(
+    commonSettings,
+
+    sbtPlugin := true,
+    scalaBinaryVersion :=
+      CrossVersion.binaryScalaVersion(scalaVersion.value),
+
+    addSbtPlugin("org.scala-js" % "sbt-scalajs" % scalaJSVersion),
+
+    // Add API mappings for sbt (seems they don't export their API URL)
+    apiMappings ++= {
+      val deps = (externalDependencyClasspath in Compile).value
+      val sbtJars = deps filter { attributed =>
+        val p = attributed.data.getPath
+        p.contains("/org.scala-sbt/") && p.endsWith(".jar")
+      }
+      val docUrl =
+        url(s"http://www.scala-sbt.org/${sbtVersion.value}/api/")
+      sbtJars.map(_.data -> docUrl).toMap
+    }
+  ).
+  dependsOn(`jsdependencies-core`)

jsdependencies-core/src/main/scala/org/scalajs/jsdependencies/core/DependencyResolver.scala

@@ -0,0 +1,199 @@
+package org.scalajs.jsdependencies.core
+
+import scala.collection.mutable
+
+import org.scalajs.core.tools.io.VirtualJSFile
+import JSLibResolveException.Problem
+
+object DependencyResolver {
+
+  type DependencyFilter =
+    Traversable[FlatJSDependency] => Traversable[FlatJSDependency]
+
+  /** Constructs an ordered list of JS libraries to include. Fails if:
+   *  - Resource names do not identify a unique resource on the classpath
+   *  - Dependencies have cycles
+   *  - Not all dependencies are available
+   */
+  def resolveDependencies(
+      manifests: Traversable[JSDependencyManifest],
+      availableLibs: Map[String, VirtualJSFile],
+      dependencyFilter: DependencyFilter): List[ResolvedJSDependency] = {
+
+    val resourceNames = collectAllResourceNames(manifests)
+    val resolvedJSLibs =
+      resolveAllResourceNames(resourceNames, availableLibs.keys)
+
+    val allFlatDeps = for {
+      manifest <- manifests
+      dep <- manifest.libDeps
+    } yield {
+      new FlatJSDependency(
+          manifest.origin,
+          resolvedJSLibs(dep.resourceName),
+          dep.dependencies.map(resolvedJSLibs),
+          dep.commonJSName,
+          dep.minifiedResourceName.map(resolvedJSLibs))
+    }
+
+    val flatDeps = dependencyFilter(allFlatDeps)
+    val includeList = createIncludeList(flatDeps)
+
+    for (info <- includeList) yield {
+      new ResolvedJSDependency(availableLibs(info.relPath),
+          info.relPathMinified.map(availableLibs), info)
+    }
+  }
+
+  /** Collects all the resource names mentioned in the manifests.
+   *  @param manifests to collect from
+   *  @return Map from resource name to the list of origins mentioning them
+   */
+  private def collectAllResourceNames(
+      manifests: Traversable[JSDependencyManifest]): Map[String, List[Origin]] = {
+
+    def allResources(dep: JSDependency) =
+      dep.resourceName :: dep.dependencies ::: dep.minifiedResourceName.toList
+
+    val nameOriginPairs = for {
+      manifest <- manifests.toList
+      dep <- manifest.libDeps
+      resourceName <- allResources(dep)
+    } yield (resourceName, manifest.origin)
+
+    nameOriginPairs.groupBy(_._1).mapValues(_.map(_._2))
+  }
+
+  /** Resolves all the resource names wrt to the current classpath.
+   *  @throws JSLibResolveException if any of the resource names cannot be resolved
+   *  @return Map from resource name to relative path
+   */
+  private def resolveAllResourceNames(
+      allResourceNames: Map[String, List[Origin]],
+      relPaths: Traversable[String]): Map[String, String] = {
+    val problems = mutable.ListBuffer.empty[Problem]
+    val resolvedLibs = Map.newBuilder[String, String]
+
+    for ((resourceName, origins) <- allResourceNames) {
+      resolveResourceName(resourceName, origins, relPaths).fold[Unit](
+          problems += _,
+          resolvedLibs += resourceName -> _)
+    }
+
+    if (problems.nonEmpty)
+      throw new JSLibResolveException(problems.toList)
+    else
+      resolvedLibs.result()
+  }
+
+  /** Resolves one resource name wrt to the current classpath. */
+  private def resolveResourceName(resourceName: String, origins: List[Origin],
+      relPaths: Traversable[String]): Either[Problem, String] = {
+    val candidates = (relPaths collect {
+      case relPath if ("/" + relPath).endsWith("/" + resourceName) =>
+        relPath
+    }).toList
+
+    candidates match {
+      case relPath :: Nil =>
+        Right(relPath)
+      case _ =>
+        Left(new Problem(resourceName, candidates, origins))
+    }
+  }
+
+  /** Create a sorted include list for js libs */
+  private def createIncludeList(
+      flatDeps: Traversable[FlatJSDependency]): List[ResolutionInfo] = {
+    val jsDeps = mergeManifests(flatDeps)
+
+    // Verify all dependencies are met
+    for {
+      lib <- flatDeps
+      dep <- lib.dependencies
+      if !jsDeps.contains(dep)
+    } throw new MissingDependencyException(lib, dep)
+
+    // Sort according to dependencies and return
+
+    // Very simple O(n²) topological sort for elements assumed to be distinct
+    // Copied :( from GenJSExports (but different exception)
+    @scala.annotation.tailrec
+    def loop(coll: List[ResolutionInfo],
+      acc: List[ResolutionInfo]): List[ResolutionInfo] = {
+
+      if (coll.isEmpty) acc
+      else if (coll.tail.isEmpty) coll.head :: acc
+      else {
+        val (selected, pending) = coll.partition { x =>
+          coll forall { y => (x eq y) || !y.dependencies.contains(x.relPath) }
+        }
+
+        if (selected.nonEmpty)
+          loop(pending, selected ::: acc)
+        else
+          throw new CyclicDependencyException(pending)
+      }
+    }
+
+    loop(jsDeps.values.toList, Nil)
+  }
+
+  /** Merges multiple JSDependencyManifests into a map of map:
+   *  resourceName -> ResolutionInfo
+   */
+  private def mergeManifests(flatDeps: Traversable[FlatJSDependency]) = {
+    checkCommonJSNameConflicts(flatDeps)
+
+    val byRelPath = flatDeps.groupBy(_.relPath)
+
+    checkMinifiedJSConflicts(byRelPath)
+
+    byRelPath.mapValues { sameName =>
+      new ResolutionInfo(
+        relPath = sameName.head.relPath,
+        dependencies = sameName.flatMap(_.dependencies).toSet,
+        origins = sameName.map(_.origin).toList,
+        commonJSName = sameName.flatMap(_.commonJSName).headOption,
+        relPathMinified = sameName.flatMap(_.relPathMinified).headOption
+      )
+    }
+  }
+
+  private def checkCommonJSNameConflicts(flatDeps: Traversable[FlatJSDependency]) = {
+    @inline
+    def hasConflict(x: FlatJSDependency, y: FlatJSDependency) = (
+        x.commonJSName.isDefined &&
+        y.commonJSName.isDefined &&
+        (x.relPath == y.relPath ^ x.commonJSName == y.commonJSName)
+    )
+
+    val conflicts = for {
+      dep <- flatDeps
+      if flatDeps.exists(hasConflict(dep, _))
+    } yield dep
+
+    if (conflicts.nonEmpty)
+      throw new ConflictingNameException(conflicts.toList)
+  }
+
+  private def checkMinifiedJSConflicts(
+      byRelPath: Map[String, Traversable[FlatJSDependency]]) = {
+
+    @inline
+    def hasConflict(x: FlatJSDependency, y: FlatJSDependency) = (
+        x.relPathMinified.isDefined &&
+        y.relPathMinified.isDefined &&
+        x.relPathMinified != y.relPathMinified
+    )
+
+    val conflicts = for {
+      (_, deps) <- byRelPath
+      x <- deps if deps.exists(y => hasConflict(x, y))
+    } yield x
+
+    if (conflicts.nonEmpty)
+      throw new ConflictingMinifiedJSException(conflicts.toList)
+  }
+
+}