Jenkins 如何管理SBT中的可变子项目位置？

我尝试将SBT用于一个主项目A和一个子项目B。A依赖于B

我很难找到如何使用SBT文档来完成它。无论如何，我以以下A/project/B.scala文件结束：

object B extends Build {

  lazy val root = Project(id = "a", base = file(".")) dependsOn (b)

  lazy val b = RootProject(file("../b"))
}

（我不确定这里使用的

Project

和

RootProject

是否正确，但它基本上都是从命令行和Eclipse编译的。）

只要项目A位于~/workspace/A，项目B位于~/workspace/B，它就可以在我的开发工作站上正常工作

但是，在我的持续集成服务器Jenkins上，情况并非如此，其中A的源文件位于~/jobs/A/workspace中，B的源文件位于~/jobs/B/workspace中

我最近从Maven切换到了SBT，它曾经与Maven一起工作（我不记得我是如何做到这一点的，但我相信我实际上可以引用Maven本地存储库中的一个源目录）

也许更多的上下文会有所帮助：B是a使用的文件格式的解析器，可能还有其他使用相同文件格式标准的项目

---

如何管理这种情况？

我认为您的构建配置混合了一些不同的概念。在sbt中，包含子项目的项目表示为文件系统中的唯一容器。我通常是这样写的：

object RootBuild extends Build {

  lazy val root = Project(id = "root", base = file(".")) aggregates(a, b)

  lazy val a = Project(id = "a", base = file("./a"))
  lazy val b = Project(id = "b", base = file("./b")) dependsOn(a)
}

在编译根目录时，聚合指示sbt同时编译a和b。当您在此配置中运行sbt时，您可以如下切换项目

$ sbt
> project a

切换项目后，所有命令都将针对该项目运行。否则，您可以为特定项目运行命令（例如编译），而无需按以下方式切换：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

甚至不进入sbt外壳，如下所示：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

在我看来，如果你想要一个没有公共项目容器的文件夹结构，你并不真的想使用子项目，而是想让你的一个项目引用另一个作为依赖项。在这种情况下，假设您在git存储库中有依赖项项目，您可能希望执行以下操作：

object A extends Build {
  lazy val dep = RootProject(uri("git://somerepo.com/B.git"))
  lazy val a = Project(id = "a", base = file("./")) dependsOn(dep)
}

在这种情况下，您可以将A和B作为简单的项目进行管理，这些项目具有自己的构建和依赖关系，并且在构建A项目时，您可以依靠sbt来获取和构建B项目

---

我确信这对git和github是有效的，可能sbt还支持其他类型的SCM，甚至是归档，请查看sbt文档以了解更多信息。

我认为您的构建配置混合了一些不同的概念。在sbt中，包含子项目的项目表示为文件系统中的唯一容器。我通常是这样写的：

object RootBuild extends Build {

  lazy val root = Project(id = "root", base = file(".")) aggregates(a, b)

  lazy val a = Project(id = "a", base = file("./a"))
  lazy val b = Project(id = "b", base = file("./b")) dependsOn(a)
}

在编译根目录时，聚合指示sbt同时编译a和b。当您在此配置中运行sbt时，您可以如下切换项目

$ sbt
> project a

切换项目后，所有命令都将针对该项目运行。否则，您可以为特定项目运行命令（例如编译），而无需按以下方式切换：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

甚至不进入sbt外壳，如下所示：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

在我看来，如果你想要一个没有公共项目容器的文件夹结构，你并不真的想使用子项目，而是想让你的一个项目引用另一个作为依赖项。在这种情况下，假设您在git存储库中有依赖项项目，您可能希望执行以下操作：

object A extends Build {
  lazy val dep = RootProject(uri("git://somerepo.com/B.git"))
  lazy val a = Project(id = "a", base = file("./")) dependsOn(dep)
}

在这种情况下，您可以将A和B作为简单的项目进行管理，这些项目具有自己的构建和依赖关系，并且在构建A项目时，您可以依靠sbt来获取和构建B项目

---

我确信这对git和github是有效的，可能sbt还支持其他类型的SCM，甚至是归档，请查看sbt文档以了解更多信息。

我认为您的构建配置混合了一些不同的概念。在sbt中，包含子项目的项目表示为文件系统中的唯一容器。我通常是这样写的：

object RootBuild extends Build {

  lazy val root = Project(id = "root", base = file(".")) aggregates(a, b)

  lazy val a = Project(id = "a", base = file("./a"))
  lazy val b = Project(id = "b", base = file("./b")) dependsOn(a)
}

在编译根目录时，聚合指示sbt同时编译a和b。当您在此配置中运行sbt时，您可以如下切换项目

$ sbt
> project a

切换项目后，所有命令都将针对该项目运行。否则，您可以为特定项目运行命令（例如编译），而无需按以下方式切换：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

甚至不进入sbt外壳，如下所示：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

在我看来，如果你想要一个没有公共项目容器的文件夹结构，你并不真的想使用子项目，而是想让你的一个项目引用另一个作为依赖项。在这种情况下，假设您在git存储库中有依赖项项目，您可能希望执行以下操作：

object A extends Build {
  lazy val dep = RootProject(uri("git://somerepo.com/B.git"))
  lazy val a = Project(id = "a", base = file("./")) dependsOn(dep)
}

在这种情况下，您可以将A和B作为简单的项目进行管理，这些项目具有自己的构建和依赖关系，并且在构建A项目时，您可以依靠sbt来获取和构建B项目

---

我确信这对git和github是有效的，可能sbt还支持其他类型的SCM，甚至是归档，请查看sbt文档以了解更多信息。

我认为您的构建配置混合了一些不同的概念。在sbt中，包含子项目的项目表示为文件系统中的唯一容器。我通常是这样写的：

object RootBuild extends Build {

  lazy val root = Project(id = "root", base = file(".")) aggregates(a, b)

  lazy val a = Project(id = "a", base = file("./a"))
  lazy val b = Project(id = "b", base = file("./b")) dependsOn(a)
}

在编译根目录时，聚合指示sbt同时编译a和b。当您在此配置中运行sbt时，您可以如下切换项目

$ sbt
> project a

切换项目后，所有命令都将针对该项目运行。否则，您可以为特定项目运行命令（例如编译），而无需按以下方式切换：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

甚至不进入sbt外壳，如下所示：

$ sbt
> a/compile

$ sbt 'a/compile'

scalaVersion := "2.10.4-RC1"

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

sbt.version=0.13.1

在我看来，如果你想有一个没有公共项目容器的文件夹结构，你并不真的想使用子项目，而是需要