Skip to main content

Porting sbt plugins!

There are many sbt plugins which are super useful, and we certainly don't want to lose them when using Bleep.

The solution is to port them:

  • sbt plugins are classes
  • sbt settings are lazy vals
  • sbt tasks are defs
  • input parameters are input parameters.

Have a look in the liberated folder in the github repo to see what it looks like, compared to sbt it is incredibly much easier to follow.

Example ported plugin: DynVerPlugin

Look at how easy it is to follow!

package bleep.plugin.dynver

import java.util.Date

class DynVerPlugin(
val baseDirectory: File,
/* The prefix to use when matching the version tag */
val dynverTagPrefix: Option[String] = None,
/* The separator to use between tag and distance, and the hash and dirty timestamp */
val dynverSeparator: String = DynVer.separator,
/* The current date, for dynver purposes */
val dynverCurrentDate: Date = new Date,
/* Whether to append -SNAPSHOT to snapshot versions */
val dynverSonatypeSnapshots: Boolean = false
) {

lazy val tagPrefix = {
val vTagPrefix = dynverVTagPrefix
val tagPrefix = dynverTagPrefix.getOrElse(if (vTagPrefix) "v" else "")
assert(vTagPrefix ^ tagPrefix != "v", s"Incoherence: dynverTagPrefix=$tagPrefix vs dynverVTagPrefix=$vTagPrefix")

/* The dynver instance for this build */
lazy val dynverInstance: DynVer =
DynVer(Some(baseDirectory), dynverSeparator, tagPrefix)

/* Whether or not tags have a 'v' prefix */
lazy val dynverVTagPrefix: Boolean =
dynverTagPrefix.getOrElse(DynVer.tagPrefix) == "v"

/* The output from git describe */
lazy val dynverGitDescribeOutput: Option[GitDescribeOutput] =

/* The last stable tag */
lazy val dynverGitPreviousStableVersion: Option[GitDescribeOutput] =

lazy val isSnapshot: Boolean =

/* The version string identifies a specific point in version control, so artifacts built from this version can be safely cached */
lazy val isVersionStable: Boolean =
/* The last stable version as seen from the current commit (does not include the current commit's version/tag) */
lazy val previousStableVersion: Option[String] =

def getVersion(date: Date, out: Option[GitDescribeOutput]): String =
out.getVersion(date, dynverSeparator, dynverSonatypeSnapshots)

// The version of your project, from git
lazy val dynver: String =
getVersion(new Date, dynverInstance.getGitDescribeOutput(new Date))

lazy val version: String =
getVersion(dynverCurrentDate, dynverGitDescribeOutput)

// Asserts if the version derives from git tags
def dynverAssertTagVersion(): Unit =

// Checks if version and dynver match
def dynverCheckVersion: Boolean =
dynver == version

// Asserts if version and dynver match
def dynverAssertVersion(): Unit = {
val v = version
val dv = dynver
if (!dynverCheckVersion)
sys.error(s"Version and dynver mismatch - version: $v, dynver: $dv")



Bleep do not have scopes, instead for instance the test scope is represented as normal projects. If you're porting an sbt plugin which makes heavy use of scopes, some more refactoring may be needed.

Global namespace

Some sbt plugins mutate the global state, and this is how values are passed between plugins and sbt. In Bleep these values must be passed as parameters

Probably more



After porting, these plugins can be (cross-) published to maven central just like any other library.