Centralized versions in main Gradle build file.

Grade build

.gitignore

@@ -1,15 +1,15 @@
 .gradle
 annotations
 .idea/*
-!.idea/modules.xml
-!.idea/libraries
-!.idea/misc.xml
-buildScript
+*.iml
+nonBuildScript
 kobaltBuild
 local.properties
 classes
 libs
 .kobalt/
-./build/
 out
 .DS_Store
+lib/kotlin-*
+build
+.history

.idea/libraries/KotlinJavaRuntime.xml

@@ -1,12 +0,0 @@
-<component name="libraryTable">
-  <library name="KotlinJavaRuntime">
-    <CLASSES>
-      <root url="jar://$PROJECT_DIR$/lib/kotlin-runtime.jar!/" />
-      <root url="jar://$PROJECT_DIR$/lib/kotlin-reflect.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES>
-      <root url="jar://$PROJECT_DIR$/lib/kotlin-runtime-sources.jar!/" />
-    </SOURCES>
-  </library>
-</component>

.idea/libraries/kobalt__Compile_.xml

@@ -1,22 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt (Compile)">
-    <CLASSES>
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/codehaus/plexus/plexus-utils/3.0.22/plexus-utils-3.0.22.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/aopalliance/aopalliance/1.0/aopalliance-1.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/inject/extensions/guice-assistedinject/4.0/guice-assistedinject-4.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/beust/jcommander/1.48/jcommander-1.48.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/squareup/okhttp3/okhttp/3.2.0/okhttp-3.2.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/squareup/okio/okio/1.6.0/okio-1.6.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/javax/inject/javax.inject/1/javax.inject-1.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/apache/maven/maven-model/3.3.3/maven-model-3.3.3.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/code/findbugs/jsr305/3.0.1/jsr305-3.0.1.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/github/spullara/mustache/java/compiler/0.9.1/compiler-0.9.1.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.0.0/kotlin-compiler-embeddable-1.0.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/code/gson/gson/2.6.2/gson-2.6.2.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/guava/guava/20.0-SNAPSHOT/guava-20.0-SNAPSHOT.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/inject/guice/4.0/guice-4.0.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/kobalt__Test_.xml

@@ -1,11 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt (Test)">
-    <CLASSES>
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/beust/jcommander/1.48/jcommander-1.48.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/beanshell/bsh/2.0b4/bsh-2.0b4.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/testng/testng/6.9.11-SNAPSHOT/testng-6.9.11-SNAPSHOT.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/kobalt_jar.xml

@@ -1,9 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt.jar">
-    <CLASSES>
-      <root url="jar://$USER_HOME$/.kobalt/wrapper/dist/kobalt-0.682/kobalt/wrapper/kobalt-0.682.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/kobalt_plugin_api__Compile_.xml

@@ -1,23 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt-plugin-api (Compile)">
-    <CLASSES>
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/codehaus/plexus/plexus-utils/3.0.22/plexus-utils-3.0.22.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/aopalliance/aopalliance/1.0/aopalliance-1.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/jetbrains/kotlinx/kotlinx.dom/0.0.9/kotlinx.dom-0.0.9.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/inject/extensions/guice-assistedinject/4.0/guice-assistedinject-4.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/squareup/retrofit2/retrofit/2.0.0/retrofit-2.0.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/beust/jcommander/1.48/jcommander-1.48.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/squareup/okio/okio/1.6.0/okio-1.6.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/squareup/okhttp3/okhttp/3.2.0/okhttp-3.2.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/javax/inject/javax.inject/1/javax.inject-1.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/org/apache/maven/maven-model/3.3.3/maven-model-3.3.3.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/io/reactivex/rxjava/1.0.16/rxjava-1.0.16.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/code/gson/gson/2.6.2/gson-2.6.2.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/squareup/retrofit2/converter-gson/2.0.0/converter-gson-2.0.0.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/guava/guava/20.0-SNAPSHOT/guava-20.0-SNAPSHOT.jar!/" />
-      <root url="jar://$USER_HOME$/.kobalt/repository/com/google/inject/guice/4.0/guice-4.0.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/kobalt_plugin_api__Test_.xml

@@ -1,7 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt-plugin-api (Test)">
-    <CLASSES />
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/kobalt_wrapper__Compile_.xml

@@ -1,7 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt-wrapper (Compile)">
-    <CLASSES />
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/kobalt_wrapper__Test_.xml

@@ -1,7 +0,0 @@
-<component name="libraryTable">
-  <library name="kobalt-wrapper (Test)">
-    <CLASSES />
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/misc.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EntryPointsManager">
-    <entry_points version="2.0" />
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" default="false" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

.idea/modules.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/kobalt/Build.kt.iml" filepath="$PROJECT_DIR$/kobalt/Build.kt.iml" />
-      <module fileurl="file://$PROJECT_DIR$/kobalt.iml" filepath="$PROJECT_DIR$/kobalt.iml" />
-      <module fileurl="file://$PROJECT_DIR$/modules/kobalt-plugin-api/kobalt-plugin-api.iml" filepath="$PROJECT_DIR$/modules/kobalt-plugin-api/kobalt-plugin-api.iml" />
-      <module fileurl="file://$PROJECT_DIR$/modules/wrapper/kobalt-wrapper.iml" filepath="$PROJECT_DIR$/modules/wrapper/kobalt-wrapper.iml" />
-    </modules>
-  </component>
-</project>

.travis.yml

@@ -1,13 +0,0 @@
-cache:
-    directories:
-    - $HOME/.m2
-    - $HOME/.kobalt
-
-language: java
-
-jdk:
-  - oraclejdk8
-
-install: true
-
-script: ./kobaltw assemble test --log 2

README.md

@@ -1,11 +1,14 @@
-# Kobalt [![Build Status](https://travis-ci.org/cbeust/kobalt.svg?branch=master)](https://travis-ci.org/cbeust/kobalt)
+# Kobalt
+
+[<img src="https://teamcity.jetbrains.com/app/rest/builds/buildType:(id:OpenSourceProjects_Kobalt_Build)/statusIcon.svg">](https://teamcity.jetbrains.com/project.html?projectId=OpenSourceProjects_Kobalt&tab=projectOverview)
+
 
 Kobalt is a universal build system.
  
 To build it:
 
 ```
-./kobaltw assemble
+$ ./kobaltw assemble
 ```
 
 Please see [the web site](http://beust.com/kobalt/) for the full documentation.

build-travis.sh

@@ -0,0 +1,8 @@
+ulimit -s 1082768
+
+#java -Xmx2048m -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* clean
+java -Xmx2048m -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* clean assemble test --parallel
+
+
+
+

build.gradle

@@ -0,0 +1,58 @@
+allprojects {
+    group = 'com.beust'
+    version = '1.1.0'
+}
+
+subprojects {
+    apply plugin: 'java'
+    apply plugin: 'maven-publish'
+
+    ext {
+        bndlib = '3.5.0'
+        findbugs = '3.0.2'
+        groovy = '2.4.12'
+        gson = '2.8.2'
+        guice = '4.2.2'
+        inject = '1'
+        jaxb = '2.3.0'
+        jcommander = '1.72'
+        kotlin = '1.2.71'
+        maven = '3.5.2'
+        mavenResolver = '1.1.0'
+        okhttp = '3.9.1'
+        okio = '1.13.0'
+        retrofit = '2.3.0'
+        slf4j = '1.7.3'
+        spark = '2.6.0'
+        testng = '6.12'
+
+        junit = '4.12'
+        junitJupiter = '5.1.0'
+        junitPlatform = '1.1.0'
+    }
+
+    repositories {
+        mavenCentral()
+        mavenLocal()
+        jcenter()
+        maven {
+            url = 'https://dl.bintray.com/cbeust/maven'
+        }
+
+        maven {
+            url = 'https://repo.maven.apache.org/maven2'
+        }
+    }
+
+    sourceCompatibility = '1.7'
+
+    task sourcesJar(type: Jar) {
+        from sourceSets.main.allJava
+        archiveClassifier = 'sources'
+    }
+
+    task javadocJar(type: Jar) {
+        from javadoc
+        archiveClassifier = 'javadoc'
+    }
+}

dist/kobaltw

@@ -1,2 +1,11 @@
-#!/usr/bin/env bash
-java -jar $(dirname $0)/../kobalt/wrapper/kobalt-wrapper.jar $*
+#!/usr/bin/env sh
+
+case "$(uname)" in
+    CYGWIN*) DIRNAME=$(cygpath -d "$(dirname "$(readlink -f "$0")")");;
+    Darwin*) DIRNAME=$(dirname "$(readlink "$0")");;
+    *) DIRNAME=$(dirname "$(readlink -f "$0")");;
+esac
+if [ "$DIRNAME" = "." ]; then
+    DIRNAME="$(dirname "$0")"
+fi
+java -jar "${DIRNAME}/../kobalt/wrapper/kobalt-wrapper.jar" $*

dist/kobaltw.bat

@@ -0,0 +1,4 @@
+@echo off
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+java -jar "%~dp0/../kobalt/wrapper/kobalt-wrapper.jar" %*

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.3-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,100 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      http://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

kobalt.iml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/src/main/kotlin" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/src/test/kotlin" isTestSource="true" />
-      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
-      <sourceFolder url="file://$MODULE_DIR$/src/test/resources" type="java-test-resource" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="library" name="kobalt (Compile)" level="project" />
-    <orderEntry type="library" scope="TEST" name="kobalt (Test)" level="project" />
-    <orderEntry type="module" module-name="kobalt-plugin-api" />
-    <orderEntry type="module" module-name="kobalt-wrapper" />
-  </component>
-</module>

kobalt/Build.kt.iml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="library" name="kobalt.jar" level="project" />
-  </component>
-</module>

kobalt/src/Build.kt

@@ -1,33 +1,57 @@
 
 import com.beust.kobalt.*
-import com.beust.kobalt.api.License
 import com.beust.kobalt.api.Project
-import com.beust.kobalt.api.Scm
 import com.beust.kobalt.api.annotation.Task
 import com.beust.kobalt.plugin.application.application
 import com.beust.kobalt.plugin.java.javaCompiler
 import com.beust.kobalt.plugin.kotlin.kotlinCompiler
 import com.beust.kobalt.plugin.packaging.assemble
+import com.beust.kobalt.plugin.publish.autoGitTag
 import com.beust.kobalt.plugin.publish.bintray
 import com.beust.kobalt.plugin.publish.github
+import org.apache.maven.model.Developer
+import org.apache.maven.model.License
+import org.apache.maven.model.Model
+import org.apache.maven.model.Scm
 import java.io.File
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.nio.file.StandardCopyOption
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
 
-val r = repos("http://dl.bintray.com/kotlin/kotlinx.dom")
-
-//val pl = plugins(file(homeDir("kotlin/kobalt-android/kobaltBuild/libs/kobalt-android-0.22.jar")))
-
-//val pl = plugins("com.beust:kobalt-android:0.20")
+val bs = buildScript {
+    repos("https://dl.bintray.com/cbeust/maven")
+}
 
 object Versions {
-    val okhttp = "3.2.0"
-    val okio = "1.6.0"
-    val retrofit = "2.0.0"
-    val gson = "2.6.2"
+    val kotlin = "1.2.71"
+    val okhttp = "3.9.1"
+    val okio = "1.13.0"
+    val retrofit = "2.3.0"
+    val gson = "2.8.2"
+    val guice = "4.2.2"
+    val maven = "3.5.2"
+    val mavenResolver = "1.1.0"
+    val slf4j = "1.7.3"
+    val aether = "1.0.2.v20150114"
+    val testng = "6.12"
+    val jcommander = "1.72"
+
+    // JUnit 5
+    val junit = "4.12"
+    val junitPlatform = "1.1.0"
+    val junitJupiter = "5.1.0"
 }
 
+fun mavenResolver(vararg m: String)
+        = m.map { "org.apache.maven.resolver:maven-resolver-$it:${Versions.mavenResolver}" }
+    .toTypedArray()
+
+fun aether(vararg m: String)
+        = m.map { "org.eclipse.aether:aether-$it:${Versions.aether}" }
+    .toTypedArray()
+
 val wrapper = project {
     name = "kobalt-wrapper"
     group = "com.beust"
@@ -40,6 +64,7 @@ val wrapper = project {
     }
 
     assemble {
+        jar { }
         jar {
             name = projectName + ".jar"
             manifest {
@@ -51,6 +76,13 @@ val wrapper = project {
     application {
         mainClass = "com.beust.kobalt.wrapper.Main"
     }
+
+    bintray {
+        publish = true
+        sign = true
+    }
+
+    pom = createPom(name, "Wrapper for Kobalt")
 }
 
 val kobaltPluginApi = project {
@@ -60,27 +92,44 @@ val kobaltPluginApi = project {
     version = readVersion()
     directory = "modules/kobalt-plugin-api"
     description = "A build system in Kotlin"
-    url = "http://beust.com/kobalt"
-    licenses = arrayListOf(License("Apache 2.0", "http://www.apache.org/licenses/LICENSE-2.0"))
-    scm = Scm(url = "http://github.com/cbeust/kobalt",
-            connection = "https://github.com/cbeust/kobalt.git",
-            developerConnection = "git@github.com:cbeust/kobalt.git")
+    url = "https://beust.com/kobalt"
+
+    pom = createPom(name, "A build system in Kotlin")
 
     dependencies {
-        compile("org.jetbrains.kotlinx:kotlinx.dom:0.0.9",
-
-                "com.google.inject:guice:4.0",
-                "com.google.inject.extensions:guice-assistedinject:4.0",
+        compile(
+                "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}",
+                "com.google.inject:guice:${Versions.guice}",
+                "com.google.inject.extensions:guice-assistedinject:4.1.0",
                 "javax.inject:javax.inject:1",
-                "com.google.guava:guava:19.0-rc2",
-                "org.apache.maven:maven-model:3.3.3",
-                "io.reactivex:rxjava:1.0.16",
-                "com.google.code.gson:gson:${Versions.gson}",
+                "com.google.guava:guava:27.0.1-jre",
+                "org.apache.maven:maven-model:${Versions.maven}",
+                "io.reactivex:rxjava:1.3.3",
                 "com.squareup.okio:okio:${Versions.okio}",
+                "com.google.code.gson:gson:${Versions.gson}",
+                "com.squareup.okhttp3:okhttp:${Versions.okhttp}",
                 "com.squareup.retrofit2:retrofit:${Versions.retrofit}",
                 "com.squareup.retrofit2:converter-gson:${Versions.retrofit}",
-                "com.beust:jcommander:1.48"
+                "com.beust:jcommander:${Versions.jcommander}",
+                "org.eclipse.jgit:org.eclipse.jgit:4.9.0.201710071750-r",
+                "org.slf4j:slf4j-simple:${Versions.slf4j}",
+                *mavenResolver("api", "spi", "util", "impl", "connector-basic", "transport-http", "transport-file"),
+                "org.apache.maven:maven-aether-provider:3.3.9",
+                "org.testng.testng-remote:testng-remote:1.3.2",
+                "org.testng:testng:${Versions.testng}",
+                "org.junit.platform:junit-platform-surefire-provider:${Versions.junitPlatform}",
+                "org.junit.platform:junit-platform-runner:${Versions.junitPlatform}",
+                "org.junit.platform:junit-platform-engine:${Versions.junitPlatform}",
+                "org.junit.platform:junit-platform-console:${Versions.junitPlatform}",
+                "org.junit.jupiter:junit-jupiter-engine:${Versions.junitJupiter}",
+                "org.junit.vintage:junit-vintage-engine:${Versions.junitJupiter}",
+                "org.apache.commons:commons-compress:1.15",
+                "commons-io:commons-io:2.6",
+
+                // Java 9
+                "javax.xml.bind:jaxb-api:2.3.0"
         )
+        exclude(*aether("impl", "spi", "util", "api"))
     }
 
 
@@ -93,12 +142,8 @@ val kobaltPluginApi = project {
         }
     }
 
-//    install {
-//        libDir = "lib-test"
-//    }
-
     kotlinCompiler {
-        args("-nowarn")
+        args("nowarn")
     }
 
     bintray {
@@ -114,24 +159,53 @@ val kobaltApp = project(kobaltPluginApi, wrapper) {
 
     dependencies {
         // Used by the plugins
-        compile("org.jetbrains.kotlin:kotlin-compiler-embeddable:1.0.0")
+        compile("org.jetbrains.kotlin:kotlin-compiler-embeddable:${Versions.kotlin}")
 
         // Used by the main app
-        compile("com.github.spullara.mustache.java:compiler:0.9.1",
+        compile(
+                "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}",
+                "com.github.spullara.mustache.java:compiler:0.9.5",
                 "javax.inject:javax.inject:1",
-                "com.google.inject:guice:4.0",
-                "com.google.inject.extensions:guice-assistedinject:4.0",
-                "com.beust:jcommander:1.48",
-                "org.apache.maven:maven-model:3.3.3",
-                "com.google.code.findbugs:jsr305:3.0.1",
+                "com.google.inject:guice:${Versions.guice}",
+                "com.google.inject.extensions:guice-assistedinject:${Versions.guice}",
+                "com.beust:jcommander:${Versions.jcommander}",
+                "org.apache.maven:maven-model:${Versions.maven}",
+                "com.google.code.findbugs:jsr305:3.0.2",
                 "com.google.code.gson:gson:${Versions.gson}",
-                "com.squareup.okhttp3:okhttp:${Versions.okhttp}",
-                "org.codehaus.plexus:plexus-utils:3.0.22")
+                "com.squareup.retrofit2:retrofit:${Versions.retrofit}",
+                "com.squareup.retrofit2:converter-gson:${Versions.retrofit}",
+//                "com.squareup.okhttp3:okhttp-ws:3.4.2",
+                "biz.aQute.bnd:biz.aQute.bndlib:3.5.0",
+                *mavenResolver("spi"),
+
+                "com.squareup.okhttp3:logging-interceptor:3.9.0",
+
+                "com.sparkjava:spark-core:2.6.0",
+                "org.codehaus.groovy:groovy:2.4.12",
+
+                // Java 9
+                "javax.xml.bind:jaxb-api:2.3.0",
+                "com.sun.xml.bind:jaxb-impl:2.3.0",
+                "com.sun.xml.bind:jaxb-core:2.3.0",
+                "com.sun.activation:javax.activation:1.2.0"
+
+//                "org.eclipse.jetty:jetty-server:${Versions.jetty}",
+//                "org.eclipse.jetty:jetty-servlet:${Versions.jetty}",
+//                "org.glassfish.jersey.core:jersey-server:${Versions.jersey}",
+//                "org.glassfish.jersey.containers:jersey-container-servlet-core:${Versions.jersey}",
+//                "org.glassfish.jersey.containers:jersey-container-jetty-http:${Versions.jersey}",
+//                "org.glassfish.jersey.media:jersey-media-moxy:${Versions.jersey}",
+//                "org.wasabi:wasabi:0.1.182"
+        )
 
     }
 
     dependenciesTest {
-        compile("org.testng:testng:6.9.11-SNAPSHOT")
+        compile("org.jetbrains.kotlin:kotlin-test:${Versions.kotlin}",
+                "org.testng:testng:${Versions.testng}",
+                "org.assertj:assertj-core:3.8.0",
+                *mavenResolver("util")
+                )
     }
 
     assemble {
@@ -143,16 +217,27 @@ val kobaltApp = project(kobaltPluginApi, wrapper) {
         }
         zip {
             val dir = "kobalt-$version"
-            include(from("dist"), to("$dir/bin"), "kobaltw")
-            include(from("$buildDirectory/libs"), to("$dir/kobalt/wrapper"),
-                    "$projectName-$version.jar")
-            include(from("modules/wrapper/$buildDirectory/libs"), to("$dir/kobalt/wrapper"),
-                    "$projectName-wrapper.jar")
+            val files = listOf(
+                    "dist", "$dir/bin", "kobaltw",
+                    "dist", "$dir/bin", "kobaltw.bat",
+                    "$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-$version.jar",
+                    "modules/wrapper/$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-wrapper.jar")
+
+            (0 .. files.size - 1 step 3).forEach { i ->
+                include(from(files[i]), to(files[i + 1]), files[i + 2])
+            }
+
+            // Package the sources
+            val currentDir = Paths.get(".").toAbsolutePath().normalize().toString()
+            zipFolders("$currentDir/$buildDirectory/libs/all-sources/$projectName-$version-sources.jar",
+                    "$currentDir/$directory/src/main/kotlin",
+                    "$currentDir/${kobaltPluginApi.directory}/src/main/kotlin")
+            include(from("$buildDirectory/libs/all-sources"), to("$dir/kobalt/wrapper"), "$projectName-$version-sources.jar")
         }
     }
 
     kotlinCompiler {
-        args("-nowarn")
+        args("nowarn")
     }
 
     bintray {
@@ -166,6 +251,32 @@ val kobaltApp = project(kobaltPluginApi, wrapper) {
     test {
         args("-log", "2", "src/test/resources/testng.xml")
     }
+
+    autoGitTag {
+        enabled = true
+    }
+}
+
+fun zipFolders(zipFilePath: String, vararg foldersPath: String) {
+    val zip = Paths.get(zipFilePath)
+    Files.deleteIfExists(zip)
+    Files.createDirectories(zip.parent)
+    val zipPath = Files.createFile(zip)
+    ZipOutputStream(Files.newOutputStream(zipPath)).use {
+        foldersPath.map {Paths.get(it)}.forEach { folderPath ->
+            Files.walk(folderPath)
+                    .filter { path -> !Files.isDirectory(path) }
+                    .forEach { path ->
+                        val zipEntry = ZipEntry(folderPath.relativize(path).toString())
+                        try {
+                            it.putNextEntry(zipEntry)
+                            Files.copy(path, it)
+                            it.closeEntry()
+                        } catch (e: Exception) {
+                        }
+                    }
+        }
+    }
 }
 
 fun readVersion() : String {
@@ -178,16 +289,38 @@ fun readVersion() : String {
     }
 }
 
-@Task(name = "copyVersionForWrapper", runBefore = arrayOf("assemble"), runAfter = arrayOf("compile"), description = "")
+@Task(name = "copyVersionForWrapper", reverseDependsOn = arrayOf("assemble"), runAfter = arrayOf("clean"))
 fun taskCopyVersionForWrapper(project: Project) : TaskResult {
     if (project.name == "kobalt-wrapper") {
         val toString = "modules/wrapper/kobaltBuild/classes"
         File(toString).mkdirs()
         val from = Paths.get("src/main/resources/kobalt.properties")
         val to = Paths.get("$toString/kobalt.properties")
+        // Only copy if necessary so we don't break incremental compilation
+        if (! to.toFile().exists() || (from.toFile().readLines() != to.toFile().readLines())) {
             Files.copy(from,
                     to,
                     StandardCopyOption.REPLACE_EXISTING)
         }
+    }
     return TaskResult()
 }
+
+fun createPom(projectName: String, projectDescription: String) = Model().apply {
+    name = projectName
+    description = projectDescription
+    url = "https://beust.com/kobalt"
+    licenses = listOf(License().apply {
+        name = "Apache-2.0"
+        url = "https://www.apache.org/licenses/LICENSE-2.0"
+    })
+    scm = Scm().apply {
+        url = "https://github.com/cbeust/kobalt"
+        connection = "https://github.com/cbeust/kobalt.git"
+        developerConnection = "git@github.com:cbeust/kobalt.git"
+    }
+    developers = listOf(Developer().apply {
+        name = "Cedric Beust"
+        email = "cedric@beust.com"
+    })
+}

kobalt/wrapper/kobalt-wrapper.properties

@@ -1 +1 @@
-kobalt.version=0.688
+kobalt.version=1.0.122

kobaltw

@@ -1,2 +1,2 @@
-#!/usr/bin/env bash
-java -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $*
+#!/usr/bin/env sh
+java -jar "`dirname "$0"`/kobalt/wrapper/kobalt-wrapper.jar" $*

kobaltw-test

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+JAR=$(ls -1 -t kobaltBuild/libs/*.jar | grep -Ev "(sources|javadoc)" | head -1)
+TEMPDIR=$(mktemp -d)
+cp -pf "$JAR" "$TEMPDIR"
+TEMPJAR=$TEMPDIR/$(basename "$JAR")
+export KOBALT_JAR=$TEMPJAR
+java -jar "$TEMPJAR" "$@"
+rm -rf "$TEMPDIR"

kobaltw.bat

@@ -1,2 +1,4 @@
 @echo off
-java -jar  %~dp0/kobalt/wrapper/kobalt-wrapper.jar %*
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+java -jar "%DIRNAME%/kobalt/wrapper/kobalt-wrapper.jar" %*

modules/kobalt-plugin-api/build.gradle

@@ -0,0 +1,85 @@
+plugins {
+    id 'org.jetbrains.kotlin.jvm' version '1.2.71'
+    id 'com.github.johnrengelman.shadow' version '5.0.0'
+}
+
+dependencies {
+    implementation "biz.aQute.bnd:biz.aQute.bndlib:$bndlib"
+    implementation "com.google.code.findbugs:jsr305:$findbugs"
+    implementation "com.sparkjava:spark-core:$spark"
+    implementation "com.squareup.okhttp3:logging-interceptor:$okhttp"
+    implementation 'commons-io:commons-io:2.6'
+    implementation 'io.reactivex:rxjava:1.3.3'
+    implementation "javax.inject:javax.inject:$inject"
+    implementation "javax.xml.bind:jaxb-api:$jaxb"
+    implementation 'org.apache.commons:commons-compress:1.15'
+    implementation 'org.apache.maven:maven-aether-provider:3.3.9'
+    implementation "org.apache.maven.resolver:maven-resolver-api:$mavenResolver"
+    implementation "org.apache.maven.resolver:maven-resolver-connector-basic:$mavenResolver"
+    implementation "org.apache.maven.resolver:maven-resolver-impl:$mavenResolver"
+    implementation "org.apache.maven.resolver:maven-resolver-spi:$mavenResolver"
+    implementation "org.apache.maven.resolver:maven-resolver-transport-file:$mavenResolver"
+    implementation "org.apache.maven.resolver:maven-resolver-transport-http:$mavenResolver"
+    implementation "org.apache.maven.resolver:maven-resolver-util:$mavenResolver"
+    implementation "org.codehaus.groovy:groovy:$groovy"
+    implementation 'org.eclipse.jgit:org.eclipse.jgit:4.9.0.201710071750-r'
+    implementation "org.junit.jupiter:junit-jupiter-engine:$junitJupiter"
+    implementation "org.junit.platform:junit-platform-console:$junitPlatform"
+    implementation "org.junit.platform:junit-platform-engine:$junitPlatform"
+    implementation "org.junit.platform:junit-platform-runner:$junitPlatform"
+    implementation "org.junit.platform:junit-platform-surefire-provider:$junitPlatform"
+    implementation "org.junit.vintage:junit-vintage-engine:$junitJupiter"
+    implementation "org.slf4j:slf4j-simple:$slf4j"
+    implementation "org.testng:testng:$testng"
+    implementation 'org.testng.testng-remote:testng-remote:1.3.2'
+    implementation "com.beust:jcommander:$jcommander"
+    implementation "com.google.code.gson:gson:$gson"
+    implementation "com.google.inject:guice:$guice"
+    implementation "com.google.inject.extensions:guice-assistedinject:$guice"
+    implementation "com.squareup.okio:okio:$okio"
+    implementation "com.squareup.retrofit2:converter-gson:$retrofit"
+    implementation "com.squareup.retrofit2:retrofit:$retrofit"
+    implementation "org.apache.maven:maven-model:$maven"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin"
+}
+
+shadowJar {
+    classifier = null
+}
+
+test {
+    useTestNG()
+}
+
+publishing {
+    publications {
+        shadow(MavenPublication) { publication ->
+            project.shadow.component(publication)
+            artifact sourcesJar
+            artifact javadocJar
+
+            pom {
+                name = project.name
+                description = 'A build system in Kotlin'
+                url = 'https://beust.com/kobalt'
+                licenses {
+                    license {
+                        name = 'Apache-2.0'
+                        url = 'https://www.apache.org/licenses/LICENSE-2.0'
+                    }
+                }
+                developers {
+                    developer {
+                        name = 'Cedric Beust'
+                        email = 'cedric@beust.com'
+                    }
+                }
+                scm {
+                    connection = 'scm:https://github.com/cbeust/kobalt.git'
+                    developerConnection = 'scm:git@github.com:cbeust/kobalt.git'
+                    url = 'https://github.com/cbeust/kobalt'
+                }
+            }
+        }
+    }
+}

modules/kobalt-plugin-api/kobalt-plugin-api.iml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src/main/kotlin" isTestSource="false" />
-    </content>
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="kobalt (Compile)" level="project" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="library" name="kobalt-plugin-api (Compile)" level="project" />
-    <orderEntry type="library" scope="TEST" name="kobalt-plugin-api (Test)" level="project" />
-  </component>
-</module>

modules/kobalt-plugin-api/pom.xml

@@ -0,0 +1,279 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.beust</groupId>
+        <artifactId>kobalt-pom</artifactId>
+        <version>1.1.0</version>
+        <relativePath>../..</relativePath>
+    </parent>
+
+    <artifactId>kobalt-plugin-api</artifactId>
+    <packaging>jar</packaging>
+    <version>1.1.0</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-aether-provider</artifactId>
+            <version>3.3.9</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.eclipse.aether</groupId>
+                    <artifactId>impl</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.eclipse.aether</groupId>
+                    <artifactId>spi</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.eclipse.aether</groupId>
+                    <artifactId>util</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.eclipse.aether</groupId>
+                    <artifactId>api</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-api</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-spi</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-util</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-impl</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-connector-basic</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-transport-http</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven.resolver</groupId>
+            <artifactId>maven-resolver-transport-file</artifactId>
+            <version>${mavenresolver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.reactivex</groupId>
+            <artifactId>rxjava</artifactId>
+            <version>1.3.3</version>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okio</groupId>
+            <artifactId>okio</artifactId>
+            <version>${okio.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.inject</groupId>
+            <artifactId>javax.inject</artifactId>
+            <version>1</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.inject</groupId>
+            <artifactId>guice</artifactId>
+            <version>4.2.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.inject.extensions</groupId>
+            <artifactId>guice-assistedinject</artifactId>
+            <version>4.2.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.beust</groupId>
+            <artifactId>jcommander</artifactId>
+            <version>1.72</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-model</artifactId>
+            <version>3.5.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <version>3.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.retrofit2</groupId>
+            <artifactId>retrofit</artifactId>
+            <version>2.3.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.retrofit2</groupId>
+            <artifactId>converter-gson</artifactId>
+            <version>2.3.0</version>
+        </dependency>
+        <dependency>
+            <groupId>biz.aQute.bnd</groupId>
+            <artifactId>biz.aQute.bndlib</artifactId>
+            <version>3.5.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>logging-interceptor</artifactId>
+            <version>${okhttp3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.sparkjava</groupId>
+            <artifactId>spark-core</artifactId>
+            <version>2.6.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.codehaus.groovy</groupId>
+            <artifactId>groovy</artifactId>
+            <version>2.4.12</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-compress</artifactId>
+            <version>1.15</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-surefire-provider</artifactId>
+            <version>${junit.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-engine</artifactId>
+            <version>${junit.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-console</artifactId>
+            <version>${junit.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junitJupiter.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.vintage</groupId>
+            <artifactId>junit-vintage-engine</artifactId>
+            <version>${junitJupiter.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.testng.testng-remote</groupId>
+            <artifactId>testng-remote</artifactId>
+            <version>1.3.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>${testng.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.jgit</groupId>
+            <artifactId>org.eclipse.jgit</artifactId>
+            <version>4.9.0.201710071750-r</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>${slf4j.version}</version>
+        </dependency>
+        <!-- java 9 -->
+        <dependency>
+            <groupId>javax.xml.bind</groupId>
+            <artifactId>jaxb-api</artifactId>
+            <version>2.3.0</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-maven-plugin</artifactId>
+                <version>${kotlin.version}</version>
+                <executions>
+                    <execution>
+                        <id>compile</id>
+                        <goals> <goal>compile</goal> </goals>
+                        <configuration>
+                            <sourceDirs>
+                                <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
+                            </sourceDirs>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>test-compile</id>
+                        <goals> <goal>test-compile</goal> </goals>
+                        <configuration>
+                            <sourceDirs>
+                                <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
+                            </sourceDirs>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <executions>
+                    <!-- Replacing default-compile as it is treated specially by maven -->
+                    <execution>
+                        <id>default-compile</id>
+                        <phase>none</phase>
+                    </execution>
+                    <!-- Replacing default-testCompile as it is treated specially by maven -->
+                    <execution>
+                        <id>default-testCompile</id>
+                        <phase>none</phase>
+                    </execution>
+                    <execution>
+                        <id>java-compile</id>
+                        <phase>compile</phase>
+                        <goals> <goal>compile</goal> </goals>
+                    </execution>
+                    <execution>
+                        <id>java-test-compile</id>
+                        <phase>test-compile</phase>
+                        <goals> <goal>testCompile</goal> </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt

@@ -0,0 +1,21 @@
+package com.beust.kobalt
+
+import com.beust.kobalt.api.KobaltContext
+import com.beust.kobalt.api.Project
+import com.beust.kobalt.archive.Zip
+import com.beust.kobalt.misc.KFiles
+import java.io.File
+
+interface ArchiveGenerator {
+    fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List<IncludedFile>
+    val suffix: String
+    fun generateArchive(project: Project, context: KobaltContext, zip: Zip, files: List<IncludedFile>) : File
+
+    fun fullArchiveName(project: Project, context: KobaltContext, archiveName: String?) : File {
+        val fullArchiveName = context.variant.archiveName(project, archiveName, suffix)
+        val archiveDir = File(KFiles.libsDir(project))
+        val result = File(archiveDir.path, fullArchiveName)
+        return result
+    }
+
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt

@@ -7,7 +7,7 @@ class Args {
     var targets: List<String> = arrayListOf()
 
     @Parameter(names = arrayOf("-bf", "--buildFile"), description = "The build file")
-    var buildFile: String? = null
+    var buildFile: String? = "kobalt/src/Build.kt"
 
     @Parameter(names = arrayOf("--checkVersions"), description = "Check if there are any newer versions of the " +
             "dependencies")
@@ -22,10 +22,18 @@ class Args {
     @Parameter(names = arrayOf("--download"), description = "Force a download from the downloadUrl in the wrapper")
     var download: Boolean = false
 
+    @Parameter(names = arrayOf("--downloadSources"),
+            description = "Force a download of sources and javadocs when resolving dependencies")
+    var downloadSources: Boolean = false
+
     @Parameter(names = arrayOf("--dryRun"), description = "Display all the tasks that will get run without " +
             "actually running them")
     var dryRun: Boolean = false
 
+    @Parameter(names = arrayOf("--force"), description = "Force a new server to be launched even if another one" +
+            " is already running")
+    var force: Boolean = false
+
     @Parameter(names = arrayOf("--gc"), description = "Delete old files")
     var gc: Boolean = false
 
@@ -38,12 +46,23 @@ class Args {
     @Parameter(names = arrayOf("--listTemplates"), description = "List the available templates")
     var listTemplates: Boolean = false
 
-    @Parameter(names = arrayOf("--log"), description = "Define the log level (1-3)")
-    var log: Int = 1
+    @Parameter(names = arrayOf("--log"), description = "Define the log level " +
+            "(${Constants.LOG_QUIET_LEVEL}-${Constants.LOG_MAX_LEVEL})")
+    var log: Int = Constants.LOG_DEFAULT_LEVEL
 
-    companion object {
-        const val DEFAULT_SERVER_PORT = 1234
-    }
+    @Parameter(names = arrayOf("--logTags"),
+            description = "Comma-separated list of tags to enable logging for")
+    var logTags: String = ""
+
+    @Parameter(names = arrayOf("--forceIncremental"),
+            description = "Force the build to be incremental even if the build file was modified")
+    var forceIncremental: Boolean = false
+
+    @Parameter(names = arrayOf("--noIncremental"), description = "Turn off incremental builds")
+    var noIncremental: Boolean = false
+
+    @Parameter(names = arrayOf("--offline"), description = "Don't try to download dependencies even if there is no cached version")
+    var offline: Boolean = false
 
     @Parameter(names = arrayOf("--plugins"), description = "Comma-separated list of plug-in Maven id's")
     var pluginIds: String? = null
@@ -52,18 +71,31 @@ class Args {
     var pluginJarFiles: String? = null
 
     @Parameter(names = arrayOf("--port"), description = "Port, if --server was specified")
-    var port: Int = DEFAULT_SERVER_PORT
+    var port: Int? = null
 
     @Parameter(names = arrayOf("--profiles"), description = "Comma-separated list of profiles to run")
     var profiles: String? = null
 
+    @Parameter(names = arrayOf("--profiling"), description = "Display task timings at the end of the build")
+    var profiling: Boolean = false
+
     @Parameter(names = arrayOf("--resolve"),
-            description = "Resolve the given comma-separated dependencies and display their dependency tree")
-    var dependencies: String? = null
+            description = "Resolve the given dependency and display its tree")
+    var dependency: String? = null
 
     @Parameter(names = arrayOf("--projectInfo"), description = "Display information about the current projects")
     var projectInfo: Boolean = false
 
+    @Parameter(names = arrayOf("--noIncrementalKotlin"), description = "Disable incremental Kotlin compilation")
+    var noIncrementalKotlin: Boolean = false
+
+    companion object {
+        const val SEQUENTIAL = "--sequential"
+    }
+
+    @Parameter(names = arrayOf(Args.SEQUENTIAL), description = "Build all the projects in sequence")
+    var sequential: Boolean = false
+
     @Parameter(names = arrayOf("--server"), description = "Run in server mode")
     var serverMode: Boolean = false
 
@@ -72,5 +104,8 @@ class Args {
 
     @Parameter(names = arrayOf("--update"), description = "Update to the latest version of Kobalt")
     var update: Boolean = false
+
+    @Parameter(names = arrayOf("--version"), description = "Display the current version of Kobalt")
+    var version: Boolean = false
 }
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt

@@ -1,9 +1,18 @@
 package com.beust.kobalt
 
-import com.beust.kobalt.misc.log
 import java.util.*
 
-
+/**
+ * Make Kobalt's output awesome and unique.
+ *
+ * I spend so much time staring at build outputs I decided I might as well make them pretty.
+ * Note that I also experimented with colors but it's hard to come up with a color scheme that
+ * will work with all the various backgrounds developers use, so I decided to be conservative
+ * and stick to simple red/yellow for errors and warnings.
+ *
+ * @author Cedric Beust <cedric@beust.com>
+ * @since 10/1/2015
+ */
 class AsciiArt {
     companion object {
         private val BANNERS = arrayOf(
@@ -26,19 +35,13 @@ class AsciiArt {
 
         val horizontalSingleLine = "\u2500\u2500\u2500\u2500\u2500"
         val horizontalDoubleLine = "\u2550\u2550\u2550\u2550\u2550"
+        val verticalBar = "\u2551"
 
 //        fun horizontalLine(n: Int) = StringBuffer().apply {
 //                repeat(n, { append("\u2500") })
 //            }.toString()
 
-        fun box(strings: List<String>) : List<String> {
-            val ul = "\u2554"
-            val ur = "\u2557"
-            val h = "\u2550"
-            val v = "\u2551"
-            val bl = "\u255a"
-            val br = "\u255d"
-
+        // Repeat
         fun r(n: Int, w: String) : String {
             with(StringBuffer()) {
                 repeat(n, { append(w) })
@@ -46,27 +49,45 @@ class AsciiArt {
             }
         }
 
+        val h = "\u2550"
+        val ul = "\u2554"
+        val ur = "\u2557"
+        val bottomLeft = "\u255a"
+        val bottomRight = "\u255d"
+
+        // Bottom left with continuation
+        val bottomLeft2 = "\u2560"
+        // Bottom right with continuation
+        val bottomRight2 = "\u2563"
+
+        fun upperBox(max: Int) = ul + r(max + 2, h) + ur
+        fun lowerBox(max: Int, bl: String = bottomLeft, br : String = bottomRight) = bl + r(max + 2, h) + br
+
+        private fun box(strings: List<String>, bl: String = bottomLeft, br: String = bottomRight) : List<String> {
+            val v = verticalBar
+
             val maxString: String = strings.maxBy { it.length } ?: ""
             val max = maxString.length
-            val result = arrayListOf(ul + r(max + 2, h) + ur)
+            val result = arrayListOf(upperBox(max))
             result.addAll(strings.map { "$v ${center(it, max - 2)} $v" })
-            result.add(bl + r(max + 2, h) + br)
+            result.add(lowerBox(max, bl, br))
             return result
         }
 
-        private fun fill(n: Int) = StringBuffer().apply { repeat(n, { append(" ")})}.toString()
-
-        val defaultLog : (s: String) -> Unit = { log(1, "          $it") }
-
-        fun logBox(strings: List<String>, print: (String) -> Unit = defaultLog) {
-            box(strings).forEach {
-                print(it)
+        fun logBox(strings: List<String>, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0): String {
+            return buildString {
+                val boxLines = box(strings, bl, br)
+                boxLines.withIndex().forEach { iv ->
+                    append(fill(indent)).append(iv.value)
+                    if (iv.index < boxLines.size - 1) append("\n")
+                }
             }
         }
 
-        fun logBox(s: String, print: (String) -> Unit = defaultLog) {
-            logBox(listOf(s), print)
-        }
+        fun logBox(s: String, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0)
+                = logBox(listOf(s), bl, br, indent)
+
+        fun fill(n: Int) = buildString { repeat(n, { append(" ")})}.toString()
 
         fun center(s: String, width: Int) : String {
             val diff = width - s.length
@@ -84,14 +105,60 @@ class AsciiArt {
         const val CYAN = "\u001B[36m"
         const val WHITE = "\u001B[37m"
 
-        private fun wrap(s: String, color: String) = color + s + RESET
-        private fun blue(s: String) = wrap(s, BLUE)
-        private fun red(s: String) = wrap(s, RED)
-        private fun yellow(s: String) = wrap(s, YELLOW)
+        fun wrap(s: CharSequence, color: String) = color + s + RESET
+        private fun blue(s: CharSequence) = wrap(s, BLUE)
+        private fun red(s: CharSequence) = wrap(s, RED)
+        private fun yellow(s: CharSequence) = wrap(s, YELLOW)
 
-        fun taskColor(s: String) = s
-        fun errorColor(s: String) = red(s)
-        fun warnColor(s: String) = red(s)
+        fun taskColor(s: CharSequence) = s
+        fun errorColor(s: CharSequence) = red(s)
+        fun warnColor(s: CharSequence) = red(s)
     }
 }
 
+class AsciiTable {
+    class Builder {
+        private val headers = arrayListOf<String>()
+        fun header(name: String) = headers.add(name)
+        fun headers(vararg names: String) = headers.addAll(names)
+
+        private val widths = arrayListOf<Int>()
+        fun columnWidth(w: Int) : Builder {
+            widths.add(w)
+            return this
+        }
+
+        private val rows = arrayListOf<List<String>>()
+        fun addRow(row: List<String>) = rows.add(row)
+
+        private fun col(width: Int, s: String) : String {
+            val format = " %1\$-${width.toString()}s"
+            val result = String.format(format, s)
+            return result
+        }
+
+        val vb = AsciiArt.verticalBar
+
+        fun build() : String {
+            val formattedHeaders =
+                    headers.mapIndexed { index, s ->
+                        val s2 = col(widths[index], s)
+                        s2
+                    }.joinToString(vb)
+            val result = StringBuffer().apply {
+                append(AsciiArt.logBox(formattedHeaders, AsciiArt.bottomLeft2, AsciiArt.bottomRight2))
+                append("\n")
+            }
+            var lineLength = 0
+            rows.forEachIndexed { _, row ->
+                val formattedRow = row.mapIndexed { i, s -> col(widths[i], s) }.joinToString(vb)
+                val line = "$vb $formattedRow $vb"
+                result.append(line).append("\n")
+                lineLength = line.length
+            }
+            result.append(AsciiArt.lowerBox(lineLength - 4))
+            return result.toString()
+        }
+
+    }
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BasePluginTask.kt

@@ -4,8 +4,9 @@ import com.beust.kobalt.api.IPlugin
 import com.beust.kobalt.api.PluginTask
 import com.beust.kobalt.api.Project
 
-public abstract class BasePluginTask(override val plugin: IPlugin,
+abstract class BasePluginTask(override val plugin: IPlugin,
         override val name: String,
         override val doc: String,
+        override val group: String,
         override val project: Project)
         : PluginTask()

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt

@@ -3,34 +3,89 @@ package com.beust.kobalt
 import com.beust.kobalt.api.IClasspathDependency
 import com.beust.kobalt.api.Kobalt
 import com.beust.kobalt.api.annotation.Directive
-import com.beust.kobalt.maven.DepFactory
+import com.beust.kobalt.internal.KobaltSettings
+import com.beust.kobalt.internal.PluginInfo
+import com.beust.kobalt.maven.DependencyManager
 import com.beust.kobalt.maven.dependency.FileDependency
+import com.beust.kobalt.misc.KobaltLogger
+import org.eclipse.aether.repository.Proxy
 import java.io.File
+import java.net.InetSocketAddress
+
+var BUILD_SCRIPT_CONFIG : BuildScriptConfig? = null
+
+class BuildScriptConfig {
+    /** The list of repos used to locate plug-ins. */
+    @Directive
+    fun repos(vararg r: String) = newRepos(*r)
+
+    /** The list of plug-ins to use for this build file. */
+    @Directive
+    fun plugins(vararg pl: String) = newPlugins(*pl)
+
+    /** The build file classpath. */
+    @Directive
+    fun buildFileClasspath(vararg bfc: String) = newBuildFileClasspath(*bfc)
+
+    /** Options passed to Kobalt */
+    @Directive
+    fun kobaltOptions(vararg options: String) = Kobalt.addKobaltOptions(options)
+
+    /** Where to find additional build files */
+    @Directive
+    fun buildSourceDirs(vararg dirs: String) = Kobalt.addBuildSourceDirs(dirs)
+
+    // The following settings modify the compiler used to compile the build file, which regular users should
+    // probably never need to do. Projects should use kotlinCompiler { compilerVersion } to configure the
+    // Kotin compiler for their source files.
+    var kobaltCompilerVersion : String? = null
+    var kobaltCompilerRepo: String? = null
+    var kobaltCompilerFlags: String? = null
+}
 
 @Directive
 fun homeDir(vararg dirs: String) : String = SystemProperties.homeDir +
         File.separator + dirs.toMutableList().joinToString(File.separator)
 
-@Directive
-fun localMavenRepo() = homeDir(".m2" + File.separator + "repository/")
-
 @Directive
 fun file(file: String) : String = FileDependency.PREFIX_FILE + file
 
-@Directive
 fun plugins(vararg dependency : IClasspathDependency) {
     dependency.forEach { Plugins.addDynamicPlugin(it) }
 }
 
-@Directive
 fun plugins(vararg dependencies : String) {
-    val factory = Kobalt.INJECTOR.getInstance(DepFactory::class.java)
+    KobaltLogger.logger.warn("Build.kt",
+            "Invoking plugins() directly is deprecated, use the buildScript{} directive")
+    newPlugins(*dependencies)
+}
+
+@Directive
+fun newPlugins(vararg dependencies : String) {
+    val factory = Kobalt.INJECTOR.getInstance(DependencyManager::class.java)
     dependencies.forEach {
         Plugins.addDynamicPlugin(factory.create(it))
     }
 }
 
-data class HostConfig(var url: String = "", var username: String? = null, var password: String? = null) {
+data class ProxyConfig(val host: String = "", val port: Int = 0, val type: String = "", val nonProxyHosts: String = "") {
+    fun toProxy() = java.net.Proxy(java.net.Proxy.Type.HTTP, InetSocketAddress(host, port))
+
+    fun toAetherProxy() = Proxy(type, host, port) // TODO make support for proxy auth
+}
+
+data class HostConfig(var url: String = "", var name: String = HostConfig.createRepoName(url),
+        var username: String? = null, var password: String? = null) {
+
+    companion object {
+        /**
+         * For repos specified in the build file (repos()) that don't have an associated unique name,
+         * create such a name from the URL. This is a requirement from Maven Resolver, and failing to do
+         * this leads to very weird resolution errors.
+         */
+        private fun createRepoName(url: String) = url.replace("/", "_").replace("\\", "_").replace(":", "_")
+    }
+
     fun hasAuth() : Boolean {
         return (! username.isNullOrBlank()) && (! password.isNullOrBlank())
     }
@@ -44,18 +99,47 @@ data class HostConfig(var url: String = "", var username: String? = null, var pa
     }
 }
 
-@Directive
 fun repos(vararg repos : String) {
+    KobaltLogger.logger.warn("Build.kt",
+            "Invoking repos() directly is deprecated, use the buildScript{} directive")
+    newRepos(*repos)
+}
+
+fun newRepos(vararg repos: String) {
     repos.forEach { Kobalt.addRepo(HostConfig(it)) }
 }
 
+fun buildFileClasspath(vararg deps: String) {
+    KobaltLogger.logger.warn("Build.kt",
+            "Invoking buildFileClasspath() directly is deprecated, use the buildScript{} directive")
+    newBuildFileClasspath(*deps)
+}
+
+fun newBuildFileClasspath(vararg deps: String) {
+    //FIXME newBuildFileClasspath called twice
+    deps.forEach { Kobalt.addBuildFileClasspath(it) }
+}
+
 @Directive
 fun authRepos(vararg repos : HostConfig) {
     repos.forEach { Kobalt.addRepo(it) }
 }
 
 @Directive
-fun authRepo(init: HostConfig.() -> Unit) = HostConfig().apply { init() }
+fun authRepo(init: HostConfig.() -> Unit) = HostConfig(name = "").apply { init() }
 
 @Directive
 fun glob(g: String) : IFileSpec.GlobSpec = IFileSpec.GlobSpec(g)
+
+/**
+ * The location of the local Maven repository.
+ */
+@Directive
+fun localMaven() : String {
+    val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java)
+    val initial = Kobalt.INJECTOR.getInstance(KobaltSettings::class.java).localMavenRepo
+    val result = pluginInfo.localMavenRepoPathInterceptors.fold(initial) { current, interceptor ->
+        File(interceptor.repoPath(current.absolutePath))
+    }
+    return result.toURI().toString()
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt

@@ -3,19 +3,23 @@ package com.beust.kobalt
 import com.beust.kobalt.misc.KFiles
 
 object Constants {
+    const val LOG_QUIET_LEVEL = 0
+    const val LOG_DEFAULT_LEVEL = 1
+    const val LOG_MAX_LEVEL = 3
     val BUILD_FILE_NAME = "Build.kt"
     val BUILD_FILE_DIRECTORY = "kobalt/src"
     val BUILD_FILE_PATH = KFiles.joinDir(BUILD_FILE_DIRECTORY, BUILD_FILE_NAME)
+    val KOTLIN_COMPILER_VERSION = "1.2.70"
 
-    internal val DEFAULT_REPOS = listOf(
-            "http://repo1.maven.org/maven2/",
-            "https://maven-central.storage.googleapis.com/",
-            "https://jcenter.bintray.com/"
+    internal val DEFAULT_REPOS = listOf<HostConfig>(
+            //            "https://maven-central.storage.googleapis.com/",
+            HostConfig("https://repo1.maven.org/maven2/", "Maven"),
+            HostConfig("https://jcenter.bintray.com/", "JCenter")
+//            "https://repository.jetbrains.com/all/", // <-- contains snapshots
 
-            // The following two repos contain snapshots, never include them or default
-//            "https://repository.jboss.org/nexus/content/repositories/root_repository/",
-//            "http://repository.jetbrains.com/all/"
+            // snapshots
 //            "https://oss.sonatype.org/content/repositories/snapshots/"
+//            , "https://repository.jboss.org/nexus/content/repositories/root_repository/"
     )
 
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt

@@ -4,9 +4,11 @@ import com.beust.kobalt.api.Kobalt
 import com.beust.kobalt.api.Project
 import com.beust.kobalt.api.annotation.Directive
 import com.beust.kobalt.internal.JvmCompilerPlugin
+import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KProperty
 
 @Directive
-public fun project(vararg projects: Project, init: Project.() -> Unit): Project {
+fun project(vararg projects: Project, init: Project.() -> Unit): Project {
     return Project("").apply {
         init()
         (Kobalt.findPlugin(JvmCompilerPlugin.PLUGIN_NAME) as JvmCompilerPlugin)
@@ -14,3 +16,24 @@ public fun project(vararg projects: Project, init: Project.() -> Unit): Project
     }
 }
 
+@Directive
+fun buildScript(init: BuildScriptConfig.() -> Unit): BuildScriptConfig {
+    val buildScriptConfig = BuildScriptConfig().apply { init() }
+    BUILD_SCRIPT_CONFIG = buildScriptConfig
+    return buildScriptConfig
+}
+
+@Directive
+fun profile(): ReadWriteProperty<Nothing?, Boolean> {
+    val result = object: ReadWriteProperty<Nothing?, Boolean> {
+        var value: Boolean = false
+        override operator fun getValue(thisRef: Nothing?, property: KProperty<*>): Boolean {
+            return value
+        }
+
+        override operator fun setValue(thisRef: Nothing?, property: KProperty<*>, value: Boolean) {
+            this.value = value
+        }
+    }
+    return result
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt

@@ -1,6 +1,6 @@
 package com.beust.kobalt
 
-import com.beust.kobalt.misc.log
+import com.beust.kobalt.misc.kobaltLog
 import java.io.File
 import java.nio.file.*
 import java.nio.file.attribute.BasicFileAttributes
@@ -28,15 +28,15 @@ sealed class IFileSpec {
         private fun isIncluded(includeMatchers: Glob, excludes: List<Glob>, rel: Path) : Boolean {
             excludes.forEach {
                 if (it.matches(rel)) {
-                    log(3, "Excluding ${rel.toFile()}")
+                    kobaltLog(3, "  Excluding ${rel.toFile()}")
                     return false
                 }
             }
             if (includeMatchers.matches(rel)) {
-                log(3, "Including ${rel.toFile().path}")
+                kobaltLog(3, "  Including ${rel.toFile().path}")
                 return true
             }
-            log(2, "Excluding ${rel.toFile()} (not matching any include pattern")
+            kobaltLog(2, "  Excluding ${rel.toFile()} (not matching any include pattern")
             return false
         }
 
@@ -44,7 +44,7 @@ sealed class IFileSpec {
             val result = arrayListOf<File>()
             val includes = Glob(*spec.toTypedArray())
 
-            if (File(filePath).isDirectory) {
+            if (File(baseDir, filePath).isDirectory) {
                 val orgRootDir = (if (File(filePath).isAbsolute) Paths.get(filePath)
                     else if (baseDir != null) Paths.get(baseDir, filePath)
                     else Paths.get(filePath)).run { normalize() }
@@ -56,7 +56,7 @@ sealed class IFileSpec {
                             val path = p.normalize()
                             val rel = orgRootDir.relativize(path)
                             if (isIncluded(includes, excludes, path)) {
-                                log(3, "  including file " + rel.toFile() + " from rootDir $rootDir")
+                                kobaltLog(3, "  including file " + rel.toFile() + " from rootDir $rootDir")
                                 result.add(rel.toFile())
                             }
                             return FileVisitResult.CONTINUE

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt

@@ -0,0 +1,43 @@
+package com.beust.kobalt
+
+import com.beust.kobalt.api.annotation.Directive
+import java.io.File
+
+/**
+ * Base classes for directives that support install(from,to) (e.g. install{} or jar{}).
+ */
+open class IncludeFromTo {
+    /**
+     * Prefix path to be removed from the zip file. For example, if you add "build/lib/a.jar" to the zip
+     * file and the excludePrefix is "build/lib", then "a.jar" will be added at the root of the zip file.
+     */
+    val includedFiles = arrayListOf<IncludedFile>()
+
+    @Directive
+    fun from(s: String) = From(s)
+
+    @Directive
+    fun to(s: String) = To(s)
+
+    @Directive
+    fun copy(from: From, to: To) {
+        val dir = File(from.path).absoluteFile.parentFile
+        includedFiles.add(IncludedFile(from(dir.absolutePath), to, listOf(IFileSpec.FileSpec(from.path))))
+    }
+
+    @Directive
+    fun include(vararg files: String) {
+        includedFiles.add(IncludedFile(files.map { IFileSpec.FileSpec(it) }))
+    }
+
+    @Directive
+    fun include(from: From, to: To, vararg specs: String) {
+        includedFiles.add(IncludedFile(from, to, specs.map { IFileSpec.FileSpec(it) }))
+    }
+
+    @Directive
+    fun include(from: From, to: To, vararg specs: IFileSpec.GlobSpec) {
+        includedFiles.add(IncludedFile(from, to, listOf(*specs)))
+    }
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt

@@ -0,0 +1,44 @@
+package com.beust.kobalt
+
+import com.beust.kobalt.misc.KFiles
+import com.beust.kobalt.misc.toString
+import java.io.File
+import java.nio.file.Paths
+
+class IncludedFile(val fromOriginal: From, val toOriginal: To, val specs: List<IFileSpec>,
+        val expandJarFiles: Boolean = false) {
+    constructor(specs: List<IFileSpec>, expandJarFiles: Boolean = false) : this(From(""), To(""), specs, expandJarFiles)
+    fun from(s: String) = File(if (fromOriginal.isCurrentDir()) s else KFiles.joinDir(from, s))
+    val from: String get() = fromOriginal.path.replace("\\", "/")
+    fun to(s: String) = File(if (toOriginal.isCurrentDir()) s else KFiles.joinDir(to, s))
+    val to: String get() = toOriginal.path.replace("\\", "/")
+    override fun toString() = toString("IncludedFile",
+            "files - ", specs.map { it.toString() },
+            "from", from,
+            "to", to)
+
+    fun allFromFiles(directory: String? = null): List<File> {
+        val result = arrayListOf<File>()
+        specs.forEach { spec ->
+//            val fullDir = if (directory == null) from else KFiles.joinDir(directory, from)
+            spec.toFiles(directory, from).forEach { source ->
+                result.add(if (source.isAbsolute) source else File(source.path))
+            }
+        }
+        return result.map { Paths.get(it.path).normalize().toFile()}
+    }
+}
+
+open class Direction(open val p: String) {
+    override fun toString() = path
+    fun isCurrentDir() = path == "./"
+
+    val path: String get() =
+        if (p.isEmpty()) "./"
+        else if (p.startsWith("/") || p.endsWith("/")) p
+        else p + "/"
+}
+
+class From(override val p: String) : Direction(p)
+
+class To(override val p: String) : Direction(p)

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncrementalTaskInfo.kt

@@ -1,16 +1,17 @@
 package com.beust.kobalt
 
+import com.beust.kobalt.api.KobaltContext
 import com.beust.kobalt.api.Project
 
 /**
- * @param inputChecksum The checksum for the input to this task. It gets compared against the checksum of
- *  if they differ, the task gets run. If they are equal, outputChecksums are then compared.
+ * @param inputChecksum The checksum for the input to this task. It gets compared against the previous checksum
+ * calculated by Kobalt. If they differ, the task gets run. If they are equal, outputChecksums are then compared.
  * @param outputChecksum The checksum for the output of this task. If null, the output is absent
  * and the task will be run. If non null, it gets compared against the checksum of the previous run and
- * if they differ, the task gets run. Note that this parameter is a closure and not a direct value
- * because Kobalt needs to call it twice: once before the task and once after a successful execution (to store it).
+ * if they differ, the task gets run.
  * @param task The task to run.
  */
-class IncrementalTaskInfo(val inputChecksum: String?,
+class IncrementalTaskInfo(val inputChecksum: () -> String?,
         val outputChecksum: () -> String?,
-        val task: (Project) -> TaskResult)
+        val task: (Project) -> TaskResult,
+        val context: KobaltContext)

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt

@@ -2,21 +2,23 @@ package com.beust.kobalt
 
 import com.beust.kobalt.api.KobaltContext
 import com.beust.kobalt.api.Project
-import com.beust.kobalt.api.ProjectDescription
 import com.beust.kobalt.archive.Archives
-import com.beust.kobalt.archive.Jar
-import com.beust.kobalt.internal.JvmCompilerPlugin
+import com.beust.kobalt.archive.MetaArchive
+import com.beust.kobalt.archive.Zip
 import com.beust.kobalt.maven.DependencyManager
-import com.beust.kobalt.misc.*
+import com.beust.kobalt.maven.aether.Scope
+import com.beust.kobalt.misc.KFiles
+import com.beust.kobalt.misc.kobaltLog
 import com.google.inject.Inject
 import java.io.File
-import java.io.OutputStream
+import java.io.FileInputStream
 import java.nio.file.Paths
-import java.util.jar.JarOutputStream
+import java.util.jar.Manifest
 
-class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) {
+class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) : ArchiveGenerator {
     companion object {
-        fun findIncludedFiles(directory: String, files: List<IncludedFile>, excludes: List<Glob>)
+        fun findIncludedFiles(directory: String, files: List<IncludedFile>, excludes: List<Glob>,
+                throwOnError: Boolean = true)
                 : List<IncludedFile> {
             val result = arrayListOf<IncludedFile>()
             files.forEach { includedFile ->
@@ -26,7 +28,7 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
                     if (File(directory, fromPath).exists()) {
                         spec.toFiles(directory, fromPath).forEach { file ->
                             val fullFile = File(KFiles.joinDir(directory, fromPath, file.path))
-                            if (! fullFile.exists()) {
+                            if (! fullFile.exists() && throwOnError) {
                                 throw AssertionError("File should exist: $fullFile")
                             }
 
@@ -34,16 +36,16 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
                                 val normalized = Paths.get(file.path).normalize().toFile().path
                                 includedSpecs.add(IFileSpec.FileSpec(normalized))
                             } else {
-                                log(2, "Not adding ${file.path} to jar file because it's excluded")
+                                kobaltLog(2, "Not adding ${file.path} to jar file because it's excluded")
                             }
 
                         }
                     } else {
-                        log(2, "Directory $fromPath doesn't exist, not including it in the jar")
+                        kobaltLog(2, "  Directory $fromPath doesn't exist, not including it in the jar")
                     }
                 }
                 if (includedSpecs.size > 0) {
-                    log(3, "Including specs $includedSpecs")
+                    kobaltLog(3, "Including specs $includedSpecs")
                     result.add(IncludedFile(From(includedFile.from), To(includedFile.to), includedSpecs))
                 }
             }
@@ -51,7 +53,9 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
         }
     }
 
-    fun findIncludedFiles(project: Project, context: KobaltContext, jar: Jar) : List<IncludedFile> {
+    override val suffix = ".jar"
+
+    override fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List<IncludedFile> {
         //
         // Add all the applicable files for the current project
         //
@@ -59,7 +63,7 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
         val result = arrayListOf<IncludedFile>()
         val classesDir = KFiles.makeDir(buildDir.path, "classes")
 
-        if (jar.includedFiles.isEmpty()) {
+        if (zip.includedFiles.isEmpty()) {
             // If no includes were specified, assume the user wants a simple jar file made of the
             // classes of the project, so we specify a From("build/classes/"), To("") and
             // a list of files containing everything under it
@@ -69,7 +73,7 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
             // Class files
             val files = KFiles.findRecursively(classesDir).map { File(relClassesDir.toFile(), it) }
             val filesNotExcluded : List<File> = files.filter {
-                ! KFiles.Companion.isExcluded(KFiles.joinDir(project.directory, it.path), jar.excludes)
+                ! KFiles.Companion.isExcluded(KFiles.joinDir(project.directory, it.path), zip.excludes)
             }
             val fileSpecs = arrayListOf<IFileSpec>()
             filesNotExcluded.forEach {
@@ -85,30 +89,30 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
             //
             // The user specified an include, just use it verbatim
             //
-            val includedFiles = findIncludedFiles(project.directory, jar.includedFiles, jar.excludes)
+            val includedFiles = findIncludedFiles(project.directory, zip.includedFiles, zip.excludes, false)
             result.addAll(includedFiles)
         }
 
         //
         // If fatJar is true, add all the transitive dependencies as well: compile, runtime and dependent projects
         //
-        if (jar.fatJar) {
-            log(2, "Creating fat jar")
-
+        if (zip.fatJar) {
             val seen = hashSetOf<String>()
             @Suppress("UNCHECKED_CAST")
-            val dependentProjects = project.projectProperties.get(JvmCompilerPlugin.DEPENDENT_PROJECTS)
-                    as List<ProjectDescription>
-            val allDependencies = project.compileDependencies + project.compileRuntimeDependencies
-            val transitiveDependencies = dependencyManager.calculateDependencies(project, context, dependentProjects,
-                    allDependencies)
+            val allDependencies = project.compileDependencies + project.compileRuntimeDependencies +
+                context.variant.buildType.compileDependencies +
+                context.variant.buildType.compileRuntimeDependencies +
+                context.variant.productFlavor.compileDependencies +
+                context.variant.productFlavor.compileRuntimeDependencies
+            val transitiveDependencies = dependencyManager.calculateDependencies(project, context,
+                    scopes = listOf(Scope.COMPILE), passedDependencies = allDependencies)
             transitiveDependencies.map {
                 it.jarFile.get()
             }.forEach { file : File ->
                 if (! seen.contains(file.path)) {
                     seen.add(file.path)
-                    if (! KFiles.Companion.isExcluded(file, jar.excludes)) {
-                        result.add(IncludedFile(specs = arrayListOf(IFileSpec.FileSpec(file.path)),
+                    if (! KFiles.Companion.isExcluded(file, zip.excludes)) {
+                        result.add(IncludedFile(specs = arrayListOf(IFileSpec.FileSpec(file.absolutePath)),
                                 expandJarFiles = true))
                     }
                 }
@@ -118,20 +122,41 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager)
         return result
     }
 
-    fun generateJar(project: Project, context: KobaltContext, jar: Jar) : File {
-        val allFiles = findIncludedFiles(project, context, jar)
-
+    override fun generateArchive(project: Project, context: KobaltContext, zip: Zip,
+            includedFiles: List<IncludedFile>) : File {
         //
         // Generate the manifest
+        // If manifest attributes were specified in the build file, use those to generateAndSave the manifest. Otherwise,
+        // try to find a META-INF/MANIFEST.MF and use that one if we find any. Otherwise, use the default manifest.
         //
-        val manifest = java.util.jar.Manifest()//FileInputStream(mf))
-        jar.attributes.forEach { attribute ->
-            manifest.mainAttributes.putValue(attribute.first, attribute.second)
+        val manifest =
+            if (zip.attributes.size > 1) {
+                context.logger.log(project.name, 2, "Creating MANIFEST.MF from " + zip.attributes.size + " attributes")
+                Manifest().apply {
+                    zip.attributes.forEach { attribute ->
+                        mainAttributes.putValue(attribute.first, attribute.second)
+                    }
+                }
+            } else {
+                fun findManifestFile(project: Project, includedFiles: List<IncludedFile>): File? {
+                    val allFiles = includedFiles.flatMap { file ->
+                        file.allFromFiles(project.directory).map { file.from(it.path) }
+                    }
+                    val manifestFiles = allFiles.filter { it.path.contains(MetaArchive.MANIFEST_MF) }
+                    return if (manifestFiles.any()) manifestFiles[0] else null
                 }
-        val jarFactory = { os: OutputStream -> JarOutputStream(os, manifest) }
 
-        return Archives.generateArchive(project, context, jar.name, ".jar", allFiles,
-                true /* expandJarFiles */, jarFactory)
+                val manifestFile = findManifestFile(project, includedFiles)
+                if (manifestFile != null) {
+                    context.logger.log(project.name, 2, "Including MANIFEST.MF file $manifestFile")
+                    Manifest(FileInputStream(manifestFile))
+                } else {
+                    null
+                }
+            }
+
+        return Archives.generateArchive(project, context, zip.name, ".jar", includedFiles,
+                true /* expandJarFiles */, manifest)
     }
 
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt

@@ -2,18 +2,18 @@ package com.beust.kobalt
 
 import java.io.File
 
-abstract public class JavaInfo {
-    public var javaExecutable: File? = null
+abstract class JavaInfo {
+    val javaExecutable: File?
         get() = findExecutable("java")
-    public var javacExecutable: File? = null
+    val javacExecutable: File?
         get() = findExecutable("javac")
-    public var javadocExecutable: File? = null
+    val javadocExecutable: File?
         get() = findExecutable("javadoc")
-    abstract public var javaHome: File?
-    abstract public var runtimeJar: File?
-    abstract public var toolsJar: File?
+    abstract var javaHome: File?
+    abstract var runtimeJar: File?
+    abstract var toolsJar: File?
 
-    abstract public fun findExecutable(command: String) : File
+    abstract fun findExecutable(command: String) : File
 
     companion object {
         fun create(javaBase: File?): Jvm {

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt

@@ -1,18 +1,18 @@
 package com.beust.kobalt
 
-import com.beust.kobalt.misc.log
+import com.beust.kobalt.misc.kobaltLog
 import com.beust.kobalt.misc.warn
 import java.io.File
 import java.io.IOException
 
-public open class Jvm constructor(
+open class Jvm constructor(
         val os: OperatingSystem,
         var javaBase: File? = null) : JavaInfo() {
 
     private var _javaHome: File? = null
-    override public var javaHome: File? = null
+    override var javaHome: File? = null
         get() = _javaHome!!
-    override public var runtimeJar: File? = null
+    override var runtimeJar: File? = null
     private fun findRuntimeJar() : File? {
         var runtimeJar = File(javaBase, "lib/rt.jar")
         if (runtimeJar.exists()) {
@@ -21,7 +21,7 @@ public open class Jvm constructor(
         runtimeJar = File(javaBase, "jre/lib/rt.jar")
         return if (runtimeJar.exists()) runtimeJar else null
     }
-    override public var toolsJar: File? = null
+    override var toolsJar: File? = null
 
     private var userSupplied: Boolean? = false
     private var javaVersion: String? = null
@@ -67,7 +67,7 @@ public open class Jvm constructor(
             return toolsJar
         }
         if (javaHome!!.name.equals("jre", true)) {
-            javaHome = javaHome!!.parentFile
+            _javaHome = javaHome!!.parentFile
             toolsJar = File(javaHome, "lib/tools.jar")
             if (toolsJar.exists()) {
                 return toolsJar
@@ -78,7 +78,7 @@ public open class Jvm constructor(
             val version = SystemProperties.Companion.javaVersion
             if (javaHome!!.name.toRegex().matches("jre\\d+")
                     || javaHome!!.name == "jre$version") {
-                javaHome = File(javaHome!!.parentFile, "jdk$version")
+                _javaHome = File(javaHome!!.parentFile, "jdk$version")
                 toolsJar = File(javaHome, "lib/tools.jar")
                 if (toolsJar.exists()) {
                     return toolsJar
@@ -89,15 +89,15 @@ public open class Jvm constructor(
         return null
     }
 
-//    open public fun isIbmJvm(): Boolean {
+//    open fun isIbmJvm(): Boolean {
 //        return false
 //    }
 
-    override public fun findExecutable(command: String): File {
+    override fun findExecutable(command: String): File {
         if (javaHome != null) {
             val jdkHome = if (javaHome!!.endsWith("jre")) javaHome!!.parentFile else javaHome
             val exec = File(jdkHome, "bin/" + command)
-            var executable = File(os.getExecutableName(exec.absolutePath))
+            val executable = File(os.getExecutableName(exec.absolutePath))
             if (executable.isFile) {
                 return executable
             }
@@ -110,7 +110,7 @@ public open class Jvm constructor(
 
         val pathExecutable = os.findInPath(command)
         if (pathExecutable != null) {
-            log(2, "Unable to find the $command executable using home: " +
+            kobaltLog(2, "Unable to find the $command executable using home: " +
                     "$javaHome but found it on the PATH: $pathExecutable.")
             return pathExecutable
         }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt

@@ -3,29 +3,32 @@ package com.beust.kobalt
 import com.beust.kobalt.api.*
 import com.beust.kobalt.api.annotation.IncrementalTask
 import com.beust.kobalt.api.annotation.Task
+import com.beust.kobalt.internal.IncrementalManager
+import com.beust.kobalt.internal.KobaltSettings
 import com.beust.kobalt.internal.PluginInfo
 import com.beust.kobalt.internal.TaskManager
-import com.beust.kobalt.maven.DepFactory
-import com.beust.kobalt.maven.LocalRepo
+import com.beust.kobalt.maven.DependencyManager
 import com.beust.kobalt.misc.JarUtils
 import com.beust.kobalt.misc.KFiles
 import com.beust.kobalt.misc.KobaltExecutors
-import com.beust.kobalt.misc.log
+import com.beust.kobalt.misc.kobaltLog
 import com.google.inject.Provider
+import java.io.File
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
+import java.net.URLClassLoader
 import java.util.*
 import java.util.jar.JarFile
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
-public class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManager>,
+class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManager>,
         val files: KFiles,
-        val depFactory: DepFactory,
-        val localRepo: LocalRepo,
+        val depManager: DependencyManager,
+        val settings: KobaltSettings,
         val executors: KobaltExecutors,
-        val pluginInfo: PluginInfo,
+        val incrementalManagerFactory: IncrementalManager.IFactory,
         val taskManager: TaskManager) {
 
     companion object {
@@ -47,6 +50,8 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider<Tas
         fun findPlugin(name: String) : IPlugin? = pluginMap[name]
     }
 
+    fun shutdownPlugins() = plugins.forEach { it.shutdown() }
+
     fun applyPlugins(context: KobaltContext, projects: List<Project>) {
         plugins.forEach { plugin ->
             addPluginInstance(plugin)
@@ -59,7 +64,7 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider<Tas
             }
 
             // Call apply() on each plug-in that accepts a project
-            log(2, "Applying plug-in \"${plugin.name}\"")
+            kobaltLog(2, "Applying plug-in \"${plugin.name}\"")
             projects.filter { plugin.accept(it) }.forEach { project ->
                 plugin.apply(project, context)
             }
@@ -75,7 +80,26 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider<Tas
 
         // Collect all the tasks from the task contributors
         context.pluginInfo.taskContributors.forEach {
-            taskManager.dynamicTasks.addAll(it.tasksFor(context).map { TaskManager.PluginDynamicTask(it.plugin, it) })
+            projects.forEach { project ->
+                taskManager.dynamicTasks.addAll(it.tasksFor(project, context))
+            }
+        }
+
+        // ... and from the incremental task contributors
+        val incrementalManager = incrementalManagerFactory.create()
+        context.pluginInfo.incrementalTaskContributors.forEach {
+            projects.forEach { project ->
+                it.incrementalTasksFor(project, context).forEach {
+                    // Convert the closure (Project) -> IncrementalTaskInfo to (Project) -> TaskResult
+                    // and create a DynamicTask out of it
+                    val closure =
+                            incrementalManager.toIncrementalTaskClosure(it.name, it.incrementalClosure, Variant())
+                    val task = DynamicTask(it.plugin, it.name, it.doc, it.group, it.project, it.dependsOn,
+                            it.reverseDependsOn, it.runBefore, it.runAfter, it.alwaysRunAfter,
+                            closure)
+                    taskManager.dynamicTasks.add(task)
+                }
+            }
         }
 
         // Now that we have collected all static and dynamic tasks, turn them all into plug-in tasks
@@ -146,20 +170,34 @@ public class Plugins @Inject constructor (val taskManagerProvider : Provider<Tas
 
     val dependencies = arrayListOf<IClasspathDependency>()
 
-    fun installPlugins(dependencies: List<IClasspathDependency>, classLoader: ClassLoader) {
+//    @Inject
+//    lateinit var pluginInfo: PluginInfo
+
+    fun installPlugins(dependencies: List<IClasspathDependency>, scriptClassLoader: ClassLoader) {
         val executor = executors.newExecutor("Plugins", 5)
         dependencies.forEach {
             //
             // Load all the jar files synchronously (can't compile the build script until
             // they are installed locally).
-            depFactory.create(it.id, executor = executor)
+            depManager.create(it.id)
 
             //
             // Open the jar, parse its kobalt-plugin.xml and add the resulting PluginInfo to pluginInfo
             //
-            val pluginXml = JarUtils.extractTextFile(JarFile(it.jarFile.get()), PluginInfo.PLUGIN_XML)
+            val file = it.jarFile.get()
+            val pluginXml = if (file.isDirectory) {
+                // The plug-in can point to a directory (e.g. plugin("classes")), in which case we just
+                // read kobalt-plugin.xml directly
+                File(file, PluginInfo.PLUGIN_XML).readText()
+            } else {
+                // The plug-in is pointing to a jar file, read kobalt-plugin.xml from it
+                JarUtils.extractTextFile(JarFile(file), PluginInfo.PLUGIN_XML)
+            }
+
+            val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java)
             if (pluginXml != null) {
-                val thisPluginInfo = PluginInfo.readPluginXml(pluginXml, classLoader)
+                val pluginClassLoader = URLClassLoader(arrayOf(file.toURI().toURL()))
+                val thisPluginInfo = PluginInfo.readPluginXml(pluginXml, pluginClassLoader, scriptClassLoader)
                 pluginInfo.addPluginInfo(thisPluginInfo)
                 thisPluginInfo.plugins.forEach {
                     Plugins.addPluginInstance(it)

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ResolveDependency.kt

@@ -3,21 +3,20 @@ package com.beust.kobalt
 import com.beust.kobalt.api.IClasspathDependency
 import com.beust.kobalt.maven.LocalRepo
 import com.beust.kobalt.maven.MavenId
-import com.beust.kobalt.maven.RepoFinder
-import com.beust.kobalt.maven.dependency.MavenDependency
-import com.beust.kobalt.misc.KobaltExecutors
-import com.beust.kobalt.misc.Node
-import com.beust.kobalt.misc.log
+import com.beust.kobalt.maven.aether.*
+import com.beust.kobalt.misc.*
 import com.google.inject.Inject
+import org.eclipse.aether.artifact.DefaultArtifact
+import org.eclipse.aether.graph.DependencyNode
 import java.util.*
 
 /**
  * Display information about a Maven id.
  */
-class ResolveDependency @Inject constructor(val repoFinder: RepoFinder,
+class ResolveDependency @Inject constructor(
         val localRepo: LocalRepo,
-        val executors: KobaltExecutors,
-        val mdFactory: MavenDependency.IFactory) {
+        val aether: KobaltMavenResolver,
+        val executors: KobaltExecutors) {
     val increment = 8
     val leftFirst = "\u2558"
     val leftMiddle = "\u255f"
@@ -26,34 +25,51 @@ class ResolveDependency @Inject constructor(val repoFinder: RepoFinder,
 
     class Dep(val dep: IClasspathDependency, val level: Int)
 
-    fun run(ids: List<String>) = ids.forEach { displayDependenciesFor(it) }
+    fun run(id: String) = displayDependenciesFor(id)
+
+    private fun latestMavenArtifact(group: String, artifactId: String, extension: String = "jar"): DependencyNode {
+        val artifact = DefaultArtifact(group, artifactId, extension, "(0,]")
+        val resolved = aether.resolveRange(artifact)
+        if (resolved != null) {
+            val newArtifact = DefaultArtifact(artifact.groupId, artifact.artifactId, artifact.extension,
+                    resolved.highestVersion.toString())
+            val artifactResult = aether.resolve(KobaltMavenResolver.artifactToId(newArtifact), null)
+            return artifactResult.root
+        } else {
+            throw KobaltException("Couldn't find latest artifact for $group:$artifactId")
+        }
+    }
+
+    class PairResult(val dependency: IClasspathDependency, val repoUrl: String)
+
+    fun latestArtifact(group: String, artifactId: String, extension: String = "jar"): PairResult
+            = latestMavenArtifact(group, artifactId, extension).let {
+        PairResult(AetherDependency(it.artifact), "(TBD repo)")
+    }
 
     private fun displayDependenciesFor(id: String) {
-        val repoResult = repoFinder.findCorrectRepo(id)
+        val mavenId = MavenId.create(id)
+        val resolved : PairResult =
+            if (mavenId.hasVersion) {
+                val node = aether.resolve(id, filter = Filters.EXCLUDE_OPTIONAL_FILTER)
+                PairResult(AetherDependency(node.root.artifact), node.artifactResults[0].repository.toString())
+            } else {
+                latestArtifact(mavenId.groupId, mavenId.artifactId)
+            }
 
+        displayDependencies(resolved.dependency, resolved.repoUrl)
+    }
+
+    private fun displayDependencies(dep: IClasspathDependency, url: String) {
         val indent = -1
-
-        val originalId = MavenId.create(id)
-        val mavenId = MavenId.create(originalId.groupId, originalId.artifactId, originalId.packaging,
-                originalId.version)
-
-        val originalDep = mdFactory.create(mavenId, executors.dependencyExecutor,
-                downloadSources = true, downloadJavadocs = true)
-        val packaging = if (mavenId.packaging != null) "@" + mavenId.packaging else ""
-
-        // We want to display the dependencies of the id we found, not the one we queries
-        val dep = mdFactory.create(MavenId.create(originalDep.shortId + repoResult.version + packaging),
-                executors.dependencyExecutor, true, true)
         val root = Node(Dep(dep, indent))
-        val seen = hashSetOf(id)
+        val seen = hashSetOf(dep.id)
         root.addChildren(findChildren(root, seen))
 
-        val url = repoResult.hostConfig.url + repoResult.path
-        val localFile = localRepo.toFullPath(repoResult.path!!)
-        AsciiArt.logBox(listOf(id, url, localFile).map { "          $it" }, {s -> println(s) })
+        kobaltLog(1, AsciiArt.logBox(listOf(dep.id, url, dep.jarFile.get()).map { "          $it" }))
 
         display(root.children)
-        println("")
+        kobaltLog(1, "")
     }
 
     private fun display(nodes: List<Node<Dep>>) {
@@ -65,10 +81,12 @@ class ResolveDependency @Inject constructor(val repoFinder: RepoFinder,
                         else leftMiddle
                 val indent = level * increment
                 for(i in 0..indent - 2) {
-                    if (i % increment == 0) print(vertical)
+                    if (!KobaltLogger.isQuiet) {
+                        if (i == 0 || ((i + 1) % increment == 0)) print(vertical)
                         else print(" ")
                     }
-                println(left + " " + dep.id)
+                }
+                kobaltLog(1, left + " " + dep.id + (if (dep.optional) " (optional)" else ""))
                 display(node.children)
             }
         }
@@ -81,13 +99,18 @@ class ResolveDependency @Inject constructor(val repoFinder: RepoFinder,
             if (! seen.contains(it.id)) {
                 val dep = Dep(it, root.value.level + 1)
                 val node = Node(dep)
-                log(2, "Found dependency ${dep.dep.id} level: ${dep.level}")
+                kobaltLog(2, "Found dependency ${dep.dep.id} level: ${dep.level}")
                 result.add(node)
                 seen.add(it.id)
+                try {
                     node.addChildren(findChildren(node, seen))
+                } catch(ex: Exception) {
+                    if (! it.optional) warn("Couldn't resolve " + node)
+                    // else don't warn about missing optional dependencies
                 }
             }
-        log(2, "Children for ${root.value.dep.id}: ${result.size}")
+        }
+        kobaltLog(2, "Children for ${root.value.dep.id}: ${result.size}")
         return result
     }
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt

@@ -1,9 +1,17 @@
 package com.beust.kobalt
 
-public class SystemProperties {
+class SystemProperties {
     companion object {
-        val javaBase = System.getProperty("java.home") ?:
-                (System.getenv("JAVA_HOME") ?: throw IllegalArgumentException("JAVA_HOME not defined"))
+        val javaBase : String
+            get() {
+                val jh = System.getenv("JAVA_HOME")
+                    ?: System.getProperty("java.home")
+                    ?: throw IllegalArgumentException("JAVA_HOME not defined")
+                val result =
+                    if (jh.toLowerCase().endsWith("jre")) jh.substring(0, jh.length - 4)
+                    else jh
+                return result
+            }
         val javaVersion = System.getProperty("java.version")
         val homeDir = System.getProperty("user.home")
         val tmpDir = System.getProperty("java.io.tmpdir")

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt

@@ -1,3 +1,8 @@
 package com.beust.kobalt
 
-open public class TaskResult(val success: Boolean = true, val errorMessage: String? = null)
+class TestResult(val success: Boolean, val shortMessage: String? = null, val longMessage: String? = null)
+
+open class TaskResult(val success: Boolean = true,
+        val testResult: TestResult? = null,
+        val errorMessage: String? = null
+)

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt

@@ -0,0 +1,40 @@
+package com.beust.kobalt
+
+import com.beust.kobalt.api.Project
+import com.beust.kobalt.api.annotation.Directive
+
+class TestConfig(val project: Project, val isDefault : Boolean = false) {
+    val testArgs = arrayListOf<String>()
+    val jvmArgs = arrayListOf<String>()
+    val testIncludes = arrayListOf("**/*Test.class")
+    val testExcludes = arrayListOf<String>()
+
+    @Directive
+    var name: String = ""
+
+    @Directive
+    fun args(vararg arg: String) {
+        testArgs.addAll(arg)
+    }
+
+    @Directive
+    fun jvmArgs(vararg arg: String) {
+        jvmArgs.addAll(arg)
+    }
+
+    @Directive
+    fun include(vararg arg: String) {
+        testIncludes.apply {
+            clear()
+            addAll(arg)
+        }
+    }
+
+    @Directive
+    fun exclude(vararg arg: String) {
+        testExcludes.apply {
+            clear()
+            addAll(arg)
+        }
+    }
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt

@@ -3,43 +3,13 @@ package com.beust.kobalt
 import com.beust.kobalt.api.Project
 import com.beust.kobalt.api.annotation.Directive
 
-class TestConfig(val project: Project) {
-    val testArgs = arrayListOf<String>()
-    val jvmArgs = arrayListOf<String>()
-    val testIncludes = arrayListOf("**/*Test.class")
-    val testExcludes = arrayListOf<String>()
-
-    var name: String = ""
-
-    fun args(vararg arg: String) {
-        testArgs.addAll(arg)
-    }
-
-    fun jvmArgs(vararg arg: String) {
-        jvmArgs.addAll(arg)
-    }
-
-    fun includes(vararg arg: String) {
-        testIncludes.apply {
-            clear()
-            addAll(arg)
-        }
-    }
-
-    fun excludes(vararg arg: String) {
-        testExcludes.apply {
-            clear()
-            addAll(arg)
-        }
-    }
-}
-
 @Directive
-fun Project.test(init: TestConfig.() -> Unit) = let { project ->
+fun Project.test(init: TestConfig.() -> Unit): TestConfig = let { project ->
     with(testConfigs) {
         val tf = TestConfig(project).apply { init() }
         if (! map { it.name }.contains(tf.name)) {
             add(tf)
+            tf
         } else {
             throw KobaltException("Test configuration \"${tf.name}\" already exists, give it a different "
                     + "name with test { name = ... }")

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt

@@ -2,9 +2,9 @@ package com.beust.kobalt
 
 import com.beust.kobalt.api.*
 import com.beust.kobalt.internal.ActorUtils
+import com.beust.kobalt.internal.ParallelLogger
 import com.beust.kobalt.internal.SourceSet
 import com.beust.kobalt.misc.KFiles
-import com.beust.kobalt.misc.log
 import java.io.File
 import java.util.*
 
@@ -29,12 +29,12 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
     /**
      * for {internal, release}, return [internalRelease, internal, release]
      */
-    fun allDirectories(project: Project): List<String> {
-        val result = arrayListOf<String>()
-        result.add(toCamelcaseDir())
-        if (productFlavor != null) result.add(productFlavor.name)
-        if (buildType != null) result.add(buildType.name)
-        return result
+    fun allDirectories(): List<String> {
+        return arrayListOf<String>().apply {
+            add(toCamelcaseDir())
+            add(productFlavor.name)
+            add(buildType.name)
+        }
     }
 
     fun sourceDirectories(project: Project, context: KobaltContext, sourceSet: SourceSet) : List<File> {
@@ -70,28 +70,27 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
         val result = arrayListOf<File>()
         val sourceDirectories = sourceSet.correctSourceSet(project)
                 .filter { File(project.directory, it).exists() }
-                .map { File(it) }
+                .map(::File)
 
         if (isDefault) {
             result.addAll(sourceDirectories)
         } else {
 //            // The ordering of files is: 1) build type 2) product flavor 3) default
+            val kobaltLog = Kobalt.INJECTOR.getInstance(ParallelLogger::class.java)
             buildType.let {
                 val dir = File(KFiles.joinDir("src", it.name, suffix))
-                log(3, "Adding source for build type ${it.name}: ${dir.path}")
+                kobaltLog.log(project.name, 3, "Adding source for build type ${it.name}: ${dir.path}")
                 result.add(dir)
             }
             productFlavor.let {
                 val dir = File(KFiles.joinDir("src", it.name, suffix))
-                log(3, "Adding source for product flavor ${it.name}: ${dir.path}")
+                kobaltLog.log(project.name, 3, "Adding source for product flavor ${it.name}: ${dir.path}")
                 result.add(dir)
             }
 
-            result.addAll(allDirectories(project).map {
-                File(KFiles.joinDir("src", it, suffix))
-            }.filter {
-                it.exists()
-            })
+            result.addAll(allDirectories()
+                    .map { File(KFiles.joinDir("src", it, suffix)) }
+                    .filter(File::exists))
 
             // Now that all the variant source directories have been added, add the project's default ones
             result.addAll(sourceDirectories)
@@ -114,8 +113,8 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
             if (isDefault) {
                 archiveName ?: project.name + "-" + project.version + suffix
             } else {
-                val base = if (archiveName != null) archiveName.substring(0, archiveName.length - suffix.length)
-                    else project.name + "-" + project.version
+                val base = archiveName?.substring(0, archiveName.length - suffix.length)
+                        ?: project.name + "-" + project.version
                 val flavor = if (productFlavor.name.isEmpty()) "" else "-" + productFlavor.name
                 val type = if (buildType.name.isEmpty()) "" else "-" + buildType.name
                 val result: String = base + flavor + type + suffix
@@ -125,18 +124,16 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
         return result
     }
 
-    val shortArchiveName = if (isDefault) "" else "-" + productFlavor.name + "-" + buildType.name
-
     var generatedSourceDirectory: File? = null
 
     private fun findBuildTypeBuildConfig(project: Project, variant: Variant?) : BuildConfig? {
         val buildTypeName = variant?.buildType?.name
-        return project.buildTypes[buildTypeName]?.buildConfig ?: null
+        return project.buildTypes[buildTypeName]?.buildConfig
     }
 
     private fun findProductFlavorBuildConfig(project: Project, variant: Variant?) : BuildConfig? {
         val buildTypeName = variant?.productFlavor?.name
-        return project.productFlavors[buildTypeName]?.buildConfig ?: null
+        return project.productFlavors[buildTypeName]?.buildConfig
     }
 
     /**
@@ -154,7 +151,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
 
     /**
      * Generate BuildConfig.java if requested. Also look up if any BuildConfig is defined on the current build type,
-     * product flavor or main project, and use them to generate any additional field (in that order to
+     * product flavor or main project, and use them to generateAndSave any additional field (in that order to
      * respect the priorities). Return the generated file if it was generated, null otherwise.
      */
     fun maybeGenerateBuildConfig(project: Project, context: KobaltContext) : File? {
@@ -163,9 +160,10 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
         if (buildConfigs.size > 0) {
             val pkg = project.packageName ?: project.group
                     ?: throw KobaltException(
-                    "packageName needs to be defined on the project in order to generate BuildConfig")
+                    "packageName needs to be defined on the project in order to generateAndSave BuildConfig")
 
-            val contributor = ActorUtils.selectAffinityActor(context.pluginInfo.buildConfigContributors, project)
+            val contributor = ActorUtils.selectAffinityActor(project, context,
+                    context.pluginInfo.buildConfigContributors)
             if (contributor != null) {
                 val code = contributor.generateBuildConfig(project, context, pkg, this, buildConfigs)
                 val result = KFiles.makeDir(KFiles.generatedSourceDir(project, this, "buildConfig"))
@@ -175,10 +173,10 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
                 val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar))
                 val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig." + contributor.buildConfigSuffix)
                 KFiles.saveFile(outputDir, code)
-                log(2, "Generated ${outputDir.path}")
+                context.logger.log(project.name, 2, "Generated ${outputDir.path}")
                 return result
             } else {
-                throw KobaltException("Couldn't find a contributor to generate BuildConfig")
+                throw KobaltException("Couldn't find a contributor to generateAndSave BuildConfig")
             }
         } else {
             return null
@@ -187,9 +185,10 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
 
     override fun toString() = toTask("")
 
+
     companion object {
         val DEFAULT_PRODUCT_FLAVOR = ProductFlavorConfig("")
-        val DEFAULT_BUILD_TYPE = BuildTypeConfig(null, "")
+        val DEFAULT_BUILD_TYPE = BuildTypeConfig("")
 
         fun allVariants(project: Project): List<Variant> {
             val result = arrayListOf<Variant>()
@@ -222,7 +221,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
     }
 
     fun toCamelcaseDir() : String {
-        fun lci(s : String) = if (s.length == 0 || s.length == 1) s else s[0].toLowerCase() + s.substring(1)
+        fun lci(s : String) = if (s.isEmpty() || s.length == 1) s else s[0].toLowerCase() + s.substring(1)
 
         return lci(productFlavor.name) + buildType.name.capitalize()
     }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BasePlugin.kt

@@ -12,6 +12,8 @@ abstract class BasePlugin : IPlugin {
         this.context = context
     }
 
+    override fun shutdown() {}
+
     override lateinit var taskManager: TaskManager
     lateinit var plugins: Plugins
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/BuildTypeConfig.kt

@@ -0,0 +1,11 @@
+package com.beust.kobalt.api
+
+class BuildTypeConfig(val name: String) : IBuildConfig, IDependencyHolder by DependencyHolder() {
+
+    var minifyEnabled = false
+    var applicationIdSuffix: String? = null
+    var proguardFile: String? = null
+
+    override var buildConfig : BuildConfig? = BuildConfig()
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt

@@ -10,6 +10,7 @@ data class CompilerActionInfo(val directory: String?,
         val sourceFiles: List<String>,
         val suffixesBeingCompiled: List<String>,
         val outputDir: File,
-        val compilerArgs: List<String>)
-
-
+        val compilerArgs: List<String>,
+        val friendPaths: List<String>,
+        val forceRecompile: Boolean,
+        val compilerSeparateProcess: Boolean = false)

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt

@@ -0,0 +1,47 @@
+package com.beust.kobalt.api
+
+import com.beust.kobalt.api.annotation.Directive
+import java.util.*
+
+/**
+ * Various elements in a build file let you specify dependencies: projects, buildType and productFlavor.
+ * They all implement this interface and delegate to an instance of the `DependencyHolder` concrete class.
+ */
+interface IDependencyHolder {
+    var project: Project
+
+    val compileDependencies : ArrayList<IClasspathDependency>
+    val optionalDependencies : ArrayList<IClasspathDependency>
+    val compileProvidedDependencies : ArrayList<IClasspathDependency>
+    val compileOnlyDependencies : ArrayList<IClasspathDependency>
+    val compileRuntimeDependencies : ArrayList<IClasspathDependency>
+    val excludedDependencies : ArrayList<IClasspathDependency>
+    val nativeDependencies : ArrayList<IClasspathDependency>
+
+    @Directive
+    var dependencies: Dependencies?
+
+    @Directive
+    fun dependencies(init: Dependencies.() -> Unit) : Dependencies
+}
+
+open class DependencyHolder : IDependencyHolder {
+    override lateinit var project: Project
+    override val compileDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    override val optionalDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    override val compileProvidedDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    override val compileOnlyDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    override val compileRuntimeDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    override val excludedDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    override val nativeDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+
+    override var dependencies : Dependencies? = null
+
+    override fun dependencies(init: Dependencies.() -> Unit) : Dependencies {
+        dependencies = Dependencies(project, compileDependencies, optionalDependencies, compileProvidedDependencies,
+                compileOnlyDependencies, compileRuntimeDependencies, excludedDependencies, nativeDependencies)
+        dependencies!!.init()
+        return dependencies!!
+    }
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IAssemblyContributor.kt

@@ -5,6 +5,6 @@ import com.beust.kobalt.TaskResult
 /**
  * Plug-ins that will be invoked during the "assemble" task.
  */
-interface IAssemblyContributor {
+interface IAssemblyContributor : IContributor {
     fun assemble(project: Project, context: KobaltContext) : TaskResult
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt

@@ -5,7 +5,7 @@ import com.beust.kobalt.Variant
 /**
  * Plug-ins that can generate a BuildConfig file.
  */
-interface IBuildConfigContributor : ISimpleAffinity<Project> {
+interface IBuildConfigContributor : IProjectAffinity {
     fun generateBuildConfig(project: Project, context: KobaltContext, packageName: String, variant: Variant,
             buildConfigs: List<BuildConfig>) : String
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigFieldContributor.kt

@@ -5,6 +5,6 @@ class BuildConfigField(val type: String, val name: String, val value: Any)
 /**
  * Plug-ins that want to add fields to BuildConfig need to implement this interface.
  */
-interface IBuildConfigFieldContributor {
+interface IBuildConfigFieldContributor : IContributor {
     fun fieldsFor(project: Project, context: KobaltContext) : List<BuildConfigField>
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildDirectoryInterceptor.kt

@@ -3,7 +3,7 @@ package com.beust.kobalt.api
 /**
  * Plug-ins can alter the build directory by implementing this interface.
  */
-interface IBuildDirectoryIncerceptor : IInterceptor {
+interface IBuildDirectoryInterceptor : IInterceptor {
     fun intercept(project: Project, context: KobaltContext, buildDirectory: String) : String
 }
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt

@@ -0,0 +1,20 @@
+package com.beust.kobalt.api
+
+/**
+ * Plug-ins that listen to build events.
+ */
+interface IBuildListener : IListener {
+
+    class TaskEndInfo(val success: Boolean, val shortMessage: String? = null,
+            val longMessage: String? = null)
+
+    fun taskStart(project: Project, context: KobaltContext, taskName: String) {}
+    fun taskEnd(project: Project, context: KobaltContext, taskName: String, info: TaskEndInfo) {}
+
+    fun projectStart(project: Project, context: KobaltContext) {}
+    fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) {}
+}
+
+enum class ProjectBuildStatus {
+    SUCCESS, FAILED, SKIPPED
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildReportContributor.kt

@@ -0,0 +1,8 @@
+package com.beust.kobalt.api
+
+/**
+ * Plug-ins that produce build reports.
+ */
+interface IBuildReportContributor : IContributor {
+    fun generateReport(context: KobaltContext)
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt

@@ -16,15 +16,26 @@ interface IClasspathDependency {
     /** Identifier for this dependency */
     val id: String
 
+    /** Version for this identifier */
+    val version: String
+
+    /** @return true if this dependency represents a Maven coordinate */
+    val isMaven: Boolean
+
+    /** @return true if this dependency is optional */
+    val optional: Boolean
+
     /** Absolute path to the jar file on the local file system */
     val jarFile: Future<File>
 
     /** Convert to a Maven <dependency> model tag */
-    fun toMavenDependencies() : Dependency
+    fun toMavenDependencies(scope: String? = null) : Dependency
 
-    /** The list of dependencies for this element (not the transitive closure */
+    /** The list of dependencies for this element (not the transitive closure) */
     fun directDependencies(): List<IClasspathDependency>
 
     /** Used to only keep the most recent version for an artifact if no version was specified */
     val shortId: String
+
+    val excluded: ArrayList<Dependencies.ExcludeConfig>
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt

@@ -2,7 +2,12 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.TaskResult
 
-interface ICompiler {
+interface ICompilerDescription : Comparable<ICompilerDescription> {
+    /**
+     * The name of the language compiled by this compiler.
+     */
+    val name: String
+
     /**
      * The suffixes handled by this compiler (without the dot, e.g. "java" or "kt").
      */
@@ -17,8 +22,47 @@ interface ICompiler {
      * Run the compilation based on the info.
      */
     fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult
+
+    companion object {
+        val DEFAULT_PRIORITY: Int = 10
     }
 
-interface ICompilerContributor : IProjectAffinity {
-    fun compilersFor(project: Project, context: KobaltContext): List<ICompiler>
+    /**
+     * The priority of this compiler. Lower priority compilers are run first.
+     */
+    val priority: Int get() = DEFAULT_PRIORITY
+
+    override fun compareTo(other: ICompilerDescription) = priority.compareTo(other.priority)
+
+    /**
+     * Can this compiler be passed directories or does it need individual source files?
+     */
+    val canCompileDirectories: Boolean get() = false
 }
+
+interface ICompilerContributor : IProjectAffinity, IContributor {
+    fun compilersFor(project: Project, context: KobaltContext): List<ICompilerDescription>
+}
+
+interface ICompiler {
+    fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult
+}
+
+class CompilerDescription(override val name: String,  override val sourceDirectory: String,
+        override val sourceSuffixes: List<String>, val compiler: ICompiler,
+        override val priority: Int = ICompilerDescription.DEFAULT_PRIORITY,
+        override val canCompileDirectories: Boolean = false) : ICompilerDescription {
+    override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult {
+        val result =
+            if (info.sourceFiles.isNotEmpty()) {
+                compiler.compile(project, context, info)
+            } else {
+                context.logger.log(project.name, 2, "$name couldn't find any source files to compile")
+                TaskResult()
+            }
+        return result
+    }
+
+    override fun toString() = name + " compiler"
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt

@@ -3,13 +3,27 @@ package com.beust.kobalt.api
 /**
  * Plugins that add compiler flags.
  */
-interface ICompilerFlagContributor : IContributor {
-    fun flagsFor(project: Project, context: KobaltContext, currentFlags: List<String>,
-            suffixesBeingCompiled: List<String>): List<String>
-    val flagPriority: Int
-        get() = DEFAULT_FLAG_PRIORITY
-
+class FlagContributor(val flagPriority: Int = DEFAULT_FLAG_PRIORITY,
+        val closure: (project: Project, context: KobaltContext, currentFlags: List<String>,
+                suffixesBeingCompiled: List<String>) -> List<String>) : IContributor {
     companion object {
         val DEFAULT_FLAG_PRIORITY = 20
     }
+
+    fun flagsFor(project: Project, context: KobaltContext, currentFlags: List<String>,
+            suffixesBeingCompiled: List<String>) = closure(project, context, currentFlags, suffixesBeingCompiled)
+}
+
+interface IFlagBase {
+    val flagPriority: Int get() = FlagContributor.DEFAULT_FLAG_PRIORITY
+}
+
+interface ICompilerFlagContributor : IContributor, IFlagBase {
+    fun compilerFlagsFor(project: Project, context: KobaltContext, currentFlags: List<String>,
+            suffixesBeingCompiled: List<String>): List<String>
+}
+
+interface IDocFlagContributor : IContributor, IFlagBase {
+    fun docFlagsFor(project: Project, context: KobaltContext, currentFlags: List<String>,
+            suffixesBeingCompiled: List<String>): List<String>
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt

@@ -0,0 +1,88 @@
+package com.beust.kobalt.api
+
+import com.beust.kobalt.maven.aether.Filters.EXCLUDE_OPTIONAL_FILTER
+import com.beust.kobalt.maven.aether.KobaltMavenResolver
+import com.beust.kobalt.maven.aether.Scope
+import com.beust.kobalt.misc.kobaltLog
+import org.eclipse.aether.graph.DependencyFilter
+import org.eclipse.aether.graph.DependencyNode
+
+/**
+ * Manage the creation of dependencies and also provide dependencies for projects.
+ */
+interface IDependencyManager {
+    /**
+     * Parse the id and return the correct IClasspathDependency
+     */
+    fun create(id: String, optional: Boolean = false, projectDirectory: String? = null): IClasspathDependency
+
+    /**
+     * Create an IClasspathDependency from a Maven id.
+     */
+    fun createMaven(id: String, optional: Boolean = false): IClasspathDependency
+
+    /**
+     * Create an IClasspathDependency from a path.
+     */
+    fun createFile(path: String): IClasspathDependency
+
+    /**
+     * @return the source dependencies for this project, including the contributors.
+     */
+    fun dependencies(project: Project, context: KobaltContext, scopes: List<Scope>): List<IClasspathDependency>
+
+    /**
+     * @return the test dependencies for this project, including the contributors.
+     */
+    fun testDependencies(project: Project, context: KobaltContext): List<IClasspathDependency>
+
+    /**
+     * @return the classpath for this project, including the IClasspathContributors.
+     * allDependencies is typically either compileDependencies or testDependencies
+     */
+    fun calculateDependencies(project: Project?, context: KobaltContext,
+            dependencyFilter: DependencyFilter =
+                createDependencyFilter(project, project?.compileDependencies ?: emptyList()),
+            scopes: List<Scope> = listOf(Scope.COMPILE),
+            vararg passedDependencies: List<IClasspathDependency>): List<IClasspathDependency>
+
+    /**
+     * Create an Aether dependency filter that uses the dependency configuration included in each
+     * IClasspathDependency.
+     */
+    fun createDependencyFilter(project: Project?, dependencies: List<IClasspathDependency>) : DependencyFilter {
+        return DependencyFilter { p0, p1 ->
+            fun isNodeExcluded(node: DependencyNode, passedDep: IClasspathDependency) : Boolean {
+                val dep = create(KobaltMavenResolver.artifactToId(node.artifact))
+                return passedDep.excluded.any { ex -> ex.isExcluded(dep)}
+            }
+            fun isDepExcluded(node: DependencyNode, excluded: List<IClasspathDependency>?) : Boolean {
+                val dep = create(KobaltMavenResolver.artifactToId(node.artifact))
+                return excluded?.map { it.id }?.contains(dep.id) ?: false
+            }
+
+            val accept = dependencies.isEmpty() || dependencies.any {
+                // Is this dependency excluded?
+                val isExcluded = isNodeExcluded(p0, it) || isDepExcluded(p0, project?.excludedDependencies)
+
+                // Is the parent dependency excluded?
+                val isParentExcluded =
+                    if (p1.any()) {
+                        isNodeExcluded(p1[0], it) || isDepExcluded(p1[0], project?.excludedDependencies)
+                    } else {
+                        false
+                    }
+
+                // Only accept if no exclusions were found
+                ! isExcluded && ! isParentExcluded
+            }
+
+            if (! accept) {
+                kobaltLog(2, "Excluding $p0")
+            }
+
+            if (accept) EXCLUDE_OPTIONAL_FILTER.accept(p0, p1)
+            else accept
+        }
+    }
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDocContributor.kt

@@ -2,7 +2,7 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.TaskResult
 
-interface IDocContributor : IProjectAffinity {
+interface IDocContributor : IProjectAffinity, IContributor {
     fun generateDoc(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult
 }
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalAssemblyContributor.kt

@@ -0,0 +1,12 @@
+package com.beust.kobalt.api
+
+import com.beust.kobalt.IncrementalTaskInfo
+
+/**
+ * Plug-ins that will be invoked during the "assemble" task and wish to return an incremental task instead
+ * of a regular one.
+ */
+interface IIncrementalAssemblyContributor : IContributor {
+    fun assemble(project: Project, context: KobaltContext) : IncrementalTaskInfo
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IIncrementalTaskContributor.kt

@@ -0,0 +1,28 @@
+package com.beust.kobalt.api
+
+import com.beust.kobalt.IncrementalTaskInfo
+
+/**
+ * Plug-ins that need to add incremental dynamic tasks (tasks that are not methods annotated with @Task) need
+ * to implement this interface.
+ */
+interface IIncrementalTaskContributor : IContributor {
+    fun incrementalTasksFor(project: Project, context: KobaltContext) : List<IncrementalDynamicTask>
+}
+
+class IncrementalDynamicTask(val context: KobaltContext,
+        val plugin: IPlugin,
+        val name: String,
+        val doc: String,
+        val group: String,
+        val project: Project,
+        val dependsOn: List<String> = listOf<String>(),
+        val reverseDependsOn: List<String> = listOf<String>(),
+        val runBefore: List<String> = listOf<String>(),
+        val runAfter: List<String> = listOf<String>(),
+        val alwaysRunAfter: List<String> = listOf<String>(),
+        val incrementalClosure: (Project) -> IncrementalTaskInfo) {
+    override fun toString() = "[IncrementalDynamicTask $name dependsOn=$dependsOn reverseDependsOn=$reverseDependsOn]"
+}
+
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IJvmFlagContributor.kt

@@ -0,0 +1,13 @@
+package com.beust.kobalt.api
+
+/**
+ * Plug-ins that add flags to the JVM used to run apps  should implement this interface.
+ */
+interface IJvmFlagContributor : IContributor {
+    /**
+     * The list of JVM flags that will be added to the JVM when the app gets run. @param[currentFlags] is only here
+     * for convenience, in case you need to look at the current JVM flags before adding your own flags.
+     */
+    fun jvmFlagsFor(project: Project, context: KobaltContext, currentFlags: List<String>) : List<String>
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ILocalMavenRepoPathInterceptor.kt

@@ -0,0 +1,8 @@
+package com.beust.kobalt.api
+
+/**
+ * Plug-ins that want to override the local maven repo path.
+ */
+interface ILocalMavenRepoPathInterceptor : IInterceptor {
+    fun repoPath(currentPath: String) : String
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPlugin.kt

@@ -2,9 +2,29 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.internal.TaskManager
 
-public interface IPlugin : IPluginActor {
+interface IPlugin : IPluginActor {
+    /**
+     * The name of this plug-in.
+     */
     val name: String
+
+    /**
+     * @return true if this plug-in decided it should be enabled for this project.
+     */
     fun accept(project: Project) : Boolean
+
+    /**
+     * Invoked on all plug-ins before the Kobalt execution stops.
+     */
+    fun shutdown()
+
+    /**
+     * Main entry point for a plug-in to initialize itself based on a project and a context.
+     */
     fun apply(project: Project, context: KobaltContext) {}
+
+    /**
+     * Injected by Kobalt to manage tasks.
+     */
     var taskManager : TaskManager
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IPluginActor.kt

@@ -1,7 +1,15 @@
 package com.beust.kobalt.api
 
-interface IPluginActor
+interface IPluginActor {
+    /**
+     * Clean up any state that your actor might have saved so it can be run again.
+     */
+    fun cleanUpActors() {}
+}
 
 interface IContributor : IPluginActor
 
 interface IInterceptor : IPluginActor
+
+interface IListener : IPluginActor
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt

@@ -1,10 +1,11 @@
 package com.beust.kobalt.api
 
 import com.beust.kobalt.TaskResult
-import com.beust.kobalt.api.IClasspathDependency
 
 /**
  * Plugins that can run a project (task "run" or "test") should implement this interface.
+ *
+ * Currently not used.
  */
 interface IRunnerContributor : IContributor, IProjectAffinity {
     /**

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISimpleAffinity.kt

@@ -8,5 +8,5 @@ interface ISimpleAffinity<T> : IAffinity {
      * @return an integer indicating the affinity of your actor. The actor that returns
      * the highest affinity gets selected.
      */
-    fun affinity(arg: T) : Int
+    fun affinity(project: T) : Int
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoriesInterceptor.kt

@@ -5,7 +5,7 @@ import java.io.File
 /**
  * Plug-ins can alter the source directories by implementing this interface.
  */
-interface ISourceDirectoryIncerceptor : IInterceptor {
+interface ISourceDirectoryInterceptor : IInterceptor {
     fun intercept(project: Project, context: KobaltContext, sourceDirectories: List<File>) : List<File>
 }
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ISourceDirectoryContributor.kt

@@ -5,7 +5,7 @@ import java.io.File
 /**
  * Plug-ins that add source directories to be compiled need to implement this interface.
  */
-interface ISourceDirectoryContributor {
+interface ISourceDirectoryContributor : IContributor {
     fun sourceDirectoriesFor(project: Project, context: KobaltContext): List<File>
 }
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt

@@ -1,17 +1,32 @@
 package com.beust.kobalt.api
 
 import com.beust.kobalt.TaskResult
+import com.beust.kobalt.internal.TaskResult2
 
 /**
  * Plug-ins that need to add dynamic tasks (tasks that are not methods annotated with @Task) need
  * to implement this interface.
  */
 interface ITaskContributor : IContributor {
-    fun tasksFor(context: KobaltContext) : List<DynamicTask>
+    fun tasksFor(project: Project, context: KobaltContext) : List<DynamicTask>
 }
 
-class DynamicTask(val plugin: IPlugin, val name: String, val description: String = "",
+class DynamicTask(override val plugin: IPlugin, override val name: String, override val doc: String,
+        override val group: String,
+        override val project: Project,
+        val dependsOn: List<String> = listOf<String>(),
+        val reverseDependsOn: List<String> = listOf<String>(),
         val runBefore: List<String> = listOf<String>(),
         val runAfter: List<String> = listOf<String>(),
         val alwaysRunAfter: List<String> = listOf<String>(),
-        val closure: (Project) -> TaskResult)
+        val closure: (Project) -> TaskResult) : ITask {
+
+    override fun call(): TaskResult2<ITask> {
+        val taskResult = closure.invoke(project)
+        return TaskResult2(taskResult.success, errorMessage = taskResult.errorMessage, value = this)
+    }
+
+    override fun toString() =
+        "[DynamicTask ${project.name}:$name dependsOn=$dependsOn reverseDependsOn=$reverseDependsOn]"
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITemplateContributor.kt

@@ -6,7 +6,7 @@ import com.beust.kobalt.Args
  * Plugins that want to participate in the --init process (they can generate files to initialize
  * a new project).
  */
-interface ITemplateContributor {
+interface ITemplateContributor : IContributor {
     companion object {
         val DIRECTORY_NAME = "templates"
     }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagContributor.kt

@@ -0,0 +1,12 @@
+package com.beust.kobalt.api
+
+/**
+ * Plug-ins that add flags to the JVM used to run tests should implement this interface.
+ */
+interface ITestJvmFlagContributor : IContributor {
+    /**
+     * The list of JVM flags that will be added to the JVM when the tests get run. @param[currentFlags] is only here
+     * for convenience, in case you need to look at the current JVM flags before adding your own flags.
+     */
+    fun testJvmFlagsFor(project: Project, context: KobaltContext, currentFlags: List<String>) : List<String>
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestJvmFlagInterceptor.kt

@@ -0,0 +1,14 @@
+package com.beust.kobalt.api
+
+/**
+ * Plug-ins that add flags to the JVM used to run tests should implement this interface.
+ */
+interface ITestJvmFlagInterceptor : IInterceptor {
+    /**
+     * @return the list of all flags that should be used. If you only want to add flags to the current list,
+     * just return the concatenation of @param[currentFlags] and your own list (or use ITestJvmFlagContributor).
+     * If you actually alter the list of flags, make sure you don't remove anything critical from @param[currentFlags].
+     */
+    fun testJvmFlagsFor(project: Project, context: KobaltContext, currentFlags: List<String>) : List<String>
+}
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITestSourceDirectoryContributor.kt

@@ -3,9 +3,9 @@ package com.beust.kobalt.api
 import java.io.File
 
 /**
- * Plug-ins that add tets source directories to be compiled need to implement this interface.
+ * Plug-ins that add test source directories to be compiled need to implement this interface.
  */
-interface ITestSourceDirectoryContributor {
+interface ITestSourceDirectoryContributor : IContributor {
     fun testSourceDirectoriesFor(project: Project, context: KobaltContext): List<File>
 }
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt

@@ -0,0 +1,55 @@
+package com.beust.kobalt.api
+
+import com.beust.kobalt.Args
+import com.beust.kobalt.misc.KFiles
+import com.beust.kobalt.misc.kobaltLog
+import java.io.*
+import java.net.URL
+import java.util.jar.JarInputStream
+
+/**
+ * Base class for templates that decompress a jar file.
+ */
+interface InputStreamJarTemplate : ITemplate {
+    val inputStream: InputStream
+
+    override fun generateTemplate(args: Args, classLoader: ClassLoader) {
+        val destDir = File(".")
+        JarInputStream(inputStream).use { ins ->
+            var entry = ins.nextEntry
+            while (entry != null) {
+                val f = File(destDir.path + File.separator + entry.name)
+                if (entry.isDirectory) {
+                    f.mkdir()
+                    entry = ins.nextEntry
+                    continue
+                }
+
+                kobaltLog(2, "  Extracting: $entry to ${f.absolutePath}")
+                FileOutputStream(f).use { fos ->
+                    KFiles.copy(ins, fos)
+                }
+                entry = ins.nextEntry
+            }
+        }
+    }
+}
+
+abstract class ResourceJarTemplate(jarName: String, val classLoader: ClassLoader) : InputStreamJarTemplate {
+    override val inputStream : InputStream = classLoader.getResource(jarName).openConnection().inputStream
+}
+
+abstract class FileJarTemplate(val fileName: String) : InputStreamJarTemplate {
+    override val inputStream = FileInputStream(File(fileName))
+}
+
+abstract class HttpJarTemplate(val url: String) : InputStreamJarTemplate {
+    override val inputStream : InputStream
+        get() {
+            try {
+                return URL(url).openConnection().inputStream
+            } catch(ex: IOException) {
+                throw IllegalArgumentException("Couldn't connect to $url")
+            }
+        }
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarFinder.kt

@@ -1,20 +1,15 @@
 package com.beust.kobalt.api
 
-import com.beust.kobalt.maven.DepFactory
-import com.beust.kobalt.misc.KobaltExecutors
+import com.beust.kobalt.maven.DependencyManager
 import java.io.File
 import java.util.concurrent.Future
 
-public class JarFinder {
+class JarFinder {
     companion object {
         /**
          * @return a Future for the jar file corresponding to this id.
          */
-        fun byIdFuture(id: String) : Future<File> {
-            val executor = Kobalt.INJECTOR.getInstance(KobaltExecutors::class.java).miscExecutor
-            val depFactory = Kobalt.INJECTOR.getInstance(DepFactory::class.java)
-            return depFactory.create(id, executor = executor).jarFile
-        }
+        fun byIdFuture(id: String) : Future<File> = DependencyManager.create(id).jarFile
 
         /**
          * @return the jar file corresponding to this id. This might cause a network call.

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarTemplate.kt

@@ -1,41 +0,0 @@
-package com.beust.kobalt.api
-
-import com.beust.kobalt.Args
-import com.beust.kobalt.misc.KFiles
-import com.beust.kobalt.misc.log
-import java.io.File
-import java.io.FileOutputStream
-import java.util.jar.JarInputStream
-
-/**
- * Base class for templates that simply decompress a jar file to generate their project.
- */
-abstract class JarTemplate(val jarName: String) : ITemplate {
-    companion object {
-        fun extractFile(ins: JarInputStream, destDir: File) {
-            var entry = ins.nextEntry
-            while (entry != null) {
-                val f = File(destDir.path + File.separator + entry.name)
-                if (entry.isDirectory) {
-                    f.mkdir()
-                    entry = ins.nextEntry
-                    continue
-                }
-
-                log(2, "Extracting: $entry to ${f.absolutePath}")
-                FileOutputStream(f).use { fos ->
-                    KFiles.copy(ins, fos)
-                }
-                entry = ins.nextEntry
-            }
-        }
-    }
-
-    override fun generateTemplate(args: Args, classLoader: ClassLoader) {
-        log(2, "Generating template with class loader $classLoader")
-        val destDir = File(".")
-        val ins = JarInputStream(classLoader.getResource(jarName).openConnection().inputStream)
-        extractFile(ins, destDir)
-    }
-
-}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt

@@ -3,38 +3,62 @@ package com.beust.kobalt.api
 import com.beust.kobalt.Constants
 import com.beust.kobalt.HostConfig
 import com.beust.kobalt.Plugins
+import com.beust.kobalt.internal.PluginInfo
+import com.beust.kobalt.maven.DependencyManager
+import com.beust.kobalt.maven.aether.KobaltMavenResolver
+import com.google.inject.Guice
 import com.google.inject.Injector
+import com.google.inject.Module
 import java.io.InputStream
 import java.time.Duration
 import java.util.*
 
-public class Kobalt {
+class Kobalt {
     companion object {
-        // This injector will eventually be replaced with a different injector initialized with the
-        // correct arguments (or with a TestModule) but it's necessary to give it a default value
-        // here so the kobalt-plugin.xml file can be read since this is done very early
         lateinit var INJECTOR : Injector
 
+        fun init(module: Module) {
+            Kobalt.INJECTOR = Guice.createInjector(module)
+
+            //
+            // Add all the plugins read in kobalt-plugin.xml to the Plugins singleton, so that code
+            // in the build file that calls Plugins.findPlugin() can find them (code in the
+            // build file do not have access to the KobaltContext).
+            //
+            val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java)
+            pluginInfo.plugins.forEach { Plugins.addPluginInstance(it) }
+        }
+
         var context: KobaltContext? = null
 
         /**
-         * @return the repos calculated from the following places:
-         * - Either repos specified in settings.xml or from Constants.DEFAULT_REPOS
-         * - Repos from the build file
+         * @return the repos calculated from various places where repos can be specified.
          */
         val repos : Set<HostConfig>
             get() {
-                val settingsRepos = Kobalt.context?.settings?.defaultRepos ?: emptyList()
+                val settingsRepos = Kobalt.context?.settings?.defaultRepos?.map { HostConfig(it) } ?: emptyList()
+                // Repos from <default-repos> in the settings
                 val result = ArrayList(
                         (if (settingsRepos.isEmpty()) Constants.DEFAULT_REPOS
                         else settingsRepos)
-                    .map { HostConfig(it) })
+                    )
 
+                // Repo from <kobalt-compiler-repo> in the settings
+                Kobalt.context?.settings?.kobaltCompilerRepo?.let {
+                    result.add(HostConfig(it))
+                }
+
+                // Repos from the repo contributors
                 Kobalt.context?.pluginInfo?.repoContributors?.forEach {
                     result.addAll(it.reposFor(null))
                 }
 
+                // Repos from the build file
                 result.addAll(reposFromBuildFiles)
+
+                result.forEach {
+                    KobaltMavenResolver.initAuthentication(it)
+                }
                 return result.toHashSet()
             }
 
@@ -44,6 +68,13 @@ public class Kobalt {
                 if (repo.url.endsWith("/")) repo
                 else repo.copy(url = (repo.url + "/")))
 
+        val buildFileClasspath = arrayListOf<IClasspathDependency>()
+
+        fun addBuildFileClasspath(dep: String) {
+            val dependencyManager = Kobalt.INJECTOR.getInstance(DependencyManager::class.java)
+            buildFileClasspath.add(dependencyManager.create(dep))
+        }
+
         private val KOBALT_PROPERTIES = "kobalt.properties"
         private val PROPERTY_KOBALT_VERSION = "kobalt.version"
         private val PROPERTY_KOBALT_VERSION_CHECK_TIMEOUT = "kobalt.version.checkTimeout"  // ISO-8601
@@ -83,11 +114,28 @@ public class Kobalt {
             properties.forEach { es -> System.setProperty(es.key.toString(), es.value.toString()) }
         }
 
-        val version = kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION)
+        val version: String
+            get() = kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION)
+
         // Note: Duration is Java 8 only, might need an alternative if we want to support Java < 8
-        val versionCheckTimeout = Duration.parse(
-                kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION_CHECK_TIMEOUT) ?: "P1D")
+        val versionCheckTimeout: Duration
+            get() = Duration.parse( kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION_CHECK_TIMEOUT) ?: "P1D")
 
         fun findPlugin(name: String) = Plugins.findPlugin(name)
+
+        val optionsFromBuild = arrayListOf<String>()
+        fun addKobaltOptions(options: Array<out String>) {
+            optionsFromBuild.addAll(options)
+        }
+
+        val buildSourceDirs = arrayListOf<String>()
+        fun addBuildSourceDirs(dirs: Array<out String>) {
+            buildSourceDirs.addAll(dirs)
+        }
+
+        fun cleanUp() {
+            buildSourceDirs.clear()
+            buildFileClasspath.clear()
+        }
     }
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt

@@ -1,25 +1,77 @@
 package com.beust.kobalt.api
 
 import com.beust.kobalt.Args
+import com.beust.kobalt.KobaltException
 import com.beust.kobalt.Plugins
 import com.beust.kobalt.Variant
+import com.beust.kobalt.internal.ILogger
+import com.beust.kobalt.internal.IncrementalManager
 import com.beust.kobalt.internal.KobaltSettings
 import com.beust.kobalt.internal.PluginInfo
 import com.beust.kobalt.maven.DependencyManager
+import com.beust.kobalt.maven.MavenId
+import com.beust.kobalt.maven.PomGenerator
+import com.beust.kobalt.maven.SimpleDep
+import com.beust.kobalt.maven.aether.KobaltMavenResolver
 import com.beust.kobalt.misc.KobaltExecutors
+import java.io.File
 
-public class KobaltContext(val args: Args) {
-    var variant: Variant = Variant()
+class KobaltContext(val args: Args) {
+    lateinit var variant: Variant
     val profiles = arrayListOf<String>()
 
     init {
-        args.profiles?.split(",")?.filterNotNull()?.forEach {
+        args.profiles?.split(',')?.filterNotNull()?.forEach {
             profiles.add(it)
         }
     }
 
     fun findPlugin(name: String) = Plugins.findPlugin(name)
 
+    /**
+     * Files that can be resolved in the local cache.
+     */
+    enum class FileType { JAR, POM, SOURCES, JAVADOC, OTHER }
+
+    /**
+     * @param{id} is the Maven coordinate (e.g. "org.testng:testng:6.9.11"). If you are looking for a file
+     * that is not described by the enum (e.g. "aar"), use OTHER and make sure your @param{id} contains
+     * the fully qualified id (e.g. "com.example:example::aar:1.0").
+     */
+    fun fileFor(id: String, fileType: FileType) : File {
+        val dep = SimpleDep(MavenId.create(id))
+        fun toQualifier(dep: SimpleDep, ext: String, qualifier: String?) =
+                dep.groupId + ":" + dep.artifactId +
+                    ":$ext" +
+                    (if (qualifier != null) ":$qualifier" else "") +
+                    ":" + dep.version
+        val fullId =
+            when (fileType) {
+                FileType.JAR -> toQualifier(dep, "jar", null)
+                FileType.POM -> toQualifier(dep, "pom", null)
+                FileType.SOURCES -> toQualifier(dep, "", "sources")
+                FileType.JAVADOC -> toQualifier(dep, "", "javadoc")
+                FileType.OTHER -> id
+            }
+        val resolved = resolver.resolveToArtifact(fullId)
+        if (resolved != null) {
+            return resolved.file
+        } else {
+            throw KobaltException("Couldn't resolve $id")
+        }
+    }
+
+    /**
+     * @return the content of the pom.xml for the given project.
+     */
+    fun generatePom(project: Project) = pomGeneratorFactory.create(project).generate()
+
+    /** All the projects that are being built during this run */
+    val allProjects = arrayListOf<Project>()
+
+    /** For internal use only */
+    val internalContext = InternalContext()
+
     //
     // Injected
     //
@@ -28,5 +80,37 @@ public class KobaltContext(val args: Args) {
     lateinit var dependencyManager: DependencyManager
     lateinit var executors: KobaltExecutors
     lateinit var settings: KobaltSettings
+    lateinit var incrementalManager: IncrementalManager
+    lateinit var resolver: KobaltMavenResolver
+    lateinit var pomGeneratorFactory: PomGenerator.IFactory
+    lateinit var logger: ILogger
 }
 
+class InternalContext {
+    /**
+     * When an incremental task decides it's up to date, it sets this boolean to true so that subsequent
+     * tasks in that project can be skipped as well. This is an internal field that should only be set by Kobalt.
+     */
+    private val incrementalSuccesses = hashSetOf<String>()
+    fun previousTaskWasIncrementalSuccess(projectName: String) = incrementalSuccesses.contains(projectName) ?: false
+    fun setIncrementalSuccess(projectName: String) = incrementalSuccesses.add(projectName)
+
+    /**
+     * Keep track of whether the build file was modified. If this boolean is true, incremental compilation
+     * will be disabled.
+     */
+    var buildFileOutOfDate: Boolean = false
+
+    /**
+     * The absolute directory of the current project.
+     */
+    var absoluteDir: File? = null
+
+    /**
+     * If true, will force a recompile of the files even if using the incremental compile
+     */
+    var forceRecompile: Boolean = false
+
+    var noIncrementalKotlin: Boolean = false
+
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/PluginTask.kt

@@ -1,16 +1,20 @@
 package com.beust.kobalt.api
 
 import com.beust.kobalt.internal.TaskResult2
-import com.beust.kobalt.misc.toString
 import java.util.concurrent.Callable
 
-abstract public class PluginTask : Callable<TaskResult2<PluginTask>> {
-    abstract val plugin: IPlugin
-    open val name: String = ""
-    open val doc: String = ""
-    abstract val project: Project
+interface ITask : Callable<TaskResult2<ITask>> {
+    val plugin: IPlugin
+    val project: Project
+    val name: String
+    val doc: String
+    val group: String
+}
 
-    override public fun toString() : String {
-        return toString("PluginTask", "plugin", plugin.name, "id", project.name + ":" + name)
-    }
+abstract class PluginTask : ITask {
+    override val name: String = ""
+    override open val doc: String = ""
+    override open val group: String = "other"
+
+    override fun toString() = project.name + ":" + name
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ProductFlavorConfig.kt

@@ -0,0 +1,9 @@
+package com.beust.kobalt.api
+
+class ProductFlavorConfig(val name: String) : IBuildConfig,
+        IDependencyHolder by DependencyHolder() {
+    var applicationId: String? = null
+    override var buildConfig : BuildConfig? = BuildConfig()
+}
+
+

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt

@@ -2,11 +2,17 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.TestConfig
 import com.beust.kobalt.api.annotation.Directive
-import com.beust.kobalt.internal.JvmCompilerPlugin
-import com.beust.kobalt.maven.dependency.MavenDependency
+import com.beust.kobalt.maven.DependencyManager
+import com.beust.kobalt.maven.aether.AetherDependency
+import com.beust.kobalt.maven.aether.KobaltMavenResolver
 import com.beust.kobalt.misc.KFiles
+import com.beust.kobalt.misc.kobaltLog
+import org.apache.maven.model.Model
 import java.io.File
 import java.util.*
+import java.util.concurrent.Future
+import java.util.concurrent.FutureTask
+import java.util.regex.Pattern
 
 open class Project(
         @Directive open var name: String = "",
@@ -16,22 +22,27 @@ open class Project(
         @Directive open var group: String? = null,
         @Directive open var artifactId: String? = null,
         @Directive open var packaging: String? = null,
-        @Directive open var dependencies: Dependencies? = null,
         @Directive open var description : String = "",
-        @Directive open var scm : Scm? = null,
         @Directive open var url: String? = null,
-        @Directive open var licenses: List<License> = arrayListOf<License>(),
-        @Directive open var packageName: String? = group) : IBuildConfig {
+        @Directive open var pom: Model? = null,
+        @Directive open var dependsOn: ArrayList<Project> = arrayListOf<Project>(),
+        @Directive open var testsDependOn: ArrayList<Project> = arrayListOf<Project>(),
+        @Directive open var packageName: String? = group)
+    : IBuildConfig, IDependencyHolder by DependencyHolder() {
+
+    init {
+        this.project = this
+    }
+
+    fun allProjectDependedOn() = project.dependsOn + project.testsDependOn
 
     class ProjectExtra(project: Project) {
-        val dependsOn = arrayListOf<Project>()
-
         var isDirty = false
 
         /**
          * @return true if any of the projects we depend on is dirty.
          */
-        fun dependsOnDirtyProjects(project: Project) = project.projectExtra.dependsOn.any { it.projectExtra.isDirty }
+        fun dependsOnDirtyProjects(project: Project) = project.allProjectDependedOn().any { it.projectExtra.isDirty }
     }
 
     /**
@@ -42,7 +53,7 @@ open class Project(
 
     val testConfigs = arrayListOf<TestConfig>()
 
-    // If one is specified by default, we only generate a BuildConfig, find a way to fix that
+    // If one is specified by default, we only generateAndSave a BuildConfig, find a way to fix that
     override var buildConfig : BuildConfig? = null // BuildConfig()
 
     val projectProperties = ProjectProperties()
@@ -50,10 +61,6 @@ open class Project(
     override fun equals(other: Any?) = name == (other as Project).name
     override fun hashCode() = name.hashCode()
 
-    /** Can be used by plug-ins */
-    val dependentProjects : List<ProjectDescription>
-            get() = projectProperties.get(JvmCompilerPlugin.DEPENDENT_PROJECTS) as List<ProjectDescription>
-
     companion object {
         val DEFAULT_SOURCE_DIRECTORIES = setOf("src/main/java", "src/main/kotlin", "src/main/resources")
         val DEFAULT_SOURCE_DIRECTORIES_TEST = setOf("src/test/java", "src/test/kotlin", "src/test/resources")
@@ -81,23 +88,11 @@ open class Project(
     // Dependencies
     //
 
-    @Directive
-    fun dependencies(init: Dependencies.() -> Unit) : Dependencies {
-        dependencies = Dependencies(this, compileDependencies, compileProvidedDependencies, compileRuntimeDependencies,
-                excludedDependencies)
-        dependencies!!.init()
-        return dependencies!!
-    }
-
-    val compileDependencies : ArrayList<IClasspathDependency> = arrayListOf()
-    val compileProvidedDependencies : ArrayList<IClasspathDependency> = arrayListOf()
-    val compileRuntimeDependencies : ArrayList<IClasspathDependency> = arrayListOf()
-    val excludedDependencies : ArrayList<IClasspathDependency> = arrayListOf()
-
     @Directive
     fun dependenciesTest(init: Dependencies.() -> Unit) : Dependencies {
-        dependencies = Dependencies(this, testDependencies, testProvidedDependencies, compileRuntimeDependencies,
-                excludedDependencies)
+        dependencies = Dependencies(this, testDependencies, arrayListOf(),
+                testProvidedDependencies, compileOnlyDependencies, compileRuntimeDependencies,
+                excludedDependencies, nativeDependencies)
         dependencies!!.init()
         return dependencies!!
     }
@@ -105,6 +100,9 @@ open class Project(
     val testDependencies : ArrayList<IClasspathDependency> = arrayListOf()
     val testProvidedDependencies : ArrayList<IClasspathDependency> = arrayListOf()
 
+    fun testsDependOn(vararg projects: Project) = testsDependOn.addAll(projects)
+    fun dependsOn(vararg projects: Project) = dependsOn.addAll(projects)
+
     /** Used to disambiguate various name properties */
     @Directive
     val projectName: String get() = name
@@ -130,6 +128,20 @@ open class Project(
         })
         return result
     }
+
+    class Dep(val file: File, val id: String)
+
+    /**
+     * @return a list of the transitive dependencies (absolute paths to jar files) for the given dependencies.
+     * Can be used for example as `collect(compileDependencies)`.
+     */
+    @Directive
+    fun collect(dependencies: List<IClasspathDependency>) : List<Dep> {
+        return (Kobalt.context?.dependencyManager?.transitiveClosure(dependencies) ?: emptyList())
+            .map { Dep(it.jarFile.get(), it.id) }
+    }
+
+    override fun toString() = "[Project $name]"
 }
 
 class Sources(val project: Project, val sources: HashSet<String>) {
@@ -139,45 +151,123 @@ class Sources(val project: Project, val sources: HashSet<String>) {
     }
 }
 
-class Dependencies(val project: Project, val dependencies: ArrayList<IClasspathDependency>,
+class Dependencies(val project: Project,
+        val dependencies: ArrayList<IClasspathDependency>,
+        val optionalDependencies: ArrayList<IClasspathDependency>,
         val providedDependencies: ArrayList<IClasspathDependency>,
+        val compileOnlyDependencies: ArrayList<IClasspathDependency>,
         val runtimeDependencies: ArrayList<IClasspathDependency>,
-        val excludedDependencies: ArrayList<IClasspathDependency>) {
+        val excludedDependencies: ArrayList<IClasspathDependency>,
+        val nativeDependencies: ArrayList<IClasspathDependency>) {
 
     /**
-     * Add the dependencies to the given ArrayList and return a list of jar files corresponding to
-     * these dependencies.
+     * Add the dependencies to the given ArrayList and return a list of future jar files corresponding to
+     * these dependencies. Futures are necessary here since this code is invoked from the build file and
+     * we might not have set up the extra IRepositoryContributors just yet. By the time these
+     * future tasks receive a get(), the repos will be correct.
      */
-    private fun addToDependencies(dependencies: ArrayList<IClasspathDependency>, dep: Array<out String>)
-            : List<File>
-        = with(dep.map { MavenDependency.create(it)}) {
+    private fun addToDependencies(project: Project, dependencies: ArrayList<IClasspathDependency>,
+            dep: Array<out String>, optional: Boolean = false, excludeConfig: ExcludeConfig? = null): List<Future<File>>
+        = with(dep.map {
+            val resolved =
+                if (KobaltMavenResolver.isRangeVersion(it)) {
+                    // Range id
+                    val node = Kobalt.INJECTOR.getInstance(KobaltMavenResolver::class.java).resolveToArtifact(it)
+                    val result = KobaltMavenResolver.artifactToId(node)
+                    kobaltLog(2, "Resolved range id $it to $result")
+                    result
+                } else {
+                    it
+                }
+            DependencyManager.create(resolved, optional, project.directory)
+        }) {
             dependencies.addAll(this)
-            this.map { it.jarFile.get() }
+            if (excludeConfig != null) {
+                this.forEach { it.excluded.add(excludeConfig) }
+            }
+
+            this.map { FutureTask { it.jarFile.get() } }
         }
 
     @Directive
-    fun compile(vararg dep: String) = addToDependencies(dependencies, dep)
+    fun compile(vararg dep: String) = addToDependencies(project, dependencies, dep)
+
+    class ExcludeConfig {
+        val ids = arrayListOf<String>()
 
         @Directive
-    fun provided(vararg dep: String) = addToDependencies(providedDependencies, dep)
+        fun exclude(vararg passedIds: String) = ids.addAll(passedIds)
+
+        class ArtifactConfig(
+            var groupId: String? = null,
+            var artifactId: String? = null,
+            var version: String? = null
+        )
+
+        val artifacts = arrayListOf<ArtifactConfig>()
 
         @Directive
-    fun runtime(vararg dep: String) = addToDependencies(runtimeDependencies, dep)
+        fun exclude(groupId: String? = null, artifactId: String? = null, version: String? = null)
+            = artifacts.add(ArtifactConfig(groupId, artifactId, version))
 
-    @Directive
-    fun exclude(vararg dep: String) = addToDependencies(excludedDependencies, dep)
+        fun match(pattern: String?, id: String) : Boolean {
+            return pattern == null || Pattern.compile(pattern).matcher(id).matches()
         }
 
-class Scm(val connection: String, val developerConnection: String, val url: String)
+        /**
+         * @return true if the dependency is excluded with any of the exclude() directives. The matches
+         * are performed by a regular expression match against the dependency.
+         */
+        fun isExcluded(dep: IClasspathDependency) : Boolean {
+            // Straight id match
+            var result = ids.any { match(it, dep.id) }
+
+            // Match on any combination of (groupId, artifactId, version)
+            if (! result && dep.isMaven) {
+                val mavenDep = dep as AetherDependency
+                val artifact = mavenDep.artifact
+                result = artifacts.any {
+                    val match1 = it.groupId == null || match(it.groupId, artifact.groupId)
+                    val match2 = it.artifactId == null || match(it.artifactId, artifact.artifactId)
+                    val match3 = it.version == null || match(it.version, artifact.version)
+                    match1 && match2 && match3
+                }
+            }
 
-class License(val name: String, val url: String) {
-    fun toMavenLicense() : org.apache.maven.model.License {
-        val result = org.apache.maven.model.License()
-        result.name = name
-        result.url = url
             return result
         }
+    }
 
+    @Directive
+    fun compile(dep: String, init: ExcludeConfig.() -> Unit) {
+        val excludeConfig = ExcludeConfig().apply {
+            init()
+        }
+        addToDependencies(project, dependencies, arrayOf(dep), excludeConfig = excludeConfig)
+    }
+
+    @Directive
+    fun compileOnly(vararg dep: String) = addToDependencies(project, compileOnlyDependencies, dep)
+
+    @Directive
+    fun compileOptional(vararg dep: String) {
+        addToDependencies(project, optionalDependencies, dep, optional = true)
+        addToDependencies(project, dependencies, dep, optional = true)
+    }
+
+    @Directive
+    fun provided(vararg dep: String) {
+        addToDependencies(project, providedDependencies, dep)
+    }
+
+    @Directive
+    fun runtime(vararg dep: String) = addToDependencies(project, runtimeDependencies, dep)
+
+    @Directive
+    fun exclude(vararg dep: String) = addToDependencies(project, excludedDependencies, dep)
+
+    @Directive
+    fun native(vararg dep: String) = addToDependencies(project, nativeDependencies, dep)
 }
 
 class BuildConfig {
@@ -203,39 +293,22 @@ interface IBuildConfig {
     }
 }
 
-class ProductFlavorConfig(val name: String) : IBuildConfig {
-    var applicationId: String? = null
-    override var buildConfig : BuildConfig? = BuildConfig()
-}
-
-@Directive
-fun Project.productFlavor(name: String, init: ProductFlavorConfig.() -> Unit) = ProductFlavorConfig(name).apply {
-        init()
-        addProductFlavor(name, this)
-    }
-
-class BuildTypeConfig(val project: Project?, val name: String) : IBuildConfig {
-    var minifyEnabled = false
-    var applicationIdSuffix: String? = null
-    var proguardFile: String? = null
-
-//    fun getDefaultProguardFile(name: String) : String {
-//        val androidPlugin = Plugins.findPlugin(AndroidPlugin.PLUGIN_NAME) as AndroidPlugin
-//        return Proguard(androidPlugin.androidHome(project)).getDefaultProguardFile(name)
-//    }
-
-    override var buildConfig : BuildConfig? = BuildConfig()
-}
-
-@Directive
-fun Project.buildType(name: String, init: BuildTypeConfig.() -> Unit) = BuildTypeConfig(this, name).apply {
-        init()
-        addBuildType(name, this)
-    }
-
 fun Project.defaultConfig(init: BuildConfig.() -> Unit) = let { project ->
     BuildConfig().apply {
         init()
         project.defaultConfig = this
     }
 }
+
+@Directive
+fun Project.buildType(name: String, init: BuildTypeConfig.() -> Unit) = BuildTypeConfig(name).apply {
+    init()
+    addBuildType(name, this)
+}
+
+
+@Directive
+fun Project.productFlavor(name: String, init: ProductFlavorConfig.() -> Unit) = ProductFlavorConfig(name).apply {
+    init()
+    addProductFlavor(name, this)
+}

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Task.kt

@@ -2,8 +2,6 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.misc.toString
 
-data public class Task(val pluginName: String, val taskName: String) {
-    override public fun toString() : String {
-        return toString("Task", pluginName, taskName)
-    }
+data class Task(val pluginName: String, val taskName: String) {
+    override fun toString() = toString("Task", pluginName, taskName)
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt

@@ -3,6 +3,7 @@ package com.beust.kobalt.api
 import com.beust.kobalt.IncrementalTaskInfo
 import com.beust.kobalt.TaskResult
 import com.beust.kobalt.Variant
+import com.beust.kobalt.api.annotation.AnnotationDefault
 import com.beust.kobalt.internal.IncrementalManager
 import com.google.inject.Inject
 
@@ -10,7 +11,8 @@ import com.google.inject.Inject
  * Plug-ins that are ITaskContributor can use this class to manage their collection of tasks and
  * implement the interface by delegating to an instance of this class (if injection permits).
  */
-class TaskContributor @Inject constructor(val incrementalManager: IncrementalManager) : ITaskContributor {
+class TaskContributor @Inject constructor(val incrementalManagerFactory: IncrementalManager.IFactory)
+        : ITaskContributor {
     val dynamicTasks = arrayListOf<DynamicTask>()
 
     /**
@@ -22,16 +24,19 @@ class TaskContributor @Inject constructor(val incrementalManager: IncrementalMan
      * depends on variants of that task.
      */
     fun addVariantTasks(plugin: IPlugin, project: Project, context: KobaltContext, taskName: String,
+            group: String = AnnotationDefault.GROUP,
+            dependsOn: List<String> = emptyList(),
+            reverseDependsOn : List<String> = emptyList(),
             runBefore : List<String> = emptyList(),
             runAfter : List<String> = emptyList(),
-            alwaysRunAfter : List<String> = emptyList(),
             runTask: (Project) -> TaskResult) {
         Variant.allVariants(project).forEach { variant ->
             val variantTaskName = variant.toTask(taskName)
-            dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName,
+            dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName, group, project,
+                    dependsOn = dependsOn.map { variant.toTask(it) },
+                    reverseDependsOn = reverseDependsOn.map { variant.toTask(it) },
                     runBefore = runBefore.map { variant.toTask(it) },
                     runAfter = runAfter.map { variant.toTask(it) },
-                    alwaysRunAfter = alwaysRunAfter.map { variant.toTask(it) },
                     closure = { p: Project ->
                         context.variant = variant
                         runTask(project)
@@ -39,20 +44,43 @@ class TaskContributor @Inject constructor(val incrementalManager: IncrementalMan
         }
     }
 
-    fun addIncrementalVariantTasks(plugin: IPlugin, project: Project, context: KobaltContext, taskName: String,
+    fun addTask(plugin: IPlugin, project: Project, taskName: String, description: String,
+            group: String = AnnotationDefault.GROUP,
+            dependsOn: List<String> = emptyList(),
+            reverseDependsOn : List<String> = emptyList(),
             runBefore : List<String> = emptyList(),
             runAfter : List<String> = emptyList(),
             alwaysRunAfter: List<String> = emptyList(),
+            runTask: (Project) -> TaskResult) {
+        dynamicTasks.add(DynamicTask(plugin, taskName, description, group, project,
+                dependsOn = dependsOn,
+                reverseDependsOn = reverseDependsOn,
+                runBefore = runBefore,
+                runAfter = runAfter,
+                alwaysRunAfter = alwaysRunAfter,
+                closure = { p: Project ->
+                    runTask(project)
+                }))
+    }
+
+    fun addIncrementalVariantTasks(plugin: IPlugin, project: Project, context: KobaltContext, taskName: String,
+            group: String = AnnotationDefault.GROUP,
+            dependsOn: List<String> = emptyList(),
+            reverseDependsOn : List<String> = emptyList(),
+            runBefore : List<String> = emptyList(),
+            runAfter : List<String> = emptyList(),
             runTask: (Project) -> IncrementalTaskInfo) {
         Variant.allVariants(project).forEach { variant ->
             val variantTaskName = variant.toTask(taskName)
-            dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName,
+            context.variant = variant
+            dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName, group, project,
+                    dependsOn = dependsOn.map { variant.toTask(it) },
+                    reverseDependsOn = reverseDependsOn.map { variant.toTask(it) },
                     runBefore = runBefore.map { variant.toTask(it) },
                     runAfter = runAfter.map { variant.toTask(it) },
-                    alwaysRunAfter = alwaysRunAfter.map { variant.toTask(it) },
-                    closure = incrementalManager.toIncrementalTaskClosure(taskName, runTask, variant)))
+                    closure = incrementalManagerFactory.create().toIncrementalTaskClosure(taskName, runTask, variant)))
         }
     }
 
-    override fun tasksFor(context: KobaltContext) : List<DynamicTask> = dynamicTasks
+    override fun tasksFor(project: Project, context: KobaltContext) : List<DynamicTask> = dynamicTasks
 }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/annotation/Annotations.kt

@@ -6,33 +6,61 @@ package com.beust.kobalt.api.annotation
  */
 annotation class Directive
 
+object AnnotationDefault {
+    const val GROUP = "other"
+}
+
 @Retention(AnnotationRetention.RUNTIME)
 annotation class Task(
+    /* This task's name */
     val name: String,
+
+    /* The documentation for this task */
     val description: String = "",
 
-    /** Tasks that this task depends on */
+    /** Used to show the task in the correct group in the IDE */
+    val group: String = AnnotationDefault.GROUP,
+
+    /** Dependency: tasks this task depends on */
+    val dependsOn: Array<String> = arrayOf(),
+
+    /** Dependency: tasks this task will be made dependend upon */
+    val reverseDependsOn: Array<String> = arrayOf(),
+
+    /** Ordering: tasks that need to be run before this one */
     val runBefore: Array<String> = arrayOf(),
 
-    /** Tasks that this task will run after if they get run */
+    /** Ordering: tasks this task runs after */
     val runAfter: Array<String> = arrayOf(),
 
-    /** Tasks that this task will always run after */
+    /** Wrapper tasks */
     val alwaysRunAfter: Array<String> = arrayOf()
 )
 
 @Retention(AnnotationRetention.RUNTIME)
 annotation class IncrementalTask(
+    /* This task's name */
     val name: String,
+
+    /* The documentation for this task */
     val description: String = "",
 
+    /** Used to show the task in the correct group in the IDE */
+    val group: String = AnnotationDefault.GROUP,
+
+    /** Dependency: tasks this task depends on */
+    val dependsOn: Array<String> = arrayOf(),
+
+    /** Dependency: tasks this task will be made dependend upon */
+    val reverseDependsOn: Array<String> = arrayOf(),
+
     /** Tasks that this task depends on */
     val runBefore: Array<String> = arrayOf(),
 
-    /** Tasks that this task will run after if they get run */
+    /** Ordering: tasks this task runs after */
     val runAfter: Array<String> = arrayOf(),
 
-    /** Tasks that this task will always run after */
+    /** Wrapper tasks */
     val alwaysRunAfter: Array<String> = arrayOf()
 )
 

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt

@@ -1,25 +1,24 @@
 package com.beust.kobalt.archive
 
-import com.beust.kobalt.Features
+import com.beust.kobalt.*
 import com.beust.kobalt.api.KobaltContext
 import com.beust.kobalt.api.Project
 import com.beust.kobalt.api.annotation.ExportedProjectProperty
-import com.beust.kobalt.misc.IncludedFile
 import com.beust.kobalt.misc.JarUtils
 import com.beust.kobalt.misc.KFiles
-import com.beust.kobalt.misc.log
+import com.beust.kobalt.misc.kobaltLog
 import java.io.File
-import java.io.FileOutputStream
-import java.io.OutputStream
 import java.util.*
-import java.util.zip.ZipOutputStream
 
 class Archives {
     companion object {
         @ExportedProjectProperty(doc = "The name of the jar file", type = "String")
         const val JAR_NAME = "jarName"
+        @ExportedProjectProperty(doc = "The name of the a jar file with a main() method", type = "String")
+        const val JAR_NAME_WITH_MAIN_CLASS = "jarNameWithMainClass"
 
-        private val DEFAULT_STREAM_FACTORY = { os : OutputStream -> ZipOutputStream(os) }
+        fun defaultArchiveName(project: Project) = project.name +
+            if (project.version.isNullOrBlank()) "" else "-${project.version}"
 
         fun generateArchive(project: Project,
                 context: KobaltContext,
@@ -27,23 +26,28 @@ class Archives {
                 suffix: String,
                 includedFiles: List<IncludedFile>,
                 expandJarFiles : Boolean = false,
-                outputStreamFactory: (OutputStream) -> ZipOutputStream = DEFAULT_STREAM_FACTORY) : File {
+                manifest: java.util.jar.Manifest? = null) : File {
             val fullArchiveName = context.variant.archiveName(project, archiveName, suffix)
             val archiveDir = File(KFiles.libsDir(project))
             val result = File(archiveDir.path, fullArchiveName)
-            log(3, "Creating $result")
+            context.logger.log(project.name, 3, "Creating $result")
             if (! Features.USE_TIMESTAMPS || isOutdated(project.directory, includedFiles, result)) {
-                val outStream = outputStreamFactory(FileOutputStream(result))
-                JarUtils.addFiles(project.directory, includedFiles, outStream, expandJarFiles)
-                log(2, text = "Added ${includedFiles.size} files to $result")
-                outStream.flush()
-                outStream.close()
-                log(1, "  Created $result")
-            } else {
-                log(3, "  $result is up to date")
+                try {
+                    MetaArchive(result, manifest).use { metaArchive ->
+                        JarUtils.addFiles(project.directory, includedFiles, metaArchive, expandJarFiles)
+                        context.logger.log(project.name, 2, "Added ${includedFiles.size} files to $result")
+                        context.logger.log(project.name, 1, "  Created $result")
+                    }
+                } catch (e: Throwable) {
+                    // make sure that incomplete archive is deleted
+                    // otherwise incremental build does not work on next run
+                    result.delete()
+                    throw e
                 }
 
-            project.projectProperties.put(JAR_NAME, result.absolutePath)
+            } else {
+                context.logger.log(project.name, 3, "  $result is up to date")
+            }
 
             return result
         }
@@ -55,13 +59,21 @@ class Archives {
             includedFiles.forEach { root ->
                 val allFiles = root.allFromFiles(directory)
                 allFiles.forEach { relFile ->
-                    val file = File(KFiles.joinDir(directory, root.from, relFile.path))
+                    val file = if (relFile.isAbsolute)
+                        relFile // e.g. jar file or classes folder (of another project) when building a fat jar
+                    else
+                        File(KFiles.joinDir(directory, root.from, relFile.path))
                     if (file.isFile) {
                         if (file.lastModified() > lastModified) {
-                            log(3, "    TS - Outdated $file and $output "
+                            kobaltLog(3, "    TS - Outdated $file and $output "
                                     + Date(file.lastModified()) + " " + Date(output.lastModified()))
                             return true
                         }
+                    } else if (file.isDirectory) {
+                        // e.g. classes folder (of another project) when building a fat jar
+                        val includedFile = IncludedFile(From(""), To(""), listOf(IFileSpec.GlobSpec("**")))
+                        if (isOutdated(file.absolutePath, listOf(includedFile), output))
+                            return true
                     }
                 }
             }

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt

@@ -1,11 +1,14 @@
 package com.beust.kobalt.archive
 
+import com.beust.kobalt.api.Project
 import com.beust.kobalt.api.annotation.Directive
 
 /**
  * A jar is exactly like a zip with the addition of a manifest and an optional fatJar boolean.
  */
-open class Jar(override var name: String? = null, var fatJar: Boolean = false) : Zip(name), AttributeHolder {
+open class Jar(override val project: Project,
+        override var name : String = Archives.defaultArchiveName(project) + ".jar",
+        override var fatJar: Boolean = false) : Zip(project, name, fatJar), AttributeHolder {
     @Directive
     fun manifest(init: Manifest.(p: Manifest) -> Unit) : Manifest {
         val m = Manifest(this)
@@ -15,7 +18,7 @@ open class Jar(override var name: String? = null, var fatJar: Boolean = false) :
 
     // Need to specify the version or attributes will just be dropped
     @Directive
-    val attributes = arrayListOf(Pair("Manifest-Version", "1.0"))
+    override val attributes = arrayListOf(Pair("Manifest-Version", "1.0"))
 
     override fun addAttribute(k: String, v: String) {
         attributes.add(Pair(k, v))

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt

@@ -0,0 +1,125 @@
+package com.beust.kobalt.archive
+
+import com.beust.kobalt.Glob
+import com.beust.kobalt.misc.KFiles
+import org.apache.commons.compress.archivers.ArchiveEntry
+import org.apache.commons.compress.archivers.zip.ZipArchiveEntry
+import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream
+import java.io.Closeable
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.jar.Manifest
+import org.apache.commons.compress.archivers.zip.ZipFile as ApacheZipFile
+
+/**
+ * Abstraction of a zip/jar/war archive that automatically manages the addition of expanded jar files.
+ * Uses ZipArchiveOutputStream for fast inclusion of expanded jar files.
+ */
+class MetaArchive(outputFile: File, val manifest: Manifest?) : Closeable {
+    companion object {
+        const val MANIFEST_MF = "META-INF/MANIFEST.MF"
+    }
+
+    private val zos= ZipArchiveOutputStream(outputFile).apply {
+        encoding = "UTF-8"
+    }
+
+    init {
+        // If no manifest was passed, create an empty one so it's the first one in the archive
+        val m = manifest ?: Manifest()
+        val manifestFile = File.createTempFile("kobalt", "tmpManifest")
+        addEntry(ZipArchiveEntry("META-INF/"), null)
+        if (manifest != null) {
+            FileOutputStream(manifestFile).use { fos ->
+                m.write(fos)
+            }
+        }
+        val entry = zos.createArchiveEntry(manifestFile, MetaArchive.MANIFEST_MF)
+        addEntry(entry, FileInputStream(manifestFile))
+    }
+
+
+    fun addFile(f: File, entryFile: File, path: String?) {
+        maybeCreateParentDirectories(f)
+        addFile2(f, entryFile, path)
+    }
+
+    private fun addFile2(f: File, entryFile: File, path: String?) {
+        val file = f.normalize()
+        FileInputStream(file).use { inputStream ->
+            val actualPath = KFiles.fixSlashes(if (path != null) path + entryFile.path else entryFile.path)
+            ZipArchiveEntry(actualPath).let { entry ->
+                maybeCreateParentDirectories(File(actualPath))
+                maybeAddEntry(entry) {
+                    addEntry(entry, inputStream)
+                }
+            }
+        }
+    }
+
+    private val createdDirs = hashSetOf<String>()
+
+    /**
+     * For an entry a/b/c/File, an entry needs to be created for each individual directory:
+     * a/
+     * a/b/
+     * a/b/c
+     * a/b/c/File
+     */
+    private fun maybeCreateParentDirectories(file: File) {
+        val toCreate = arrayListOf<String>()
+        var current = file.parentFile
+        while (current != null && current.path != ".") {
+            if (!createdDirs.contains(current.path)) {
+                toCreate.add(0, KFiles.fixSlashes(current) + "/")
+                createdDirs.add(current.path)
+            }
+            current = current.parentFile
+        }
+        toCreate.forEach { dir ->
+            addEntry(ZipArchiveEntry(dir), null)
+        }
+    }
+
+    fun addArchive(jarFile: File) {
+        ApacheZipFile(jarFile).use { jar ->
+            val jarEntries = jar.entries
+            for (entry in jarEntries) {
+                maybeAddEntry(entry) {
+                    zos.addRawArchiveEntry(entry, jar.getRawInputStream(entry))
+                }
+            }
+        }
+    }
+
+
+
+    private fun okToAdd(name: String) : Boolean {
+        val result = !KFiles.isExcluded(name,
+                Glob("META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA", MANIFEST_MF))
+//        if (name.startsWith("META-INF")) println((if (result) "ADDING" else "NOT ADDING") + " $name")
+        return result
+    }
+
+    override fun close() = zos.close()
+
+    private fun addEntry(entry: ArchiveEntry, inputStream: FileInputStream?) {
+        zos.putArchiveEntry(entry)
+        inputStream?.use { ins ->
+            ins.copyTo(zos, 50 * 1024)
+        }
+        zos.closeArchiveEntry()
+    }
+
+    private val seen = hashSetOf<String>()
+
+    private fun maybeAddEntry(entry: ArchiveEntry, action:() -> Unit) {
+        entry.name.let { name ->
+            if (!seen.contains(name) && okToAdd(name)) {
+                action()
+            }
+            seen.add(name)
+        }
+    }
+}