com.carrotgarden.maven.scalor.base.Build.scala Maven / Gradle / Ivy

Go to download
package com.carrotgarden.maven.scalor.base

import org.apache.maven.plugins.annotations._
import org.apache.maven.model.Resource

import java.io.File
import java.net.JarURLConnection
import java.nio.file.Paths
import java.nio.file.Files
import java.nio.file.FileVisitOption
import java.nio.file.Path

import java.util.stream.Collectors
import java.util.Arrays
import java.util.regex.Pattern
import java.util.HashSet
import java.util.List
import java.util.ArrayList

import com.carrotgarden.maven.scalor._
import com.carrotgarden.maven.tools.Description

import com.carrotgarden.maven.scalor.A._
//import com.github.dwickern.macros.NameOf._

import meta.Macro._
import util.Error._
import util.Folder._

/**
 * Build resource definitions for any scope.
 */
trait Build extends AnyRef
  with BuildAnyDependency
  with BuildAnySources
  with BuildAnyTarget {
}

/**
 * Required build dependencies.
 */
trait BuildAnyDependency {

  /**
   * Required class dependency folders.
   */
  def buildDependencyFolders : Array[ File ]

  /**
   * Required artifact dependency scopes.
   */
  def buildDependencyScopes : Scope.Bucket

}

/**
 * Root source folder list.
 */
trait BuildAnySources {

  /**
   * Root resource folder list.
   */
  def buildResourceFolders : Array[ Resource ]

  /**
   * Root source folder list.
   */
  def buildSourceFolders : Array[ File ]

}

/**
 * Build results directory.
 */
trait BuildAnyTarget {

  /**
   * Compile target directory.
   */
  def buildTargetFolder : File

}

/**
 * Regular expression to select sources.
 */
trait BuildAnyRegex {

  import com.carrotgarden.maven.scalor.util.Folder
  import BuildAnyRegex._

  /**
   * Regular expression to include Java sources.
   */
  def buildRegexJavaInclude : String

  /**
   * Regular expression to exclude Java sources.
   */
  def buildRegexJavaExclude : String

  /**
   * Regular expression to include Scala sources.
   */
  def buildRegexScalaInclude : String

  /**
   * Regular expression to exclude Scala sources.
   */
  def buildRegexScalaExclude : String

  def buildSourceList( buildSourceFolders : Array[ File ] ) : Array[ File ] = {
    val include = Option( regexOR( buildRegexJavaInclude, buildRegexScalaInclude ) )
    val exclude = Option( regexOR( buildRegexJavaExclude, buildRegexScalaExclude ) )
    Folder.fileListByRegex( buildSourceFolders, include, exclude )
  }

  def buildSourceJavaList( buildSourceFolders : Array[ File ] ) : Array[ File ] = {
    val include = Option( buildRegexJavaInclude )
    val exclude = Option( buildRegexJavaExclude )
    Folder.fileListByRegex( buildSourceFolders, include, exclude )
  }

  def buildSourceScalaList( buildSourceFolders : Array[ File ] ) : Array[ File ] = {
    val include = Option( buildRegexScalaInclude )
    val exclude = Option( buildRegexScalaExclude )
    Folder.fileListByRegex( buildSourceFolders, include, exclude )
  }

}

object BuildAnyRegex {

  def regexOR( one : String, two : String ) = {
    if ( one == null && two == null ) null
    else if ( one != null && two == null ) one
    else if ( one == null && two != null ) two
    else s"${one}|${two}"
  }

}

/**
 * Build definition for compilation scope=macro.
 */
trait BuildMacro extends Build
  with BuildMacroDependency
  with BuildMacroSources
  with BuildMainTarget

object BuildMacro extends BuildMacro {
  // Ensure variables have default values.
}

trait BuildMacroDependency extends BuildAnyDependency {

  @Description( """
  Project folders containing build classes
  which are dependency for compilation scope=macro.
  Normally is empty.
  """ )
  @Parameter(
    property     = "scalor.buildMacroDependencyFolders",
    defaultValue = "" // empty
  )
  var buildMacroDependencyFolders : Array[ File ] = Array.empty

  @Description( """
  Maven dependency scopes which control selection
  of project dependency artifacts to be included
  in the classpath of compilation scope=macro.
  Scopes reference.
  """ )
  @Parameter(
    property     = "scalor.buildMacroDependencyScopes",
    defaultValue = "compile,provided,system"
  )
  var buildMacroDependencyScopes : Array[ String ] = Array.empty

  override def buildDependencyFolders = buildMacroDependencyFolders
  override def buildDependencyScopes = buildMacroDependencyScopes

}

trait BuildMacroSources extends BuildAnySources {

  @Description( """
  Java source root folders to be included in compilation scope=macro.
  Normally uses src/macro/java.
  """ )
  @Parameter(
    property     = "scalor.buildMacroSourceJavaFolders",
    defaultValue = "${project.build.sourceDirectory}/../../macro/java"
  )
  var buildMacroSourceJavaFolders : Array[ File ] = Array.empty

  @Description( """
  Scala source root folders to be included in compilation scope=macro.
  Normally uses src/macro/scala.
  """ )
  @Parameter(
    property     = "scalor.buildMacroSourceScalaFolders",
    defaultValue = "${project.build.sourceDirectory}/../../macro/scala"
  )
  var buildMacroSourceScalaFolders : Array[ File ] = Array.empty

  @Description( """
  Resource root folders to be included in compilation scope=macro.
  There are no macro resource folders by default.
  Component reference: 

  Resource
.
  Example entry in pom.xml:
<buildMacroResourceFolders>
  <resource>
    <directory>${project.basedir}/src/macro/resources</directory>
  </resource>  
</buildMacroResourceFolders>

  """ )
  @Parameter(
    property     = "scalor.buildMacroResourceFolders",
    defaultValue = ""
  )
  var buildMacroResourceFolders : Array[ Resource ] = Array.empty

  override def buildSourceFolders = buildMacroSourceJavaFolders ++ buildMacroSourceScalaFolders
  override def buildResourceFolders = buildMacroResourceFolders

}

/**
 * Build definition for compilation scope=main.
 */
trait BuildMain extends Build
  with BuildMainDependency
  with BuildMainSources
  with BuildMainTarget

object BuildMain extends BuildMain {
  // Ensure variables have default values.
}

trait BuildMainDependency extends BuildAnyDependency {

  @Description( """
  Project folders containing build classes
  which are dependency for compilation scope=main.
  Normally includes folder scope=[macro,main] (target/classes).
  """ )
  @Parameter(
    property     = "scalor.buildMainDependencyFolders",
    defaultValue = "${project.build.outputDirectory}"
  )
  var buildMainDependencyFolders : Array[ File ] = Array.empty

  @Description( """
  Maven dependency scopes which control selection
  of project dependency artifacts to be included
  in the classpath of compilation scope=main.
  Scopes reference.
  """ )
  @Parameter(
    property     = "scalor.buildMainDependencyScopes",
    defaultValue = "compile,provided,system"
  )
  var buildMainDependencyScopes : Array[ String ] = Array.empty

  override def buildDependencyFolders = buildMainDependencyFolders
  override def buildDependencyScopes = buildMainDependencyScopes

}

trait BuildMainSources extends BuildAnySources {

  @Description( """
  Java source root folders to be included in compilation scope=main.
  Absolute path.
  Normally uses src/main/java.
  Example custom entry in pom.xml:
<buildMainSourceJavaFolders>
  <source>${project.build.sourceDirectory}</source>
  <source>${project.basedir}/target/generated/main/java</source>
</buildMainSourceJavaFolders>

  """ )
  @Parameter(
    property     = "scalor.buildMainSourceJavaFolders",
    defaultValue = "${project.build.sourceDirectory}"
  )
  var buildMainSourceJavaFolders : Array[ File ] = Array.empty

  @Description( """
  Scala source root folders to be included in compilation scope=main.
  Absolute path.
  Normally uses src/main/scala.
  Example custom entry in pom.xml:
<buildMainSourceScalaFolders>
  <source>${project.build.sourceDirectory}/../scala</source>
  <source>${project.basedir}/target/generated/main/scala</source>
</buildMainSourceScalaFolders>

  """ )
  @Parameter(
    property     = "scalor.buildMainSourceScalaFolders",
    defaultValue = "${project.build.sourceDirectory}/../scala"
  )
  var buildMainSourceScalaFolders : Array[ File ] = Array.empty

  @Description( """
  Resource root folders to be included in compilation scope=main.
  Normally uses src/main/resources.
  Absolute path.
  Component reference: 

  Resource
.
  Example custom entry in pom.xml:
<buildMainResourceFolders>
  <resource>
    <directory>${project.basedir}/src/main/resources</directory>
  </resource>  
  <resource>
    <directory>${project.basedir}/target/generated/main/resources</directory>
  </resource>  
</buildMainResourceFolders>

  """ )
  @Parameter(
    property     = "scalor.buildMainResourceFolders",
    defaultValue = "${project.build.resources}"
  )
  var buildMainResourceFolders : Array[ Resource ] = Array.empty

  override def buildSourceFolders = buildMainSourceJavaFolders ++ buildMainSourceScalaFolders
  override def buildResourceFolders = buildMainResourceFolders

}

trait BuildMainTarget extends BuildAnyTarget {

  @Description( """
  Build target folder with result classes of compilation scope=[macro,main].
  Normally uses target/classes.
  """ )
  @Parameter(
    property     = "scalor.buildMainTargetFolder",
    defaultValue = "${project.build.outputDirectory}"
  )
  var buildMainTargetFolder : File = _

  override def buildTargetFolder = buildMainTargetFolder

}

/**
 * Build definition for compilation scope=test.
 */
trait BuildTest extends Build
  with BuildTestDependency
  with BuildTestSources
  with BuildTestTarget

object BuildTest extends BuildTest {
  // Ensure variables have default values.
}

trait BuildTestDependency extends BuildAnyDependency {

  @Description( """
  Project folders containing build classes
  which are dependency for compilation scope=test.
  Normally includes folder scope=[macro,main,test] (target/classes, target/test-classes).
  """ )
  @Parameter(
    property     = "scalor.buildTestDependencyFolders",
    defaultValue = "${project.build.outputDirectory},${project.build.testOutputDirectory}"
  )
  var buildTestDependencyFolders : Array[ File ] = Array.empty

  @Description( """
  Maven dependency scopes which control selection
  of project dependency artifacts to be included
  in the classpath of compilation scope=test.
  Scopes reference.
  """ )
  @Parameter(
    property     = "scalor.buildTestDependencyScopes",
    defaultValue = "compile,provided,system,test,runtime"
  )
  var buildTestDependencyScopes : Array[ String ] = Array.empty

  override def buildDependencyFolders = buildTestDependencyFolders
  override def buildDependencyScopes = buildTestDependencyScopes

}

trait BuildTestSources extends BuildAnySources {

  @Description( """
  Java source root folders to be included in compilation scope=test.
  Absolute path.
  Normally uses src/test/java.
  Example custom entry in pom.xml:
<buildTestSourceJavaFolders>
  <source>${project.build.testSourceDirectory}</source>
  <source>${project.basedir}/target/generated/test/java</source>
</buildTestSourceJavaFolders>

  """ )
  @Parameter(
    property     = "scalor.buildTestSourceJavaFolders",
    defaultValue = "${project.build.testSourceDirectory}"
  )
  var buildTestSourceJavaFolders : Array[ File ] = Array.empty

  @Description( """
  Scala source root folders to be included in compilation scope=test.
  Absolute path.
  Normally uses src/test/scala.
  Example custom entry in pom.xml:
<buildTestSourceScalaFolders>
  <source>${project.build.testSourceDirectory}/../scala</source>
  <source>${project.basedir}/target/generated/test/scala</source>
</buildTestSourceScalaFolders>

  """ )
  @Parameter(
    property     = "scalor.buildTestSourceScalaFolders",
    defaultValue = "${project.build.testSourceDirectory}/../scala"
  )
  var buildTestSourceScalaFolders : Array[ File ] = Array.empty

  @Description( """
  Resource root folders to be included in compilation scope=test.
  Absolute path.
  Normally uses src/test/resources.
  Component reference: 

  Resource
.
  Example custom entry in pom.xml:
<buildTestResourceFolders>
  <resource>
    <directory>${project.basedir}/src/test/resources</directory>
  </resource>  
  <resource>
    <directory>${project.basedir}/target/generated/test/resources</directory>
  </resource>  
</buildTestResourceFolders>

  """ )
  @Parameter(
    property     = "scalor.buildTestResourceFolders",
    defaultValue = "${project.build.testResources}"
  )
  var buildTestResourceFolders : Array[ Resource ] = Array.empty

  override def buildSourceFolders = buildTestSourceJavaFolders ++ buildTestSourceScalaFolders
  override def buildResourceFolders = buildTestResourceFolders

}

trait BuildTestTarget extends BuildAnyTarget {

  @Description( """
  Build target folder with result classes of compilation scope=test.
  Normally uses target/test-classes.
  """ )
  @Parameter(
    property     = "scalor.buildTestTargetFolder",
    defaultValue = "${project.build.testOutputDirectory}"
  )
  var buildTestTargetFolder : File = _

  override def buildTargetFolder = buildTestTargetFolder

}

trait BuildEnsure {

  @Description( """
  Create build source root and target root folders when missing.
  """ )
  @Parameter(
    property     = "scalor.buildEnsureFolders",
    defaultValue = "true"
  )
  var buildEnsureFolders : Boolean = _

}

object Build {

  /**
   * Build constants.
   */
  object Param {

    /**
     * Define plugin scope names. Mapped to attrib.scope
     */
    object scope {
      val `macro` = "macro"
      val `main` = "main"
      val `test` = "test"
    }

    /**
     * Define class path entry attributes used in ".classpath".
     */
    object attrib {
      /**
       * Name of custom compilation scope attribute for Eclipse class path entry.
       */
      val scope = "scalor.scope"
      /**
       * Eclipse "optional" class path entry does not complain when folder is missing.
       */
      val optional = "optional"
      /**
       * Eclipse "test" class path entry is assigned to m2e dependency scope=test.
       */
      val test = "test"
    }

  }

}