你如何在 sbt 中编写任务？

Question

我正在尝试构建一个自定义任务，以便在我们的持续集成环境中构建我们的项目。这是一组类似的步骤

1. 向聊天室发送构建开始消息
2. 编译模板
3. 运行 npm 测试
4. 运行 jshint
5. 编译
6. 构建应用程序工件
7. 将工件上传到我们的部署服务器
8. 运行测试
9. 将测试结果发送到我们的部署服务器
10. 将构建结果消息发送到聊天室

请注意，如果任何步骤失败，则应执行第 10 步，并且应根据失败的步骤自定义消息，例如如果第 5 步失败，它应该显示“编译失败”，如果第 8 步失败，它应该显示运行了多少测试以及失败了多少。

为了让事情变得更有趣，这是一个多项目构建，因此在运行测试和发布结果时，它应该运行所有测试并发布聚合结果。

为了让事情变得更有趣，npm 测试、jshint 和 artifact 仅在 webapp 子项目中才真正有意义，其中 Javascript 和 Web 服务器所在的位置。

我一直在寻找 sbt-release 以获得灵感，但我对如何获取一项任务产生的价值并在下一项中使用它，如何聚合运行任务并获得产生的价值感到困惑（我在Extracted 中看到了一个运行聚合任务的方法，但它没有给出产生的值），如何在子项目中运行任务并获取产生的值，以及如何进行错误处理。

到目前为止，我已经尝试了两种方法

npmTest.result.value match {                                                                    
  case Inc(inc) =>                                                                              
    println(inc)                                                                                
  case Value(res) => Def.taskDyn {                                                              
    (executeTests in Test).result.value match {                                                 
      case Inc(inc) =>                                                                          
        println(inc)                                                                            
      case Value(res) =>                                                                        
        println(res)                                                                            
    }                                                                                           
  }

上面的问题是executeTests总是运行，即使npmTest失败。并且没有一个printlns 被执行。

npmTest.result.                                                                                    
 flatMap {-                                                                                       
   case Inc(inc) =>                                                                               
     task { println(inc) }                                                                        
   case Value(res) =>-                                                                            
     (executeTests in Test).result.                                                               
       flatMap {                                                                                  
         case Inc(inc) =>                                                                         
           task { println(inc) }                                                                  
         case Value(res) =>                                                                       
           task { println(res) }                                                                  
       }                                                                                          
 }                

这个不能编译，因为(executeTasks in Test)... 产生一个Initialize[Task[Unit]] 值并且Task[Unit] 是必需的。

有没有办法用 sbt 完成这个？

Answer 1

我找到了一个解决方案，可以让您使用旧的 flatMap 和 map 来编写任务。

sealed abstract class Step[A] {
  def run: Def.Initialize[Task[Result[A]]]
  def map[B](f: A => B): Step[B]
  def flatMap[B](f: A => Step[B]): Step[B]
}

object Step {
  val thisProjectRef = settingKey(Keys.thisProjectRef)
  val clean = taskKey(Keys.clean)
  val compile = taskKey(Keys.compile.in(Compile))
  val assembly = taskKey(sbtassembly.AssemblyPlugin.autoImport.assembly)

  private[this] def apply[A](task: Def.Initialize[Task[Result[A]]]): Step[A] =
    new Step[A] {
      val run = task

      def map[B](f: A => B): Step[B] =
        apply[B](Def.taskDyn {
          run.value match {
            case Inc(inc) => Def.task(Inc(inc): Result[B])
            case Value(a) => Def.task(Value(f(a)))
          }
        })

      def flatMap[B](f: A => Step[B]): Step[B] =
        apply[B](Def.taskDyn {
          run.value match {
            case Inc(inc) => Def.task(Inc(inc): Result[B])
            case Value(a) => Def.task(f(a).run.value)
          }
        })
    }

  def task[A](t: Def.Initialize[Task[A]]): Step[A] =
    apply(t.result)

  def taskKey[A](t: TaskKey[A]): Step[A] =
    apply(Def.task(t.result.value))

  def settingKey[A](s: SettingKey[A]): Step[A] =
    apply(Def.task(s.value).result)
}

然后你可以将你的任务定义为

    rainicornPublish <<= {
      val result = 
        for {
          ass <- Step.assembly
          juri <- uploadAssemblyTask(ass)
          to <- runAllTests
          _ <- finish(ass, juri, to)
        } yield (ass, to)

      Def.task(result.run.value match {
        case Inc(inc) => throw new RainicornException(None)
        case Value(v) => v
      })
    }

每个任务都会按顺序发生，正如您所期望的那样。