package cbt
import cbt.paths._
import java.io._
import java.lang.reflect.InvocationTargetException
import java.net._
import java.nio.file.{Path =>_,_}
import java.nio.file.Files.readAllBytes
import java.security.MessageDigest
import java.util.jar._
import scala.collection.immutable.Seq
import scala.reflect.runtime.{universe => ru}
import scala.util._
import ammonite.ops.{cwd => _,_}
abstract class PackageBuild(context: Context) extends Build(context) with ArtifactInfo{
def `package`: Seq[File] = lib.concurrently( enableConcurrency )(
Seq(() => jar, () => docJar, () => srcJar)
)( _() )
private object cacheJarBasicBuild extends Cache[File]
def jar: File = cacheJarBasicBuild{
lib.jar( artifactId, version, compile, jarTarget )
}
private object cacheSrcJarBasicBuild extends Cache[File]
def srcJar: File = cacheSrcJarBasicBuild{
lib.srcJar(sources, artifactId, version, scalaTarget)
}
private object cacheDocBasicBuild extends Cache[File]
def docJar: File = cacheDocBasicBuild{
lib.docJar( sources, dependencyClasspath, apiTarget, jarTarget, artifactId, version, scalacOptions )
}
override def jars = jar +: dependencyJars
override def exportedJars: Seq[File] = Seq(jar)
}
abstract class PublishBuild(context: Context) extends PackageBuild(context){
def name = artifactId
def description: String
def url: URL
def developers: Seq[Developer]
def licenses: Seq[License]
def scmUrl: String
def scmConnection: String
def pomExtra: Seq[scala.xml.Node] = Seq()
// ========== package ==========
/** put additional xml that should go into the POM file in here */
def pom: File = lib.pom(
groupId = groupId,
artifactId = artifactId,
version = version,
name = name,
description = description,
url = url,
developers = developers,
licenses = licenses,
scmUrl = scmUrl,
scmConnection = scmConnection,
dependencies = dependencies,
pomExtra = pomExtra,
jarTarget = jarTarget
)
// ========== publish ==========
final protected def releaseFolder = s"/${groupId.replace(".","/")}/$artifactId/$version/"
def snapshotUrl = new URL("https://oss.sonatype.org/content/repositories/snapshots")
def releaseUrl = new URL("https://oss.sonatype.org/service/local/staging/deploy/maven2")
def publishSnapshot: Unit = lib.publishSnapshot(sourceFiles, pom +: `package`, new URL(snapshotUrl + releaseFolder) )
def publishSigned: Unit = lib.publishSigned(sourceFiles, pom +: `package`, new URL(releaseUrl + releaseFolder) )
}
class BasicBuild(context: Context) extends Build(context)
class Build(val context: Context) extends Dependency with TriggerLoop{
// library available to builds
final val logger = context.logger
override final protected val lib: Lib = new Lib(logger)
// ========== general stuff ==========
def enableConcurrency = false
final def projectDirectory: File = new File(context.cwd)
assert( projectDirectory.exists, "projectDirectory does not exist: "+projectDirectory )
final def usage: Unit = new lib.ReflectBuild(this).usage
/*
def scaffold: Unit = lib.generateBasicBuildFile(
projectDirectory, scalaVersion, groupId, artifactId, version
)
*/
// ========== meta data ==========
def scalaVersion: String = constants.scalaVersion
final def scalaMajorVersion: String = scalaVersion.split("\\.").take(2).mkString(".")
def zincVersion = "0.3.9"
def dependencies: Seq[Dependency] = Seq(
"org.scala-lang" % "scala-library" % scalaVersion
)
// ========== paths ==========
final private val defaultSourceDirectory = new File(projectDirectory+"/src/")
/** base directory where stuff should be generated */
def target = new File(projectDirectory+"/target")
/** base directory where stuff should be generated for this scala version*/
def scalaTarget = new File(target + s"/scala-$scalaMajorVersion")
/** directory where jars (and the pom file) should be put */
def jarTarget = scalaTarget
/** directory where the scaladoc should be put */
def apiTarget = new File(scalaTarget + "/api")
/** directory where the class files should be put (in package directories) */
def compileTarget = new File(scalaTarget + "/classes")
/** Source directories and files. Defaults to .scala and .java files in src/ and top-level. */
def sources: Seq[File] = Seq(defaultSourceDirectory) ++ projectDirectory.listFiles.toVector.filter(sourceFileFilter)
/** Which file endings to consider being source files. */
def sourceFileFilter(file: File): Boolean = file.toString.endsWith(".scala") || file.toString.endsWith(".java")
/** Absolute path names for all individual files found in sources directly or contained in directories. */
final def sourceFiles: Seq[File] = for {
base <- sources.filter(_.exists).map(lib.realpath)
file <- lib.listFilesRecursive(base) if file.isFile && sourceFileFilter(file)
} yield file
protected def assertSourceDirectories(): Unit = {
val nonExisting =
sources
.filterNot( _.exists )
.diff( Seq(defaultSourceDirectory) )
assert(
nonExisting.isEmpty,
"Some sources do not exist: \n"+nonExisting.mkString("\n")
)
}
assertSourceDirectories()
/** SBT-like dependency builder DSL */
class GroupIdAndArtifactId( groupId: String, artifactId: String ){
def %(version: String) = new MavenDependency(groupId, artifactId, version)(lib.logger)
}
implicit class DependencyBuilder(groupId: String){
def %%(artifactId: String) = new GroupIdAndArtifactId( groupId, artifactId+"_"+scalaMajorVersion )
def %(artifactId: String) = new GroupIdAndArtifactId( groupId, artifactId )
}
final def BuildDependency(path: String) = cbt.BuildDependency(
context.copy(
cwd = path,
args = Seq()
)
)
def triggerLoopFiles: Seq[File] = sources ++ transitiveDependencies.collect{ case b: TriggerLoop => b.triggerLoopFiles }.flatten
def localJars : Seq[File] =
Seq(projectDirectory + "/lib/")
.map(new File(_))
.filter(_.exists)
.flatMap(_.listFiles)
.filter(_.toString.endsWith(".jar"))
//def cacheJar = false
override def dependencyClasspath : ClassPath = ClassPath(localJars) ++ super.dependencyClasspath
override def dependencyJars : Seq[File] = localJars ++ super.dependencyJars
def exportedClasspath : ClassPath = ClassPath(Seq(compile))
def exportedJars: Seq[File] = Seq()
// ========== compile, run, test ==========
/** scalac options used for zinc and scaladoc */
def scalacOptions: Seq[String] = Seq( "-feature", "-deprecation", "-unchecked" )
val updated: Boolean = {
val existingClassFiles = lib.listFilesRecursive(compileTarget)
val sourcesChanged = existingClassFiles.nonEmpty && {
val oldestClassFile = existingClassFiles.sortBy(_.lastModified).head
val oldestClassFileAge = oldestClassFile.lastModified
val changedSourceFiles = sourceFiles.filter(_.lastModified > oldestClassFileAge)
if(changedSourceFiles.nonEmpty){
/*
println(changedSourceFiles)
println(changedSourceFiles.map(_.lastModified))
println(changedSourceFiles.map(_.lastModified > oldestClassFileAge))
println(oldestClassFile)
println(oldestClassFileAge)
println("-"*80)
*/
}
changedSourceFiles.nonEmpty
}
sourcesChanged || transitiveDependencies.map(_.updated).fold(false)(_ || _)
}
private object cacheCompileBasicBuild extends Cache[File]
def compile: File = cacheCompileBasicBuild{
//println(transitiveDependencies.filter(_.updated).mkString("\n"))
lib.compile(
updated,
sourceFiles, compileTarget, dependencyClasspath, scalacOptions,
zincVersion = zincVersion, scalaVersion = scalaVersion
)
}
def runClass: String = "Main"
def run: Unit = lib.runMainIfFound( runClass, Seq(), classLoader )
def test: Unit = lib.test(context)
context.logger.composition(">"*80)
context.logger.composition("class "+this.getClass)
context.logger.composition("dir "+context.cwd)
context.logger.composition("sources "+sources.toList.mkString(" "))
context.logger.composition("target "+target)
context.logger.composition("dependencyTree\n"+dependencyTree)
context.logger.composition("<"*80)
// ========== cbt internals ==========
private[cbt] def finalBuild = this
override def show = this.getClass.getSimpleName + "("+context.cwd+")"
}
