scalafx-utils/project/Build.scala

import sbt._
import Keys._

import com.typesafe.sbt.site._
import sbtrelease.ReleasePlugin.autoImport._
import com.typesafe.sbt.SbtPgp.autoImport._

import scala.util.Properties.envOrNone
import com.typesafe.sbteclipse.plugin.EclipsePlugin._

import Helpers._

sealed trait Basics {
  final val buildOrganization     = "org.gerweck.scalafx"
  final val buildOrganizationName = "Sarah Gerweck"
  final val buildOrganizationUrl  = Some("https://github.com/sarahgerweck")

  final val buildScalaVersion     = "2.11.8"
  final val extraScalaVersions    = Seq.empty
  final val minimumJavaVersion    = "1.8"
  lazy  val defaultOptimize       = true
  final val projectMainClass      = None

  lazy  val parallelBuild         = false
  lazy  val cachedResolution      = true

  /* Metadata definitions */
  lazy val buildMetadata = Vector(
    licenses    := Seq("Apache License, Version 2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0.txt")),
    homepage    := Some(url("https://github.com/sarahgerweck/scalafx-utils")),
    description := "ScalaFX Utilities",
    startYear   := Some(2015),
    scmInfo     := Some(ScmInfo(url("https://github.com/sarahgerweck/scalafx-utils"), "scm:git:git@github.com:sarahgerweck/scalafx-utils.git"))
  )

  lazy val developerInfo = {
    <developers>
      <developer>
        <id>sarah</id>
        <name>Sarah Gerweck</name>
        <email>sarah.a180@gmail.com</email>
        <url>https://github.com/sarahgerweck</url>
        <timezone>America/Los_Angeles</timezone>
      </developer>
    </developers>
  }
}

object BuildSettings extends Basics {
  /* Overridable flags */
  lazy val optimize     = boolFlag("OPTIMIZE") orElse boolFlag("OPTIMISE") getOrElse defaultOptimize
  lazy val deprecation  = boolFlag("NO_DEPRECATION") map (!_) getOrElse true
  lazy val inlineWarn   = boolFlag("INLINE_WARNINGS") getOrElse false
  lazy val debug        = boolFlag("DEBUGGER") getOrElse false
  lazy val debugPort    = envOrNone("DEBUGGER_PORT") map { _.toInt } getOrElse 5050
  lazy val debugSuspend = boolFlag("DEBUGGER_SUSPEND") getOrElse true
  lazy val unusedWarn   = boolFlag("UNUSED_WARNINGS") getOrElse false
  lazy val importWarn   = boolFlag("IMPORT_WARNINGS") getOrElse false

  lazy val buildScalaVersions = buildScalaVersion +: extraScalaVersions
  val buildScalacOptions = Seq (
    "-unchecked",
    "-feature",
    "-target:jvm-" + minimumJavaVersion
  ) ++ (
    if (deprecation) Seq("-deprecation") else Seq.empty
  ) ++ (
    if (optimize) Seq("-optimize") else Seq.empty
  ) ++ (
    if (inlineWarn) Seq("-Yinline-warnings") else Seq.empty
  ) ++ (
    if (unusedWarn) Seq("-Ywarn-unused") else Seq.empty
  ) ++ (
    if (importWarn) Seq("-Ywarn-unused-import") else Seq.empty
  )

  /* Java build setup */
  val buildJavacOptions = Seq(
    "-target", minimumJavaVersion,
    "-source", minimumJavaVersion
  ) ++ (
    if (deprecation) Seq("-Xlint:deprecation") else Seq.empty
  )

  /** A wrapper so we can call `commonSettings()` on a project. */
  implicit class ProjectSettingsHelper(p: Project) {
    def commonSettings() = siteSettings(p).settings(buildSettings: _*)

    private[this] def siteSettings(p: Project) = p.enablePlugins(SiteScaladocPlugin)

    private[this] val buildSettings = buildMetadata ++
                        projectMainClass.toSeq.map(mainClass := Some(_)) ++
                        Seq (
      organization         :=  buildOrganization,
      organizationName     :=  buildOrganizationName,
      organizationHomepage :=  buildOrganizationUrl map { url _ },

      scalaVersion         :=  buildScalaVersion,
      crossScalaVersions   :=  buildScalaVersions,

      scalacOptions        ++= buildScalacOptions,
      javacOptions         ++= buildJavacOptions,
      autoAPIMappings      :=  true,

      updateOptions        :=  updateOptions.value.withCachedResolution(cachedResolution),
      parallelExecution    :=  parallelBuild,

      evictionWarningOptions in update :=
        EvictionWarningOptions.default.withWarnTransitiveEvictions(false).withWarnDirectEvictions(false).withWarnScalaVersionEviction(false)
    )
  }
}

object Helpers {
  def getProp(name: String): Option[String] = sys.props.get(name) orElse sys.env.get(name)
  def parseBool(str: String): Boolean = Set("yes", "y", "true", "t", "1") contains str.trim.toLowerCase
  def boolFlag(name: String): Option[Boolean] = getProp(name) map { parseBool _ }
  def boolFlag(name: String, default: Boolean): Boolean = boolFlag(name) getOrElse default
  def opts(names: String*): Option[String] = names.view.map(getProp _).foldLeft(None: Option[String]) { _ orElse _ }

  import scala.xml._
  def excludePomDeps(exclude: (String, String) => Boolean): Node => Node = { node: Node =>
    val rewriteRule = new transform.RewriteRule {
      override def transform(n: Node): NodeSeq = {
        if ((n.label == "dependency") && exclude((n \ "groupId").text, (n \ "artifactId").text))
          NodeSeq.Empty
        else
          n
      }
    }
    val transformer = new transform.RuleTransformer(rewriteRule)
    transformer.transform(node)(0)
  }
}

object Resolvers {
  val sonatypeSnaps   = Resolver.sonatypeRepo("snapshots")
  val sonatypeRelease = Resolver.sonatypeRepo("releases")
  val sonatypeStaging = "Sonatype Staging" at "https://oss.sonatype.org/service/local/staging/deploy/maven2"
}

object Publish {
  import BuildSettings._
  import Resolvers._
  import Helpers._

  val sonaCreds = (
    for {
      user <- getProp("SONATYPE_USER")
      pass <- getProp("SONATYPE_PASS")
    } yield {
      credentials +=
          Credentials("Sonatype Nexus Repository Manager",
                      "oss.sonatype.org",
                      user, pass)
    }
  ).toSeq

  val settings = sonaCreds ++ Seq (
    publishMavenStyle       := true,
    pomIncludeRepository    := { _ => false },
    publishArtifact in Test := false,

    publishTo               := {
      if (version.value.trim endsWith "SNAPSHOT")
        Some(sonatypeSnaps)
      else
        Some(sonatypeStaging)
    },

    pomExtra                := developerInfo
  )

  /** Use this if you don't want to publish a certain module.
    * (SBT's release plugin doesn't handle this well.)
    */
  val falseSettings = settings ++ Seq (
    publishArtifact in Compile := false,
    publishArtifact in Test := false,
    publishTo := Some(Resolver.file("phony-repo", file("target/repo")))
  )
}

object Release {
  val settings = Seq (
    releaseCrossBuild := true,
    releasePublishArtifactsAction := PgpKeys.publishSigned.value
  )
}

object Eclipse {
  import com.typesafe.sbteclipse.plugin.EclipsePlugin._

  val settings = Seq (
    EclipseKeys.createSrc            := EclipseCreateSrc.Default + EclipseCreateSrc.Resource,
    EclipseKeys.projectFlavor        := EclipseProjectFlavor.Scala,
    EclipseKeys.executionEnvironment := Some(EclipseExecutionEnvironment.JavaSE18),
    EclipseKeys.withSource           := true,
    EclipseKeys.eclipseOutput        := Some("target/scala-2.11/classes")
  )
}

object Dependencies {
  /* ********************************************************************** */
  /*                                  Akka                                  */
  /* ********************************************************************** */
  final val akkaVersion = "2.4.6"

  val akkaActor  = "com.typesafe.akka" %% "akka-actor"  % akkaVersion
  val akkaAgent  = "com.typesafe.akka" %% "akka-agent"  % akkaVersion
  val akkaStream = "com.typesafe.akka" %% "akka-stream" % akkaVersion

  /* ********************************************************************** */
  /*                          Utility Dependencies                          */
  /* ********************************************************************** */
  final val slf4jVersion       = "1.7.21"
  final val log4sVersion       = "1.3.0"
  final val logbackVersion     = "1.1.7"
  final val commonsVfsVersion  = "2.0"
  final val commonsIoVersion   = "2.4"
  final val spireVersion       = "0.11.0"
  final val groovyVersion      = "2.4.4"
  final val scalaParserVersion = "1.0.4"
  final val scalaXmlVersion    = "1.0.5"
  final val gerweckUtilVersion = "1.7.1"
  final val scalazVersion      = "7.2.3"
  final val shapelessVersion   = "2.3.1"
  final val scallopVersion     = "1.0.1"

  val log4s       = "org.log4s"           %% "log4s"               % log4sVersion
  val slf4j       = "org.slf4j"           %  "slf4j-api"           % slf4jVersion
  val jclBridge   = "org.slf4j"           %  "jcl-over-slf4j"      % slf4jVersion
  val log4jBridge = "org.slf4j"           %  "log4j-over-slf4j"    % slf4jVersion
  val logback     = "ch.qos.logback"      %  "logback-classic"     % logbackVersion
  val spire       = "org.spire-math"      %% "spire"               % spireVersion
  val commonsIo   = "commons-io"          %  "commons-io"          % commonsIoVersion
  val groovy      = "org.codehaus.groovy" %  "groovy-all"          % groovyVersion
  val gerweckUtil = "org.gerweck.scala"   %% "gerweck-utils-java8" % gerweckUtilVersion
  val scalaz      = "org.scalaz"          %% "scalaz-core"         % scalazVersion
  val shapeless   = "com.chuusai"         %% "shapeless"           % shapelessVersion
  val scallop     = "org.rogach"          %% "scallop"             % scallopVersion

  val commonsVfs = {
    val base      = "org.apache.commons"  %  "commons-vfs2"     % commonsVfsVersion
    base.exclude("commons-logging",      "commons-logging")
        .exclude("org.apache.maven.scm", "maven-scm-provider-svnexe")
        .exclude("org.apache.maven.scm", "maven-scm-api")
    base
  }

  /* Use like this: libraryDependencies <++= (scalaBinaryVersion) (scalaParser) */
  def scalaParser(optional: Boolean): String => Seq[ModuleID] = { scalaBinaryVersion: String =>
    optionalize(optional) {
      scalaBinaryVersion match {
        case "2.11" => Seq("org.scala-lang.modules" %% "scala-parser-combinators" % scalaParserVersion % "optional")
        case _      => Seq.empty
      }
    }
  }

  def scalaXml(optional: Boolean)(scalaBinaryVersion: String): String => Seq[ModuleID] = { scalaBinaryVersion: String =>
    optionalize(optional) {
      scalaBinaryVersion match {
        case "2.11" => Seq("org.scala-lang.modules" %% "scala-xml" % scalaXmlVersion % "optional")
        case _      => Seq.empty
      }
    }
  }

  /* ********************************************************************** */
  /*                          Testing Dependencies                          */
  /* ********************************************************************** */
  final val scalaCheckVersion  = "1.12.2"
  final val scalaTestVersion   = "2.2.4"

  val scalaCheck = "org.scalacheck" %% "scalacheck" % scalaCheckVersion
  val scalaTest  = "org.scalatest"  %% "scalatest"  % scalaTestVersion

  /* ********************************************************************** */
  /*                                ScalaFX                                 */
  /* ********************************************************************** */
  final val scalaFxVersion = "8.0.92-R10"

  val scalaFx = "org.scalafx" %% "scalafx" % scalaFxVersion

  /* ********************************************************************** */
  /*                                Helpers                                 */
  /* ********************************************************************** */
  private[this] def optionalize(optional: Boolean)(f: => Seq[ModuleID]): Seq[ModuleID] = {
    if (optional) {
      f map { _ % "optional" }
    } else {
      f
    }
  }

  private[this] def noCL(m: ModuleID) = (
    m exclude("commons-logging", "commons-logging")
      exclude("commons-logging", "commons-logging-api")
  )
}

object UtilsBuild extends Build {
  build =>

  import BuildSettings._
  import Resolvers._
  import Dependencies._
  import Helpers._

  lazy val root = (project in file ("."))
    .commonSettings()
    .settings(Eclipse.settings: _*)
    .settings(Publish.settings: _*)
    .settings(Release.settings: _*)
    .settings(resolvers += sonatypeRelease)
    .settings(
      name := "ScalaFX Utils",

      libraryDependencies ++= Seq (
        log4s,
        slf4j,
        jclBridge   % "runtime,optional",
        log4jBridge % "runtime,optional",
        logback     % "runtime,optional",
        gerweckUtil,
        scalaFx,
        scalaz,
        shapeless
      ),

      /* Akka dependencies */
      libraryDependencies ++= Seq (
        akkaActor   % "optional",
        akkaStream  % "optional",
        akkaAgent   % "optional"
      ),

      unmanagedJars in Compile += Attributed.blank(file(System.getenv("JAVA_HOME") + "/jre/lib/ext/jfxrt.jar"))
    )
}