bitcoin-atm

BuildSettings.scala

(4817B)

 import sbt._
 import sbt.Keys._
 
 import com.earldouglas.xsbtwebplugin.WebPlugin.{container, webSettings}
 import com.earldouglas.xsbtwebplugin.PluginKeys._
 import sbtbuildinfo.Plugin._
 import com.typesafe.sbteclipse.plugin.EclipsePlugin.EclipseKeys
 import ohnosequences.sbt.SbtS3Resolver._
 
 object BuildSettings {
   object Ver {
     val lift = "3.0-M1"
     val lift_edition = "3.0"
     val jetty = "9.1.4.v20140401"
   }
 
   // call grunt init - requires npm be installed
   val gruntInit = TaskKey[Int]("grunt-init", "Initialize project for grunt")
   def gruntInitTask = (baseDirectory in Compile) map { dir =>
     Process(Seq("npm", "install"), dir) !
   }
 
   // call grunt default
   val gruntDefault = TaskKey[Int]("grunt-default", "Call the grunt default command")
   def gruntDefaultTask = (baseDirectory in Compile, streams) map { (dir, s) =>
     val code: Int = Process(Seq("grunt", "default"), dir) ! s.log
     s.log.info("grunt-init: "+code.toString)
     if (code != 0) {
       sys.error("grunt-init failed.")
     }
     code
   }
 
   // call grunt build
   val gruntBuild = TaskKey[Int]("grunt-build", "Call the grunt build command")
   def gruntBuildTask = (baseDirectory in Compile) map { dir =>
     Process(Seq("grunt", "build"), dir) !
   }
 
   // call grunt test
   val gruntTest = TaskKey[Int]("grunt-test", "Call the grunt test command")
   def gruntTestTask = (baseDirectory in Compile) map { dir =>
     Process(Seq("grunt", "test"), dir) !
   }
 
   val buildTime = SettingKey[String]("build-time")
 
   val basicSettings = Defaults.defaultSettings ++ Seq(
     name := "chimera",
     version := "0.1-SNAPSHOT",
     organization := "inc.pyc",
     scalaVersion := "2.10.4",
     scalacOptions <<= scalaVersion map { sv: String =>
       if (sv.startsWith("2.10."))
         Seq("-deprecation", "-unchecked", "-feature", "-language:postfixOps", "-language:implicitConversions")
       else
         Seq("-deprecation", "-unchecked")
     },
     resolvers ++= Seq[Resolver](
         "Sonatype Releases" at "http://oss.sonatype.org/content/repositories/releases",
         "Sonatype Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots",
         s3resolver.value("PYC Releases", s3("releases-pyc-inc")),
         s3resolver.value("PYC Snapshots", s3("snapshots-pyc-inc")),
         "clojars.org" at "http://clojars.org/repo"
     )
   )
 
   val gruntSettings = Seq(
     gruntInit <<= gruntInitTask,
     gruntDefault <<= gruntDefaultTask,
     gruntBuild <<= gruntBuildTask,
     gruntTest <<= gruntTestTask
   )
 
   val liftAppSettings = 
     basicSettings ++
     gruntSettings ++
     webSettings ++
     S3Resolver.defaults ++
     buildInfoSettings ++
     seq(
       buildTime := System.currentTimeMillis.toString,
 
       // build-info
       buildInfoKeys ++= Seq[BuildInfoKey](buildTime),
       buildInfoPackage := "inc.pyc.chimera",
       sourceGenerators in Compile <+= buildInfo,
 
       // eclipse
       EclipseKeys.withSource := true,
 
       // dependencies
       //compile in Compile <<= (compile in Compile) dependsOn gruntBuild,
       // (start in container.Configuration) <<= (start in container.Configuration) dependsOn gruntBuild,
       Keys.`package` <<= (Keys.`package` in Compile) dependsOn gruntDefault,
       Keys.`package` <<= (Keys.`package` in Test) dependsOn gruntDefault,
       test in Test <<= (test in Test) dependsOn gruntTest,
 
       // add javascript and css source files to the webapp, for development
       (webappResources in Compile) <+= (target in Compile) { _ / "grunt" / "build" / "css" },
 
       // add grunt generated resources to the classpath
       (unmanagedResourceDirectories in Compile) <+=
         (target in Compile) { _ / "grunt" / "resources" },
 
       // massage the war
       (warPostProcess in Compile) <<= (target in Compile) map { tgt =>
         val webapp = tgt / "webapp"
         val gdist = tgt / "grunt" / "dist"
         () => {
           // remove the frontend sources
           val files = Seq(webapp / "app", webapp / "assets", webapp / "less", webapp / "vendor")
           IO.delete(files)
           // copy the minified assets
           IO.copyDirectory(gdist, webapp)
         }
       },
 
       s3credentials := {
         Path.userHome / ".ivy2" / ".s3credentials"
       },
 
       licenses := Seq("Apache 2.0 License" -> url("http://www.apache.org/licenses/LICENSE-2.0.html")),
       pomExtra := (
         <url>https://bitbucket.org/pyd/chimera</url>
         <scm>
           <url>git@bitbucket.org:pyd/chimera.git</url>
           <connection>scm:git:git@bitbucket.org:pyd/chimera.git</connection>
         </scm>
         <developers>
           <developer>
             <id>jcabrra</id>
             <name>Julio Cabrera</name>
           </developer>
         </developers>
       )
     )
 
   lazy val noPublishing = seq(
     publish := (),
     publishLocal := ()
   )
 }