Add trickleCheckVersion to confirm a dependency was updated

README.md

@@ -20,6 +20,13 @@ trickleCreatePullRequests  // Creates pull requests to bump versions
 Def.sequential(trickleUpdateSelf, trickleCreatePullRequests).value
 ```
 
+Pull request creation can use the following input task to make sure the dependencies
+were properly updated. If any differing revision is found, it will fail.
+
+```sbt-console
+trickleCheckVersion org:name:revision {...}
+```
+
 The following tasks/commands are provided for sbt console usage:
 
 ```sbt-console

build.sbt

@@ -17,8 +17,7 @@
 name := "sbt-trickle"
 
 // TODO: work on a command/alias that makes release work for me
-ThisBuild / version := "0.2.2"
-ThisBuild / baseVersion := "0.2.2"
+ThisBuild / baseVersion := "0.2"
 ThisBuild / organization := "com.dcsobral"
 ThisBuild / publishGithubUser := "dcsobral"
 ThisBuild / publishFullName := "Daniel Sobral"

src/main/scala/sbttrickle/TrickleKeys.scala

@@ -27,14 +27,15 @@ trait TrickleKeys {
   // Self
   val trickleRepositoryName = settingKey[String]("Repository name to be used when storing metadata")
   val trickleRepositoryURI = settingKey[String]("This repository locator")
-  val trickleSelfMetadata = taskKey[RepositoryMetadata]("Project dependency metadata")
+  val trickleSelfMetadata = settingKey[RepositoryMetadata]("Project dependency metadata")
 
   // Auto bump
   val trickleCreatePullRequest = settingKey[OutdatedRepository => Unit]("Function to create a pull request for one repository")
   val trickleCreatePullRequests = taskKey[Unit]("Create autobump pull requests on repositories without them")
   val trickleIsAutobumpPullRequestOpen = settingKey[OutdatedRepository => Boolean]("Predicate for trickle-created PRs")
   val trickleOutdatedRepositories = taskKey[Seq[OutdatedRepository]]("Outdated repositories and the dependencies that need updating")
   val trickleUpdatableRepositories = taskKey[Seq[OutdatedRepository]]("Outdated repositories that can be bumped")
+  val trickleCheckVersion = inputKey[Unit]("Verifies that a dependency has the expected version")
 
   // Database
   val trickleDbURI = settingKey[String]("Metadata database locator")

src/main/scala/sbttrickle/TricklePlugin.scala

@@ -21,6 +21,7 @@ import github4s.domain.PullRequest
 import sbt._
 import sbt.Def.Initialize
 import sbt.Keys._
+import sbt.complete.{DefaultParsers, FixedSetExamples, Parser}
 import sbt.plugins.JvmPlugin
 
 import sbttrickle.git._
@@ -72,6 +73,7 @@ object TricklePlugin extends AutoPlugin {
     trickleOutdatedRepositories := Autobump.getOutdatedRepositories(trickleFetchDb.value, streams.value.log),
     trickleUpdatableRepositories / aggregate := false,
     trickleUpdatableRepositories := trickleUpdatableRepositoriesTask.value,
+    trickleCheckVersion := trickleCheckVersionTask.evaluated,  // default aggregate value
 
     // Database
     trickleBuildTopology / aggregate := false,
@@ -107,6 +109,29 @@ object TricklePlugin extends AutoPlugin {
 
   } tag (Tags.Update, Tags.Network)
 
+  lazy val trickleCheckVersionTask: Initialize[InputTask[Unit]] = Def.inputTask {
+    val log = streams.value.log
+    val prj = moduleName.value
+    val modules = checkVersionParser.parsed
+    val lib = libraryDependencies.value
+    val missing = modules.filter {
+      case (org, name, rev) => lib.exists(m => m.organization == org && m.name == name && m.revision != rev)
+    }
+    if (missing.nonEmpty) {
+      missing.foreach {
+        case (org, name, rev) =>
+          val existing = lib.filter(m => m.organization == org && m.name == name).map(_.revision).distinct
+          log.error(s"$prj / trickleCheckVersion")
+          if (existing.isEmpty) {
+            log.error(s"$prj $org:$name:* not found")
+          } else {
+            log.error(s"$org:$name:$rev not found; in use: ${existing.mkString(" ")}")
+          }
+      }
+      sys.error("Dependency check error")
+    }
+  }
+
   lazy val trickleGitDbRepositoryTask: Initialize[Task[File]] = Def.task {
     GitDb.getRepository(trickleCache.value, trickleGitBranch.value, trickleGitConfig.value, streams.value.log)
   } tag Tags.Network
@@ -122,7 +147,7 @@ object TricklePlugin extends AutoPlugin {
     GitDb.updateSelf(repositoryMetadata, repository, sv, commitMessage, config, log)
   } tag Tags.Network
 
-  lazy val trickleSelfMetadataTask: Initialize[Task[RepositoryMetadata]] = Def.task {
+  lazy val trickleSelfMetadataTask: Initialize[RepositoryMetadata] = Def.setting {
     val name = trickleRepositoryName.value
     val thisRepositoryUrl = trickleRepositoryURI.value
     val projectMetadata = projectWithDependencies
@@ -170,4 +195,21 @@ object TricklePlugin extends AutoPlugin {
       .map(url => Project.normalizeModuleID(url.getPath.substring(1)))
       .getOrElse(baseDirectory.value.name)
   }
+
+  lazy val checkVersionParser: Initialize[Parser[Seq[(String, String, String)]]] = Def.setting {
+    import DefaultParsers._
+    val lib = libraryDependencies.value.map(m => ModuleID(m.organization, m.name, m.revision)).distinct
+
+    def select1(items: Iterable[String]): Parser[String] = token(StringBasic.examples(FixedSetExamples(items)))
+    def sep: Parser[Any] = OptSpace ~ '%' ~ OptSpace | ':'
+    def moduleParser: Parser[(String, String, String)] = for {
+      org <- select1(lib.map(_.organization))
+      lib1 = lib.filter(_.organization == org)
+      name <- sep ~> select1(lib1.map(_.name))
+      lib2 = lib1.filter(_.name == name)
+      revision <- sep ~> select1(lib2.map(_.revision))
+    } yield (org, name, revision)
+
+    (Space ~> moduleParser).+
+  }
 }