Como pode sbt extrair artefatos de dependência do git?

Eu ouvi (e sei que já vi exemplos também, se apenas eu me lembro onde) que sbt pode obter dependencies de um repository git.

Eu estou olhando para obter a dependência harrah / up do github. O repository não fornece arquivos JAR de artefato, apenas uma tree de origem configurada para ser construída usando sbt . O processo que estou imaginando é que o sbt o sbt origem, o construirá e usará isso como o artefato de dependência.

Eu posso estar imaginando que sbt pode de fato fazer algo assim. Pode? E se sim, como?

Sim, de fato. Você pode dar ao seu Project uma dependência com o operador dependsOn , e você pode referenciar um projeto do Github por seu URI, por exemplo, RootProject(uri("git://github.com/dragos/dupcheck.git")) . Como alternativa, você pode git clone o projeto e fazer referência à sua cópia local com RootProject(file(...)) . Veja “Configuração Completa” no wiki do SBT para detalhes e exemplos.

Você pode importar dependencies não empacotadas para o seu projeto do GitHub tratando-as como dependencies do projeto, usando o operador dependsOn . (Isso é diferente da maneira como as dependencies da biblioteca pré-compilada são incluídas).

Observe que você pode especificar qual ramificação usar usando # notação. Aqui está um código do Scala SBT que está funcionando bem para mim:

 object V { val depProject = "master" // Other library versions } object Projects { lazy val depProject = RootProject(uri("git://github.com/me/dep-project.git#%s".format(V.depProject))) } // Library dependencies lazy val myProject = Project("my-project", file(".")) .settings(myProjectSettings: _*) .dependsOn(Projects.depProject) .settings( libraryDependencies ++= Seq(... 

Observe que, se você tiver vários projetos de SBT dependendo do mesmo projeto externo, vale a pena configurar um sbt.boot.directory central para evitar recompilações desnecessárias (consulte as instruções aqui ).

Como tive problemas para resolver as dependencies da minha biblioteca (usando o RootProject sugerido), gostaria de RootProject a RootProject para o object chamado ProjectRef . Assim, se precisarmos depender de uma biblioteca residente no git, sugiro fazer isso da seguinte maneira:

 import sbt.Keys._ import sbt._ object MyBuild extends Build { lazy val root = Project("root", file(".")) .dependsOn(myLibraryinGit) .settings( ..., libraryDependencies ++= Seq(...)) lazy val myLibraryinGit = ProjectRef(uri("git://git@github.com:user/repo.git#branch"), "repo-name") } 

Fonte: http://blog.xebia.com/git-subproject-compile-time-dependencies-in-sbt/

Eu queria adicionar uma resposta para sbt 0.13+. Basta colocar algo assim para o seu build.sbt na pasta raiz do projeto (não Build.scala ):

 lazy val root = (project in file(".")).dependsOn(playJongo) lazy val playJongo = RootProject(uri("https://github.com/bekce/play-jongo.git"))