.gitignore

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

.idea/modules.xml

@@ -0,0 +1,11 @@
+<?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

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

README.md

@@ -1,15 +1,11 @@
 # 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.
-

TODO.md

@@ -2,31 +2,48 @@ To do:
 
 Android:
 
+- [ ] Dex dependencies into kobaltBuild/intermediates/pre-dexed and preserve those across builds
+- [ ] Move the calculated applicationId back into the merged AndroidManifest.xml 
+- [ ] Dex from android builder
+- [ ] Keep exploded aars between runs
+- [ ] aars keep being refetched
+- [ ] See if there is an android manifest file in builder
 
 General
 
-- [ ] KFiles.findSourceFiles should cache its results
-- [ ] createCompilerAction should calculate source files once and for all, including contributors and interceptors
-- [ ] Need a -resolve with no dependency which gives the tree for the whole project
-- [ ] If jitpack specified with http and not https, 301 is not handled correctly
 - [ ] Apt should run from serviceloader
+- [ ] Auto add variant
+- [ ] The test runner only selects classes with a parameterless constructor, which works for JUnit but not for TestNG
+ factories
+- [ ] Add a "Auto complete Build.kt" menu in the plug-in
+- [ ] "All artifacts successfully uploaded" is shown before the upload is actually done
+- [ ] use groupId/artifactId
 - [ ] Console mode with watch service, so recompilation can occur as soon as a source file is modified
 - [ ] ProjectGenerator: support migration from pom.xml (starting with dependencies)
 - [ ] Specify where to upload snapshots
+- [ ] Upload in a thread pool
 - [ ] repos() must appear before plugins(): fix that
+- [ ] Support version ranges
 - [ ] Generate .idea and other IDEA files
+- [ ] logs for users should not show any timestamp, class file or thread id, this should only be in --dev mode
 - [ ] Fetch .pom with DynamicGraph
 - [ ] Centralize all the executors
 - [ ] Archetypes (e.g. "--initWith kobalt-plug-in")
-- [ ] Compile TestNG (last piece missing: OSGi headers)
+- [ ] Compile TestNG (including generating Version.java and OSGi headers)
 - [ ] Support additional .kt files in ~/.kobalt/src
+- [ ] generateArchive() should use Path instead of File
 - [ ] --init: import dependencies from build.gradle
 - [ ] --init: also extract kobalt.bat (or generate it along with kobaltw)
+- [ ] Bug: --tasks displays multiple tasks when there are multiple projects
+- [ ] Bug: ./kobaltw --dryRun kobalt:uploadJcenter runs "kobalt-wrapper:clean" twice
+- [ ] Replace File with java.nio.Files and Path
+- [ ] Create a wiki page for plugins
+- [ ] Make kobaltw executable in the zip file
 - [ ] Encapsulate ProcessBuilder code
+- [ ] --resolve <dep>
 
 Done:
 
-- [x] Dex dependencies into kobaltBuild/intermediates/pre-dexed and preserve those across builds
 - [x] Compile with javax.tool
 - [x] Android: multiple -source/-target flags
 - [x] Dokka: allow multiple format outputs e.g `outputFormat("html", "javadoc")`
@@ -67,24 +84,5 @@ just a straight Java class with minimal dependencies for fast start up
 - [x] Upload non maven files
 - [x] Jar packaging: include the jar in the jar (not supported by JarFile)
 - [x] Encapsulate BuildFile for better log messages
-- [x] The test runner only selects classes with a parameterless constructor, which works for JUnit but not for TestNG
-- [x] Add a "Auto complete Build.kt" menu in the plug-in
-- [x] "All artifacts successfully uploaded" is shown before the upload is actually done
-- [x] use groupId/artifactId
- factories
-- [x] Support version ranges
-- [x] Upload in a thread pool
-- [x] logs for users should not show any timestamp, class file or thread id, this should only be in --dev mode
-- [x] Bug: --tasks displays multiple tasks when there are multiple projects
-- [x] Bug: ./kobaltw --dryRun kobalt:uploadJcenter runs "kobalt-wrapper:clean" twice
-- [x] Create a wiki page for plugins
-- [x] Make kobaltw executable in the zip file
-- [x] --resolve <dep>
 
-- [x] Move the calculated applicationId back into the merged AndroidManifest.xml
-- [x] Dex from android builder
-- [x] Keep exploded aars between runs
-- [x] aars keep being refetched
-- [x] See if there is an android manifest file in builder
-- [x] Auto add variant
 

build-travis.sh

@@ -1,8 +0,0 @@
-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

@@ -1,58 +1,92 @@
-allprojects {
+buildscript {
-    group = 'com.beust'
+    ext.kotlin_version = '1.0.0-beta-2423'
-    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'
     }
-
+    dependencies {
-        maven {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlin_version}"
-            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'
     }
 }
+
+plugins {
+    id "com.jfrog.bintray" version "1.2"
+}
+
+version = '0.121'
+
+//apply plugin: 'java'
+apply plugin: 'kotlin'
+apply plugin: 'com.jfrog.bintray'
+
+apply from: 'gradle/publishing.gradle'
+
+repositories {
+    jcenter()
+}
+
+dependencies {
+    compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}",
+            "org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlin_version}",
+            'org.jetbrains.kotlinx:kotlinx.dom:0.0.4',
+            'org.jetbrains.dokka:dokka-fatjar:0.9.2',
+//            "org.jetbrains.kotlin:kotlin-compiler:${kotlin_version}",
+
+            "com.android.tools.build:builder:2.0.0-alpha3",
+
+            'com.beust:jcommander:1.48',
+            'com.squareup.okhttp:okhttp:2.5.0',
+            'org.jsoup:jsoup:1.8.3',
+            'com.google.inject:guice:4.0',
+            'com.google.inject.extensions:guice-assistedinject:4.0',
+            'javax.inject:javax.inject:1',
+            'com.google.guava:guava:19.0-rc2',
+            'org.apache.maven:maven-model:3.3.3',
+            'com.github.spullara.mustache.java:compiler:0.9.1',
+            'io.reactivex:rxjava:1.0.16',
+            'com.google.code.gson:gson:2.4',
+            'com.squareup.retrofit:retrofit:1.9.0',
+            'com.squareup.okio:okio:1.6.0',
+            project("modules/wrapper")
+
+//    compile files("/Users/beust/.kobalt/repository/com/beust/kobalt-example-plugin/build/libs/kobalt-example-plugin.jar")
+    testCompile 'org.testng:testng:6.9.9'
+//    testCompile 'junit:junit:4.12'
+}
+
+task sourceJar(type: Jar) {
+    group 'Build'
+    description 'An archive of the source code'
+    classifier 'sources'
+    from sourceSets.main.allSource
+}
+
+artifacts {
+    file('build/libs/kobalt.jar')
+    sourceJar
+}
+
+test {
+    useTestNG()
+    beforeTest { descriptor ->
+        logger.lifecycle("    Running test: " + descriptor)
+    }
+}
+
+compileKotlin {
+    kotlinOptions.suppressWarnings = true
+}
+
+apply plugin: 'application'
+mainClassName = 'com.beust.kobalt.KobaltPackage'
+
+jar {
+    manifest {
+        attributes "Main-Class": "$mainClassName"
+    }
+
+    from {
+        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
+    }
+}
+

dist/kobaltw

@@ -1,11 +0,0 @@
-#!/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

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

gradle/buildWithTravis.sh

@@ -0,0 +1 @@
+../gradlew check

gradle/publishing.gradle

@@ -0,0 +1,60 @@
+import java.text.SimpleDateFormat
+
+Date buildTimeAndDate = new Date()
+ext {
+    buildTime = new SimpleDateFormat('yyyy-MM-dd').format(buildTimeAndDate)
+    buildDate = new SimpleDateFormat('HH:mm:ss.SSSZ').format(buildTimeAndDate)
+}
+
+apply plugin: 'maven-publish'
+apply plugin: 'com.jfrog.bintray'
+
+jar {
+    manifest {
+        attributes(
+            'Built-By': System.properties['user.name'],
+            'Created-By': System.properties['java.version'] + " (" + System.properties['java.vendor'] + " " + System.getProperty("java.vm.version") + ")",
+            'Build-Date': project.buildTime,
+            'Build-Time': project.buildDate,
+            'Specification-Title': project.name,
+            'Specification-Version': project.version,
+        )
+    }
+}
+
+publishing {
+    publications {
+        mavenCustom(MavenPublication) {
+            from components.java
+            artifact sourceJar
+
+            groupId 'com.beust'
+            artifactId 'kobalt'
+            version project.version
+        }
+    }
+}
+
+task install(dependsOn: publishToMavenLocal)
+
+Properties properties = new Properties()
+if (new File('local.properties').exists()) {
+    properties.load(project.rootProject.file('local.properties').newDataInputStream())
+}
+
+bintray {
+    user = properties.getProperty("bintray.user")
+    key = properties.getProperty("bintray.apikey")
+    publications = ['mavenCustom']
+    pkg {
+        repo = 'maven'
+        name = 'klaxon'
+        desc = 'JSON parsing for Kotlin'
+        licenses = ['Apache-2.0']
+        labels = ['kotlin']
+
+        version {
+            name = project.version //Bintray logical version name
+        }
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Sun Oct 04 21:38:45 EDT 2015
 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
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.9-all.zip

gradlew

@@ -1,20 +1,4 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
-
-#
-# 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.
-#
 
 ##############################################################################
 ##
@@ -22,6 +6,47 @@
 ##
 ##############################################################################
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# 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
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -36,49 +61,9 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
+cd "`dirname \"$PRG\"`/" >&-
 APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+cd "$SAVED" >&-
-
-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
 
@@ -105,7 +90,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -129,7 +114,6 @@ fi
 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`
@@ -170,19 +154,11 @@ if $cygwin ; then
     esac
 fi
 
-# Escape application args
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-save () {
+function splitJvmOpts() {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    JVM_OPTS=("$@")
-    echo " "
 }
-APP_ARGS=$(save "$@")
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
-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

@@ -1,19 +1,3 @@
-@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
@@ -24,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
+@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=
+
 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
 
@@ -62,9 +46,10 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windows variants
+@rem Get command-line arguments, handling Windowz variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -75,6 +60,11 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

kobalt-incremental-tasks.md

@@ -1,78 +0,0 @@
-Kobalt's incremental task algorithm is not based on timestamps but on checksums.
-
-You make a task incremental by declaring it `@IncrementalTask` instead of `@Task`. The only other difference is that instead of returning a `TaskResult`, incremental tasks return an `IncrementalTaskInfo`:
-
-```
-class IncrementalTaskInfo(
-    val inputChecksum: String?,
-    val outputChecksum: String?,
-    val task: (Project) -> TaskResult)
-```
-
-This class contains three fields:
-
-- A task closure, which is your effective task: `(Project) -> TaskResult`
-- An input checksum (`String?`)
-- An output checksum (`String?`)
-
-These checksums are numbers that each task calculates for their input and output. For example, the `"compile"` task calculates an MD5 checksum of all the source files. Similarly, the output checksum is for produced artifacts, e.g. checksum of `.class` files or `.jar` files, etc...
-
-Example of an incremental task:
-
-```
-    @IncrementalTask(name = JvmCompilerPlugin.TASK_COMPILE, description = "Compile the project")
-    fun taskCompile(project: Project) : IncrementalTaskInfo {
-        val inputChecksum = Md5.toMd5Directories(project.sourceDirectories.map {
-            File(project.directory, it)
-        })
-        return IncrementalTaskInfo(
-                inputChecksum = inputChecksum,
-                outputChecksum = "1",
-                task = { project -> doTaskCompile(project) }
-        )
-    }
-```
-
-The advantage of checksums is that they take care of all the scenarios that would cause that task to run:
-
-- A file was modified
-- A file was added
-- A file was removed
-
-The output checksum covers the case where the input is unchanged but the output files were deleted or modified. If 
-both the input and output checksums match the previous run, it's extremely likely that the task has nothing to do.
-
-Another advantage of checksums is that they are generic and not necessarily tied to files. For example, a Kobalt task might perform some network operations and return a checksum based on a network result to avoid performing a more expensive operation (e.g. don't download a file from a server if it hasn't changed).
-
-Internally, Kobalt maintains information about all the checksums and tasks that it has seen in a file `.kobalt/build-info.json`. Whenever an incremental task is about to run, Kobalt compares its input and output checksums to the ones from the previous run and if any differs, that task is run. Otherwise, it's skipped.
-
-Example timings for Kobalt:
-
-| Task | First run | Second run |
-| ---- | --------- | ---------- |
-|  kobalt-wrapper:compile | 627 ms | 22 ms |
-|  kobalt-wrapper:assemble | 9 ms | 9 ms |
-|  kobalt-plugin-api:compile | 10983 ms | 54 ms |
-|  kobalt-plugin-api:assemble | 1763 ms | 154 ms |
-|  kobalt:compile | 11758 ms | 11 ms |
-|  kobalt:assemble | 42333 ms | 2130 ms |
-| | 70 seconds | 2 seconds |
-
-Android (u2020):
-
-| Task | First run | Second run |
-| ---- | --------- | ---------- |
-|  u2020:generateRInternalDebug | 32350 ms | 1652 ms |
-|  u2020:compileInternalDebug | 3629 ms | 24 ms |
-|  u2020:retrolambdaInternalDebug | 668 ms | 473 ms |
-|  u2020:generateDexInternalDebug | 6130 ms |55 ms |
-|  u2020:signApkInternalDebug | 449 ms | 404 ms |
-|  u2020:assembleInternalDebug | 0 ms | 0 ms |
-| | 43 seconds | 2 seconds |
-
-
-
-
-
-
-

kobalt.iml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.linked.project.id="kobalt" external.linked.project.path="$USER_HOME$" external.root.project.path="$USER_HOME$" external.system.id="GRADLE" external.system.module.group="" external.system.module.version="0.121" 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/kotlin" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/resources" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/kotlin" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <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

@@ -0,0 +1,13 @@
+<?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:///Library/Java/JavaVirtualMachines/jdk1.8.0_25.jdk/Contents/Home" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="kobalt.jar" level="project" />
+  </component>
+</module>

kobalt/src/Build.kt

@@ -1,61 +1,29 @@
 
-import com.beust.kobalt.*
+import com.beust.kobalt.TaskResult
+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.homeDir
 import com.beust.kobalt.plugin.application.application
 import com.beust.kobalt.plugin.java.javaCompiler
+import com.beust.kobalt.plugin.java.javaProject
 import com.beust.kobalt.plugin.kotlin.kotlinCompiler
+import com.beust.kobalt.plugin.kotlin.kotlinProject
 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 com.beust.kobalt.plugin.publish.jcenter
-import org.apache.maven.model.License
+import com.beust.kobalt.repos
-import org.apache.maven.model.Model
+import com.beust.kobalt.test
-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 bs = buildScript {
+val r = repos("http://dl.bintray.com/kotlin/kotlinx.dom")
-    repos("https://dl.bintray.com/cbeust/maven")
-}
 
-object Versions {
+val wrapper = javaProject {
-    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"
-    artifactId = name
     version = readVersion()
     directory = "modules/wrapper"
 
@@ -64,7 +32,6 @@ val wrapper = project {
     }
 
     assemble {
-        jar { }
         jar {
             name = projectName + ".jar"
             manifest {
@@ -76,60 +43,41 @@ val wrapper = project {
     application {
         mainClass = "com.beust.kobalt.wrapper.Main"
     }
-
-    bintray {
-        publish = true
-        sign = true
-    }
-
-    pom = createPom(name, "Wrapper for Kobalt")
 }
 
-val kobaltPluginApi = project {
+
+val kobaltPluginApi = kotlinProject {
     name = "kobalt-plugin-api"
     group = "com.beust"
     artifactId = name
     version = readVersion()
     directory = "modules/kobalt-plugin-api"
     description = "A build system in Kotlin"
-    url = "https://beust.com/kobalt"
+    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")
 
-    pom = createPom(name, "A build system in Kotlin")
+    dependenciesTest {
+        compile("org.testng:testng:6.9.9")
+    }
 
     dependencies {
-        compile(
+        compile("org.jetbrains.kotlinx:kotlinx.dom:0.0.4",
-                "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: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:${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
+                "com.squareup.okhttp:okhttp:2.5.0",
-                "javax.xml.bind:jaxb-api:2.3.0"
+                "com.squareup.okio:okio:1.6.0",
+                "com.google.inject:guice:4.0",
+                "com.google.inject.extensions:guice-assistedinject:4.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:2.4",
+                "com.squareup.retrofit:retrofit:1.9.0",
+                "com.beust:jcommander:1.48"
                 )
-        exclude(*aether("impl", "spi", "util", "api"))
     }
 
 
@@ -142,16 +90,24 @@ val kobaltPluginApi = project {
         }
     }
 
-    kotlinCompiler {
+//    install {
-        args("nowarn")
+//        libDir = "lib-test"
+//    }
+
+    test {
+        args("-log", "1", "src/test/resources/testng.xml")
     }
 
-    bintray {
+    kotlinCompiler {
+        args("-nowarn")
+    }
+
+    jcenter {
         publish = true
     }
 }
 
-val kobaltApp = project(kobaltPluginApi, wrapper) {
+val kobaltApp = kotlinProject(kobaltPluginApi, wrapper) {
     name = "kobalt"
     group = "com.beust"
     artifactId = name
@@ -159,53 +115,25 @@ val kobaltApp = project(kobaltPluginApi, wrapper) {
 
     dependencies {
         // Used by the plugins
-        compile("org.jetbrains.kotlin:kotlin-compiler-embeddable:${Versions.kotlin}")
+        compile("com.android.tools.build:builder:2.0.0-alpha3",
+                "org.jetbrains.kotlin:kotlin-compiler-embeddable:1.0.0-beta-3595",
+                "org.jetbrains.dokka:dokka-fatjar:0.9.3")
 
         // Used by the main app
-        compile(
+        compile("com.github.spullara.mustache.java:compiler:0.9.1",
-                "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}",
+                "com.squareup.okhttp:okhttp:2.5.0",
-                "com.github.spullara.mustache.java:compiler:0.9.5",
                 "javax.inject:javax.inject:1",
-                "com.google.inject:guice:${Versions.guice}",
+                "com.google.inject:guice:4.0",
-                "com.google.inject.extensions:guice-assistedinject:${Versions.guice}",
+                "com.google.inject.extensions:guice-assistedinject:4.0",
-                "com.beust:jcommander:${Versions.jcommander}",
+                "com.beust:jcommander:1.48",
-                "org.apache.maven:maven-model:${Versions.maven}",
+                "com.squareup.retrofit:retrofit:1.9.0",
-                "com.google.code.findbugs:jsr305:3.0.2",
+                "org.apache.maven:maven-model:3.3.3",
-                "com.google.code.gson:gson:${Versions.gson}",
+                "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.jetbrains.kotlin:kotlin-test:${Versions.kotlin}",
+        compile("org.testng:testng:6.9.9")
-                "org.testng:testng:${Versions.testng}",
-                "org.assertj:assertj-core:3.8.0",
-                *mavenResolver("util")
-                )
     }
 
     assemble {
@@ -216,111 +144,47 @@ val kobaltApp = project(kobaltPluginApi, wrapper) {
             }
         }
         zip {
-            val dir = "kobalt-$version"
+            include("kobaltw")
-            val files = listOf(
+            include(from("$buildDirectory/libs"), to("kobalt/wrapper"),
-                    "dist", "$dir/bin", "kobaltw",
+                    "$projectName-$version.jar")
-                    "dist", "$dir/bin", "kobaltw.bat",
+            include(from("modules/wrapper/$buildDirectory/libs"), to("kobalt/wrapper"),
-                    "$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-$version.jar",
+                    "$projectName-wrapper.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 {
+    jcenter {
         publish = true
     }
 
     github {
         file("$buildDirectory/libs/$name-$version.zip", "$name/$version/$name-$version.zip")
     }
-
-    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 {
-    val localFile =
+    val p = java.util.Properties()
-            listOf("src/main/resources/kobalt.properties",
+    var localFile = java.io.File("src/main/resources/kobalt.properties")
-                homeDir("kotlin", "kobalt", "src/main/resources/kobalt.properties")).first { File(it).exists() }
+    if (! localFile.exists()) {
-    with(java.util.Properties()) {
+        localFile = File(homeDir("kotlin", "kobalt", "src/main/resources/kobalt.properties"))
-        load(java.io.FileReader(localFile))
-        return getProperty("kobalt.version")
     }
+    p.load(java.io.FileReader(localFile))
+    return p.getProperty("kobalt.version")
 }
 
-@Task(name = "copyVersionForWrapper", reverseDependsOn = arrayOf("assemble"), runAfter = arrayOf("clean"))
+@Task(name = "copyVersionForWrapper", runBefore = arrayOf("assemble"), runAfter = arrayOf("compile"), description = "")
 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=1.0.122
+kobalt.version=0.350

kobaltw

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

kobaltw-test

@@ -1,8 +0,0 @@
-#!/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,4 +1,2 @@
 @echo off
-set DIRNAME=%~dp0
+java -jar  %~dp0/kobalt/wrapper/kobalt-wrapper.jar %*
-if "%DIRNAME%" == "" set DIRNAME=.
-java -jar "%DIRNAME%/kobalt/wrapper/kobalt-wrapper.jar" %*

modules/kobalt-plugin-api/build.gradle

@@ -1,85 +0,0 @@
-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

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="kobalt (Compile)" level="project" />
+    <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

@@ -1,279 +0,0 @@
-<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

@@ -1,21 +0,0 @@
-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? = "kobalt/src/Build.kt"
+    var buildFile: String? = null
 
     @Parameter(names = arrayOf("--checkVersions"), description = "Check if there are any newer versions of the " +
             "dependencies")
@@ -16,86 +16,38 @@ class Args {
     @Parameter(names = arrayOf("--client"))
     var client: Boolean = false
 
-    @Parameter(names = arrayOf("--dev"), description = "Turn on dev mode, resulting in a more verbose log output")
+    @Parameter(names = arrayOf("--dev"), description = "Turn of dev mode, resulting in a more verbose log output")
     var dev: Boolean = false
 
     @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
-
     @Parameter(names = arrayOf("--help", "--usage"), description = "Display the help")
     var usage: Boolean = false
 
-    @Parameter(names = arrayOf("-i", "--init"), description = "Invoke the templates named, separated by a comma")
+    @Parameter(names = arrayOf("-i", "--init"), description = "Create a build file based on the current project")
-    var templates: String? = null
+    var init: Boolean = false
 
-    @Parameter(names = arrayOf("--listTemplates"), description = "List the available templates")
+    @Parameter(names = arrayOf("--log"), description = "Define the log level (1-3)")
-    var listTemplates: Boolean = false
+    var log: Int = 1
 
-    @Parameter(names = arrayOf("--log"), description = "Define the log level " +
+    companion object {
-            "(${Constants.LOG_QUIET_LEVEL}-${Constants.LOG_MAX_LEVEL})")
+        const val DEFAULT_SERVER_PORT = 1234
-    var log: Int = Constants.LOG_DEFAULT_LEVEL
+    }
-
-    @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
-
-    @Parameter(names = arrayOf("--pluginJarFiles"), description = "Comma-separated list of plug-in jar files")
-    var pluginJarFiles: String? = null
 
     @Parameter(names = arrayOf("--port"), description = "Port, if --server was specified")
-    var port: Int? = null
+    var port: Int = DEFAULT_SERVER_PORT
 
     @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")
+    @Parameter(names = arrayOf("--resolve"), description = "Resolve the given dependency and display its tree")
-    var profiling: Boolean = false
-
-    @Parameter(names = arrayOf("--resolve"),
-            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
 
@@ -104,8 +56,5 @@ 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,18 +1,9 @@
 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(
@@ -35,13 +26,19 @@ 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()
 
-        // Repeat
+        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"
+
             fun r(n: Int, w: String) : String {
                 with(StringBuffer()) {
                     repeat(n, { append(w) })
@@ -49,45 +46,27 @@ 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(upperBox(max))
+            val result = arrayListOf(ul + r(max + 2, h) + ur)
             result.addAll(strings.map { "$v ${center(it, max - 2)} $v" })
-            result.add(lowerBox(max, bl, br))
+            result.add(bl + r(max + 2, h) + br)
             return result
         }
 
-        fun logBox(strings: List<String>, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0): String {
+        private fun fill(n: Int) = StringBuffer().apply { repeat(n, { append(" ")})}.toString()
-            return buildString {
+
-                val boxLines = box(strings, bl, br)
+        val defaultLog : (s: String) -> Unit = { log(1, "          $it") }
-                boxLines.withIndex().forEach { iv ->
+
-                    append(fill(indent)).append(iv.value)
+        fun logBox(strings: List<String>, print: (String) -> Unit = defaultLog) {
-                    if (iv.index < boxLines.size - 1) append("\n")
+            box(strings).forEach {
-                }
+                print(it)
             }
         }
 
-        fun logBox(s: String, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0)
+        fun logBox(s: String, print: (String) -> Unit = defaultLog) {
-                = logBox(listOf(s), bl, br, indent)
+            logBox(listOf(s), print)
-
+        }
-        fun fill(n: Int) = buildString { repeat(n, { append(" ")})}.toString()
 
         fun center(s: String, width: Int) : String {
             val diff = width - s.length
@@ -105,60 +84,14 @@ class AsciiArt {
         const val CYAN = "\u001B[36m"
         const val WHITE = "\u001B[37m"
 
-        fun wrap(s: CharSequence, color: String) = color + s + RESET
+        private fun wrap(s: String, color: String) = color + s + RESET
-        private fun blue(s: CharSequence) = wrap(s, BLUE)
+        private fun blue(s: String) = wrap(s, BLUE)
-        private fun red(s: CharSequence) = wrap(s, RED)
+        private fun red(s: String) = wrap(s, RED)
-        private fun yellow(s: CharSequence) = wrap(s, YELLOW)
+        private fun yellow(s: String) = wrap(s, YELLOW)
 
-        fun taskColor(s: CharSequence) = s
+        fun taskColor(s: String) = s
-        fun errorColor(s: CharSequence) = red(s)
+        fun errorColor(s: String) = red(s)
-        fun warnColor(s: CharSequence) = red(s)
+        fun warnColor(s: String) = 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,9 +4,8 @@ import com.beust.kobalt.api.IPlugin
 import com.beust.kobalt.api.PluginTask
 import com.beust.kobalt.api.Project
 
-abstract class BasePluginTask(override val plugin: IPlugin,
+public 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,89 +3,34 @@ 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.internal.KobaltSettings
+import com.beust.kobalt.maven.DepFactory
-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)
+        File.separator + dirs.toArrayList().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) }
 }
 
-fun plugins(vararg dependencies : String) {
-    KobaltLogger.logger.warn("Build.kt",
-            "Invoking plugins() directly is deprecated, use the buildScript{} directive")
-    newPlugins(*dependencies)
-}
-
 @Directive
-fun newPlugins(vararg dependencies : String) {
+fun plugins(vararg dependencies : String) {
-    val factory = Kobalt.INJECTOR.getInstance(DependencyManager::class.java)
+    val factory = Kobalt.INJECTOR.getInstance(DepFactory::class.java)
     dependencies.forEach {
         Plugins.addDynamicPlugin(factory.create(it))
     }
 }
 
-data class ProxyConfig(val host: String = "", val port: Int = 0, val type: String = "", val nonProxyHosts: String = "") {
+data class HostConfig(var url: String = "", var username: String? = null, var password: String? = null) {
-    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())
     }
@@ -99,47 +44,18 @@ data class HostConfig(var url: String = "", var name: String = HostConfig.create
     }
 }
 
+@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(name = "").apply { init() }
+fun authRepo(init: HostConfig.() -> Unit) = HostConfig().apply { init() }
 
 @Directive
-fun glob(g: String) : IFileSpec.GlobSpec = IFileSpec.GlobSpec(g)
+fun glob(g: String) : IFileSpec.Glob = IFileSpec.Glob(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

@@ -1,25 +1,14 @@
 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<HostConfig>(
+    internal val DEFAULT_REPOS = listOf(
-            //            "https://maven-central.storage.googleapis.com/",
+            "http://repo1.maven.org/maven2/",
-            HostConfig("https://repo1.maven.org/maven2/", "Maven"),
+            "https://maven-central.storage.googleapis.com/",
-            HostConfig("https://jcenter.bintray.com/", "JCenter")
+            "https://repository.jboss.org/nexus/content/repositories/root_repository/",
-//            "https://repository.jetbrains.com/all/", // <-- contains snapshots
+            "https://jcenter.bintray.com/"
-
-            // 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

@@ -1,39 +0,0 @@
-package com.beust.kobalt
-
-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
-fun project(vararg projects: Project, init: Project.() -> Unit): Project {
-    return Project("").apply {
-        init()
-        (Kobalt.findPlugin(JvmCompilerPlugin.PLUGIN_NAME) as JvmCompilerPlugin)
-                .addDependentProjects(this, projects.toList())
-    }
-}
-
-@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,102 +1,38 @@
 package com.beust.kobalt
 
-import com.beust.kobalt.misc.kobaltLog
+import com.beust.kobalt.misc.log
 import java.io.File
 import java.nio.file.*
 import java.nio.file.attribute.BasicFileAttributes
 
-/**
- * Subclasses of IFileSpec can be turned into a list of files. There are two kings: FileSpec (a single file)
- * and GlobSpec (a spec defined by a glob, e.g. ** slash *Test.class)
- */
 sealed class IFileSpec {
-    abstract fun toFiles(baseDir: String?, filePath: String, excludes: List<Glob> = emptyList<Glob>()): List<File>
+    abstract fun toFiles(directory: String): List<File>
 
     class FileSpec(val spec: String) : IFileSpec() {
-        override fun toFiles(baseDir: String?, filePath: String, excludes: List<Glob>) = listOf(File(spec))
+        override public fun toFiles(directory: String) = arrayListOf(File(spec))
 
-        override fun toString() = spec
+        override public fun toString() = spec
     }
 
-    /**
+    class Glob(val spec: String) : IFileSpec() {
-     * A glob matcher, see http://docs.oracle.com/javase/7/docs/api/java/nio/file/FileSystem.html#getPathMatcher%28java.lang.String%29
+        override public fun toFiles(directory: String): List<File> {
-     */
-    class GlobSpec(val spec: List<String>) : IFileSpec() {
-
-        constructor(spec: String) : this(arrayListOf(spec))
-
-        private fun isIncluded(includeMatchers: Glob, excludes: List<Glob>, rel: Path) : Boolean {
-            excludes.forEach {
-                if (it.matches(rel)) {
-                    kobaltLog(3, "  Excluding ${rel.toFile()}")
-                    return false
-                }
-            }
-            if (includeMatchers.matches(rel)) {
-                kobaltLog(3, "  Including ${rel.toFile().path}")
-                return true
-            }
-            kobaltLog(2, "  Excluding ${rel.toFile()} (not matching any include pattern")
-            return false
-        }
-
-        override fun toFiles(baseDir: String?, filePath: String, excludes: List<Glob>): List<File> {
             val result = arrayListOf<File>()
-            val includes = Glob(*spec.toTypedArray())
 
-            if (File(baseDir, filePath).isDirectory) {
+            val matcher = FileSystems.getDefault().getPathMatcher("glob:${spec}")
-                val orgRootDir = (if (File(filePath).isAbsolute) Paths.get(filePath)
+            Files.walkFileTree(Paths.get(directory), object : SimpleFileVisitor<Path>() {
-                    else if (baseDir != null) Paths.get(baseDir, filePath)
+                override public fun visitFile(path: Path, attrs: BasicFileAttributes): FileVisitResult {
-                    else Paths.get(filePath)).run { normalize() }
+                    val rel = Paths.get(directory).relativize(path)
-                // Paths.get(".").normalize() returns an empty string, which is not a valid file :-(
+                    if (matcher.matches(rel)) {
-                val rootDir = if (orgRootDir.toFile().path.isEmpty()) Paths.get("./") else orgRootDir
+                        log(3, "Adding ${rel.toFile()}")
-                if (rootDir.toFile().exists()) {
-                    Files.walkFileTree(rootDir, object : SimpleFileVisitor<Path>() {
-                        override fun visitFile(p: Path, attrs: BasicFileAttributes): FileVisitResult {
-                            val path = p.normalize()
-                            val rel = orgRootDir.relativize(path)
-                            if (isIncluded(includes, excludes, path)) {
-                                kobaltLog(3, "  including file " + rel.toFile() + " from rootDir $rootDir")
                         result.add(rel.toFile())
                     }
                     return FileVisitResult.CONTINUE
                 }
             })
-                } else {
-                    throw AssertionError("Directory \"$rootDir\" should exist")
-                }
-            } else {
-                if (isIncluded(includes, excludes, Paths.get(filePath))) {
-                    result.add(File(filePath))
-                }
-            }
-
             return result
         }
 
-        override fun toString(): String {
+        override public fun toString() = spec
-            var result = ""
-            spec.apply {
-                if (!isEmpty()) {
-                    result += "Included files: " + joinToString { ", " }
-                }
-            }
-            return result
-        }
     }
 
 }
-
-/**
- * A Glob is a simple file name matcher.
- */
-class Glob(vararg specs: String) {
-    val matchers = prepareMatchers(specs.toList())
-
-    private fun prepareMatchers(specs: List<String>): List<PathMatcher> =
-            specs.map { it -> FileSystems.getDefault().getPathMatcher("glob:$it") }
-
-    fun matches(s: String) = matches(Paths.get(s))
-
-    fun matches(path: Path) = matchers.any { it.matches(path) }
-}

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

@@ -1,43 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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,17 +0,0 @@
-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 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.
- * @param task The task to run.
- */
-class IncrementalTaskInfo(val inputChecksum: () -> String?,
-        val outputChecksum: () -> String?,
-        val task: (Project) -> TaskResult,
-        val context: KobaltContext)

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

@@ -1,162 +0,0 @@
-package com.beust.kobalt
-
-import com.beust.kobalt.api.KobaltContext
-import com.beust.kobalt.api.Project
-import com.beust.kobalt.archive.Archives
-import com.beust.kobalt.archive.MetaArchive
-import com.beust.kobalt.archive.Zip
-import com.beust.kobalt.maven.DependencyManager
-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.FileInputStream
-import java.nio.file.Paths
-import java.util.jar.Manifest
-
-class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) : ArchiveGenerator {
-    companion object {
-        fun findIncludedFiles(directory: String, files: List<IncludedFile>, excludes: List<Glob>,
-                throwOnError: Boolean = true)
-                : List<IncludedFile> {
-            val result = arrayListOf<IncludedFile>()
-            files.forEach { includedFile ->
-                val includedSpecs = arrayListOf<IFileSpec>()
-                includedFile.specs.forEach { spec ->
-                    val fromPath = includedFile.from
-                    if (File(directory, fromPath).exists()) {
-                        spec.toFiles(directory, fromPath).forEach { file ->
-                            val fullFile = File(KFiles.joinDir(directory, fromPath, file.path))
-                            if (! fullFile.exists() && throwOnError) {
-                                throw AssertionError("File should exist: $fullFile")
-                            }
-
-                            if (!KFiles.isExcluded(fullFile, excludes)) {
-                                val normalized = Paths.get(file.path).normalize().toFile().path
-                                includedSpecs.add(IFileSpec.FileSpec(normalized))
-                            } else {
-                                kobaltLog(2, "Not adding ${file.path} to jar file because it's excluded")
-                            }
-
-                        }
-                    } else {
-                        kobaltLog(2, "  Directory $fromPath doesn't exist, not including it in the jar")
-                    }
-                }
-                if (includedSpecs.size > 0) {
-                    kobaltLog(3, "Including specs $includedSpecs")
-                    result.add(IncludedFile(From(includedFile.from), To(includedFile.to), includedSpecs))
-                }
-            }
-            return result
-        }
-    }
-
-    override val suffix = ".jar"
-
-    override fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List<IncludedFile> {
-        //
-        // Add all the applicable files for the current project
-        //
-        val buildDir = KFiles.buildDir(project)
-        val result = arrayListOf<IncludedFile>()
-        val classesDir = KFiles.makeDir(buildDir.path, "classes")
-
-        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
-            val relClassesDir = Paths.get(project.directory).relativize(Paths.get(classesDir.path))
-            val prefixPath = Paths.get(project.directory).relativize(Paths.get(classesDir.path + "/"))
-
-            // 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), zip.excludes)
-            }
-            val fileSpecs = arrayListOf<IFileSpec>()
-            filesNotExcluded.forEach {
-                fileSpecs.add(IFileSpec.FileSpec(it.path.toString().substring(prefixPath.toString().length + 1)))
-            }
-            result.add(IncludedFile(From(prefixPath.toString()), To(""), fileSpecs))
-
-            // Resources, if applicable
-            context.variant.resourceDirectories(project).forEach {
-                result.add(IncludedFile(From(it.path), To(""), listOf(IFileSpec.GlobSpec("**"))))
-            }
-        } else {
-            //
-            // The user specified an include, just use it verbatim
-            //
-            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 (zip.fatJar) {
-            val seen = hashSetOf<String>()
-            @Suppress("UNCHECKED_CAST")
-            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, zip.excludes)) {
-                        result.add(IncludedFile(specs = arrayListOf(IFileSpec.FileSpec(file.absolutePath)),
-                                expandJarFiles = true))
-                    }
-                }
-            }
-        }
-
-        return result
-    }
-
-    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 =
-            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 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 class JavaInfo {
+abstract public class JavaInfo {
-    val javaExecutable: File?
+    public var javaExecutable: File? = null
         get() = findExecutable("java")
-    val javacExecutable: File?
+    public var javacExecutable: File? = null
         get() = findExecutable("javac")
-    val javadocExecutable: File?
+    public var javadocExecutable: File? = null
         get() = findExecutable("javadoc")
-    abstract var javaHome: File?
+    abstract public var javaHome: File?
-    abstract var runtimeJar: File?
+    abstract public var runtimeJar: File?
-    abstract var toolsJar: File?
+    abstract public var toolsJar: File?
 
-    abstract fun findExecutable(command: String) : File
+    abstract public 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.kobaltLog
+import com.beust.kobalt.misc.log
 import com.beust.kobalt.misc.warn
 import java.io.File
 import java.io.IOException
 
-open class Jvm constructor(
+public open class Jvm constructor(
         val os: OperatingSystem,
         var javaBase: File? = null) : JavaInfo() {
 
     private var _javaHome: File? = null
-    override var javaHome: File? = null
+    override public var javaHome: File? = null
         get() = _javaHome!!
-    override var runtimeJar: File? = null
+    override public var runtimeJar: File? = null
     private fun findRuntimeJar() : File? {
         var runtimeJar = File(javaBase, "lib/rt.jar")
         if (runtimeJar.exists()) {
@@ -21,7 +21,7 @@ open class Jvm constructor(
         runtimeJar = File(javaBase, "jre/lib/rt.jar")
         return if (runtimeJar.exists()) runtimeJar else null
     }
-    override var toolsJar: File? = null
+    override public var toolsJar: File? = null
 
     private var userSupplied: Boolean? = false
     private var javaVersion: String? = null
@@ -67,7 +67,7 @@ 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 @@ 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 @@ open class Jvm constructor(
         return null
     }
 
-//    open fun isIbmJvm(): Boolean {
+//    open public fun isIbmJvm(): Boolean {
 //        return false
 //    }
 
-    override fun findExecutable(command: String): File {
+    override public fun findExecutable(command: String): File {
         if (javaHome != null) {
             val jdkHome = if (javaHome!!.endsWith("jre")) javaHome!!.parentFile else javaHome
             val exec = File(jdkHome, "bin/" + command)
-            val executable = File(os.getExecutableName(exec.absolutePath))
+            var executable = File(os.getExecutableName(exec.absolutePath))
             if (executable.isFile) {
                 return executable
             }
@@ -110,7 +110,7 @@ open class Jvm constructor(
 
         val pathExecutable = os.findInPath(command)
         if (pathExecutable != null) {
-            kobaltLog(2, "Unable to find the $command executable using home: " +
+            log(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

@@ -1,34 +1,30 @@
 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.DependencyManager
+import com.beust.kobalt.maven.DepFactory
-import com.beust.kobalt.misc.JarUtils
+import com.beust.kobalt.maven.LocalRepo
 import com.beust.kobalt.misc.KFiles
 import com.beust.kobalt.misc.KobaltExecutors
-import com.beust.kobalt.misc.kobaltLog
+import com.beust.kobalt.misc.log
+import com.beust.kobalt.misc.JarUtils
 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
-class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManager>,
+public class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManager>,
         val files: KFiles,
-        val depManager: DependencyManager,
+        val depFactory: DepFactory,
-        val settings: KobaltSettings,
+        val localRepo: LocalRepo,
         val executors: KobaltExecutors,
-        val incrementalManagerFactory: IncrementalManager.IFactory,
+        val pluginInfo: PluginInfo,
         val taskManager: TaskManager) {
 
     companion object {
@@ -50,8 +46,6 @@ class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManage
         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)
@@ -64,87 +58,45 @@ class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManage
             }
 
             // Call apply() on each plug-in that accepts a project
-            kobaltLog(2, "Applying plug-in \"${plugin.name}\"")
+            log(2, "Applying plug-in \"${plugin.name}\"")
             projects.filter { plugin.accept(it) }.forEach { project ->
                 plugin.apply(project, context)
             }
 
-            findStaticTasks(plugin, Task::class.java, { method -> isValidTaskMethod(method)}).forEach {
+            var currentClass : Class<in Any> = plugin.javaClass
-                taskManager.addAnnotationTask(plugin, it.first, it.second)
-            }
-            findStaticTasks(plugin, IncrementalTask::class.java,
-                    { method -> isValidIncrementalTaskMethod(method)}).forEach {
-            taskManager.addIncrementalTask(plugin, it.first, it.second)
-            }
-        }
-
-        // Collect all the tasks from the task contributors
-        context.pluginInfo.taskContributors.forEach {
-            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
-        taskManager.computePluginTasks(projects)
-    }
-
-    private fun <T: Annotation> findStaticTasks(plugin: IPlugin, klass: Class<T>, validate: (Method) -> Boolean)
-            : List<Pair<Method, T>> {
-        val result = arrayListOf<Pair<Method, T>>()
-
-        var currentClass : Class<in Any>? = plugin.javaClass
 
             // Tasks can come from two different places: plugin classes and build files.
             // When a task is read from a build file, ScriptCompiler adds it right away to plugin.methodTasks.
             // The following loop introspects the current plugin, finds all the tasks using the @Task annotation
             // and adds them to plugin.methodTasks
-        while (currentClass != null && ! (klass.equals(currentClass))) {
+            while (! (currentClass.equals(Any::class.java))) {
                 currentClass.declaredMethods.map {
-                Pair(it, it.getAnnotation(klass))
+                    Pair(it, it.getAnnotation(Task::class.java))
                 }.filter {
                     it.second != null
                 }.filter {
-                validate(it.first)
+                    isValidTaskMethod(it.first)
                 }.forEach {
                     if (Modifier.isPrivate(it.first.modifiers)) {
                         throw KobaltException("A task method cannot be private: ${it.first}")
                     }
-                result.add(it)
+                    val annotation = it.second
+
+                    taskManager.staticTasks.add(TaskManager.StaticTask(plugin, it.first, annotation))
                 }
 
                 currentClass = currentClass.superclass
             }
-        return result
+
         }
 
-    /**
+        // Collect all the tasks from the task contributors
-     * Make sure this task method has the right signature.
+        context.pluginInfo.taskContributors.forEach {
-     */
+            taskManager.dynamicTasks.addAll(it.tasksFor(context).map { TaskManager.PluginDynamicTask(it.plugin, it) })
-    private fun isValidIncrementalTaskMethod(method: Method): Boolean {
-        val t = "Task ${method.declaringClass.simpleName}.${method.name}: "
-
-        if (method.returnType != IncrementalTaskInfo::class.java) {
-            throw IllegalArgumentException("${t}should return a IncrementalTaskInfo")
         }
-        return true
+
+        // Now that we have collected all static and dynamic tasks, turn them all into plug-in tasks
+        taskManager.computePluginTasks(plugins, projects)
     }
 
     /**
@@ -170,34 +122,20 @@ class Plugins @Inject constructor (val taskManagerProvider : Provider<TaskManage
 
     val dependencies = arrayListOf<IClasspathDependency>()
 
-//    @Inject
+    fun installPlugins(dependencies: List<IClasspathDependency>, classLoader: ClassLoader) {
-//    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).
-            depManager.create(it.id)
+            depFactory.create(it.id, executor)
 
             //
             // Open the jar, parse its kobalt-plugin.xml and add the resulting PluginInfo to pluginInfo
             //
-            val file = it.jarFile.get()
+            val pluginXml = JarUtils.extractTextFile(JarFile(it.jarFile.get()), PluginInfo.PLUGIN_XML)
-            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 pluginClassLoader = URLClassLoader(arrayOf(file.toURI().toURL()))
+                val thisPluginInfo = PluginInfo.readPluginXml(pluginXml, classLoader)
-                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,20 +3,18 @@ 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.aether.*
+import com.beust.kobalt.maven.RepoFinder
-import com.beust.kobalt.misc.*
+import com.beust.kobalt.maven.SimpleDep
+import com.beust.kobalt.maven.dependency.MavenDependency
+import com.beust.kobalt.misc.Node
+import com.beust.kobalt.misc.log
 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(
+class ResolveDependency @Inject constructor(val repoFinder: RepoFinder, val localRepo: LocalRepo) {
-        val localRepo: LocalRepo,
-        val aether: KobaltMavenResolver,
-        val executors: KobaltExecutors) {
     val increment = 8
     val leftFirst = "\u2558"
     val leftMiddle = "\u255f"
@@ -25,51 +23,24 @@ class ResolveDependency @Inject constructor(
 
     class Dep(val dep: IClasspathDependency, val level: Int)
 
-    fun run(id: String) = displayDependenciesFor(id)
+    fun run(id: String) {
+        val repoResult = repoFinder.findCorrectRepo(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 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 originalDep = MavenDependency.create(id)
+        // We want to display the dependencies of the id we found, not the one we queries
+        val dep = MavenDependency.create(originalDep.shortId + repoResult.version)
         val root = Node(Dep(dep, indent))
-        val seen = hashSetOf(dep.id)
+        val seen = hashSetOf(id)
         root.addChildren(findChildren(root, seen))
 
-        kobaltLog(1, AsciiArt.logBox(listOf(dep.id, url, dep.jarFile.get()).map { "          $it" }))
+        val simpleDep = SimpleDep(MavenId.create(id))
+        val url = repoResult.hostConfig.url + simpleDep.toJarFile(repoResult)
+        val localFile = localRepo.toFullPath(simpleDep.toJarFile(repoResult))
+        AsciiArt.logBox(listOf(id, url, localFile).map { "          $it" }, {s -> println(s) })
 
         display(root.children)
-        kobaltLog(1, "")
+        println("")
     }
 
     private fun display(nodes: List<Node<Dep>>) {
@@ -81,12 +52,10 @@ class ResolveDependency @Inject constructor(
                         else leftMiddle
                 val indent = level * increment
                 for(i in 0..indent - 2) {
-                    if (!KobaltLogger.isQuiet) {
+                    if (i % increment == 0) print(vertical)
-                        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)
             }
         }
@@ -99,18 +68,13 @@ class ResolveDependency @Inject constructor(
             if (! seen.contains(it.id)) {
                 val dep = Dep(it, root.value.level + 1)
                 val node = Node(dep)
-                kobaltLog(2, "Found dependency ${dep.dep.id} level: ${dep.level}")
+                log(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,17 +1,9 @@
 package com.beust.kobalt
 
-class SystemProperties {
+public class SystemProperties {
     companion object {
-        val javaBase : String
+        val javaBase = System.getProperty("java.home") ?:
-            get() {
+                (System.getenv("JAVA_HOME") ?: throw IllegalArgumentException("JAVA_HOME not defined"))
-                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,8 +1,3 @@
 package com.beust.kobalt
 
-class TestResult(val success: Boolean, val shortMessage: String? = null, val longMessage: String? = null)
+open public class TaskResult(val success: Boolean = true, val errorMessage: 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

@@ -1,40 +0,0 @@
-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,16 +3,21 @@ package com.beust.kobalt
 import com.beust.kobalt.api.Project
 import com.beust.kobalt.api.annotation.Directive
 
-@Directive
+class TestConfig(val project: Project) {
-fun Project.test(init: TestConfig.() -> Unit): TestConfig = let { project ->
+    fun args(vararg arg: String) {
-    with(testConfigs) {
+        project.testArgs.addAll(arg)
-        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 = ... }")
     }
+
+    fun jvmArgs(vararg arg: String) {
+        project.testJvmArgs.addAll(arg)
     }
 }
+
+@Directive
+fun Project.test(init: TestConfig.() -> Unit) : TestConfig {
+    val result = TestConfig(this)
+    result.init()
+    return result
+}
+
+

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

@@ -1,12 +1,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.*
 
 /**
  * Capture the product flavor and the build type of a build.
@@ -29,71 +26,49 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
     /**
      * for {internal, release}, return [internalRelease, internal, release]
      */
-    fun allDirectories(): List<String> {
+    fun allDirectories(project: Project): List<String> {
-        return arrayListOf<String>().apply {
+        val result = arrayListOf<String>()
-            add(toCamelcaseDir())
+        result.add(toCamelcaseDir())
-            add(productFlavor.name)
+        if (productFlavor != null) result.add(productFlavor.name)
-            add(buildType.name)
+        if (buildType != null) result.add(buildType.name)
-        }
+        return result
     }
 
-    fun sourceDirectories(project: Project, context: KobaltContext, sourceSet: SourceSet) : List<File> {
+    fun resDirectories(project: Project) : List<File> = sourceDirectories(project, "res")
-        val result = arrayListOf<File>()
-        val compilerContributors = ActorUtils.selectAffinityActors(project, context,
-                context.pluginInfo.compilerContributors)
-        compilerContributors.forEach {
-            it.compilersFor(project, context).forEach { compiler ->
-                result.addAll(sourceDirectories(project, compiler.sourceDirectory, variantFirst = true,
-                        sourceSet = sourceSet))
-            }
 
-        }
+    fun sourceDirectories(project: Project) : List<File> =
-        return result.filter { ! KFiles.isResource(it.path) }.toList()
+            sourceDirectories(project, project.projectInfo.sourceDirectory)
-    }
 
     /**
-     * Might be used by plug-ins.
+     * suffix is either "java" (to find source files) or "res" (to find resources)
      */
-    fun resourceDirectories(project: Project, sourceSet: SourceSet = SourceSet.MAIN)
+    private fun sourceDirectories(project: Project, suffix: String) : List<File> {
-            = sourceDirectories(project, "resources", variantFirst = false, sourceSet = sourceSet)
-        .filter { KFiles.isResource(it.path) }
-
-    /**
-     * suffix is either "java" (to find source files) or "resources" (to find resources).
-     * The priority directory is always returned first. For example, if a "pro" product flavor
-     * is requested, "src/pro/kotlin" will appear in the result before "src/main/kotlin". Later,
-     * files that have already been seen get skipped, which is how compilation and resources
-     * receive the correct priority in the final jar.
-     */
-    private fun sourceDirectories(project: Project, suffix: String, variantFirst: Boolean, sourceSet: SourceSet)
-            : List<File> {
         val result = arrayListOf<File>()
-        val sourceDirectories = sourceSet.correctSourceSet(project)
+        val sourceDirectories = project.sourceDirectories.map { File(it) }
-                .filter { File(project.directory, it).exists() }
-                .map(::File)
-
         if (isDefault) {
             result.addAll(sourceDirectories)
         } else {
+            result.addAll(allDirectories(project).map {
+                File(KFiles.joinDir("src", it, suffix))
+                }.filter {
+                    it.exists()
+                })
+
 //            // 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))
+                val dir = File(KFiles.joinDir("src", it.name, project.projectInfo.sourceDirectory))
-                kobaltLog.log(project.name, 3, "Adding source for build type ${it.name}: ${dir.path}")
+                log(3, "Adding source for build type ${it.name}: ${dir.path}")
                 result.add(dir)
             }
             productFlavor.let {
-                val dir = File(KFiles.joinDir("src", it.name, suffix))
+                val dir = File(KFiles.joinDir("src", it.name, project.projectInfo.sourceDirectory))
-                kobaltLog.log(project.name, 3, "Adding source for product flavor ${it.name}: ${dir.path}")
+                log(3, "Adding source for product flavor ${it.name}: ${dir.path}")
                 result.add(dir)
             }
 
-            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)
+            return result
         }
 
         // Generated directory, if applicable
@@ -101,11 +76,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
             result.add(it)
         }
 
-        val filteredResult = result.filter { File(project.directory, it.path).exists() }
+        return result
-        val sortedResult = if (variantFirst) filteredResult
-            else filteredResult.reversed().toList()
-        val deduplicatedResult = LinkedHashSet(sortedResult).toList()
-        return deduplicatedResult
     }
 
     fun archiveName(project: Project, archiveName: String?, suffix: String) : String {
@@ -113,27 +84,28 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
             if (isDefault) {
                 archiveName ?: project.name + "-" + project.version + suffix
             } else {
-                val base = archiveName?.substring(0, archiveName.length - suffix.length)
+                val base = if (archiveName != null) archiveName.substring(0, archiveName.length - suffix.length)
-                        ?: project.name + "-" + project.version
+                else project.name + "-" + project.version
-                val flavor = if (productFlavor.name.isEmpty()) "" else "-" + productFlavor.name
+                val result: String =
-                val type = if (buildType.name.isEmpty()) "" else "-" + buildType.name
+                        base + "-${productFlavor.name}" + "-${buildType.name}"
-                val result: String = base + flavor + type + suffix
 
                 result
             }
         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
+        return project.buildTypes.getRaw(buildTypeName)?.buildConfig ?: null
     }
 
     private fun findProductFlavorBuildConfig(project: Project, variant: Variant?) : BuildConfig? {
         val buildTypeName = variant?.productFlavor?.name
-        return project.productFlavors[buildTypeName]?.buildConfig
+        return project.productFlavors.getRaw(buildTypeName)?.buildConfig ?: null
     }
 
     /**
@@ -151,7 +123,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 generateAndSave any additional field (in that order to
+     * product flavor or main project, and use them to generate 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? {
@@ -160,24 +132,18 @@ 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 generateAndSave BuildConfig")
+                    "packageName needs to be defined on the project in order to generate BuildConfig")
 
-            val contributor = ActorUtils.selectAffinityActor(project, context,
+            val code = project.projectInfo.generateBuildConfig(project, context, pkg, this, buildConfigs)
-                    context.pluginInfo.buildConfigContributors)
-            if (contributor != null) {
-                val code = contributor.generateBuildConfig(project, context, pkg, this, buildConfigs)
             val result = KFiles.makeDir(KFiles.generatedSourceDir(project, this, "buildConfig"))
             // Make sure the generatedSourceDirectory doesn't contain the project.directory since
             // that directory will be added when trying to find recursively all the sources in it
-                generatedSourceDirectory = result.relativeTo(File(project.directory))
+            generatedSourceDirectory = File(result.relativeTo(File(project.directory)))
             val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar))
-                val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig." + contributor.buildConfigSuffix)
+            val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig" + project.sourceSuffix)
             KFiles.saveFile(outputDir, code)
-                context.logger.log(project.name, 2, "Generated ${outputDir.path}")
+            log(2, "Generated ${outputDir.path}")
             return result
-            } else {
-                throw KobaltException("Couldn't find a contributor to generateAndSave BuildConfig")
-            }
         } else {
             return null
         }
@@ -185,10 +151,9 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
 
     override fun toString() = toTask("")
 
-
     companion object {
         val DEFAULT_PRODUCT_FLAVOR = ProductFlavorConfig("")
-        val DEFAULT_BUILD_TYPE = BuildTypeConfig("")
+        val DEFAULT_BUILD_TYPE = BuildTypeConfig(null, "")
 
         fun allVariants(project: Project): List<Variant> {
             val result = arrayListOf<Variant>()
@@ -221,9 +186,9 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null,
     }
 
     fun toCamelcaseDir() : String {
-        fun lci(s : String) = if (s.isEmpty() || s.length == 1) s else s[0].toLowerCase() + s.substring(1)
+        val pfName = productFlavor.name
-
+        val btName = buildType.name
-        return lci(productFlavor.name) + buildType.name.capitalize()
+        return pfName[0].toLowerCase() + pfName.substring(1) + btName[0].toUpperCase() + btName.substring(1)
     }
 
     fun toIntermediateDir() : String {

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

@@ -3,7 +3,7 @@ package com.beust.kobalt.api
 import com.beust.kobalt.Plugins
 import com.beust.kobalt.internal.TaskManager
 
-abstract class BasePlugin : IPlugin {
+abstract public class BasePlugin : IPlugin {
     lateinit var context: KobaltContext
 
     override fun accept(project: Project) = true
@@ -12,7 +12,13 @@ abstract class BasePlugin : IPlugin {
         this.context = context
     }
 
-    override fun shutdown() {}
+    /**
+     * The list of projects depended upon (e.g. val p = javaProject(dependentProject)).
+     */
+    protected val projects = arrayListOf<ProjectDescription>()
+
+    fun addProject(project: Project, dependsOn: Array<out Project>) =
+            projects.add(ProjectDescription(project, dependsOn.toList()))
 
     override lateinit var taskManager: TaskManager
     lateinit var plugins: Plugins

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

@@ -1,11 +0,0 @@
-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

@@ -8,9 +8,7 @@ import java.io.File
 data class CompilerActionInfo(val directory: String?,
         val dependencies: List<IClasspathDependency>,
         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/ConfigActor.kt

@@ -1,19 +0,0 @@
-package com.beust.kobalt.api
-
-import java.util.*
-
-/**
- * Actors that have one config object per project can implement `IConfigActor` by delegating to
- * `ConfigActor`. Then they can easily add and look up configurations per project.
- */
-interface IConfigActor<T> {
-    val configurations : HashMap<String, T>
-
-    fun configurationFor(project: Project?) = if (project != null) configurations[project.name] else null
-
-    fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration)
-}
-
-open class ConfigActor<T>: IConfigActor<T> {
-    override val configurations : HashMap<String, T> = hashMapOf()
-}

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

@@ -0,0 +1,12 @@
+package com.beust.kobalt.api
+
+/**
+ * A plug-in that has some per-project configuration in the build file.
+ */
+abstract public class ConfigPlugin<T> : BasePlugin() {
+    private val configurations = hashMapOf<String, T>()
+
+    fun configurationFor(project: Project?) = if (project != null) configurations[project.name] else null
+
+    fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration)
+}

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

@@ -1,19 +0,0 @@
-package com.beust.kobalt.api
-
-import com.google.common.collect.ArrayListMultimap
-import com.google.common.collect.ListMultimap
-
-/**
- * Actors that have more than config object per project can use this helper class.
- */
-interface IConfigsActor<T> {
-    val configurations : ListMultimap<String, T>
-
-    fun configurationFor(project: Project?) = if (project != null) configurations[project.name] else null
-
-    fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration)
-}
-
-open class ConfigsActor<T>: IConfigsActor<T> {
-    override val configurations = ArrayListMultimap.create<String, T>()
-}

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

@@ -0,0 +1,14 @@
+package com.beust.kobalt.api
+
+import com.google.common.collect.ArrayListMultimap
+
+/**
+ * A plug-in that has some per-project list of configurations in the build file.
+ */
+abstract public class ConfigsPlugin<T> : BasePlugin() {
+    private val configurations = ArrayListMultimap.create<String, T>()
+
+    fun configurationFor(project: Project) = configurations[project.name]
+
+    fun addConfiguration(project: Project, configuration: T) = configurations.put(project.name, configuration)
+}

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

@@ -1,47 +0,0 @@
-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

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

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

@@ -1,16 +0,0 @@
-package com.beust.kobalt.api
-
-import com.beust.kobalt.Variant
-
-/**
- * Plug-ins that can generate a BuildConfig file.
- */
-interface IBuildConfigContributor : IProjectAffinity {
-    fun generateBuildConfig(project: Project, context: KobaltContext, packageName: String, variant: Variant,
-            buildConfigs: List<BuildConfig>) : String
-
-    /**
-     * The suffix of the generated BuildConfig, e.g. ".java".
-     */
-    val buildConfigSuffix: 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 : IContributor {
+interface IBuildConfigFieldContributor {
     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 IBuildDirectoryInterceptor : IInterceptor {
+interface IBuildDirectoryIncerceptor : IInterceptor {
     fun intercept(project: Project, context: KobaltContext, buildDirectory: String) : String
 }
 

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

@@ -1,20 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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/IClasspathContributor.kt

@@ -1,10 +1,12 @@
 package com.beust.kobalt.api
 
+import com.beust.kobalt.api.IClasspathDependency
+
 /**
  * Plugins that export classpath entries need to implement this interface.
  */
 interface IClasspathContributor : IContributor {
-    fun classpathEntriesFor(project: Project?, context: KobaltContext) : Collection<IClasspathDependency>
+    fun entriesFor(project: Project?) : Collection<IClasspathDependency>
 }
 
 

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

@@ -8,34 +8,20 @@ import java.util.concurrent.Future
  * Encapsulate a dependency that can be put on the classpath. This interface
  * has two subclasses: FileDependency, a physical file, and MavenDependency,
  * which represents a dependency living in a Maven repo.
- *
- * You can instantiate either of these concrete classes with DependencyManager#createMaven
- * and DependencyManager#createFile.
  */
 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(scope: String? = null) : Dependency
+    fun toMavenDependencies() : 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

@@ -1,68 +1,9 @@
 package com.beust.kobalt.api
 
 import com.beust.kobalt.TaskResult
+import com.beust.kobalt.api.IClasspathDependency
+import java.io.File
 
-interface ICompilerDescription : Comparable<ICompilerDescription> {
+interface ICompilerContributor : IProjectAffinity {
-    /**
-     * 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").
-     */
-    val sourceSuffixes: List<String>
-
-    /**
-     * The trailing end of the source directory (e.g. "kotlin" in "src/main/kotlin")
-     */
-    val sourceDirectory: String
-
-    /**
-     * Run the compilation based on the info.
-     */
     fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult
-
-    companion object {
-        val DEFAULT_PRIORITY: Int = 10
-    }
-
-    /**
-     * 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,27 +3,6 @@ package com.beust.kobalt.api
 /**
  * Plugins that add compiler flags.
  */
-class FlagContributor(val flagPriority: Int = DEFAULT_FLAG_PRIORITY,
+interface ICompilerFlagContributor : IContributor {
-        val closure: (project: Project, context: KobaltContext, currentFlags: List<String>,
+    fun flagsFor(project: Project, context: KobaltContext, currentFlags: List<String>): 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

@@ -1,88 +0,0 @@
-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, IContributor {
+interface IDocContributor : IProjectAffinity {
     fun generateDoc(project: Project, context: KobaltContext, info: CompilerActionInfo) : TaskResult
 }
 

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

@@ -1,12 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/IInitContributor.kt

@@ -0,0 +1,15 @@
+package com.beust.kobalt.api
+
+import java.io.OutputStream
+
+/**
+ * Plugins that want to participate in the --init process (they can generate files to initialize
+ * a new project).
+ */
+interface IInitContributor<T> : ISimpleAffinity<T> {
+    /**
+     * Generate the Build.kt file into the given OutputStream.
+     */
+    fun generateBuildFile(os: OutputStream)
+}
+

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

@@ -1,13 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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,29 +2,9 @@ package com.beust.kobalt.api
 
 import com.beust.kobalt.internal.TaskManager
 
-interface IPlugin : IPluginActor {
+public 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,15 +1,9 @@
 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,11 +1,10 @@
 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(project: T) : Int
+    fun affinity(arg: 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 ISourceDirectoryInterceptor : IInterceptor {
+interface ISourceDirectoryIncerceptor : 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,16 +5,6 @@ import java.io.File
 /**
  * Plug-ins that add source directories to be compiled need to implement this interface.
  */
-interface ISourceDirectoryContributor : IContributor {
+interface ISourceDirectoryContributor {
     fun sourceDirectoriesFor(project: Project, context: KobaltContext): List<File>
 }
-
-/**
- * @return the source directories for this project including source contributors.
- */
-fun KobaltContext.sourceDirectories(project: Project) : Set<File> {
-    val result = pluginInfo.sourceDirContributors.flatMap {
-        it.sourceDirectoriesFor(project, this)
-    }
-    return result.toSet()
-}

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

@@ -1,32 +1,17 @@
 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(project: Project, context: KobaltContext) : List<DynamicTask>
+    fun tasksFor(context: KobaltContext) : List<DynamicTask>
 }
 
-class DynamicTask(override val plugin: IPlugin, override val name: String, override val doc: String,
+class DynamicTask(val plugin: IPlugin, val name: String, val description: 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) : ITask {
+        val closure: (Project) -> TaskResult)
-
-    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

@@ -1,45 +0,0 @@
-package com.beust.kobalt.api
-
-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 : IContributor {
-    companion object {
-        val DIRECTORY_NAME = "templates"
-    }
-
-    val templates: List<ITemplate>
-}
-
-interface ITemplate {
-    /**
-     * The name of this template. This is the name that will be looked up when passed to the --init
-     * argument.
-     */
-    val templateName: String
-
-    /**
-     * Description of this template.
-     */
-    val templateDescription: String
-
-    /**
-     * The plug-in this template belongs to.
-     */
-    val pluginName: String
-
-    /**
-     * Instructions to display to the user after a template has been generated.
-     */
-    val instructions : String get() = "Build this project with `./kobaltw assemble`"
-
-    /**
-     * Generate the files for this template. The parameter is the arguments that were passed to the kobaltw
-     * command.
-     */
-    fun generateTemplate(args: Args, classLoader: ClassLoader)
-}
-

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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/ITestRunnerContributor.kt

@@ -7,9 +7,8 @@ import com.beust.kobalt.TaskResult
  */
 interface ITestRunnerContributor : IContributor, IProjectAffinity {
     /**
-     * Run the tests. If [[configName]] is not empty, a specific test configuration is requested.
+     * Run the project.
      */
-    fun run(project: Project, context: KobaltContext, configName: String,
+    fun run(project: Project, context: KobaltContext, classpath: List<IClasspathDependency>) : TaskResult
-            classpath: List<IClasspathDependency>) : TaskResult
 }
 

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

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

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

@@ -1,55 +0,0 @@
-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,15 +1,20 @@
 package com.beust.kobalt.api
 
-import com.beust.kobalt.maven.DependencyManager
+import com.beust.kobalt.maven.DepFactory
+import com.beust.kobalt.misc.KobaltExecutors
 import java.io.File
 import java.util.concurrent.Future
 
-class JarFinder {
+public class JarFinder {
     companion object {
         /**
          * @return a Future for the jar file corresponding to this id.
          */
-        fun byIdFuture(id: String) : Future<File> = DependencyManager.create(id).jarFile
+        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).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/Kobalt.kt

@@ -3,81 +3,27 @@ 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.*
 
-class Kobalt {
+public 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
 
-        /**
+        val repos = HashSet<HostConfig>(Constants.DEFAULT_REPOS.map { HostConfig(it) })
-         * @return the repos calculated from various places where repos can be specified.
-         */
-        val repos : Set<HostConfig>
-            get() {
-                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)
-                    )
 
-                // Repo from <kobalt-compiler-repo> in the settings
+        fun addRepo(repo: HostConfig) = repos.add(
-                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()
-            }
-
-        val reposFromBuildFiles = hashSetOf<HostConfig>()
-
-        fun addRepo(repo: HostConfig) = reposFromBuildFiles.add(
                 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
+        private val KOBALT_PROPERTIES = "kobalt.properties"
 
         /** kobalt.properties */
         private val kobaltProperties: Properties by lazy { readProperties() }
@@ -114,28 +60,8 @@ class Kobalt {
             properties.forEach { es -> System.setProperty(es.key.toString(), es.value.toString()) }
         }
 
-        val version: String
+        val version = kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION)
-            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
-            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,77 +1,24 @@
 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
 
-class KobaltContext(val args: Args) {
+public class KobaltContext(val args: Args) {
-    lateinit var variant: Variant
+    var variant: 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
     //
@@ -79,38 +26,5 @@ class KobaltContext(val args: Args) {
     lateinit var pluginProperties: PluginProperties
     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,20 +1,16 @@
 package com.beust.kobalt.api
 
 import com.beust.kobalt.internal.TaskResult2
+import com.beust.kobalt.misc.toString
 import java.util.concurrent.Callable
 
-interface ITask : Callable<TaskResult2<ITask>> {
+abstract public class PluginTask : Callable<TaskResult2<PluginTask>> {
-    val plugin: IPlugin
+    abstract val plugin: IPlugin
-    val project: Project
+    open val name: String = ""
-    val name: String
+    open val doc: String = ""
-    val doc: String
+    abstract val project: Project
-    val group: String
-}
 
-abstract class PluginTask : ITask {
+    override public fun toString() : String {
-    override val name: String = ""
+        return toString("PluginTask", "id", project.name + ":" + name)
-    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

@@ -1,9 +0,0 @@
-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

@@ -1,69 +1,41 @@
 package com.beust.kobalt.api
 
-import com.beust.kobalt.TestConfig
 import com.beust.kobalt.api.annotation.Directive
-import com.beust.kobalt.maven.DependencyManager
+import com.beust.kobalt.internal.IProjectInfo
-import com.beust.kobalt.maven.aether.AetherDependency
+import com.beust.kobalt.maven.dependency.MavenDependency
-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 = "",
+        @Directive open var name: String,
         @Directive open var version: String? = null,
         @Directive open var directory: String = ".",
         @Directive open var buildDirectory: String = KFiles.KOBALT_BUILD_DIR,
         @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 sourceSuffix : String = "",
         @Directive open var description : String = "",
+        @Directive open var scm : Scm? = null,
         @Directive open var url: String? = null,
-        @Directive open var pom: Model? = null,
+        @Directive open var licenses: List<License> = arrayListOf<License>(),
-        @Directive open var dependsOn: ArrayList<Project> = arrayListOf<Project>(),
+        @Directive open var packageName: String? = group,
-        @Directive open var testsDependOn: ArrayList<Project> = arrayListOf<Project>(),
+        val projectInfo: IProjectInfo) : IBuildConfig {
-        @Directive open var packageName: String? = group)
-    : IBuildConfig, IDependencyHolder by DependencyHolder() {
 
-    init {
+    override var buildConfig : BuildConfig? = null //BuildConfig()
-        this.project = this
-    }
 
-    fun allProjectDependedOn() = project.dependsOn + project.testsDependOn
+    val testArgs = arrayListOf<String>()
-
+    val testJvmArgs = arrayListOf<String>()
-    class ProjectExtra(project: Project) {
-        var isDirty = false
-
-        /**
-         * @return true if any of the projects we depend on is dirty.
-         */
-        fun dependsOnDirtyProjects(project: Project) = project.allProjectDependedOn().any { it.projectExtra.isDirty }
-    }
-
-    /**
-     * This field caches a bunch of things we don't want to recalculate all the time, such as the list of suffixes
-     * found in this project.
-     */
-    val projectExtra = ProjectExtra(this)
-
-    val testConfigs = arrayListOf<TestConfig>()
-
-    // 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()
 
-    override fun equals(other: Any?) = name == (other as Project).name
+    override fun equals(other: Any?): Boolean {
-    override fun hashCode() = name.hashCode()
+        return name == (other as Project).name
+    }
 
-    companion object {
+    override fun hashCode(): Int {
-        val DEFAULT_SOURCE_DIRECTORIES = setOf("src/main/java", "src/main/kotlin", "src/main/resources")
+        return name.hashCode()
-        val DEFAULT_SOURCE_DIRECTORIES_TEST = setOf("src/test/java", "src/test/kotlin", "src/test/resources")
     }
 
     //
@@ -72,27 +44,49 @@ open class Project(
 
     @Directive
     fun sourceDirectories(init: Sources.() -> Unit) : Sources {
-        return Sources(this, sourceDirectories).apply { init() }
+        val sources = Sources(this, sourceDirectories)
+        sources.init()
+        return sources
     }
 
-    var sourceDirectories = hashSetOf<String>().apply { addAll(DEFAULT_SOURCE_DIRECTORIES)}
+    var sourceDirectories : HashSet<String> = hashSetOf()
+        get() = if (field.isEmpty()) projectInfo.defaultSourceDirectories else field
+        set(value) {
+            field = value
+        }
 
     @Directive
     fun sourceDirectoriesTest(init: Sources.() -> Unit) : Sources {
-        return Sources(this, sourceDirectoriesTest).apply { init() }
+        val sources = Sources(this, sourceDirectoriesTest)
+        sources.init()
+        return sources
     }
 
-    var sourceDirectoriesTest = hashSetOf<String>().apply { addAll(DEFAULT_SOURCE_DIRECTORIES_TEST)}
+    var sourceDirectoriesTest : HashSet<String> = hashSetOf()
+        get() = if (field.isEmpty()) projectInfo.defaultTestDirectories
+                else field
+        set(value) {
+            field = value
+        }
 
     //
     // Dependencies
     //
 
+    @Directive
+    fun dependencies(init: Dependencies.() -> Unit) : Dependencies {
+        dependencies = Dependencies(this, compileDependencies, compileProvidedDependencies, compileRuntimeDependencies)
+        dependencies!!.init()
+        return dependencies!!
+    }
+
+    val compileDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    val compileProvidedDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+    val compileRuntimeDependencies : ArrayList<IClasspathDependency> = arrayListOf()
+
     @Directive
     fun dependenciesTest(init: Dependencies.() -> Unit) : Dependencies {
-        dependencies = Dependencies(this, testDependencies, arrayListOf(),
+        dependencies = Dependencies(this, testDependencies, testProvidedDependencies, compileRuntimeDependencies)
-                testProvidedDependencies, compileOnlyDependencies, compileRuntimeDependencies,
-                excludedDependencies, nativeDependencies)
         dependencies!!.init()
         return dependencies!!
     }
@@ -100,9 +94,6 @@ 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
@@ -113,8 +104,6 @@ open class Project(
         productFlavors.put(name, pf)
     }
 
-    var defaultConfig : BuildConfig? = null
-
     val buildTypes = hashMapOf<String, BuildTypeConfig>()
 
     fun addBuildType(name: String, bt: BuildTypeConfig) {
@@ -128,20 +117,6 @@ 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>) {
@@ -151,130 +126,39 @@ class Sources(val project: Project, val sources: HashSet<String>) {
     }
 }
 
-class Dependencies(val project: Project,
+class Dependencies(val project: Project, val dependencies: ArrayList<IClasspathDependency>,
-        val dependencies: ArrayList<IClasspathDependency>,
-        val optionalDependencies: ArrayList<IClasspathDependency>,
         val providedDependencies: ArrayList<IClasspathDependency>,
-        val compileOnlyDependencies: ArrayList<IClasspathDependency>,
+        val runtimeDependencies: ArrayList<IClasspathDependency>) {
-        val runtimeDependencies: ArrayList<IClasspathDependency>,
-        val excludedDependencies: ArrayList<IClasspathDependency>,
-        val nativeDependencies: ArrayList<IClasspathDependency>) {
-
-    /**
-     * 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(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)
-            if (excludeConfig != null) {
-                this.forEach { it.excluded.add(excludeConfig) }
-            }
-
-            this.map { FutureTask { it.jarFile.get() } }
-        }
-
     @Directive
-    fun compile(vararg dep: String) = addToDependencies(project, dependencies, dep)
+    fun compile(vararg dep: String) {
-
+        dep.forEach { dependencies.add(MavenDependency.create(it)) }
-    class ExcludeConfig {
-        val ids = arrayListOf<String>()
-
-        @Directive
-        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 exclude(groupId: String? = null, artifactId: String? = null, version: String? = null)
-            = artifacts.add(ArtifactConfig(groupId, artifactId, version))
-
-        fun match(pattern: String?, id: String) : Boolean {
-            return pattern == null || Pattern.compile(pattern).matcher(id).matches()
-        }
-
-        /**
-         * @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
-                }
-            }
-
-            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)
+        dep.forEach { providedDependencies.add(MavenDependency.create(it))}
     }
 
     @Directive
-    fun runtime(vararg dep: String) = addToDependencies(project, runtimeDependencies, dep)
+    fun runtime(vararg dep: String) {
+        dep.forEach { runtimeDependencies.add(MavenDependency.create(it))}
+    }
+}
 
-    @Directive
+class Scm(val connection: String, val developerConnection: String, val url: String)
-    fun exclude(vararg dep: String) = addToDependencies(project, excludedDependencies, dep)
+
+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 native(vararg dep: String) = addToDependencies(project, nativeDependencies, dep)
 }
 
 class BuildConfig {
-    class Field(val name: String, val type: String, val value: Any) {
+    class Field(val name: String, val type: String, val value: Any)
-        override fun hashCode() = name.hashCode()
-        override fun equals(other: Any?) = (other as Field).name == name
-    }
 
     val fields = arrayListOf<Field>()
 
@@ -293,22 +177,32 @@ interface IBuildConfig {
     }
 }
 
-fun Project.defaultConfig(init: BuildConfig.() -> Unit) = let { project ->
+class ProductFlavorConfig(val name: String) : IBuildConfig {
-    BuildConfig().apply {
+    var applicationId: String? = null
-        init()
+    override var buildConfig : BuildConfig? = BuildConfig()
-        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)
+    }
+
+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)
+    }

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

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

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

@@ -1,18 +1,13 @@
 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
 
 /**
  * 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 incrementalManagerFactory: IncrementalManager.IFactory)
+class TaskContributor : ITaskContributor {
-        : ITaskContributor {
     val dynamicTasks = arrayListOf<DynamicTask>()
 
     /**
@@ -24,19 +19,16 @@ class TaskContributor @Inject constructor(val incrementalManagerFactory: Increme
      * 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, group, project,
+            dynamicTasks.add(DynamicTask(plugin, variantTaskName, variantTaskName,
-                    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)
@@ -44,43 +36,5 @@ class TaskContributor @Inject constructor(val incrementalManagerFactory: Increme
         }
     }
 
-    fun addTask(plugin: IPlugin, project: Project, taskName: String, description: String,
+    override fun tasksFor(context: KobaltContext) : List<DynamicTask> = dynamicTasks
-            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)
-            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) },
-                    closure = incrementalManagerFactory.create().toIncrementalTaskClosure(taskName, runTask, variant)))
-        }
-    }
-
-    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,61 +6,18 @@ 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 = "",
 
-    /** 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(),
-
-    /** Ordering: tasks this task runs after */
-    val runAfter: Array<String> = arrayOf(),
-
-    /** 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(),
 
-    /** Ordering: tasks this task runs after */
+    /** Tasks that this task will run after if they get run */
     val runAfter: Array<String> = arrayOf(),
 
-    /** Wrapper tasks */
+    /** Tasks that this task will always run after */
     val alwaysRunAfter: Array<String> = arrayOf()
 )
 

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

@@ -1,83 +0,0 @@
-package com.beust.kobalt.archive
-
-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.JarUtils
-import com.beust.kobalt.misc.KFiles
-import com.beust.kobalt.misc.kobaltLog
-import java.io.File
-import java.util.*
-
-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"
-
-        fun defaultArchiveName(project: Project) = project.name +
-            if (project.version.isNullOrBlank()) "" else "-${project.version}"
-
-        fun generateArchive(project: Project,
-                context: KobaltContext,
-                archiveName: String?,
-                suffix: String,
-                includedFiles: List<IncludedFile>,
-                expandJarFiles : Boolean = false,
-                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)
-            context.logger.log(project.name, 3, "Creating $result")
-            if (! Features.USE_TIMESTAMPS || isOutdated(project.directory, includedFiles, result)) {
-                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
-                }
-
-            } else {
-                context.logger.log(project.name, 3, "  $result is up to date")
-            }
-
-            return result
-        }
-
-        private fun isOutdated(directory: String, includedFiles: List<IncludedFile>, output: File): Boolean {
-            if (! output.exists()) return true
-
-            val lastModified = output.lastModified()
-            includedFiles.forEach { root ->
-                val allFiles = root.allFromFiles(directory)
-                allFiles.forEach { relFile ->
-                    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) {
-                            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
-                    }
-                }
-            }
-            return false
-        }
-    }
-}

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

@@ -1,6 +0,0 @@
-package com.beust.kobalt.archive
-
-interface AttributeHolder {
-    fun addAttribute(k: String, v: String)
-}
-

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

@@ -1,28 +0,0 @@
-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 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)
-        m.init(m)
-        return m
-    }
-
-    // Need to specify the version or attributes will just be dropped
-    @Directive
-    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/Manifest.kt

@@ -1,11 +0,0 @@
-package com.beust.kobalt.archive
-
-import com.beust.kobalt.api.annotation.Directive
-
-class Manifest(val jar: AttributeHolder) {
-    @Directive
-    fun attributes(k: String, v: String) {
-        jar.addAttribute(k, v)
-    }
-}
-

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

@@ -1,125 +0,0 @@
-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)
-        }
-    }
-}