在两个ScalaJS SBT项目之间使用DependsOn

Question

(很久以前的问题.简化tl;底部是博士).

我有两个使用SBT构建的ScalaJS项目 - "myapp"和"mylib",在以下目录结构中

root/build.sbt

root/myapp/build.sbt
root/myapp/jvm/
root/myapp/js/
root/myapp/shared/

root/mylib/build.sbt
root/mylib/jvm
root/mylib/js
root/mylib/shared

lib导出名为"com.example:mylib:0.1"的工件,该工件用作库依赖项myapp.

myapp和mylib位于不同的存储库中,包含自己的构建文件,并且应该能够完全单独构建(即它们必须包含自己的构建配置).

在生产中,它们将单独构建,mylib首先作为maven工件发布,然后myapp单独构建.

然而,在开发中,我希望能够将它们合并到父SBT项目中,以便两者可以并行开发,而无需publishLocal在每次更改后使用.

在传统(不是scalajs)项目中,这将非常容易

$ROOT/build.sbt:

lazy val mylib = project
lazy val myapp = project.dependsOn(mylib)

然而,在ScalaJS,我们实际上有两个项目每个模块里面- ,,appJVM 和.因此,上述配置仅查找聚合根项目,并且未将配置正确应用于实际的JVM和JS项目.appJSlibJVMlibJSdependsOn

(即myapp和mylib build.sbt每个包含两个项目,以及一个聚合根项目)

理想情况下,我希望能够做类似以下的事情

lazy val mylibJVM = project
lazy val myappJVM = project.dependsOn(mylibJVM)

lazy val mylibJS = project
lazy val myappJS = project.dependsOn(myappJS)

不幸的是,这只是在根目录中创建新项目而不是自己导入子项目.

我也尝试了各种路径组合(例如)

lazy val mylibJVM = project.in(file("mylib/jvm"))

但是这没有看到build.sbt文件中的配置 mylib

最终我继续遇到同样的问题 - 当将现有的多项目SBT项目导入父sbt文件时,它会导入根项目,但似乎没有提供从现有多模块SBT文件导入子项目的方法.一种允许我添加dependsOn配置的方法.

TL;博士

如果我有

• root/mylib/build.sbt 定义了多个项目
• root/myapp/build.sbt 定义了多个项目

是否可以root/build.sbt从子模块导入单个子项目而不是根项目？

即我可以有两层多项目构建.

Answer 1

在花了很多时间挖掘 SBT 源代码之后，我设法找到了一个解决方案。这并不干净，但它有效。（为了获得奖励积分，它可以正确导入 IntelliJ）。

// Add this function to your root build.sbt file. 
// It can be used to define a dependency between any
// `ProjectRef` without needing a full project definition.
def addDep(from:String, to:String) = {
  buildDependencies in Global <<= (
  buildDependencies in Global, 
  thisProjectRef in from, 
  thisProjectRef in to) { 
    (deps, fromref, toref) => 
      deps.addClasspath(fromref, ResolvedClasspathDependency(toref, None))
  }
}

// `project` will import the `build.sbt` file
// in the subdirectory of the same name as the `lazy val`
// (performed by an SBT macro). i.e. `./mylib/build.sbt`
// 
// This won't reference the actual subprojects directly, 
// will but import them into the namespace such that they 
// can be referenced as "ProjectRefs", which are implicitly
// converted to from strings.
// 
// We then aggregate the JVM and JS ScalaJS projects 
// into the new root project we've defined. (Which unfortunately
// won't inherit anything from the child build.sbt)

lazy val mylib = project.aggregate("mylibJVM","mylibJS")
lazy val myapp = project.aggregate("myappJVM","myappJS")

// Define a root project to aggregate everything
lazy val root = project.in(file(".")).aggregate(mylib,myapp)


// We now call our custom function to define a ClassPath dependency
// between `myapp` -> `mylib` for both JVM and JS subprojects.
// In particular, this will correctly find exported artifacts
// so that `myapp` can refer to `mylib` in libraryDependencies
// without needing to use `publishLocal`. 
addDep("myappJVM", "mylibJVM")
addDep("myappJS","mylibJS")