diff --git a/.gitignore b/.gitignore index 7e740ce2..a680191b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,15 +1,15 @@ .gradle annotations .idea/* -!.idea/modules.xml -!.idea/libraries -!.idea/misc.xml -buildScript +*.iml +nonBuildScript kobaltBuild local.properties classes libs .kobalt/ -./build/ out .DS_Store +lib/kotlin-* +build +.history diff --git a/.idea/libraries/kobalt_jar.xml b/.idea/libraries/kobalt_jar.xml deleted file mode 100644 index 9e02804a..00000000 --- a/.idea/libraries/kobalt_jar.xml +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100644 index df7e8eb0..00000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index a41ffd7c..00000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 0c1d3b1d..00000000 --- a/.travis.yml +++ /dev/null @@ -1,13 +0,0 @@ -cache: - directories: - - $HOME/.m2 - - $HOME/.kobalt - -language: java - -jdk: - - oraclejdk8 - -install: true - -script: ./build-travis.sh diff --git a/README.md b/README.md index e8db3ef6..d5d7cbe0 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,14 @@ -# Kobalt [![Build Status](https://travis-ci.org/cbeust/kobalt.svg?branch=master)](https://travis-ci.org/cbeust/kobalt) +# Kobalt + +[](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. diff --git a/build-travis.sh b/build-travis.sh index 467849b9..c7cb1152 100755 --- a/build-travis.sh +++ b/build-travis.sh @@ -1,4 +1,8 @@ -java -Xmx2048m -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* assemble +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 + + -java -Xmx2048m -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* test diff --git a/build.gradle b/build.gradle new file mode 100644 index 00000000..3f0053cc --- /dev/null +++ b/build.gradle @@ -0,0 +1,58 @@ +allprojects { + group = 'com.beust' + version = '1.1.0' +} + +subprojects { + apply plugin: 'java' + apply plugin: 'maven-publish' + + ext { + bndlib = '3.5.0' + findbugs = '3.0.2' + groovy = '2.4.12' + gson = '2.8.2' + guice = '4.2.2' + inject = '1' + jaxb = '2.3.0' + jcommander = '1.72' + kotlin = '1.2.71' + maven = '3.5.2' + mavenResolver = '1.1.0' + okhttp = '3.9.1' + okio = '1.13.0' + retrofit = '2.3.0' + slf4j = '1.7.3' + spark = '2.6.0' + testng = '6.12' + + junit = '4.12' + junitJupiter = '5.1.0' + junitPlatform = '1.1.0' + } + + repositories { + mavenCentral() + mavenLocal() + jcenter() + maven { + url = 'https://dl.bintray.com/cbeust/maven' + } + + maven { + url = 'https://repo.maven.apache.org/maven2' + } + } + + sourceCompatibility = '1.7' + + task sourcesJar(type: Jar) { + from sourceSets.main.allJava + archiveClassifier = 'sources' + } + + task javadocJar(type: Jar) { + from javadoc + archiveClassifier = 'javadoc' + } +} diff --git a/dist/kobaltw b/dist/kobaltw index a8df4bb9..333738df 100755 --- a/dist/kobaltw +++ b/dist/kobaltw @@ -1,2 +1,11 @@ #!/usr/bin/env sh -java -jar "`dirname "$0"`/../kobalt/wrapper/kobalt-wrapper.jar" $* \ No newline at end of file + +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" $* \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 00000000..5c2d1cf0 Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..838e6bc8 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-5.3-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100755 index 00000000..b0d6d0ab --- /dev/null +++ b/gradlew @@ -0,0 +1,188 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 00000000..9991c503 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,100 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem http://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/kobalt.iml b/kobalt.iml deleted file mode 100644 index f4ff4022..00000000 --- a/kobalt.iml +++ /dev/null @@ -1,408 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/kobalt/Build.kt.iml b/kobalt/Build.kt.iml deleted file mode 100644 index 7bc9dd64..00000000 --- a/kobalt/Build.kt.iml +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - - - - - - \ No newline at end of file diff --git a/kobalt/src/Build.kt b/kobalt/src/Build.kt index 7226dcfc..0d09844a 100644 --- a/kobalt/src/Build.kt +++ b/kobalt/src/Build.kt @@ -1,32 +1,57 @@ -import com.beust.kobalt.plugin.application.application -import com.beust.kobalt.plugin.java.javaCompiler -import com.beust.kobalt.plugin.packaging.assemble -import com.beust.kobalt.project -import com.beust.kobalt.TaskResult +import com.beust.kobalt.* import com.beust.kobalt.api.Project 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.kotlin.kotlinCompiler +import com.beust.kobalt.plugin.packaging.assemble +import com.beust.kobalt.plugin.publish.autoGitTag import com.beust.kobalt.plugin.publish.bintray import com.beust.kobalt.plugin.publish.github -import com.beust.kobalt.test -import org.apache.maven.model.* +import org.apache.maven.model.Developer +import org.apache.maven.model.License +import org.apache.maven.model.Model +import org.apache.maven.model.Scm import java.io.File import java.nio.file.Files import java.nio.file.Paths import java.nio.file.StandardCopyOption +import java.util.zip.ZipEntry +import java.util.zip.ZipOutputStream + +val bs = buildScript { + repos("https://dl.bintray.com/cbeust/maven") +} object Versions { - val okhttp = "3.2.0" - val okio = "1.6.0" - val retrofit = "2.1.0" - val gson = "2.6.2" - val aether = "1.1.0" - val sonatypeAether = "1.13.1" - val maven = "3.3.9" + 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" @@ -39,6 +64,7 @@ val wrapper = project { } assemble { + jar { } jar { name = projectName + ".jar" manifest { @@ -50,6 +76,13 @@ val wrapper = project { application { mainClass = "com.beust.kobalt.wrapper.Main" } + + bintray { + publish = true + sign = true + } + + pom = createPom(name, "Wrapper for Kobalt") } val kobaltPluginApi = project { @@ -59,52 +92,44 @@ val kobaltPluginApi = project { version = readVersion() directory = "modules/kobalt-plugin-api" description = "A build system in Kotlin" - url = "http://beust.com/kobalt" + url = "https://beust.com/kobalt" - pom = Model().apply { - name = project.name - description = "A build system in Kotlin" - url = "http://beust.com/kobalt" - licenses = listOf(License().apply { - name = "Apache 2.0" - url = "http://www.apache .org/licenses/LICENSE-2.0" - }) - scm = Scm().apply { - url = "http://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" - }) - } + pom = createPom(name, "A build system in Kotlin") dependencies { compile( - "com.google.inject:guice:4.0", - "com.google.inject.extensions:guice-assistedinject:4.0", + "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}", + "com.google.inject:guice:${Versions.guice}", + "com.google.inject.extensions:guice-assistedinject:4.1.0", "javax.inject:javax.inject:1", - "com.google.guava:guava:19.0", + "com.google.guava:guava:27.0.1-jre", "org.apache.maven:maven-model:${Versions.maven}", - "io.reactivex:rxjava:1.1.5", + "io.reactivex:rxjava:1.3.3", "com.squareup.okio:okio:${Versions.okio}", "com.google.code.gson:gson:${Versions.gson}", "com.squareup.okhttp3:okhttp:${Versions.okhttp}", "com.squareup.retrofit2:retrofit:${Versions.retrofit}", "com.squareup.retrofit2:converter-gson:${Versions.retrofit}", - "com.beust:jcommander:1.48", + "com.beust:jcommander:${Versions.jcommander}", + "org.eclipse.jgit:org.eclipse.jgit:4.9.0.201710071750-r", + "org.slf4j:slf4j-simple:${Versions.slf4j}", + *mavenResolver("api", "spi", "util", "impl", "connector-basic", "transport-http", "transport-file"), + "org.apache.maven:maven-aether-provider:3.3.9", + "org.testng.testng-remote:testng-remote:1.3.2", + "org.testng:testng:${Versions.testng}", + "org.junit.platform:junit-platform-surefire-provider:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-runner:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-engine:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-console:${Versions.junitPlatform}", + "org.junit.jupiter:junit-jupiter-engine:${Versions.junitJupiter}", + "org.junit.vintage:junit-vintage-engine:${Versions.junitJupiter}", + "org.apache.commons:commons-compress:1.15", + "commons-io:commons-io:2.6", - "org.slf4j:slf4j-nop:1.6.0", - "org.eclipse.aether:aether-spi:${Versions.aether}", - "org.eclipse.aether:aether-impl:${Versions.aether}", - "org.eclipse.aether:aether-connector-basic:${Versions.aether}", - "org.eclipse.aether:aether-transport-file:${Versions.aether}", - "org.eclipse.aether:aether-transport-http:${Versions.aether}", - "org.sonatype.aether:aether-api:${Versions.sonatypeAether}", - "org.sonatype.aether:aether-connector-wagon:1.13.1", - "org.apache.maven:maven-aether-provider:${Versions.maven}" + // Java 9 + "javax.xml.bind:jaxb-api:2.3.0" ) + exclude(*aether("impl", "spi", "util", "api")) } @@ -117,12 +142,8 @@ val kobaltPluginApi = project { } } -// install { -// libDir = "lib-test" -// } - kotlinCompiler { - args("-nowarn") + args("nowarn") } bintray { @@ -138,26 +159,35 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { dependencies { // Used by the plugins - compile("org.jetbrains.kotlin:kotlin-compiler-embeddable:1.0.3") + compile("org.jetbrains.kotlin:kotlin-compiler-embeddable:${Versions.kotlin}") // Used by the main app - compile("com.github.spullara.mustache.java:compiler:0.9.1", + compile( + "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}", + "com.github.spullara.mustache.java:compiler:0.9.5", "javax.inject:javax.inject:1", - "com.google.inject:guice:4.0", - "com.google.inject.extensions:guice-assistedinject:4.0", - "com.beust:jcommander:1.48", + "com.google.inject:guice:${Versions.guice}", + "com.google.inject.extensions:guice-assistedinject:${Versions.guice}", + "com.beust:jcommander:${Versions.jcommander}", "org.apache.maven:maven-model:${Versions.maven}", - "com.google.code.findbugs:jsr305:3.0.1", + "com.google.code.findbugs:jsr305:3.0.2", "com.google.code.gson:gson:${Versions.gson}", "com.squareup.retrofit2:retrofit:${Versions.retrofit}", "com.squareup.retrofit2:converter-gson:${Versions.retrofit}", - "com.squareup.okhttp3:okhttp-ws:${Versions.okhttp}", - "org.codehaus.plexus:plexus-utils:3.0.22", - "biz.aQute.bnd:bndlib:2.4.0", +// "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.2.0", + "com.squareup.okhttp3:logging-interceptor:3.9.0", - "com.sparkjava:spark-core:2.5" + "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}", @@ -171,8 +201,11 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { } dependenciesTest { - compile("org.testng:testng:6.9.11", - "org.assertj:assertj-core:3.4.1") + compile("org.jetbrains.kotlin:kotlin-test:${Versions.kotlin}", + "org.testng:testng:${Versions.testng}", + "org.assertj:assertj-core:3.8.0", + *mavenResolver("util") + ) } assemble { @@ -184,17 +217,27 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { } zip { val dir = "kobalt-$version" - include(from("dist"), to("$dir/bin"), "kobaltw") - include(from("dist"), to("$dir/bin"), "kobaltw.bat") - include(from("$buildDirectory/libs"), to("$dir/kobalt/wrapper"), - "$projectName-$version.jar") - include(from("modules/wrapper/$buildDirectory/libs"), to("$dir/kobalt/wrapper"), - "$projectName-wrapper.jar") + val files = listOf( + "dist", "$dir/bin", "kobaltw", + "dist", "$dir/bin", "kobaltw.bat", + "$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-$version.jar", + "modules/wrapper/$buildDirectory/libs", "$dir/kobalt/wrapper", "$projectName-wrapper.jar") + + (0 .. files.size - 1 step 3).forEach { i -> + include(from(files[i]), to(files[i + 1]), files[i + 2]) + } + + // Package the sources + val currentDir = Paths.get(".").toAbsolutePath().normalize().toString() + zipFolders("$currentDir/$buildDirectory/libs/all-sources/$projectName-$version-sources.jar", + "$currentDir/$directory/src/main/kotlin", + "$currentDir/${kobaltPluginApi.directory}/src/main/kotlin") + include(from("$buildDirectory/libs/all-sources"), to("$dir/kobalt/wrapper"), "$projectName-$version-sources.jar") } } kotlinCompiler { - args("-nowarn") + args("nowarn") } bintray { @@ -208,6 +251,32 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { test { args("-log", "2", "src/test/resources/testng.xml") } + + autoGitTag { + enabled = true + } +} + +fun zipFolders(zipFilePath: String, vararg foldersPath: String) { + val zip = Paths.get(zipFilePath) + Files.deleteIfExists(zip) + Files.createDirectories(zip.parent) + val zipPath = Files.createFile(zip) + ZipOutputStream(Files.newOutputStream(zipPath)).use { + foldersPath.map {Paths.get(it)}.forEach { folderPath -> + Files.walk(folderPath) + .filter { path -> !Files.isDirectory(path) } + .forEach { path -> + val zipEntry = ZipEntry(folderPath.relativize(path).toString()) + try { + it.putNextEntry(zipEntry) + Files.copy(path, it) + it.closeEntry() + } catch (e: Exception) { + } + } + } + } } fun readVersion() : String { @@ -220,16 +289,38 @@ fun readVersion() : String { } } -@Task(name = "copyVersionForWrapper", reverseDependsOn = arrayOf("assemble")) +@Task(name = "copyVersionForWrapper", reverseDependsOn = arrayOf("assemble"), runAfter = arrayOf("clean")) fun taskCopyVersionForWrapper(project: Project) : TaskResult { if (project.name == "kobalt-wrapper") { val toString = "modules/wrapper/kobaltBuild/classes" File(toString).mkdirs() val from = Paths.get("src/main/resources/kobalt.properties") val to = Paths.get("$toString/kobalt.properties") - Files.copy(from, - to, - StandardCopyOption.REPLACE_EXISTING) + // 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" + }) +} diff --git a/kobalt/wrapper/kobalt-wrapper.jar b/kobalt/wrapper/kobalt-wrapper.jar index 6ca6ca57..848fb463 100644 Binary files a/kobalt/wrapper/kobalt-wrapper.jar and b/kobalt/wrapper/kobalt-wrapper.jar differ diff --git a/kobalt/wrapper/kobalt-wrapper.properties b/kobalt/wrapper/kobalt-wrapper.properties index a936b53d..0ca8045f 100644 --- a/kobalt/wrapper/kobalt-wrapper.properties +++ b/kobalt/wrapper/kobalt-wrapper.properties @@ -1 +1 @@ -kobalt.version=0.881 \ No newline at end of file +kobalt.version=1.0.122 \ No newline at end of file diff --git a/kobaltw b/kobaltw index b27b3d89..c5186d5a 100755 --- a/kobaltw +++ b/kobaltw @@ -1 +1,2 @@ -java -jar $(dirname $0)/kobalt/wrapper/kobalt-wrapper.jar $* +#!/usr/bin/env sh +java -jar "`dirname "$0"`/kobalt/wrapper/kobalt-wrapper.jar" $* diff --git a/kobaltw-test b/kobaltw-test new file mode 100755 index 00000000..2693c3aa --- /dev/null +++ b/kobaltw-test @@ -0,0 +1,8 @@ +#!/usr/bin/env sh +JAR=$(ls -1 -t kobaltBuild/libs/*.jar | grep -Ev "(sources|javadoc)" | head -1) +TEMPDIR=$(mktemp -d) +cp -pf "$JAR" "$TEMPDIR" +TEMPJAR=$TEMPDIR/$(basename "$JAR") +export KOBALT_JAR=$TEMPJAR +java -jar "$TEMPJAR" "$@" +rm -rf "$TEMPDIR" \ No newline at end of file diff --git a/kobaltw.bat b/kobaltw.bat index d5780716..2887a567 100644 --- a/kobaltw.bat +++ b/kobaltw.bat @@ -1,4 +1,4 @@ -@echo off -set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. -java -jar "%DIRNAME%/kobalt/wrapper/kobalt-wrapper.jar" %* +@echo off +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +java -jar "%DIRNAME%/kobalt/wrapper/kobalt-wrapper.jar" %* diff --git a/lib/kotlin-reflect.jar b/lib/kotlin-reflect.jar deleted file mode 100644 index 62340e2d..00000000 Binary files a/lib/kotlin-reflect.jar and /dev/null differ diff --git a/lib/kotlin-runtime-sources.jar b/lib/kotlin-runtime-sources.jar deleted file mode 100644 index e661b300..00000000 Binary files a/lib/kotlin-runtime-sources.jar and /dev/null differ diff --git a/lib/kotlin-runtime.jar b/lib/kotlin-runtime.jar deleted file mode 100644 index 4d7a9270..00000000 Binary files a/lib/kotlin-runtime.jar and /dev/null differ diff --git a/modules/kobalt-plugin-api/build.gradle b/modules/kobalt-plugin-api/build.gradle new file mode 100644 index 00000000..56085220 --- /dev/null +++ b/modules/kobalt-plugin-api/build.gradle @@ -0,0 +1,85 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' version '1.2.71' + id 'com.github.johnrengelman.shadow' version '5.0.0' +} + +dependencies { + implementation "biz.aQute.bnd:biz.aQute.bndlib:$bndlib" + implementation "com.google.code.findbugs:jsr305:$findbugs" + implementation "com.sparkjava:spark-core:$spark" + implementation "com.squareup.okhttp3:logging-interceptor:$okhttp" + implementation 'commons-io:commons-io:2.6' + implementation 'io.reactivex:rxjava:1.3.3' + implementation "javax.inject:javax.inject:$inject" + implementation "javax.xml.bind:jaxb-api:$jaxb" + implementation 'org.apache.commons:commons-compress:1.15' + implementation 'org.apache.maven:maven-aether-provider:3.3.9' + implementation "org.apache.maven.resolver:maven-resolver-api:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-connector-basic:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-impl:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-spi:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-transport-file:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-transport-http:$mavenResolver" + implementation "org.apache.maven.resolver:maven-resolver-util:$mavenResolver" + implementation "org.codehaus.groovy:groovy:$groovy" + implementation 'org.eclipse.jgit:org.eclipse.jgit:4.9.0.201710071750-r' + implementation "org.junit.jupiter:junit-jupiter-engine:$junitJupiter" + implementation "org.junit.platform:junit-platform-console:$junitPlatform" + implementation "org.junit.platform:junit-platform-engine:$junitPlatform" + implementation "org.junit.platform:junit-platform-runner:$junitPlatform" + implementation "org.junit.platform:junit-platform-surefire-provider:$junitPlatform" + implementation "org.junit.vintage:junit-vintage-engine:$junitJupiter" + implementation "org.slf4j:slf4j-simple:$slf4j" + implementation "org.testng:testng:$testng" + implementation 'org.testng.testng-remote:testng-remote:1.3.2' + implementation "com.beust:jcommander:$jcommander" + implementation "com.google.code.gson:gson:$gson" + implementation "com.google.inject:guice:$guice" + implementation "com.google.inject.extensions:guice-assistedinject:$guice" + implementation "com.squareup.okio:okio:$okio" + implementation "com.squareup.retrofit2:converter-gson:$retrofit" + implementation "com.squareup.retrofit2:retrofit:$retrofit" + implementation "org.apache.maven:maven-model:$maven" + implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin" +} + +shadowJar { + classifier = null +} + +test { + useTestNG() +} + +publishing { + publications { + shadow(MavenPublication) { publication -> + project.shadow.component(publication) + artifact sourcesJar + artifact javadocJar + + pom { + name = project.name + description = 'A build system in Kotlin' + url = 'https://beust.com/kobalt' + licenses { + license { + name = 'Apache-2.0' + url = 'https://www.apache.org/licenses/LICENSE-2.0' + } + } + developers { + developer { + name = 'Cedric Beust' + email = 'cedric@beust.com' + } + } + scm { + connection = 'scm:https://github.com/cbeust/kobalt.git' + developerConnection = 'scm:git@github.com:cbeust/kobalt.git' + url = 'https://github.com/cbeust/kobalt' + } + } + } + } +} diff --git a/modules/kobalt-plugin-api/kobalt-plugin-api.iml b/modules/kobalt-plugin-api/kobalt-plugin-api.iml deleted file mode 100644 index c9fd390e..00000000 --- a/modules/kobalt-plugin-api/kobalt-plugin-api.iml +++ /dev/null @@ -1,428 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/modules/kobalt-plugin-api/pom.xml b/modules/kobalt-plugin-api/pom.xml new file mode 100644 index 00000000..f9026387 --- /dev/null +++ b/modules/kobalt-plugin-api/pom.xml @@ -0,0 +1,279 @@ + + 4.0.0 + + com.beust + kobalt-pom + 1.1.0 + ../.. + + + kobalt-plugin-api + jar + 1.1.0 + + + + org.jetbrains.kotlin + kotlin-stdlib + ${kotlin.version} + + + org.apache.maven + maven-aether-provider + 3.3.9 + + + org.eclipse.aether + impl + + + org.eclipse.aether + spi + + + org.eclipse.aether + util + + + org.eclipse.aether + api + + + + + org.apache.maven.resolver + maven-resolver-api + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-spi + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-util + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-impl + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-connector-basic + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-transport-http + ${mavenresolver.version} + + + org.apache.maven.resolver + maven-resolver-transport-file + ${mavenresolver.version} + + + io.reactivex + rxjava + 1.3.3 + + + com.squareup.okio + okio + ${okio.version} + + + javax.inject + javax.inject + 1 + compile + + + com.google.inject + guice + 4.2.2 + + + com.google.inject.extensions + guice-assistedinject + 4.2.2 + + + com.beust + jcommander + 1.72 + + + org.apache.maven + maven-model + 3.5.2 + + + com.google.code.findbugs + jsr305 + 3.0.2 + + + com.google.code.gson + gson + 2.8.2 + + + com.squareup.retrofit2 + retrofit + 2.3.0 + + + com.squareup.retrofit2 + converter-gson + 2.3.0 + + + biz.aQute.bnd + biz.aQute.bndlib + 3.5.0 + + + com.squareup.okhttp3 + logging-interceptor + ${okhttp3.version} + + + com.sparkjava + spark-core + 2.6.0 + + + org.codehaus.groovy + groovy + 2.4.12 + + + org.apache.commons + commons-compress + 1.15 + + + commons-io + commons-io + 2.6 + + + org.junit.platform + junit-platform-surefire-provider + ${junit.version} + + + org.junit.platform + junit-platform-runner + ${junit.version} + + + org.junit.platform + junit-platform-engine + ${junit.version} + + + org.junit.platform + junit-platform-console + ${junit.version} + + + org.junit.jupiter + junit-jupiter-engine + ${junitJupiter.version} + + + org.junit.vintage + junit-vintage-engine + ${junitJupiter.version} + + + org.testng.testng-remote + testng-remote + 1.3.2 + + + org.testng + testng + ${testng.version} + + + org.eclipse.jgit + org.eclipse.jgit + 4.9.0.201710071750-r + + + org.slf4j + slf4j-simple + ${slf4j.version} + + + + javax.xml.bind + jaxb-api + 2.3.0 + + + + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + + ${project.basedir}/src/main/kotlin + + + + + test-compile + test-compile + + + ${project.basedir}/src/test/kotlin + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + + + default-compile + none + + + + default-testCompile + none + + + java-compile + compile + compile + + + java-test-compile + test-compile + testCompile + + + + + + \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt new file mode 100644 index 00000000..8158c642 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/ArchiveGenerator.kt @@ -0,0 +1,21 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.archive.Zip +import com.beust.kobalt.misc.KFiles +import java.io.File + +interface ArchiveGenerator { + fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List + val suffix: String + fun generateArchive(project: Project, context: KobaltContext, zip: Zip, files: List) : 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 + } + +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt index f43a85b6..372f1ba1 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Args.kt @@ -7,7 +7,7 @@ class Args { var targets: List = arrayListOf() @Parameter(names = arrayOf("-bf", "--buildFile"), description = "The build file") - var buildFile: String? = null + var buildFile: String? = "kobalt/src/Build.kt" @Parameter(names = arrayOf("--checkVersions"), description = "Check if there are any newer versions of the " + "dependencies") @@ -22,6 +22,10 @@ class Args { @Parameter(names = arrayOf("--download"), description = "Force a download from the downloadUrl in the wrapper") var download: Boolean = false + @Parameter(names = arrayOf("--downloadSources"), + description = "Force a download of sources and javadocs when resolving dependencies") + var downloadSources: Boolean = false + @Parameter(names = arrayOf("--dryRun"), description = "Display all the tasks that will get run without " + "actually running them") var dryRun: Boolean = false @@ -43,9 +47,13 @@ class Args { var listTemplates: Boolean = false @Parameter(names = arrayOf("--log"), description = "Define the log level " + - "(${Constants.LOG_DEFAULT_LEVEL}-${Constants.LOG_MAX_LEVEL})") + "(${Constants.LOG_QUIET_LEVEL}-${Constants.LOG_MAX_LEVEL})") 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 @@ -53,8 +61,8 @@ class Args { @Parameter(names = arrayOf("--noIncremental"), description = "Turn off incremental builds") var noIncremental: Boolean = false - @Parameter(names = arrayOf("--parallel"), description = "Build all the projects in parallel whenever possible") - var parallel: 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 @@ -72,12 +80,22 @@ class Args { var profiling: Boolean = false @Parameter(names = arrayOf("--resolve"), - description = "Resolve the given comma-separated dependencies and display their dependency tree") - var dependencies: String? = null + description = "Resolve the given dependency and display its tree") + var dependency: String? = null @Parameter(names = arrayOf("--projectInfo"), description = "Display information about the current projects") var projectInfo: Boolean = false + @Parameter(names = arrayOf("--noIncrementalKotlin"), description = "Disable incremental Kotlin compilation") + var noIncrementalKotlin: Boolean = false + + companion object { + const val SEQUENTIAL = "--sequential" + } + + @Parameter(names = arrayOf(Args.SEQUENTIAL), description = "Build all the projects in sequence") + var sequential: Boolean = false + @Parameter(names = arrayOf("--server"), description = "Run in server mode") var serverMode: Boolean = false @@ -86,5 +104,8 @@ class Args { @Parameter(names = arrayOf("--update"), description = "Update to the latest version of Kobalt") var update: Boolean = false + + @Parameter(names = arrayOf("--version"), description = "Display the current version of Kobalt") + var version: Boolean = false } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt index fdd2b372..e138fabc 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/AsciiArt.kt @@ -1,6 +1,5 @@ package com.beust.kobalt -import com.beust.kobalt.misc.log import java.util.* /** @@ -18,16 +17,16 @@ class AsciiArt { companion object { private val BANNERS = arrayOf( " __ __ __ __ __ \n" + - " / //_/ ____ / /_ ____ _ / / / /_\n" + - " / ,< / __ \\ / __ \\ / __ `/ / / / __/\n" + - " / /| | / /_/ / / /_/ // /_/ / / / / /_ \n" + - " /_/ |_| \\____/ /_.___/ \\__,_/ /_/ \\__/ ", + " / //_/ ____ / /_ ____ _ / / / /_\n" + + " / ,< / __ \\ / __ \\ / __ `/ / / / __/\n" + + " / /| | / /_/ / / /_/ // /_/ / / / / /_ \n" + + " /_/ |_| \\____/ /_.___/ \\__,_/ /_/ \\__/ ", " _ __ _ _ _ \n" + - " | |/ / ___ | |__ __ _ | | | |_ \n" + - " | ' / / _ \\ | '_ \\ / _` | | | | __|\n" + - " | . \\ | (_) | | |_) | | (_| | | | | |_ \n" + - " |_|\\_\\ \\___/ |_.__/ \\__,_| |_| \\__| " + " | |/ / ___ | |__ __ _ | | | |_ \n" + + " | ' / / _ \\ | '_ \\ / _` | | | | __|\n" + + " | . \\ | (_) | | |_) | | (_| | | | | |_ \n" + + " |_|\\_\\ \\___/ |_.__/ \\__,_| |_| \\__| " ) val banner : String get() = BANNERS[Random().nextInt(BANNERS.size)] @@ -75,20 +74,20 @@ class AsciiArt { return result } - private fun fill(n: Int) = StringBuffer().apply { repeat(n, { append(" ")})}.toString() - - val defaultLog : (s: String) -> Unit = { log(1, " $it") } - - fun logBox(strings: List, bl: String = bottomLeft, br: String = bottomRight, - print: (String) -> Unit = defaultLog) { - box(strings, bl, br).forEach { - print(it) + fun logBox(strings: List, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0): String { + return buildString { + val boxLines = box(strings, bl, br) + boxLines.withIndex().forEach { iv -> + append(fill(indent)).append(iv.value) + if (iv.index < boxLines.size - 1) append("\n") + } } } - fun logBox(s: String, bl: String = bottomLeft, br: String = bottomRight, print: (String) -> Unit = defaultLog) { - logBox(listOf(s), bl, br, print) - } + fun logBox(s: String, bl: String = bottomLeft, br: String = bottomRight, indent: Int = 0) + = logBox(listOf(s), bl, br, indent) + + fun fill(n: Int) = buildString { repeat(n, { append(" ")})}.toString() fun center(s: String, width: Int) : String { val diff = width - s.length @@ -106,7 +105,7 @@ class AsciiArt { const val CYAN = "\u001B[36m" const val WHITE = "\u001B[37m" - private fun wrap(s: CharSequence, color: String) = color + s + RESET + fun wrap(s: CharSequence, color: String) = color + s + RESET private fun blue(s: CharSequence) = wrap(s, BLUE) private fun red(s: CharSequence) = wrap(s, RED) private fun yellow(s: CharSequence) = wrap(s, YELLOW) @@ -117,3 +116,49 @@ class AsciiArt { } } +class AsciiTable { + class Builder { + private val headers = arrayListOf() + fun header(name: String) = headers.add(name) + fun headers(vararg names: String) = headers.addAll(names) + + private val widths = arrayListOf() + fun columnWidth(w: Int) : Builder { + widths.add(w) + return this + } + + private val rows = arrayListOf>() + fun addRow(row: List) = 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() + } + + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt index 7f646774..4c35b9ed 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt @@ -7,10 +7,42 @@ import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.internal.PluginInfo import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.dependency.FileDependency +import com.beust.kobalt.misc.KobaltLogger import org.eclipse.aether.repository.Proxy import java.io.File import java.net.InetSocketAddress +var BUILD_SCRIPT_CONFIG : BuildScriptConfig? = null + +class BuildScriptConfig { + /** The list of repos used to locate plug-ins. */ + @Directive + fun repos(vararg r: String) = newRepos(*r) + + /** The list of plug-ins to use for this build file. */ + @Directive + fun plugins(vararg pl: String) = newPlugins(*pl) + + /** The build file classpath. */ + @Directive + fun buildFileClasspath(vararg bfc: String) = newBuildFileClasspath(*bfc) + + /** Options passed to Kobalt */ + @Directive + fun kobaltOptions(vararg options: String) = Kobalt.addKobaltOptions(options) + + /** Where to find additional build files */ + @Directive + fun buildSourceDirs(vararg dirs: String) = Kobalt.addBuildSourceDirs(dirs) + + // The following settings modify the compiler used to compile the build file, which regular users should + // probably never need to do. Projects should use kotlinCompiler { compilerVersion } to configure the + // Kotin compiler for their source files. + var kobaltCompilerVersion : String? = null + var kobaltCompilerRepo: String? = null + var kobaltCompilerFlags: String? = null +} + @Directive fun homeDir(vararg dirs: String) : String = SystemProperties.homeDir + File.separator + dirs.toMutableList().joinToString(File.separator) @@ -18,13 +50,18 @@ fun homeDir(vararg dirs: String) : String = SystemProperties.homeDir + @Directive fun file(file: String) : String = FileDependency.PREFIX_FILE + file -@Directive fun plugins(vararg dependency : IClasspathDependency) { dependency.forEach { Plugins.addDynamicPlugin(it) } } -@Directive fun plugins(vararg dependencies : String) { + KobaltLogger.logger.warn("Build.kt", + "Invoking plugins() directly is deprecated, use the buildScript{} directive") + newPlugins(*dependencies) +} + +@Directive +fun newPlugins(vararg dependencies : String) { val factory = Kobalt.INJECTOR.getInstance(DependencyManager::class.java) dependencies.forEach { Plugins.addDynamicPlugin(factory.create(it)) @@ -37,7 +74,18 @@ data class ProxyConfig(val host: String = "", val port: Int = 0, val type: Strin fun toAetherProxy() = Proxy(type, host, port) // TODO make support for proxy auth } -data class HostConfig(var url: String = "", var username: String? = null, var password: String? = null) { +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()) } @@ -51,13 +99,24 @@ data class HostConfig(var url: String = "", var username: String? = null, var pa } } -@Directive fun repos(vararg repos : String) { + KobaltLogger.logger.warn("Build.kt", + "Invoking repos() directly is deprecated, use the buildScript{} directive") + newRepos(*repos) +} + +fun newRepos(vararg repos: String) { repos.forEach { Kobalt.addRepo(HostConfig(it)) } } -@Directive 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) } } @@ -67,7 +126,7 @@ fun authRepos(vararg repos : HostConfig) { } @Directive -fun authRepo(init: HostConfig.() -> Unit) = HostConfig().apply { init() } +fun authRepo(init: HostConfig.() -> Unit) = HostConfig(name = "").apply { init() } @Directive fun glob(g: String) : IFileSpec.GlobSpec = IFileSpec.GlobSpec(g) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt index 530560d9..8eb73c84 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Constants.kt @@ -3,17 +3,19 @@ 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( + internal val DEFAULT_REPOS = listOf( // "https://maven-central.storage.googleapis.com/", - "http://repo1.maven.org/maven2/", - "https://jcenter.bintray.com/", - "http://repository.jetbrains.com/all/" + HostConfig("https://repo1.maven.org/maven2/", "Maven"), + HostConfig("https://jcenter.bintray.com/", "JCenter") +// "https://repository.jetbrains.com/all/", // <-- contains snapshots // snapshots // "https://oss.sonatype.org/content/repositories/snapshots/" diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt index a655325a..93d9434c 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Directives.kt @@ -4,9 +4,11 @@ import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.api.annotation.Directive import com.beust.kobalt.internal.JvmCompilerPlugin +import kotlin.properties.ReadWriteProperty +import kotlin.reflect.KProperty @Directive -public fun project(vararg projects: Project, init: Project.() -> Unit): Project { +fun project(vararg projects: Project, init: Project.() -> Unit): Project { return Project("").apply { init() (Kobalt.findPlugin(JvmCompilerPlugin.PLUGIN_NAME) as JvmCompilerPlugin) @@ -14,3 +16,24 @@ public fun project(vararg projects: Project, init: Project.() -> Unit): Project } } +@Directive +fun buildScript(init: BuildScriptConfig.() -> Unit): BuildScriptConfig { + val buildScriptConfig = BuildScriptConfig().apply { init() } + BUILD_SCRIPT_CONFIG = buildScriptConfig + return buildScriptConfig +} + +@Directive +fun profile(): ReadWriteProperty { + val result = object: ReadWriteProperty { + 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 +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt index 043e2bac..1eb409f4 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt @@ -1,6 +1,6 @@ package com.beust.kobalt -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import java.io.File import java.nio.file.* import java.nio.file.attribute.BasicFileAttributes @@ -28,15 +28,15 @@ sealed class IFileSpec { private fun isIncluded(includeMatchers: Glob, excludes: List, rel: Path) : Boolean { excludes.forEach { if (it.matches(rel)) { - log(3, "Excluding ${rel.toFile()}") + kobaltLog(3, " Excluding ${rel.toFile()}") return false } } if (includeMatchers.matches(rel)) { - log(3, "Including ${rel.toFile().path}") + kobaltLog(3, " Including ${rel.toFile().path}") return true } - log(2, "Excluding ${rel.toFile()} (not matching any include pattern") + kobaltLog(2, " Excluding ${rel.toFile()} (not matching any include pattern") return false } @@ -56,7 +56,7 @@ sealed class IFileSpec { val path = p.normalize() val rel = orgRootDir.relativize(path) if (isIncluded(includes, excludes, path)) { - log(3, " including file " + rel.toFile() + " from rootDir $rootDir") + kobaltLog(3, " including file " + rel.toFile() + " from rootDir $rootDir") result.add(rel.toFile()) } return FileVisitResult.CONTINUE diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt new file mode 100644 index 00000000..ea189851 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludeFromTo.kt @@ -0,0 +1,43 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.annotation.Directive +import java.io.File + +/** + * Base classes for directives that support install(from,to) (e.g. install{} or jar{}). + */ +open class IncludeFromTo { + /** + * Prefix path to be removed from the zip file. For example, if you add "build/lib/a.jar" to the zip + * file and the excludePrefix is "build/lib", then "a.jar" will be added at the root of the zip file. + */ + val includedFiles = arrayListOf() + + @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))) + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt new file mode 100644 index 00000000..46dea15e --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/IncludedFile.kt @@ -0,0 +1,44 @@ +package com.beust.kobalt + +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.toString +import java.io.File +import java.nio.file.Paths + +class IncludedFile(val fromOriginal: From, val toOriginal: To, val specs: List, + val expandJarFiles: Boolean = false) { + constructor(specs: List, 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 { + val result = arrayListOf() + 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) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt index 54f531bd..19bb52c6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JarGenerator.kt @@ -3,21 +3,22 @@ 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.Jar +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.* +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.io.OutputStream import java.nio.file.Paths -import java.util.jar.JarOutputStream import java.util.jar.Manifest -class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) { +class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) : ArchiveGenerator { companion object { - fun findIncludedFiles(directory: String, files: List, excludes: List) + fun findIncludedFiles(directory: String, files: List, excludes: List, + throwOnError: Boolean = true) : List { val result = arrayListOf() files.forEach { includedFile -> @@ -27,7 +28,7 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) if (File(directory, fromPath).exists()) { spec.toFiles(directory, fromPath).forEach { file -> val fullFile = File(KFiles.joinDir(directory, fromPath, file.path)) - if (! fullFile.exists()) { + if (! fullFile.exists() && throwOnError) { throw AssertionError("File should exist: $fullFile") } @@ -35,16 +36,16 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) val normalized = Paths.get(file.path).normalize().toFile().path includedSpecs.add(IFileSpec.FileSpec(normalized)) } else { - log(2, "Not adding ${file.path} to jar file because it's excluded") + kobaltLog(2, "Not adding ${file.path} to jar file because it's excluded") } } } else { - log(2, "Directory $fromPath doesn't exist, not including it in the jar") + kobaltLog(2, " Directory $fromPath doesn't exist, not including it in the jar") } } if (includedSpecs.size > 0) { - log(3, "Including specs $includedSpecs") + kobaltLog(3, "Including specs $includedSpecs") result.add(IncludedFile(From(includedFile.from), To(includedFile.to), includedSpecs)) } } @@ -52,7 +53,9 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) } } - fun findIncludedFiles(project: Project, context: KobaltContext, jar: Jar) : List { + override val suffix = ".jar" + + override fun findIncludedFiles(project: Project, context: KobaltContext, zip: Zip) : List { // // Add all the applicable files for the current project // @@ -60,7 +63,7 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) val result = arrayListOf() val classesDir = KFiles.makeDir(buildDir.path, "classes") - if (jar.includedFiles.isEmpty()) { + if (zip.includedFiles.isEmpty()) { // If no includes were specified, assume the user wants a simple jar file made of the // classes of the project, so we specify a From("build/classes/"), To("") and // a list of files containing everything under it @@ -70,7 +73,7 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) // Class files val files = KFiles.findRecursively(classesDir).map { File(relClassesDir.toFile(), it) } val filesNotExcluded : List = files.filter { - ! KFiles.Companion.isExcluded(KFiles.joinDir(project.directory, it.path), jar.excludes) + ! KFiles.Companion.isExcluded(KFiles.joinDir(project.directory, it.path), zip.excludes) } val fileSpecs = arrayListOf() filesNotExcluded.forEach { @@ -86,16 +89,14 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) // // The user specified an include, just use it verbatim // - val includedFiles = findIncludedFiles(project.directory, jar.includedFiles, jar.excludes) + val includedFiles = findIncludedFiles(project.directory, zip.includedFiles, zip.excludes, false) result.addAll(includedFiles) } // // If fatJar is true, add all the transitive dependencies as well: compile, runtime and dependent projects // - if (jar.fatJar) { - log(2, "Finding included files for fat jar") - + if (zip.fatJar) { val seen = hashSetOf() @Suppress("UNCHECKED_CAST") val allDependencies = project.compileDependencies + project.compileRuntimeDependencies + @@ -104,13 +105,13 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) context.variant.productFlavor.compileDependencies + context.variant.productFlavor.compileRuntimeDependencies val transitiveDependencies = dependencyManager.calculateDependencies(project, context, - listOf(Scope.COMPILE), allDependencies) + scopes = listOf(Scope.COMPILE), passedDependencies = allDependencies) transitiveDependencies.map { it.jarFile.get() }.forEach { file : File -> if (! seen.contains(file.path)) { seen.add(file.path) - if (! KFiles.Companion.isExcluded(file, jar.excludes)) { + if (! KFiles.Companion.isExcluded(file, zip.excludes)) { result.add(IncludedFile(specs = arrayListOf(IFileSpec.FileSpec(file.absolutePath)), expandJarFiles = true)) } @@ -121,19 +122,18 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) return result } - fun generateJar(project: Project, context: KobaltContext, jar: Jar) : File { - val includedFiles = findIncludedFiles(project, context, jar) - + override fun generateArchive(project: Project, context: KobaltContext, zip: Zip, + includedFiles: List) : 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 (jar.attributes.size > 1) { - log(2, "Creating MANIFEST.MF from " + jar.attributes.size + " attributes") + if (zip.attributes.size > 1) { + context.logger.log(project.name, 2, "Creating MANIFEST.MF from " + zip.attributes.size + " attributes") Manifest().apply { - jar.attributes.forEach { attribute -> + zip.attributes.forEach { attribute -> mainAttributes.putValue(attribute.first, attribute.second) } } @@ -142,23 +142,21 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) val allFiles = includedFiles.flatMap { file -> file.allFromFiles(project.directory).map { file.from(it.path) } } - val manifestFiles = allFiles.filter { it.path.contains("META-INF/MANIFEST.MF") } + 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) { - log(2, "Including MANIFEST.MF file $manifestFile") + context.logger.log(project.name, 2, "Including MANIFEST.MF file $manifestFile") Manifest(FileInputStream(manifestFile)) } else { - Manifest() + null } } - val jarFactory = { os: OutputStream -> JarOutputStream(os, manifest) } - - return Archives.generateArchive(project, context, jar.name, ".jar", includedFiles, - true /* expandJarFiles */, jarFactory) + return Archives.generateArchive(project, context, zip.name, ".jar", includedFiles, + true /* expandJarFiles */, manifest) } } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt index 53c4e010..3c957454 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/JavaInfo.kt @@ -2,18 +2,18 @@ package com.beust.kobalt import java.io.File -abstract public class JavaInfo { - public var javaExecutable: File? = null +abstract class JavaInfo { + val javaExecutable: File? get() = findExecutable("java") - public var javacExecutable: File? = null + val javacExecutable: File? get() = findExecutable("javac") - public var javadocExecutable: File? = null + val javadocExecutable: File? get() = findExecutable("javadoc") - abstract public var javaHome: File? - abstract public var runtimeJar: File? - abstract public var toolsJar: File? + abstract var javaHome: File? + abstract var runtimeJar: File? + abstract var toolsJar: File? - abstract public fun findExecutable(command: String) : File + abstract fun findExecutable(command: String) : File companion object { fun create(javaBase: File?): Jvm { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt index 7dda6015..14c55efd 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Jvm.kt @@ -1,18 +1,18 @@ package com.beust.kobalt -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.beust.kobalt.misc.warn import java.io.File import java.io.IOException -public open class Jvm constructor( +open class Jvm constructor( val os: OperatingSystem, var javaBase: File? = null) : JavaInfo() { private var _javaHome: File? = null - override public var javaHome: File? = null + override var javaHome: File? = null get() = _javaHome!! - override public var runtimeJar: File? = null + override var runtimeJar: File? = null private fun findRuntimeJar() : File? { var runtimeJar = File(javaBase, "lib/rt.jar") if (runtimeJar.exists()) { @@ -21,7 +21,7 @@ public open class Jvm constructor( runtimeJar = File(javaBase, "jre/lib/rt.jar") return if (runtimeJar.exists()) runtimeJar else null } - override public var toolsJar: File? = null + override var toolsJar: File? = null private var userSupplied: Boolean? = false private var javaVersion: String? = null @@ -67,7 +67,7 @@ public open class Jvm constructor( return toolsJar } if (javaHome!!.name.equals("jre", true)) { - javaHome = javaHome!!.parentFile + _javaHome = javaHome!!.parentFile toolsJar = File(javaHome, "lib/tools.jar") if (toolsJar.exists()) { return toolsJar @@ -78,7 +78,7 @@ public open class Jvm constructor( val version = SystemProperties.Companion.javaVersion if (javaHome!!.name.toRegex().matches("jre\\d+") || javaHome!!.name == "jre$version") { - javaHome = File(javaHome!!.parentFile, "jdk$version") + _javaHome = File(javaHome!!.parentFile, "jdk$version") toolsJar = File(javaHome, "lib/tools.jar") if (toolsJar.exists()) { return toolsJar @@ -89,15 +89,15 @@ public open class Jvm constructor( return null } -// open public fun isIbmJvm(): Boolean { +// open fun isIbmJvm(): Boolean { // return false // } - override public fun findExecutable(command: String): File { + override fun findExecutable(command: String): File { if (javaHome != null) { val jdkHome = if (javaHome!!.endsWith("jre")) javaHome!!.parentFile else javaHome val exec = File(jdkHome, "bin/" + command) - var executable = File(os.getExecutableName(exec.absolutePath)) + val executable = File(os.getExecutableName(exec.absolutePath)) if (executable.isFile) { return executable } @@ -110,7 +110,7 @@ public open class Jvm constructor( val pathExecutable = os.findInPath(command) if (pathExecutable != null) { - log(2, "Unable to find the $command executable using home: " + + kobaltLog(2, "Unable to find the $command executable using home: " + "$javaHome but found it on the PATH: $pathExecutable.") return pathExecutable } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt index e794ae8d..0102dd8b 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Plugins.kt @@ -4,14 +4,14 @@ 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.LocalRepo import com.beust.kobalt.misc.JarUtils import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.inject.Provider import java.io.File import java.lang.reflect.Method @@ -26,9 +26,8 @@ import javax.inject.Singleton class Plugins @Inject constructor (val taskManagerProvider : Provider, val files: KFiles, val depManager: DependencyManager, - val localRepo: LocalRepo, + val settings: KobaltSettings, val executors: KobaltExecutors, - val pluginInfo: PluginInfo, val incrementalManagerFactory: IncrementalManager.IFactory, val taskManager: TaskManager) { @@ -65,7 +64,7 @@ class Plugins @Inject constructor (val taskManagerProvider : Provider plugin.apply(project, context) } @@ -171,6 +170,9 @@ class Plugins @Inject constructor (val taskManagerProvider : Provider() +// @Inject +// lateinit var pluginInfo: PluginInfo + fun installPlugins(dependencies: List, scriptClassLoader: ClassLoader) { val executor = executors.newExecutor("Plugins", 5) dependencies.forEach { @@ -191,6 +193,8 @@ class Plugins @Inject constructor (val taskManagerProvider : Provider) = ids.forEach { displayDependenciesFor(it) } + fun run(id: String) = displayDependenciesFor(id) + + private fun latestMavenArtifact(group: String, artifactId: String, extension: String = "jar"): DependencyNode { + val artifact = DefaultArtifact(group, artifactId, extension, "(0,]") + val resolved = aether.resolveRange(artifact) + if (resolved != null) { + val newArtifact = DefaultArtifact(artifact.groupId, artifact.artifactId, artifact.extension, + resolved.highestVersion.toString()) + val artifactResult = aether.resolve(KobaltMavenResolver.artifactToId(newArtifact), null) + return artifactResult.root + } else { + throw KobaltException("Couldn't find latest artifact for $group:$artifactId") + } + } + + class PairResult(val dependency: IClasspathDependency, val repoUrl: String) + + fun latestArtifact(group: String, artifactId: String, extension: String = "jar"): PairResult + = latestMavenArtifact(group, artifactId, extension).let { + PairResult(AetherDependency(it.artifact), "(TBD repo)") + } private fun displayDependenciesFor(id: String) { val mavenId = MavenId.create(id) - val resolved = - if (mavenId.hasVersion) aether.resolve(id) - else aether.latestArtifact(mavenId.groupId, mavenId.artifactId) + 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) } @@ -42,10 +66,10 @@ class ResolveDependency @Inject constructor( val seen = hashSetOf(dep.id) root.addChildren(findChildren(root, seen)) - AsciiArt.logBox(listOf(dep.id, url, dep.jarFile.get()).map { " $it" }, print = {s -> println(s) }) + kobaltLog(1, AsciiArt.logBox(listOf(dep.id, url, dep.jarFile.get()).map { " $it" })) display(root.children) - println("") + kobaltLog(1, "") } private fun display(nodes: List>) { @@ -57,10 +81,12 @@ class ResolveDependency @Inject constructor( else leftMiddle val indent = level * increment for(i in 0..indent - 2) { - if (i % increment == 0) print(vertical) - else print(" ") + if (!KobaltLogger.isQuiet) { + if (i == 0 || ((i + 1) % increment == 0)) print(vertical) + else print(" ") + } } - println(left + " " + dep.id) + kobaltLog(1, left + " " + dep.id + (if (dep.optional) " (optional)" else "")) display(node.children) } } @@ -73,13 +99,18 @@ class ResolveDependency @Inject constructor( if (! seen.contains(it.id)) { val dep = Dep(it, root.value.level + 1) val node = Node(dep) - log(2, "Found dependency ${dep.dep.id} level: ${dep.level}") + kobaltLog(2, "Found dependency ${dep.dep.id} level: ${dep.level}") result.add(node) seen.add(it.id) - node.addChildren(findChildren(node, seen)) + 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 } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt index b7877264..d5507497 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/SystemProperties.kt @@ -1,9 +1,17 @@ package com.beust.kobalt -public class SystemProperties { +class SystemProperties { companion object { - val javaBase = System.getProperty("java.home") ?: - (System.getenv("JAVA_HOME") ?: throw IllegalArgumentException("JAVA_HOME not defined")) + val javaBase : String + get() { + val jh = System.getenv("JAVA_HOME") + ?: System.getProperty("java.home") + ?: throw IllegalArgumentException("JAVA_HOME not defined") + val result = + if (jh.toLowerCase().endsWith("jre")) jh.substring(0, jh.length - 4) + else jh + return result + } val javaVersion = System.getProperty("java.version") val homeDir = System.getProperty("user.home") val tmpDir = System.getProperty("java.io.tmpdir") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt index 4d6a45f3..241bc045 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TaskResult.kt @@ -1,3 +1,8 @@ package com.beust.kobalt -open public class TaskResult(val success: Boolean = true, val errorMessage: String? = null) +class TestResult(val success: Boolean, val shortMessage: String? = null, val longMessage: String? = null) + +open class TaskResult(val success: Boolean = true, + val testResult: TestResult? = null, + val errorMessage: String? = null +) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt new file mode 100644 index 00000000..f84b094d --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestConfig.kt @@ -0,0 +1,40 @@ +package com.beust.kobalt + +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.annotation.Directive + +class TestConfig(val project: Project, val isDefault : Boolean = false) { + val testArgs = arrayListOf() + val jvmArgs = arrayListOf() + val testIncludes = arrayListOf("**/*Test.class") + val testExcludes = arrayListOf() + + @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) + } + } +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt index d7f6cb7e..ad026380 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/TestDirective.kt @@ -3,43 +3,13 @@ package com.beust.kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.api.annotation.Directive -class TestConfig(val project: Project, val isDefault : Boolean = false) { - val testArgs = arrayListOf() - val jvmArgs = arrayListOf() - val testIncludes = arrayListOf("**/*Test.class") - val testExcludes = arrayListOf() - - var name: String = "" - - fun args(vararg arg: String) { - testArgs.addAll(arg) - } - - fun jvmArgs(vararg arg: String) { - jvmArgs.addAll(arg) - } - - fun include(vararg arg: String) { - testIncludes.apply { - clear() - addAll(arg) - } - } - - fun exclude(vararg arg: String) { - testExcludes.apply { - clear() - addAll(arg) - } - } -} - @Directive -fun Project.test(init: TestConfig.() -> Unit) = let { project -> +fun Project.test(init: TestConfig.() -> Unit): TestConfig = let { project -> with(testConfigs) { val tf = TestConfig(project).apply { init() } if (! map { it.name }.contains(tf.name)) { add(tf) + tf } else { throw KobaltException("Test configuration \"${tf.name}\" already exists, give it a different " + "name with test { name = ... }") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt index 2bafde37..13120fa0 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/Variant.kt @@ -2,9 +2,9 @@ package com.beust.kobalt import com.beust.kobalt.api.* import com.beust.kobalt.internal.ActorUtils +import com.beust.kobalt.internal.ParallelLogger import com.beust.kobalt.internal.SourceSet import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log import java.io.File import java.util.* @@ -29,7 +29,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, /** * for {internal, release}, return [internalRelease, internal, release] */ - fun allDirectories(project: Project): List { + fun allDirectories(): List { return arrayListOf().apply { add(toCamelcaseDir()) add(productFlavor.name) @@ -70,28 +70,27 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, val result = arrayListOf() val sourceDirectories = sourceSet.correctSourceSet(project) .filter { File(project.directory, it).exists() } - .map { File(it) } + .map(::File) if (isDefault) { result.addAll(sourceDirectories) } else { // // The ordering of files is: 1) build type 2) product flavor 3) default + val kobaltLog = Kobalt.INJECTOR.getInstance(ParallelLogger::class.java) buildType.let { val dir = File(KFiles.joinDir("src", it.name, suffix)) - log(3, "Adding source for build type ${it.name}: ${dir.path}") + kobaltLog.log(project.name, 3, "Adding source for build type ${it.name}: ${dir.path}") result.add(dir) } productFlavor.let { val dir = File(KFiles.joinDir("src", it.name, suffix)) - log(3, "Adding source for product flavor ${it.name}: ${dir.path}") + kobaltLog.log(project.name, 3, "Adding source for product flavor ${it.name}: ${dir.path}") result.add(dir) } - result.addAll(allDirectories(project).map { - File(KFiles.joinDir("src", it, suffix)) - }.filter { - it.exists() - }) + result.addAll(allDirectories() + .map { File(KFiles.joinDir("src", it, suffix)) } + .filter(File::exists)) // Now that all the variant source directories have been added, add the project's default ones result.addAll(sourceDirectories) @@ -114,8 +113,8 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, if (isDefault) { archiveName ?: project.name + "-" + project.version + suffix } else { - val base = if (archiveName != null) archiveName.substring(0, archiveName.length - suffix.length) - else project.name + "-" + project.version + val base = archiveName?.substring(0, archiveName.length - suffix.length) + ?: project.name + "-" + project.version val flavor = if (productFlavor.name.isEmpty()) "" else "-" + productFlavor.name val type = if (buildType.name.isEmpty()) "" else "-" + buildType.name val result: String = base + flavor + type + suffix @@ -125,18 +124,16 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, return result } - val shortArchiveName = if (isDefault) "" else "-" + productFlavor.name + "-" + buildType.name - var generatedSourceDirectory: File? = null private fun findBuildTypeBuildConfig(project: Project, variant: Variant?) : BuildConfig? { val buildTypeName = variant?.buildType?.name - return project.buildTypes[buildTypeName]?.buildConfig ?: null + return project.buildTypes[buildTypeName]?.buildConfig } private fun findProductFlavorBuildConfig(project: Project, variant: Variant?) : BuildConfig? { val buildTypeName = variant?.productFlavor?.name - return project.productFlavors[buildTypeName]?.buildConfig ?: null + return project.productFlavors[buildTypeName]?.buildConfig } /** @@ -165,7 +162,8 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, ?: throw KobaltException( "packageName needs to be defined on the project in order to generateAndSave BuildConfig") - val contributor = ActorUtils.selectAffinityActor(context.pluginInfo.buildConfigContributors, project) + val contributor = ActorUtils.selectAffinityActor(project, context, + context.pluginInfo.buildConfigContributors) if (contributor != null) { val code = contributor.generateBuildConfig(project, context, pkg, this, buildConfigs) val result = KFiles.makeDir(KFiles.generatedSourceDir(project, this, "buildConfig")) @@ -175,7 +173,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar)) val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig." + contributor.buildConfigSuffix) KFiles.saveFile(outputDir, code) - log(2, "Generated ${outputDir.path}") + context.logger.log(project.name, 2, "Generated ${outputDir.path}") return result } else { throw KobaltException("Couldn't find a contributor to generateAndSave BuildConfig") @@ -223,7 +221,7 @@ class Variant(val initialProductFlavor: ProductFlavorConfig? = null, } fun toCamelcaseDir() : String { - fun lci(s : String) = if (s.length == 0 || s.length == 1) s else s[0].toLowerCase() + s.substring(1) + fun lci(s : String) = if (s.isEmpty() || s.length == 1) s else s[0].toLowerCase() + s.substring(1) return lci(productFlavor.name) + buildType.name.capitalize() } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt index f0be2eb5..e323e474 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/CompilerActionInfo.kt @@ -11,4 +11,6 @@ data class CompilerActionInfo(val directory: String?, val suffixesBeingCompiled: List, val outputDir: File, val compilerArgs: List, - val friendPaths: List) + val friendPaths: List, + val forceRecompile: Boolean, + val compilerSeparateProcess: Boolean = false) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt index 2103bdc1..e1195ca3 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/DependencyHolder.kt @@ -11,7 +11,9 @@ interface IDependencyHolder { var project: Project val compileDependencies : ArrayList + val optionalDependencies : ArrayList val compileProvidedDependencies : ArrayList + val compileOnlyDependencies : ArrayList val compileRuntimeDependencies : ArrayList val excludedDependencies : ArrayList val nativeDependencies : ArrayList @@ -26,7 +28,9 @@ interface IDependencyHolder { open class DependencyHolder : IDependencyHolder { override lateinit var project: Project override val compileDependencies : ArrayList = arrayListOf() + override val optionalDependencies : ArrayList = arrayListOf() override val compileProvidedDependencies : ArrayList = arrayListOf() + override val compileOnlyDependencies : ArrayList = arrayListOf() override val compileRuntimeDependencies : ArrayList = arrayListOf() override val excludedDependencies : ArrayList = arrayListOf() override val nativeDependencies : ArrayList = arrayListOf() @@ -34,8 +38,8 @@ open class DependencyHolder : IDependencyHolder { override var dependencies : Dependencies? = null override fun dependencies(init: Dependencies.() -> Unit) : Dependencies { - dependencies = Dependencies(project, compileDependencies, compileProvidedDependencies, - compileRuntimeDependencies, excludedDependencies, nativeDependencies) + dependencies = Dependencies(project, compileDependencies, optionalDependencies, compileProvidedDependencies, + compileOnlyDependencies, compileRuntimeDependencies, excludedDependencies, nativeDependencies) dependencies!!.init() return dependencies!! } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt index 35553f74..ef9d3b4d 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildConfigContributor.kt @@ -5,7 +5,7 @@ import com.beust.kobalt.Variant /** * Plug-ins that can generate a BuildConfig file. */ -interface IBuildConfigContributor : ISimpleAffinity { +interface IBuildConfigContributor : IProjectAffinity { fun generateBuildConfig(project: Project, context: KobaltContext, packageName: String, variant: Variant, buildConfigs: List) : String diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt index 1e53cc49..2b0fdadb 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IBuildListener.kt @@ -4,8 +4,12 @@ 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, success: Boolean) {} + fun taskEnd(project: Project, context: KobaltContext, taskName: String, info: TaskEndInfo) {} fun projectStart(project: Project, context: KobaltContext) {} fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) {} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt index 80d9e998..527e6f13 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IClasspathDependency.kt @@ -22,15 +22,20 @@ interface IClasspathDependency { /** @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 /** Convert to a Maven model tag */ - fun toMavenDependencies() : Dependency + fun toMavenDependencies(scope: String? = null) : Dependency /** The list of dependencies for this element (not the transitive closure) */ fun directDependencies(): List /** Used to only keep the most recent version for an artifact if no version was specified */ val shortId: String + + val excluded: ArrayList } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt index b4788370..b6ce8fd2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerContributor.kt @@ -1,7 +1,6 @@ package com.beust.kobalt.api import com.beust.kobalt.TaskResult -import com.beust.kobalt.misc.warn interface ICompilerDescription : Comparable { /** @@ -55,13 +54,15 @@ class CompilerDescription(override val name: String, override val sourceDirecto override val canCompileDirectories: Boolean = false) : ICompilerDescription { override fun compile(project: Project, context: KobaltContext, info: CompilerActionInfo): TaskResult { val result = - if (info.sourceFiles.size > 0) { + if (info.sourceFiles.isNotEmpty()) { compiler.compile(project, context, info) } else { - warn("Couldn't find any source files to compile") + context.logger.log(project.name, 2, "$name couldn't find any source files to compile") TaskResult() } return result } + + override fun toString() = name + " compiler" } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt index 5962e9fb..2d8febe4 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ICompilerFlagContributor.kt @@ -3,13 +3,27 @@ package com.beust.kobalt.api /** * Plugins that add compiler flags. */ -interface ICompilerFlagContributor : IContributor { - fun flagsFor(project: Project, context: KobaltContext, currentFlags: List, - suffixesBeingCompiled: List): List - val flagPriority: Int - get() = DEFAULT_FLAG_PRIORITY - +class FlagContributor(val flagPriority: Int = DEFAULT_FLAG_PRIORITY, + val closure: (project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List) -> List) : IContributor { companion object { val DEFAULT_FLAG_PRIORITY = 20 } + + fun flagsFor(project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List) = 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, + suffixesBeingCompiled: List): List +} + +interface IDocFlagContributor : IContributor, IFlagBase { + fun docFlagsFor(project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List): List +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt index ef7fb959..3a66f980 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt @@ -1,6 +1,11 @@ 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. @@ -9,12 +14,12 @@ interface IDependencyManager { /** * Parse the id and return the correct IClasspathDependency */ - fun create(id: String, projectDirectory: String? = null): IClasspathDependency + fun create(id: String, optional: Boolean = false, projectDirectory: String? = null): IClasspathDependency /** * Create an IClasspathDependency from a Maven id. */ - fun createMaven(id: String): IClasspathDependency + fun createMaven(id: String, optional: Boolean = false): IClasspathDependency /** * Create an IClasspathDependency from a path. @@ -24,7 +29,7 @@ interface IDependencyManager { /** * @return the source dependencies for this project, including the contributors. */ - fun dependencies(project: Project, context: KobaltContext): List + fun dependencies(project: Project, context: KobaltContext, scopes: List): List /** * @return the test dependencies for this project, including the contributors. @@ -36,6 +41,48 @@ interface IDependencyManager { * allDependencies is typically either compileDependencies or testDependencies */ fun calculateDependencies(project: Project?, context: KobaltContext, - scopeFilters: Collection = listOf(Scope.COMPILE), + dependencyFilter: DependencyFilter = + createDependencyFilter(project, project?.compileDependencies ?: emptyList()), + scopes: List = listOf(Scope.COMPILE), vararg passedDependencies: List): List + + /** + * Create an Aether dependency filter that uses the dependency configuration included in each + * IClasspathDependency. + */ + fun createDependencyFilter(project: Project?, dependencies: List) : 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?) : 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 + } + } } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt index 5ab88cb0..f8c28b52 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IRunnerContributor.kt @@ -1,10 +1,11 @@ package com.beust.kobalt.api import com.beust.kobalt.TaskResult -import com.beust.kobalt.api.IClasspathDependency /** * Plugins that can run a project (task "run" or "test") should implement this interface. + * + * Currently not used. */ interface IRunnerContributor : IContributor, IProjectAffinity { /** diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt index 83621451..c606d54f 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/ITaskContributor.kt @@ -23,9 +23,10 @@ class DynamicTask(override val plugin: IPlugin, override val name: String, overr override fun call(): TaskResult2 { val taskResult = closure.invoke(project) - return TaskResult2(taskResult.success, taskResult.errorMessage, this) + return TaskResult2(taskResult.success, errorMessage = taskResult.errorMessage, value = this) } - override fun toString() = "[DynamicTask $name dependsOn=$dependsOn reverseDependsOn=$reverseDependsOn]" + override fun toString() = + "[DynamicTask ${project.name}:$name dependsOn=$dependsOn reverseDependsOn=$reverseDependsOn]" } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt new file mode 100644 index 00000000..222a2829 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/InputStreamJarTemplate.kt @@ -0,0 +1,55 @@ +package com.beust.kobalt.api + +import com.beust.kobalt.Args +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog +import java.io.* +import java.net.URL +import java.util.jar.JarInputStream + +/** + * Base class for templates that decompress a jar file. + */ +interface InputStreamJarTemplate : ITemplate { + val inputStream: InputStream + + override fun generateTemplate(args: Args, classLoader: ClassLoader) { + val destDir = File(".") + JarInputStream(inputStream).use { ins -> + var entry = ins.nextEntry + while (entry != null) { + val f = File(destDir.path + File.separator + entry.name) + if (entry.isDirectory) { + f.mkdir() + entry = ins.nextEntry + continue + } + + kobaltLog(2, " Extracting: $entry to ${f.absolutePath}") + FileOutputStream(f).use { fos -> + KFiles.copy(ins, fos) + } + entry = ins.nextEntry + } + } + } +} + +abstract class ResourceJarTemplate(jarName: String, val classLoader: ClassLoader) : InputStreamJarTemplate { + override val inputStream : InputStream = classLoader.getResource(jarName).openConnection().inputStream +} + +abstract class FileJarTemplate(val fileName: String) : InputStreamJarTemplate { + override val inputStream = FileInputStream(File(fileName)) +} + +abstract class HttpJarTemplate(val url: String) : InputStreamJarTemplate { + override val inputStream : InputStream + get() { + try { + return URL(url).openConnection().inputStream + } catch(ex: IOException) { + throw IllegalArgumentException("Couldn't connect to $url") + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarTemplate.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarTemplate.kt deleted file mode 100644 index 1966b747..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/JarTemplate.kt +++ /dev/null @@ -1,41 +0,0 @@ -package com.beust.kobalt.api - -import com.beust.kobalt.Args -import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log -import java.io.File -import java.io.FileOutputStream -import java.util.jar.JarInputStream - -/** - * Base class for templates that simply decompress a jar file to generate their project. - */ -abstract class JarTemplate(val jarName: String) : ITemplate { - companion object { - fun extractFile(ins: JarInputStream, destDir: File) { - var entry = ins.nextEntry - while (entry != null) { - val f = File(destDir.path + File.separator + entry.name) - if (entry.isDirectory) { - f.mkdir() - entry = ins.nextEntry - continue - } - - log(2, "Extracting: $entry to ${f.absolutePath}") - FileOutputStream(f).use { fos -> - KFiles.copy(ins, fos) - } - entry = ins.nextEntry - } - } - } - - override fun generateTemplate(args: Args, classLoader: ClassLoader) { - log(2, "Generating template with class loader $classLoader") - val destDir = File(".") - val ins = JarInputStream(classLoader.getResource(jarName).openConnection().inputStream) - extractFile(ins, destDir) - } - -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt index 49b82050..7d37a0b8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt @@ -5,6 +5,7 @@ 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 @@ -35,12 +36,12 @@ class Kobalt { */ val repos : Set get() { - val settingsRepos = Kobalt.context?.settings?.defaultRepos ?: emptyList() + val settingsRepos = Kobalt.context?.settings?.defaultRepos?.map { HostConfig(it) } ?: emptyList() // Repos from in the settings val result = ArrayList( (if (settingsRepos.isEmpty()) Constants.DEFAULT_REPOS else settingsRepos) - .map { HostConfig(it) }) + ) // Repo from in the settings Kobalt.context?.settings?.kobaltCompilerRepo?.let { @@ -55,6 +56,9 @@ class Kobalt { // Repos from the build file result.addAll(reposFromBuildFiles) + result.forEach { + KobaltMavenResolver.initAuthentication(it) + } return result.toHashSet() } @@ -118,5 +122,20 @@ class Kobalt { get() = Duration.parse( kobaltProperties.getProperty(PROPERTY_KOBALT_VERSION_CHECK_TIMEOUT) ?: "P1D") fun findPlugin(name: String) = Plugins.findPlugin(name) + + val optionsFromBuild = arrayListOf() + fun addKobaltOptions(options: Array) { + optionsFromBuild.addAll(options) + } + + val buildSourceDirs = arrayListOf() + fun addBuildSourceDirs(dirs: Array) { + buildSourceDirs.addAll(dirs) + } + + fun cleanUp() { + buildSourceDirs.clear() + buildFileClasspath.clear() + } } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt index c927517d..b7e5ace8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/KobaltContext.kt @@ -4,6 +4,7 @@ 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 @@ -11,7 +12,7 @@ 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.KobaltAether +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.misc.KobaltExecutors import java.io.File @@ -52,9 +53,9 @@ class KobaltContext(val args: Args) { FileType.JAVADOC -> toQualifier(dep, "", "javadoc") FileType.OTHER -> id } - val resolved = aether.resolveToArtifact(fullId) + val resolved = resolver.resolveToArtifact(fullId) if (resolved != null) { - return resolved.artifact.file + return resolved.file } else { throw KobaltException("Couldn't resolve $id") } @@ -80,8 +81,9 @@ class KobaltContext(val args: Args) { lateinit var executors: KobaltExecutors lateinit var settings: KobaltSettings lateinit var incrementalManager: IncrementalManager - lateinit var aether: KobaltAether + lateinit var resolver: KobaltMavenResolver lateinit var pomGeneratorFactory: PomGenerator.IFactory + lateinit var logger: ILogger } class InternalContext { @@ -103,4 +105,12 @@ class InternalContext { * 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 + } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt index 374fb90d..e54e30ec 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Project.kt @@ -3,12 +3,16 @@ 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.maven.aether.AetherDependency +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.kobaltLog import org.apache.maven.model.Model import java.io.File import java.util.* import java.util.concurrent.Future import java.util.concurrent.FutureTask +import java.util.regex.Pattern open class Project( @Directive open var name: String = "", @@ -22,6 +26,7 @@ open class Project( @Directive open var url: String? = null, @Directive open var pom: Model? = null, @Directive open var dependsOn: ArrayList = arrayListOf(), + @Directive open var testsDependOn: ArrayList = arrayListOf(), @Directive open var packageName: String? = group) : IBuildConfig, IDependencyHolder by DependencyHolder() { @@ -29,13 +34,15 @@ open class Project( this.project = this } + fun allProjectDependedOn() = project.dependsOn + project.testsDependOn + class ProjectExtra(project: Project) { var isDirty = false /** * @return true if any of the projects we depend on is dirty. */ - fun dependsOnDirtyProjects(project: Project) = project.dependsOn.any { it.projectExtra.isDirty } + fun dependsOnDirtyProjects(project: Project) = project.allProjectDependedOn().any { it.projectExtra.isDirty } } /** @@ -83,7 +90,8 @@ open class Project( @Directive fun dependenciesTest(init: Dependencies.() -> Unit) : Dependencies { - dependencies = Dependencies(this, testDependencies, testProvidedDependencies, compileRuntimeDependencies, + dependencies = Dependencies(this, testDependencies, arrayListOf(), + testProvidedDependencies, compileOnlyDependencies, compileRuntimeDependencies, excludedDependencies, nativeDependencies) dependencies!!.init() return dependencies!! @@ -92,6 +100,9 @@ open class Project( val testDependencies : ArrayList = arrayListOf() val testProvidedDependencies : ArrayList = 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 @@ -118,6 +129,18 @@ 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) : List { + return (Kobalt.context?.dependencyManager?.transitiveClosure(dependencies) ?: emptyList()) + .map { Dep(it.jarFile.get(), it.id) } + } + override fun toString() = "[Project $name]" } @@ -130,7 +153,9 @@ class Sources(val project: Project, val sources: HashSet) { class Dependencies(val project: Project, val dependencies: ArrayList, + val optionalDependencies: ArrayList, val providedDependencies: ArrayList, + val compileOnlyDependencies: ArrayList, val runtimeDependencies: ArrayList, val excludedDependencies: ArrayList, val nativeDependencies: ArrayList) { @@ -142,17 +167,98 @@ class Dependencies(val project: Project, * future tasks receive a get(), the repos will be correct. */ private fun addToDependencies(project: Project, dependencies: ArrayList, - dep: Array): List> - = with(dep.map { DependencyManager.create(it, project.directory)}) { + dep: Array, optional: Boolean = false, excludeConfig: ExcludeConfig? = null): List> + = 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) + class ExcludeConfig { + val ids = arrayListOf() + + @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() + + @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 provided(vararg dep: String) = addToDependencies(project, providedDependencies, dep) + fun compile(dep: String, init: ExcludeConfig.() -> Unit) { + val excludeConfig = ExcludeConfig().apply { + init() + } + addToDependencies(project, dependencies, arrayOf(dep), excludeConfig = excludeConfig) + } + + @Directive + fun compileOnly(vararg dep: String) = addToDependencies(project, compileOnlyDependencies, dep) + + @Directive + fun compileOptional(vararg dep: String) { + addToDependencies(project, optionalDependencies, dep, optional = true) + addToDependencies(project, dependencies, dep, optional = true) + } + + @Directive + fun provided(vararg dep: String) { + addToDependencies(project, providedDependencies, dep) + } @Directive fun runtime(vararg dep: String) = addToDependencies(project, runtimeDependencies, dep) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt index 65eb529d..8c68be94 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/TaskContributor.kt @@ -44,6 +44,25 @@ class TaskContributor @Inject constructor(val incrementalManagerFactory: Increme } } + fun addTask(plugin: IPlugin, project: Project, taskName: String, description: String, + group: String = AnnotationDefault.GROUP, + dependsOn: List = emptyList(), + reverseDependsOn : List = emptyList(), + runBefore : List = emptyList(), + runAfter : List = emptyList(), + alwaysRunAfter: List = 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 = emptyList(), diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt index 31bc254a..5334e09f 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Archives.kt @@ -1,30 +1,24 @@ package com.beust.kobalt.archive -import com.beust.kobalt.Features -import com.beust.kobalt.IFileSpec +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.From -import com.beust.kobalt.misc.IncludedFile import com.beust.kobalt.misc.JarUtils import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log -import com.beust.kobalt.misc.To +import com.beust.kobalt.misc.kobaltLog import java.io.File -import java.io.FileOutputStream -import java.io.OutputStream import java.util.* -import java.util.zip.ZipOutputStream class Archives { companion object { @ExportedProjectProperty(doc = "The name of the jar file", type = "String") const val JAR_NAME = "jarName" + @ExportedProjectProperty(doc = "The name of the a jar file with a main() method", type = "String") + const val JAR_NAME_WITH_MAIN_CLASS = "jarNameWithMainClass" - private val DEFAULT_STREAM_FACTORY = { os : OutputStream -> ZipOutputStream(os) } - - fun defaultArchiveName(project: Project) = project.name + "-" + project.version + fun defaultArchiveName(project: Project) = project.name + + if (project.version.isNullOrBlank()) "" else "-${project.version}" fun generateArchive(project: Project, context: KobaltContext, @@ -32,17 +26,17 @@ class Archives { suffix: String, includedFiles: List, expandJarFiles : Boolean = false, - outputStreamFactory: (OutputStream) -> ZipOutputStream = DEFAULT_STREAM_FACTORY) : File { + manifest: java.util.jar.Manifest? = null) : File { val fullArchiveName = context.variant.archiveName(project, archiveName, suffix) val archiveDir = File(KFiles.libsDir(project)) val result = File(archiveDir.path, fullArchiveName) - log(3, "Creating $result") + context.logger.log(project.name, 3, "Creating $result") if (! Features.USE_TIMESTAMPS || isOutdated(project.directory, includedFiles, result)) { try { - outputStreamFactory(FileOutputStream(result)).use { - JarUtils.addFiles(project.directory, includedFiles, it, expandJarFiles) - log(2, text = "Added ${includedFiles.size} files to $result") - log(1, " Created $result") + 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 @@ -52,11 +46,9 @@ class Archives { } } else { - log(3, " $result is up to date") + context.logger.log(project.name, 3, " $result is up to date") } - project.projectProperties.put(JAR_NAME, result.absolutePath) - return result } @@ -73,7 +65,7 @@ class Archives { File(KFiles.joinDir(directory, root.from, relFile.path)) if (file.isFile) { if (file.lastModified() > lastModified) { - log(3, " TS - Outdated $file and $output " + kobaltLog(3, " TS - Outdated $file and $output " + Date(file.lastModified()) + " " + Date(output.lastModified())) return true } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt index f8a47848..d5086cbd 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Jar.kt @@ -8,7 +8,7 @@ import com.beust.kobalt.api.annotation.Directive */ open class Jar(override val project: Project, override var name : String = Archives.defaultArchiveName(project) + ".jar", - var fatJar: Boolean = false) : Zip(project, name), AttributeHolder { + override var fatJar: Boolean = false) : Zip(project, name, fatJar), AttributeHolder { @Directive fun manifest(init: Manifest.(p: Manifest) -> Unit) : Manifest { val m = Manifest(this) @@ -18,7 +18,7 @@ open class Jar(override val project: Project, // Need to specify the version or attributes will just be dropped @Directive - val attributes = arrayListOf(Pair("Manifest-Version", "1.0")) + override val attributes = arrayListOf(Pair("Manifest-Version", "1.0")) override fun addAttribute(k: String, v: String) { attributes.add(Pair(k, v)) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt new file mode 100644 index 00000000..c217c83e --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/MetaArchive.kt @@ -0,0 +1,125 @@ +package com.beust.kobalt.archive + +import com.beust.kobalt.Glob +import com.beust.kobalt.misc.KFiles +import org.apache.commons.compress.archivers.ArchiveEntry +import org.apache.commons.compress.archivers.zip.ZipArchiveEntry +import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream +import java.io.Closeable +import java.io.File +import java.io.FileInputStream +import java.io.FileOutputStream +import java.util.jar.Manifest +import org.apache.commons.compress.archivers.zip.ZipFile as ApacheZipFile + +/** + * Abstraction of a zip/jar/war archive that automatically manages the addition of expanded jar files. + * Uses ZipArchiveOutputStream for fast inclusion of expanded jar files. + */ +class MetaArchive(outputFile: File, val manifest: Manifest?) : Closeable { + companion object { + const val MANIFEST_MF = "META-INF/MANIFEST.MF" + } + + private val zos= ZipArchiveOutputStream(outputFile).apply { + encoding = "UTF-8" + } + + init { + // If no manifest was passed, create an empty one so it's the first one in the archive + val m = manifest ?: Manifest() + val manifestFile = File.createTempFile("kobalt", "tmpManifest") + addEntry(ZipArchiveEntry("META-INF/"), null) + if (manifest != null) { + FileOutputStream(manifestFile).use { fos -> + m.write(fos) + } + } + val entry = zos.createArchiveEntry(manifestFile, MetaArchive.MANIFEST_MF) + addEntry(entry, FileInputStream(manifestFile)) + } + + + fun addFile(f: File, entryFile: File, path: String?) { + maybeCreateParentDirectories(f) + addFile2(f, entryFile, path) + } + + private fun addFile2(f: File, entryFile: File, path: String?) { + val file = f.normalize() + FileInputStream(file).use { inputStream -> + val actualPath = KFiles.fixSlashes(if (path != null) path + entryFile.path else entryFile.path) + ZipArchiveEntry(actualPath).let { entry -> + maybeCreateParentDirectories(File(actualPath)) + maybeAddEntry(entry) { + addEntry(entry, inputStream) + } + } + } + } + + private val createdDirs = hashSetOf() + + /** + * 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() + 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() + + private fun maybeAddEntry(entry: ArchiveEntry, action:() -> Unit) { + entry.name.let { name -> + if (!seen.contains(name) && okToAdd(name)) { + action() + } + seen.add(name) + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt index 295a1987..978f21bf 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/War.kt @@ -6,7 +6,7 @@ import com.beust.kobalt.glob class War(override val project: Project, override var name: String = Archives.defaultArchiveName(project) + ".war") : Jar(project, name), AttributeHolder { init { - include(from("src/main/webapp"),to(""), glob("**")) + include(from("src/main/webapp"), to(""), glob("**")) include(from("kobaltBuild/classes"), to("WEB-INF/classes"), glob("**")) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt index 61237291..41957218 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/archive/Zip.kt @@ -1,22 +1,13 @@ package com.beust.kobalt.archive -import com.beust.kobalt.Glob -import com.beust.kobalt.IFileSpec +import com.beust.kobalt.* import com.beust.kobalt.api.Project import com.beust.kobalt.api.annotation.Directive -import com.beust.kobalt.misc.From -import com.beust.kobalt.misc.IncludedFile -import com.beust.kobalt.misc.To -open class Zip(open val project: Project, open var name: String = Archives.defaultArchiveName(project) + ".zip") { +open class Zip(open val project: Project, open var name: String = Archives.defaultArchiveName(project) + ".zip", + open var fatJar: Boolean = false): AttributeHolder, IncludeFromTo() { val excludes = arrayListOf() - @Directive - fun from(s: String) = From(s) - - @Directive - fun to(s: String) = To(s) - @Directive fun exclude(vararg files: String) { files.forEach { excludes.add(Glob(it)) } @@ -28,26 +19,9 @@ open class Zip(open val project: Project, open var name: String = Archives.defau } @Directive - fun include(vararg files: String) { - includedFiles.add(IncludedFile(files.map { IFileSpec.FileSpec(it) })) + open val attributes = arrayListOf(Pair("Manifest-Version", "1.0")) + + override fun addAttribute(k: String, v: String) { + attributes.add(Pair(k, v)) } - - @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))) - } - - /** - * 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() - } - - diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt index 42aac9e2..e9b315a5 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ActorUtils.kt @@ -1,7 +1,6 @@ package com.beust.kobalt.internal import com.beust.kobalt.api.IProjectAffinity -import com.beust.kobalt.api.ISimpleAffinity import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project @@ -11,19 +10,13 @@ class ActorUtils { * Return the plug-in actor with the highest affinity. */ fun selectAffinityActor(project: Project, context: KobaltContext, actors: List) - = actors.maxBy { it.affinity(project, context) } + = actors.maxBy { it.affinity(project, context) } /** * Return all the plug-in actors with a non zero affinity sorted from the highest to the lowest. */ fun selectAffinityActors(project: Project, context: KobaltContext, actors: List) = actors.filter { it.affinity(project, context) > 0 } - .sortedByDescending { it.affinity(project, context) } - - /** - * Return the plug-in actor with the highest affinity. - */ - fun , A> selectAffinityActor(actors: List, arg: A) = actors.maxBy { it.affinity(arg) } + .sortedByDescending { it.affinity(project, context) } } - } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt index cfece392..e89fc9aa 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseJvmPlugin.kt @@ -12,7 +12,7 @@ abstract class BaseJvmPlugin(open val configActor: ConfigActor) : ICompilerFlagContributor { companion object { // Run before other flag contributors - val FLAG_CONTRIBUTOR_PRIORITY = ICompilerFlagContributor.DEFAULT_FLAG_PRIORITY - 10 + val FLAG_CONTRIBUTOR_PRIORITY = FlagContributor.DEFAULT_FLAG_PRIORITY - 10 } protected fun maybeCompilerArgs(sourceSuffixes: List, suffixesBeingCompiled: List, @@ -21,14 +21,17 @@ abstract class BaseJvmPlugin(open val configActor: ConfigActor) : override val flagPriority = FLAG_CONTRIBUTOR_PRIORITY - override fun accept(project: Project) = hasSourceFiles(project) + override fun accept(project: Project) = sourceFileCount(project) > 0 // IBuildConfigContributor + protected fun sourceFileCount(project: Project) + = KFiles.findSourceFiles(project.directory, project.sourceDirectories, sourceSuffixes()).size + + KFiles.findSourceFiles(project.directory, project.sourceDirectoriesTest, sourceSuffixes()).size - private fun hasSourceFiles(project: Project) - = KFiles.findSourceFiles(project.directory, project.sourceDirectories, sourceSuffixes()).size > 0 + fun affinity(project: Project) = sourceFileCount(project) - fun affinity(project: Project) = if (hasSourceFiles(project)) 1 else 0 + // IDocContributor + open fun affinity(project: Project, context: KobaltContext) = sourceFileCount(project) abstract fun sourceSuffixes() : List } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt index 40859d83..963255bd 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt @@ -1,7 +1,11 @@ package com.beust.kobalt.internal +import com.beust.kobalt.TestResult +import com.beust.kobalt.api.IBuildListener +import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project -import com.beust.kobalt.misc.log +import com.beust.kobalt.api.ProjectBuildStatus +import com.beust.kobalt.misc.kobaltLog import com.google.common.annotations.VisibleForTesting import com.google.common.collect.ArrayListMultimap import com.google.common.collect.Multimap @@ -13,7 +17,26 @@ abstract class BaseProjectRunner { : TaskManager.RunTargetResult companion object { - val LOG_LEVEL = TaskManager.LOG_LEVEL + val TAG = "graph" + + fun runBuildListenersForProject(project: Project, context: KobaltContext, start: Boolean, + status: ProjectBuildStatus = ProjectBuildStatus.SUCCESS) { + context.pluginInfo.buildListeners.forEach { + if (start) it.projectStart(project, context) else it.projectEnd(project, context, status) + } + } + + fun runBuildListenersForTask(project: Project, context: KobaltContext, taskName: String, start: Boolean, + success: Boolean = false, testResult: TestResult? = null) { + context.pluginInfo.buildListeners.forEach { + if (start) { + it.taskStart(project, context, taskName) + } else { + val info = IBuildListener.TaskEndInfo(success, testResult?.shortMessage, testResult?.longMessage) + it.taskEnd(project, context, taskName, info) + } + } + } /** * Create a graph representing the tasks and their dependencies. That graph will then be run @@ -34,6 +57,20 @@ abstract class BaseProjectRunner { accept: (T) -> Boolean): DynamicGraph { + /** + * Add an edge from @param from to all its tasks. + */ + fun addEdge(result: DynamicGraph, from: String, to: String, newToProcess: ArrayList, text: String) { + val froms = nodeMap[from] + froms.forEach { f: T -> + nodeMap[to].forEach { t: T -> + kobaltLog(TAG, " Adding edge ($text) $f -> $t") + result.addEdge(f, t) + newToProcess.add(t) + } + } + } + val result = DynamicGraph() val newToProcess = arrayListOf() val seen = hashSetOf() @@ -63,37 +100,23 @@ abstract class BaseProjectRunner { while (toProcess.size > 0) { - /** - * Add an edge from @param from to all its tasks. - */ - fun addEdge(result: DynamicGraph, from: String, to: String, newToProcess: ArrayList, text: String) { - val froms = nodeMap[from] - froms.forEach { f: T -> - nodeMap[to].forEach { t: T -> - log(LOG_LEVEL, " Adding edge ($text) $f -> $t") - result.addEdge(f, t) - newToProcess.add(t) - } - } - } - /** * Whenever a task is added to the graph, we also add its alwaysRunAfter tasks. */ fun processAlways(always: Multimap, node: T) { - log(LOG_LEVEL, " Processing always for $node") + kobaltLog(TAG, " Processing always for $node") always[toName(node)]?.let { to: Collection -> to.forEach { t -> nodeMap[t].forEach { from -> - log(LOG_LEVEL, " Adding always edge $from -> $node") + kobaltLog(TAG, " Adding always edge $from -> $node") result.addEdge(from, node) } } - log(LOG_LEVEL, " ... done processing always for $node") + kobaltLog(TAG, " ... done processing always for $node") } } - log(LOG_LEVEL, " Current batch to process: $toProcess") + kobaltLog(TAG, " Current batch to process: $toProcess") // // Move dependsOn + reverseDependsOn in one multimap called allDepends @@ -115,7 +138,7 @@ abstract class BaseProjectRunner { // toProcess.forEach { taskInfo -> val taskName = taskInfo.taskName - log(LOG_LEVEL, " ***** Current node: $taskName") + kobaltLog(TAG, " ***** Current node: $taskName") nodeMap[taskName].forEach { result.addNode(it) processAlways(always, it) @@ -128,33 +151,36 @@ abstract class BaseProjectRunner { addEdge(result, taskName, to, newToProcess, "dependsOn") } - // - // runBefore and runAfter (task ordering) are only considered for explicit tasks (tasks that were - // explicitly requested by the user) - // - passedTasks.map { it.id }.let { taskNames -> - runBefore[taskName].forEach { from -> - if (taskNames.contains(from)) { - addEdge(result, from, taskName, newToProcess, "runBefore") - } - } - runAfter[taskName].forEach { to -> - if (taskNames.contains(to)) { - addEdge(result, taskName, to, newToProcess, "runAfter") - } - } - } seen.add(taskName) } newToProcess.forEach { processAlways(always, it) } toProcess.clear() - toProcess.addAll(newToProcess.filter { !seen.contains(toName(it)) }.map { TaskManager.TaskInfo(toName(it)) }) + toProcess.addAll( + newToProcess + .filter { !seen.contains(toName(it)) } + .map { TaskManager.TaskInfo(toName(it)) }) newToProcess.clear() } + + // + // Now that we have all the tasks tnat need to run, process runBefore/runAfter, which + // are not allowed to add new tasks. Therefore, we only add edges to the graph if both + // the from and the to are already present. + // + val finalTaskNames = result.nodes.map { TaskManager.TaskInfo(it.toString()).taskName } + finalTaskNames.forEach { taskName -> + runBefore[taskName].filter { finalTaskNames.contains(it) }.forEach { from -> + addEdge(result, from, taskName, newToProcess, "runBefore") + } + runAfter[taskName].filter { finalTaskNames.contains(it) }.forEach { to -> + addEdge(result, to, taskName, newToProcess, "runAfter") + } + } + + return result } } - } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt index 96b6e10e..58d8eed8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BuildListeners.kt @@ -3,60 +3,126 @@ package com.beust.kobalt.internal import com.beust.kobalt.Args import com.beust.kobalt.AsciiArt import com.beust.kobalt.api.* -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import java.util.concurrent.ConcurrentHashMap /** - * Record timings and display them at the end of the build. + * Record timings and statuses for tasks and projects and display them at the end of the build. */ class BuildListeners : IBuildListener, IBuildReportContributor { class ProfilerInfo(val taskName: String, val durationMillis: Long) + class ProjectInfo(val projectName: String, var durationMillis: Long = 0, + var shortMessage: String? = null, var longMessage: String? = null) private val startTimes = ConcurrentHashMap() private val timings = arrayListOf() + private val projectInfos = hashMapOf() + private var hasFailures = false + private val args: Args get() = Kobalt.INJECTOR.getInstance(Args::class.java) + private var buildStartTime: Long? = null + // IBuildListener override fun taskStart(project: Project, context: KobaltContext, taskName: String) { startTimes.put(taskName, System.currentTimeMillis()) + if (! projectInfos.containsKey(project.name)) { + projectInfos.put(project.name, ProjectInfo(project.name)) + } } - override fun taskEnd(project: Project, context: KobaltContext, taskName: String, success: Boolean) { + // IBuildListener + override fun taskEnd(project: Project, context: KobaltContext, taskName: String, info: IBuildListener.TaskEndInfo) { + val success = info.success + if (! success) hasFailures = true startTimes[taskName]?.let { - timings.add(ProfilerInfo(taskName, System.currentTimeMillis() - it)) + val taskTime = System.currentTimeMillis() - it + timings.add(ProfilerInfo(taskName, taskTime)) + projectInfos[project.name]?.let { + it.durationMillis += taskTime + if (info.shortMessage != null && it.shortMessage == null) it.shortMessage = info.shortMessage + if (info.longMessage != null && it.longMessage == null) it.longMessage = info.longMessage + } } } + private val projectStatuses = arrayListOf>() + + // IBuildListener + override fun projectStart(project: Project, context: KobaltContext) { + if (buildStartTime == null) buildStartTime = System.currentTimeMillis() + } + + // IBuildListener + override fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) { + val shortMessage = projectInfos[project.name]?.shortMessage + val statusText = status.toString() + (if (shortMessage != null) " ($shortMessage)" else "") + projectStatuses.add(Pair(project, statusText)) + } + + // IBuildReportContributor override fun generateReport(context: KobaltContext) { - val profiling = Kobalt.INJECTOR.getInstance(Args::class.java).profiling + fun formatMillis(millis: Long, format: String) = String.format(format, millis.toDouble() / 1000) + fun formatMillisRight(millis: Long, length: Int) = formatMillis(millis, "%1\$$length.2f") + fun formatMillisLeft(millis: Long, length: Int) = formatMillis(millis, "%1\$-$length.2f") + + fun millisToSeconds(millis: Long) = (millis.toDouble() / 1000).toInt() + + val profiling = args.profiling if (profiling) { - log(1, "\n" + AsciiArt.horizontalSingleLine + " Timings (in seconds)") + kobaltLog(1, "\n" + AsciiArt.horizontalSingleLine + " Timings (in seconds)") timings.sortedByDescending { it.durationMillis }.forEach { - log(1, String.format("%1$10.2f", it.durationMillis.toDouble() / 1000) - + " " + it.taskName) + kobaltLog(1, formatMillisRight(it.durationMillis, 10) + " " + it.taskName) } - log(1, "\n") + kobaltLog(1, "\n") } + // Calculate the longest short message so we can create a column long enough to contain it + val width = 12 + (projectInfos.values.map { it.shortMessage?.length ?: 0 }.maxBy { it } ?: 0) + fun col1(s: String) = String.format(" %1\$-30s", s) - fun col2(s: String) = String.format(" %1\$-10s", s) + fun col2(s: String) = String.format(" %1\$-${width}s", s) + fun col3(s: String) = String.format(" %1\$-8s", s) - val line = listOf(col1("Project"), col2("Build status")).joinToString(AsciiArt.verticalBar) - AsciiArt.logBox(listOf(line), AsciiArt.bottomLeft2, AsciiArt.bottomRight2) - projectStatuses.forEach { pair -> - val cl = listOf(col1(pair.first.name), col2(pair.second.toString())).joinToString(AsciiArt.verticalBar) - log(1, " " + AsciiArt.verticalBar + " " + cl + " " + AsciiArt.verticalBar) + + + // Only print the build report if there is more than one project and at least one of them failed + if (timings.any()) { +// if (timings.size > 1 && hasFailures) { + val line = listOf(col1("Project"), col2("Build status"), col3("Time")) + .joinToString(AsciiArt.verticalBar) + val table = StringBuffer() + table.append(AsciiArt.logBox(listOf(line), AsciiArt.bottomLeft2, AsciiArt.bottomRight2, indent = 10) + "\n") + projectStatuses.forEach { pair -> + val projectName = pair.first.name + val cl = listOf(col1(projectName), col2(pair.second), + col3(formatMillisLeft(projectInfos[projectName]!!.durationMillis, 8))) + .joinToString(AsciiArt.verticalBar) + table.append(" " + AsciiArt.verticalBar + " " + cl + " " + AsciiArt.verticalBar + "\n") + } + table.append(" " + AsciiArt.lowerBox(line.length)) + kobaltLog(1, table.toString()) +// } } - log(1, " " + AsciiArt.lowerBox(line.length)) - } + val buildTime = + if (buildStartTime != null) + millisToSeconds(System.currentTimeMillis() - buildStartTime!!) + else + 0 + // BUILD SUCCESSFUL / FAILED message + val message = + if (hasFailures) { + String.format("BUILD FAILED", buildTime) + } else if (! args.sequential) { + val sequentialBuildTime = ((projectInfos.values.sumByDouble { it.durationMillis.toDouble() }) / 1000) + .toInt() + String.format("PARALLEL BUILD SUCCESSFUL (%d SECONDS), sequential build would have taken %d seconds", + buildTime, sequentialBuildTime) + } else { + String.format("BUILD SUCCESSFUL (%d SECONDS)", buildTime) + } + kobaltLog(1, message) - -// override fun projectStart(project: Project, context: KobaltContext) {} - - private val projectStatuses = arrayListOf>() - - override fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) { - projectStatuses.add(Pair(project, status)) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt index bab12aee..758a10e9 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/CompilerUtils.kt @@ -3,11 +3,9 @@ package com.beust.kobalt.internal import com.beust.kobalt.TaskResult import com.beust.kobalt.api.* import com.beust.kobalt.maven.DependencyManager -import com.beust.kobalt.maven.DependencyManager2 import com.beust.kobalt.maven.aether.Scope import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log import com.google.inject.Inject import java.io.File import java.nio.file.Paths @@ -16,14 +14,12 @@ import java.util.* /** * Central place to compile files, used by plug-ins and non plug-ins. */ -class CompilerUtils @Inject constructor(val files: KFiles, - val dependencyManager: DependencyManager, - val dependencyManager2: DependencyManager2) { +class CompilerUtils @Inject constructor(val files: KFiles, val dependencyManager: DependencyManager) { class CompilerResult(val successResults: List, val failedResult: TaskResult?) fun invokeCompiler(project: Project, context: KobaltContext, compiler: ICompilerDescription, - sourceDirectories: List, isTest: Boolean): CompilerResult { + sourceDirectories: List, isTest: Boolean, buildDirectory: File): CompilerResult { val results = arrayListOf() var failedResult: TaskResult? = null val contributedSourceDirs = @@ -34,18 +30,19 @@ class CompilerUtils @Inject constructor(val files: KFiles, } val sourceFiles = KFiles.findSourceFiles(project.directory, contributedSourceDirs.map { it.path }, compiler.sourceSuffixes) - if (sourceFiles.size > 0) { + if (sourceFiles.isNotEmpty()) { // TODO: createCompilerActionInfo recalculates the source files, only compute them // once and pass them val info = createCompilerActionInfo(project, context, compiler, isTest, - sourceDirectories, sourceSuffixes = compiler.sourceSuffixes) + sourceDirectories, sourceSuffixes = compiler.sourceSuffixes, buildDirectory = buildDirectory) val thisResult = invokeCompiler(project, context, compiler, info) results.addAll(thisResult.successResults) if (failedResult == null) { failedResult = thisResult.failedResult } } else { - log(2, "${compiler.name} compiler not running on ${project.name} since no source files were found") + context.logger.log(project.name, 2, + "${compiler.name} compiler not running on ${project.name} since no source files were found") } return CompilerResult(results, failedResult) @@ -68,32 +65,22 @@ class CompilerUtils @Inject constructor(val files: KFiles, * Runs all the contributors and interceptors relevant to that task. */ fun createCompilerActionInfo(project: Project, context: KobaltContext, compiler: ICompilerDescription, - isTest: Boolean, sourceDirectories: List, sourceSuffixes: List): CompilerActionInfo { + isTest: Boolean, sourceDirectories: List, sourceSuffixes: List, buildDirectory: File) + : CompilerActionInfo { copyResources(project, context, SourceSet.of(isTest)) - val fullClasspath = dependencyManager2.resolve(project, context, isTest, listOf(Scope.COMPILE, Scope.TEST)) + val fullClasspath = dependencyManager.calculateDependencies(project, context, + scopes = if (isTest) { + listOf(Scope.COMPILE, Scope.COMPILEONLY, Scope.TEST) + } else { + listOf(Scope.COMPILE, Scope.COMPILEONLY) + }) -// if (project.name == "ktor-core" && isTest) { -// val contains = fullClasspath.filter{it.id.contains("json")} -// val fc1 = -// if (isTest) dependencyManager.testDependencies(project, context) -// else dependencyManager.dependencies(project, context) -// -// println("DONOTCOMMIT") -// val d2 = dependencyManager2.resolve(project, context, isTest, listOf(Scope.COMPILE, Scope.TEST)) -// } - - // The directory where the classes get compiled - val buildDirectory = - if (isTest) File(project.buildDirectory, KFiles.TEST_CLASSES_DIR) - else File(project.classesDir(context)) File(project.directory, buildDirectory.path).mkdirs() // Remove all the excluded dependencies from the classpath - var classpath = fullClasspath.filter { - ! isDependencyExcluded(it, project.excludedDependencies) - } + var classpath = fullClasspath // The classpath needs to contain $buildDirectory/classes as well so that projects that contain // multiple languages can use classes compiled by the compiler run before them. @@ -137,7 +124,8 @@ class CompilerUtils @Inject constructor(val files: KFiles, // depending on the compiler's ability, sourceFiles can actually contain a list of directories // instead of individual source files. val projectDirectory = File(project.directory) - val sourceFiles = if (compiler.canCompileDirectories) { + val sourceFiles = + if (compiler.canCompileDirectories) { allSourceDirectories.map { File(projectDirectory, it.path).path } } else { files.findRecursively(projectDirectory, allSourceDirectories, @@ -185,7 +173,7 @@ class CompilerUtils @Inject constructor(val files: KFiles, // Finally, alter the info with the compiler interceptors before returning it val initialActionInfo = CompilerActionInfo(projectDirectory.path, classpath, allSources, sourceSuffixes, buildDirectory, emptyList() /* the flags will be provided by flag contributors */, - emptyList()) + emptyList(), context.internalContext.forceRecompile) val result = context.pluginInfo.compilerInterceptors.fold(initialActionInfo, { ai, interceptor -> interceptor.intercept(project, context, ai) }) @@ -205,27 +193,40 @@ class CompilerUtils @Inject constructor(val files: KFiles, val outputDir = sourceSet.outputDir val variantSourceDirs = context.variant.resourceDirectories(project, sourceSet) - if (variantSourceDirs.size > 0) { - JvmCompilerPlugin.lp(project, "Copying $sourceSet resources") + if (variantSourceDirs.isNotEmpty()) { + context.logger.log(project.name, 2, "Copying $sourceSet resources") val absOutputDir = File(KFiles.joinDir(project.directory, project.buildDirectory, outputDir)) - variantSourceDirs.map { File(project.directory, it.path) }.filter { - it.exists() - }.forEach { - log(2, "Copying from $it to $absOutputDir") - KFiles.copyRecursively(it, absOutputDir, deleteFirst = false) - } + variantSourceDirs + .map { File(project.directory, it.path) } + .filter(File::exists) + .forEach { + context.logger.log(project.name, 2, "Copying from $it to $absOutputDir") + KFiles.copyRecursively(it, absOutputDir, replaceExisting = true) + } } else { - JvmCompilerPlugin.lp(project, "No resources to copy for $sourceSet") + context.logger.log(project.name, 2, "No resources to copy for $sourceSet") } } + fun sourceCompilerFlags(project: Project?, context: KobaltContext, info: CompilerActionInfo) : List { + val adapters = context.pluginInfo.compilerFlagContributors.map { + val closure = { project: Project, context: KobaltContext, currentFlags: List, + suffixesBeingCompiled: List + -> it.compilerFlagsFor(project, context, currentFlags, suffixesBeingCompiled) } + FlagContributor(it.flagPriority, closure) + } + return compilerFlags(project, context, info, adapters) + } - /** - * Naïve implementation: just exclude all dependencies that start with one of the excluded dependencies. - * Should probably make exclusion more generic (full on string) or allow exclusion to be specified - * formally by groupId or artifactId. - */ - private fun isDependencyExcluded(id: IClasspathDependency, excluded: List) - = excluded.any { id.id.startsWith(it.id) } - + fun compilerFlags(project: Project?, context: KobaltContext, info: CompilerActionInfo, + adapters: List) : List { + val result = arrayListOf() + if (project != null) { + adapters.sortedBy { it.flagPriority } + adapters.forEach { + result.addAll(it.flagsFor(project, context, result, info.suffixesBeingCompiled)) + } + } + return result + } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt index 8acab0ab..93010294 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DocUrl.kt @@ -2,7 +2,7 @@ package com.beust.kobalt.internal class DocUrl { companion object { - private const val HOST = "http://beust.com/kobalt/" + private const val HOST = "https://beust.com/kobalt/" private fun url(path: String) = HOST + path val PUBLISH_PLUGIN_URL = url("plug-ins/index.html#publishing") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt index a363d878..a3e26afd 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/DynamicGraph.kt @@ -1,21 +1,19 @@ package com.beust.kobalt.internal -import com.beust.kobalt.KobaltException -import com.beust.kobalt.TaskResult -import com.beust.kobalt.misc.NamedThreadFactory -import com.beust.kobalt.misc.error -import com.beust.kobalt.misc.log +import com.beust.kobalt.* +import com.beust.kobalt.misc.* import com.google.common.collect.HashMultimap import java.lang.reflect.InvocationTargetException import java.util.* import java.util.concurrent.* -open class TaskResult2(success: Boolean, errorMessage: String?, val value: T) : TaskResult(success, errorMessage) { +open class TaskResult2(success: Boolean, testResult: TestResult? = null, + errorMessage: String? = null, val value: T) : TaskResult(success, testResult, errorMessage) { override fun toString() = com.beust.kobalt.misc.toString("TaskResult", "value", value, "success", success) } class DynamicGraph { - val VERBOSE = 2 + val VERBOSE = 3 val values : Collection get() = nodes.map { it.value } val nodes = hashSetOf>() private val dependedUpon = HashMultimap.create, PrivateNode>() @@ -63,16 +61,19 @@ class DynamicGraph { } } - fun transitiveClosureGraph(roots: List, childrenFor: (T) -> List) : List> - = roots.map { transitiveClosureGraph(it, childrenFor) } + fun transitiveClosureGraph(roots: List, childrenFor: (T) -> List, + filter: (T) -> Boolean): List> + = roots.map { transitiveClosureGraph(it, childrenFor, filter) } - fun transitiveClosureGraph(root: T, childrenFor: (T) -> List, seen: HashSet = hashSetOf()) : Node { + fun transitiveClosureGraph(root: T, childrenFor: (T) -> List, + filter: (T) -> Boolean = { t: T -> true }, + seen: HashSet = hashSetOf()) : Node { val children = arrayListOf>() - childrenFor(root).forEach { child -> + childrenFor(root).filter(filter).forEach { child -> if (! seen.contains(child)) { - val c = transitiveClosureGraph(child, childrenFor) - children.add(c) seen.add(child) + val c = transitiveClosureGraph(child, childrenFor, filter, seen) + children.add(c) } } return Node(root, children) @@ -89,7 +90,7 @@ class DynamicGraph { } fun removeNode(t: T) = synchronized(nodes) { - log(VERBOSE, " Removing node $t") + kobaltLog(VERBOSE, " Removing node $t") PrivateNode(t).let { node -> nodes.remove(node) dependingOn.removeAll(node) @@ -129,7 +130,7 @@ class DynamicGraph { } } val result = nodes.map { it.value }.filter { !nonFree.contains(it) }.toHashSet() - log(VERBOSE, " Free nodes: $result") + kobaltLog(VERBOSE, " Free nodes: $result") return result } } @@ -162,6 +163,8 @@ interface IWorker : Callable> { */ // val tasks : List + val name: String + /** * @return the priority of this task. */ @@ -181,11 +184,16 @@ interface IThreadWorkerFactory { } class DynamicGraphExecutor(val graph : DynamicGraph, val factory: IThreadWorkerFactory, - threadCount: Int = 1) { + val threadCount: Int = 1) { val executor : ExecutorService = Executors.newFixedThreadPool(threadCount, NamedThreadFactory("DynamicGraphExecutor")) val completion = ExecutorCompletionService>(executor) + data class HistoryLog(val name: String, val timestamp: Long, val threadId: Long, val start: Boolean) + + val historyLog = arrayListOf() + val threadIds = ConcurrentHashMap() + fun run() : TaskResult { try { return run2() @@ -201,7 +209,24 @@ class DynamicGraphExecutor(val graph : DynamicGraph, val factory: IThreadW val newFreeNodes = HashSet(graph.freeNodes) while (failedResult == null && (running > 0 || newFreeNodes.size > 0)) { nodesRun.addAll(newFreeNodes) - val callables : List> = factory.createWorkers(newFreeNodes) + val callables : List> = factory.createWorkers(newFreeNodes).map { + it -> object: IWorker { + override val priority: Int + get() = it.priority + + override val name: String get() = it.name + override fun call(): TaskResult2 { + val threadId = Thread.currentThread().id + historyLog.add(HistoryLog(it.name, System.currentTimeMillis(), threadId, + start = true)) + threadIds.put(threadId, threadId) + val result = it.call() + historyLog.add(HistoryLog(it.name, System.currentTimeMillis(), Thread.currentThread().id, + start = false)) + return result + } + } + } callables.forEach { completion.submit(it) } running += callables.size @@ -211,19 +236,19 @@ class DynamicGraphExecutor(val graph : DynamicGraph, val factory: IThreadW running-- if (taskResult.success) { nodesRun.add(taskResult.value) - log(2, "Task succeeded: $taskResult") + kobaltLog(3, "Task succeeded: $taskResult") graph.removeNode(taskResult.value) newFreeNodes.clear() newFreeNodes.addAll(graph.freeNodes.minus(nodesRun)) } else { - log(2, "Task failed: $taskResult") + kobaltLog(3, "Task failed: $taskResult") newFreeNodes.clear() if (failedResult == null) { failedResult = taskResult } } } catch(ex: TimeoutException) { - log(2, "Time out") + kobaltLog(3, "Time out") } catch(ex: Exception) { val ite = ex.cause if (ite is InvocationTargetException) { @@ -241,6 +266,116 @@ class DynamicGraphExecutor(val graph : DynamicGraph, val factory: IThreadW } return if (failedResult != null) failedResult else TaskResult() } + + fun dumpHistory() { + kobaltLog(1, "Thread report") + + val table = AsciiTable.Builder() + .columnWidth(11) + threadIds.keys.forEach { + table.columnWidth(24) + } + table.header("Time (sec)") + threadIds.keys.forEach { + table.header("Thread " + it.toString()) + } + + fun toSeconds(millis: Long) = (millis / 1000).toInt().toString() + + fun displayCompressedLog(table: AsciiTable.Builder) : AsciiTable.Builder { + data class CompressedLog(val timestamp: Long, val threadMap: HashMap) + + fun compressLog(historyLog: List): ArrayList { + val compressed = arrayListOf() + + var currentLog: CompressedLog? = null + + val projectStart = hashMapOf() + fun toName(hl: HistoryLog) : String { + var duration = "" + if (! hl.start) { + val start = projectStart[hl.name] + if (start != null) { + duration = " (" + ((hl.timestamp - start) / 1000) + .toInt().toString() + ")" + } else { + kobaltLog(1, "DONOTCOMMIT") + } + } + return hl.name + duration + } + + historyLog.forEach { hl -> + kobaltLog(1, "CURRENT LOG: " + currentLog + " HISTORY LINE: " + hl) + if (hl.start) { + projectStart[hl.name] = hl.timestamp + } + if (currentLog == null) { + currentLog = CompressedLog(hl.timestamp, hashMapOf(hl.threadId to hl.name)) + } else currentLog?.let { cl -> + if (! hl.start || hl.timestamp - cl.timestamp < 1000) { + kobaltLog(1, " CURRENT LOG IS WITHING ONE SECOND: $hl") + cl.threadMap[hl.threadId] = toName(hl) + } else { + kobaltLog(1, " ADDING COMPRESSED LINE $cl") + compressed.add(cl) + currentLog = CompressedLog(hl.timestamp, hashMapOf(hl.threadId to toName(hl))) + } + } + } + return compressed + } + + compressLog(historyLog).forEach { + val row = arrayListOf() + row.add(toSeconds(it.timestamp)) + it.threadMap.values.forEach { + row.add(it) + } + table.addRow(row) + } + + return table + } + + fun displayRegularLog(table: AsciiTable.Builder) : AsciiTable.Builder { + if (historyLog.any()) { + if (historyLog[0] != null) { + val start = historyLog[0].timestamp + val projectStart = ConcurrentHashMap() + historyLog.forEach { line -> + val row = arrayListOf() + row.add(toSeconds(line.timestamp - start)) + threadIds.keys.forEach { + if (line.threadId == it) { + var duration = "" + if (line.start) { + projectStart[line.name] = line.timestamp + } else { + val projectStart = projectStart[line.name] + if (projectStart != null) { + duration = " (" + ((line.timestamp - projectStart) / 1000) + .toInt().toString() + ")" + } else { + warn("Couldn't determine project start: " + line.name) + } + } + row.add((line.name + duration)) + } else { + row.add("") + } + } + table.addRow(row) + } + } else { + warn("Couldn't find historyLog") + } + } + return table + } + + kobaltLog(1, displayRegularLog(table).build()) + } } fun main(argv: Array) { @@ -258,11 +393,12 @@ fun main(argv: Array) { return nodes.map { object: IWorker { override fun call(): TaskResult2? { - log(1, " Running worker $it") - return TaskResult2(true, null, it) + kobaltLog(1, " Running worker $it") + return TaskResult2(true, value = it) } override val priority: Int get() = 0 + override val name: String = "workerName" } } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt index 77e45e49..995dba53 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GenericRunner.kt @@ -2,10 +2,9 @@ package com.beust.kobalt.internal import com.beust.kobalt.* import com.beust.kobalt.api.* -import com.beust.kobalt.maven.DependencyManager2 import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log import com.google.common.annotations.VisibleForTesting +import com.google.inject.Inject import java.io.File import java.util.* @@ -17,17 +16,31 @@ abstract class GenericTestRunner: ITestRunnerContributor { abstract val dependencyName : String abstract val mainClass: String abstract val annotationPackage: String + abstract val runnerName: String + open var shortMessage: String? = null + open var longMessage: String? = null + + @Inject + private lateinit var jvm: Jvm + abstract fun args(project: Project, context: KobaltContext, classpath: List, testConfig: TestConfig) : List + open fun onFinish(project: Project) {} + + open val extraClasspath: List = emptyList() + + open fun filterTestClasses(project: Project, context: KobaltContext, classes: List) : List = classes + override fun run(project: Project, context: KobaltContext, configName: String, - classpath: List) - = TaskResult(runTests(project, context, classpath, configName)) + classpath: List) : TaskResult { + val tr = runTests(project, context, classpath, configName) + return TaskResult(tr.success, testResult = tr) + } override fun affinity(project: Project, context: KobaltContext) : Int { - val td = Kobalt.INJECTOR.getInstance(DependencyManager2::class.java).resolve(project, context, isTest = true) val result = - if (td.any { it.id.contains(dependencyName) }) IAffinity.DEFAULT_POSITIVE_AFFINITY + if (project.testDependencies.any { it.id.contains(dependencyName) }) IAffinity.DEFAULT_POSITIVE_AFFINITY else 0 return result } @@ -55,8 +68,8 @@ abstract class GenericTestRunner: ITestRunnerContributor { // result // } - log(2, "Found ${result.size} test classes") - return result.map { it.second } + context.logger.log(project.name, 2, "Found ${result.size} test classes") + return filterTestClasses(project, context, result.map { it.second }) } /** @@ -95,17 +108,20 @@ abstract class GenericTestRunner: ITestRunnerContributor { /** * @return true if all the tests passed */ - fun runTests(project: Project, context: KobaltContext, classpath: List, - configName: String) : Boolean { + open fun runTests(project: Project, context: KobaltContext, classpath: List, + configName: String) : TestResult { var result = false + context.logger.log(project.name, 1, "Running tests with $runnerName") + val testConfig = project.testConfigs.firstOrNull { it.name == configName } + var errorCode = -1 if (testConfig != null) { val args = args(project, context, classpath, testConfig) if (args.size > 0) { - val java = JavaInfo.create(File(SystemProperties.javaBase)).javaExecutable + val java = jvm.javaExecutable val jvmArgs = calculateAllJvmArgs(project, context, testConfig, classpath, Kobalt.INJECTOR.getInstance (PluginInfo::class.java)) val allArgs = arrayListOf().apply { @@ -118,24 +134,28 @@ abstract class GenericTestRunner: ITestRunnerContributor { val pb = ProcessBuilder(allArgs) pb.directory(File(project.directory)) pb.inheritIO() - log(2, "Running tests with classpath size ${classpath.size}") - log(2, "Launching " + allArgs.joinToString(" ")) + context.logger.log(project.name, 2, "Running tests with classpath size ${classpath.size}") + context.logger.log(project.name, 2, "Launching " + allArgs.joinToString(" ")) val process = pb.start() - val errorCode = process.waitFor() - if (errorCode == 0) { - log(1, "All tests passed") - } else { - log(1, "Test failures") - } + errorCode = process.waitFor() result = result || errorCode == 0 } else { - log(1, " No tests to run") + context.logger.log(project.name, 1, " No tests to run") result = true } } else { throw KobaltException("Couldn't find a test configuration named \"$configName\"") } - return result + + onFinish(project) + + if (errorCode == 0) { + context.logger.log(project.name, 1, "All tests passed") + } else { + context.logger.log(project.name, 1, longMessage!!) + } + + return TestResult(result, shortMessage, longMessage) } /* @@ -144,11 +164,13 @@ abstract class GenericTestRunner: ITestRunnerContributor { @VisibleForTesting fun calculateAllJvmArgs(project: Project, context: KobaltContext, testConfig: TestConfig, classpath: List, pluginInfo: IPluginInfo) : List { + val fullClasspath = classpath.map { it.jarFile.get().absolutePath } + extraClasspath // Default JVM args val jvmFlags = arrayListOf().apply { addAll(testConfig.jvmArgs) + add("-ea") add("-classpath") - add(classpath.map { it.jarFile.get().absolutePath }.joinToString(File.pathSeparator)) + add(fullClasspath.joinToString(File.pathSeparator)) } // JVM flags from the contributors @@ -165,7 +187,8 @@ abstract class GenericTestRunner: ITestRunnerContributor { } if (result.any()) { - log(2, "Final JVM test flags after running the contributors and interceptors: $result") + context.logger.log(project.name, 2, + "Final JVM test flags after running the contributors and interceptors: $result") } return result diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GraphUtil.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GraphUtil.kt new file mode 100644 index 00000000..6cef8ada --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/GraphUtil.kt @@ -0,0 +1,35 @@ +package com.beust.kobalt.internal + +/** + * Generic operations on graph-like structures. + */ +object GraphUtil { + /** + * Apply the operation in `closure` to all the nodes in the tree. + */ + fun map(roots: List, children: (T) -> List, closure: (T) -> Unit) { + roots.forEach { + closure(it) + map(children(it), children, closure) + } + } + + /** + * Display each node in the roots by calling the `display` function on each of them. + */ + fun displayGraph(roots: List, + children: (T) -> List, + display: (node: T, indent: String) -> Unit) { + + fun pd(node: T, indent: String) { + display(node, indent) + children(node).forEach { + pd(it, indent + " ") + } + } + roots.forEach { + pd(it, "") + } + } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt index f69e7107..067cf0c1 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/IncrementalManager.kt @@ -7,7 +7,7 @@ import com.beust.kobalt.Variant import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.gson.Gson import com.google.gson.GsonBuilder import com.google.inject.Inject @@ -55,6 +55,7 @@ class IncrementalManager @Inject constructor(val args: Args, @Assisted val fileN private fun save(map: Map) { val bi = BuildInfo(map.values.toList()) val json = GsonBuilder().setPrettyPrinting().create().toJson(bi) + Files.write(Paths.get(fileName), json.toByteArray(Charset.defaultCharset())) } @@ -62,24 +63,32 @@ class IncrementalManager @Inject constructor(val args: Args, @Assisted val fileN = taskInfos.getOrPut(taskName, { -> TaskInfo(taskName) }) fun saveInputChecksum(taskName: String, inputChecksum: String) { - with(taskInfos()) { - taskInfoFor(this, taskName).inputChecksum = inputChecksum - save(this) + synchronized(BUILD_INFO_FILE) { + with(taskInfos()) { + taskInfoFor(this, taskName).inputChecksum = inputChecksum + save(this) + } } } fun inputChecksumFor(taskName: String) : String? = + synchronized(BUILD_INFO_FILE) { taskInfoFor(taskInfos(), taskName).inputChecksum + } fun saveOutputChecksum(taskName: String, outputChecksum: String) { - with(taskInfos()) { - taskInfoFor(this, taskName).outputChecksum = outputChecksum - save(this) + synchronized(BUILD_INFO_FILE) { + with(taskInfos()) { + taskInfoFor(this, taskName).outputChecksum = outputChecksum + save(this) + } } } fun outputChecksumFor(taskName: String) : String? = + synchronized(BUILD_INFO_FILE) { taskInfoFor(taskInfos(), taskName).outputChecksum + } /** * @param method is assumed to return an IncrementalTaskInfo. @@ -173,5 +182,5 @@ class IncrementalManager @Inject constructor(val args: Args, @Assisted val fileN } val LEVEL = 2 - private fun logIncremental(level: Int, s: String) = log(level, " INC - $s") + private fun logIncremental(level: Int, s: String) = kobaltLog(level, " INC - $s") } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnit5Runner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnit5Runner.kt new file mode 100644 index 00000000..2e9b534c --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnit5Runner.kt @@ -0,0 +1,152 @@ +package com.beust.kobalt.internal + +import com.beust.jcommander.JCommander +import com.beust.jcommander.Parameter +import com.beust.kobalt.TestConfig +import com.beust.kobalt.api.IAffinity +import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.KobaltLogger +import com.google.inject.Inject +import org.junit.platform.engine.TestExecutionResult +import org.junit.platform.engine.discovery.DiscoverySelectors +import org.junit.platform.engine.reporting.ReportEntry +import org.junit.platform.engine.support.descriptor.MethodSource +import org.junit.platform.launcher.LauncherDiscoveryRequest +import org.junit.platform.launcher.TestExecutionListener +import org.junit.platform.launcher.TestIdentifier +import org.junit.platform.launcher.TestPlan +import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder +import org.junit.platform.launcher.core.LauncherFactory +import java.io.File +import java.nio.file.Paths + +/** + * Runner for JUnit 5 tests. This class also contains a main() entry point since JUnit 5 no longer supplies one. + */ +class JUnit5Runner @Inject constructor(kFiles: KFiles) : GenericTestRunner() { + + override val dependencyName = "jupiter" + override val annotationPackage = "org.junit.jupiter.api" + override val mainClass = "com.beust.kobalt.internal.JUnit5RunnerKt" + override val runnerName = "JUnit 5" + + override fun affinity(project: Project, context: KobaltContext) : Int { + val result = + if (project.testDependencies.any { it.id.contains("junit5") || it.id.contains("jupiter") }) + IAffinity.DEFAULT_POSITIVE_AFFINITY + 100 + else 0 + return result + + } + + override fun args(project: Project, context: KobaltContext, classpath: List, testConfig: TestConfig): List { + val testClassDir = KFiles.joinDir(project.buildDirectory, KFiles.TEST_CLASSES_DIR) + val classDir = KFiles.joinDir(project.buildDirectory, KFiles.CLASSES_DIR) + val args = listOf("--testClassDir", testClassDir, + "--classDir", classDir, + "--log", KobaltLogger.LOG_LEVEL.toString()) + return args + } + + override val extraClasspath = kFiles.kobaltJar +} + +private class Args { + @Parameter(names = arrayOf("--log")) + var log: Int = 1 + + @Parameter(names = arrayOf("--testClassDir")) + var testClassDir: String = "kobaltBuild/test-classes" + + @Parameter(names = arrayOf("--classDir")) + var classDir: String = "kobaltBuild/classes" +} + +fun main(argv: Array) { + val args = Args() + val jc = JCommander(args) + jc.parse(*argv) + + val testClassDir = File(args.testClassDir).absolutePath + val classDir = File(args.classDir).absolutePath + val request : LauncherDiscoveryRequest = LauncherDiscoveryRequestBuilder() + .selectors(DiscoverySelectors.selectClasspathRoots(setOf( + Paths.get(testClassDir), + Paths.get(classDir) + ))) + .selectors(DiscoverySelectors.selectDirectory(testClassDir)) + .build() + + fun testName(id: TestIdentifier) : String? { + val result = + if (id.source.isPresent) { + val source = id.source.get() + if (source is MethodSource) { + source.className + "." + source.methodName + } else { + null + } + } else { + null + } + return result + } + + var passed = 0 + var failed = 0 + var skipped = 0 + var aborted = 0 + + fun log(level: Int, s: String) { + if (level <= args.log) println(s) + } + + val listener = object: TestExecutionListener { + override fun executionFinished(testIdentifier: TestIdentifier, testExecutionResult: TestExecutionResult) { + val testName = testName(testIdentifier) + if (testName != null) { + when(testExecutionResult.status) { + TestExecutionResult.Status.FAILED -> { + log(1, "FAILED: $testName, reason: " + testExecutionResult.throwable.get().toString()) + failed++ + } + TestExecutionResult.Status.ABORTED -> { + log(1, "ABORTED: $testName, reason: " + testExecutionResult.throwable.get().toString()) + aborted++ + } + TestExecutionResult.Status.SUCCESSFUL -> { + log(2, "PASSED: $testName") + passed++ + } else -> { + + } + } + } + } + + override fun executionSkipped(testIdentifier: TestIdentifier, reason: String) { + testName(testIdentifier)?.let { + log(1, "Skipping $it because $reason") + skipped++ + } + } + + override fun executionStarted(testIdentifier: TestIdentifier) { + testName(testIdentifier)?.let { + log(2, "Starting $it") + } + } + + override fun testPlanExecutionStarted(testPlan: TestPlan?) {} + override fun dynamicTestRegistered(testIdentifier: TestIdentifier?) {} + override fun reportingEntryPublished(testIdentifier: TestIdentifier?, entry: ReportEntry?) {} + override fun testPlanExecutionFinished(testPlan: TestPlan?) {} + } + + LauncherFactory.create().execute(request, listener) + + log(1, "TEST RESULTS: $passed PASSED, $failed FAILED, $skipped SKIPPED, $aborted ABORTED") +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt index eec22afd..c5b36997 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JUnitRunner.kt @@ -4,16 +4,29 @@ import com.beust.kobalt.TestConfig import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project +import com.beust.kobalt.maven.DependencyManager +import com.google.inject.Inject +import java.lang.reflect.Modifier +import java.net.URLClassLoader open class JUnitRunner() : GenericTestRunner() { override val mainClass = "org.junit.runner.JUnitCore" - override val annotationPackage = "org.junit" - override val dependencyName = "junit" + override val runnerName = "JUnit 4" override fun args(project: Project, context: KobaltContext, classpath: List, testConfig: TestConfig) = findTestClasses(project, context, testConfig) + + @Inject + lateinit var dependencyManager: DependencyManager + + override fun filterTestClasses(project: Project, context: KobaltContext, classes: List) : List { + val deps = dependencyManager.testDependencies(project, context) + val cl = URLClassLoader(deps.map { it.jarFile.get().toURI().toURL() }.toTypedArray()) + return classes.filter { !Modifier.isAbstract(cl.loadClass(it).modifiers) } + } + } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt index dd612256..e7773737 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompiler.kt @@ -15,36 +15,25 @@ import java.util.* * Also validates the classpath and run all the contributors. */ class JvmCompiler @Inject constructor(val dependencyManager: DependencyManager) { - /** * Take the given CompilerActionInfo and enrich it with all the applicable contributors and * then pass it to the ICompilerAction. */ - fun doCompile(project: Project?, context: KobaltContext?, action: ICompilerAction, info: CompilerActionInfo) - : TaskResult { + fun doCompile(project: Project?, context: KobaltContext?, action: ICompilerAction, info: CompilerActionInfo, + flags: List): TaskResult { // Dependencies - val allDependencies = (info.dependencies - + dependencyManager.calculateDependencies(project, context!!, passedDependencies = info.dependencies)) + val allDependencies = (info.dependencies + dependencyManager.calculateDependencies(project, context!!, + passedDependencies = info.dependencies)) .distinct() // Plugins that add flags to the compiler - val currentFlags = arrayListOf().apply { addAll(info.compilerArgs) } - val contributorFlags : List = if (project != null) { - val contributors = context.pluginInfo.compilerFlagContributors - contributors.sortBy { it.flagPriority } - context.pluginInfo.compilerFlagContributors.forEach { - currentFlags.addAll(it.flagsFor(project, context, currentFlags, info.suffixesBeingCompiled)) - } - currentFlags - } else { - emptyList() - } + val contributorFlags : List = if (project != null) flags else emptyList() val addedFlags = contributorFlags + ArrayList(info.compilerArgs) validateClasspath(allDependencies.map { it.jarFile.get().absolutePath }) - return action.compile(project?.name, info.copy(dependencies = allDependencies, compilerArgs = addedFlags)) + return action.compile(project, info.copy(dependencies = allDependencies, compilerArgs = addedFlags)) } private fun validateClasspath(cp: List) { @@ -57,5 +46,5 @@ class JvmCompiler @Inject constructor(val dependencyManager: DependencyManager) } interface ICompilerAction { - fun compile(projectName: String?, info: CompilerActionInfo): TaskResult + fun compile(project: Project?, info: CompilerActionInfo): TaskResult } \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt index cb89f661..5e2a9354 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/JvmCompilerPlugin.kt @@ -9,25 +9,25 @@ import com.beust.kobalt.api.annotation.ExportedProjectProperty import com.beust.kobalt.api.annotation.IncrementalTask import com.beust.kobalt.api.annotation.Task import com.beust.kobalt.maven.DependencyManager -import com.beust.kobalt.maven.DependencyManager2 -import com.beust.kobalt.maven.LocalRepo import com.beust.kobalt.maven.Md5 -import com.beust.kobalt.misc.* +import com.beust.kobalt.maven.aether.Scope +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.KobaltExecutors +import com.beust.kobalt.misc.error +import com.beust.kobalt.misc.warn import java.io.File import java.util.* import javax.inject.Inject import javax.inject.Singleton /** - * This plug-in takes care of compilation: it declares a bunch of tasks ("compile", "compileTest") and + * This plug-in takes care of compilation: it declares several common tasks ("compile", "compileTest") * and picks up all the compiler contributors in order to run them whenever a compilation is requested. */ @Singleton open class JvmCompilerPlugin @Inject constructor( - open val localRepo: LocalRepo, open val files: KFiles, open val dependencyManager: DependencyManager, - open val dependencyManager2: DependencyManager2, open val executors: KobaltExecutors, open val taskContributor : TaskContributor, val compilerUtils: CompilerUtils) @@ -49,13 +49,6 @@ open class JvmCompilerPlugin @Inject constructor( const val GROUP_TEST = "test" const val GROUP_BUILD = "build" const val GROUP_DOCUMENTATION = "documentation" - - /** - * Log with a project. - */ - fun lp(project: Project, s: String) { - log(2, "${project.name}: $s") - } } override val name: String = PLUGIN_NAME @@ -86,17 +79,22 @@ open class JvmCompilerPlugin @Inject constructor( } private fun taskTest(project: Project, configName: String): TaskResult { - lp(project, "Running tests: $configName") + context.logger.log(project.name, 2, "Running tests: $configName") val testContributor = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.testRunnerContributors) if (testContributor != null && testContributor.affinity(project, context) > 0) { // val td1 = dependencyManager.testDependencies(project, context) - val testDependencies = dependencyManager2.resolve(project, context, isTest = true) - val compileDependencies = dependencyManager2.resolve(project, context, isTest = false) - return testContributor.run(project, context, configName, testDependencies + compileDependencies) + val testDependencies = dependencyManager.calculateDependencies(project, context, + dependencyFilter = dependencyManager.createDependencyFilter(project, project.testDependencies), + scopes = listOf(Scope.TEST)) + val compileDependencies = dependencyManager.calculateDependencies(project, context, + scopes = listOf(Scope.COMPILE, Scope.COMPILEONLY)) + val allDependencies = (testDependencies + compileDependencies).distinct() + return testContributor.run(project, context, configName, allDependencies.toList()) } else { - log(2, "Couldn't find a test runner for project ${project.name}, did you specify dependenciesTest{}?") + context.logger.log(project.name, 2, + "Couldn't find a test runner for project ${project.name}, did you specify dependenciesTest{}?") return TaskResult() } } @@ -153,13 +151,16 @@ open class JvmCompilerPlugin @Inject constructor( val results = arrayListOf() val compilerContributors = context.pluginInfo.compilerContributors - ActorUtils.selectAffinityActors(project, context, - context.pluginInfo.compilerContributors) + ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors) var failedResult: TaskResult? = null if (compilerContributors.isEmpty()) { throw KobaltException("Couldn't find any compiler for project ${project.name}") } else { + + // Generate BuildConfig if applicable + context.variant.maybeGenerateBuildConfig(project, context) + val allCompilers = compilerContributors.flatMap { it.compilersFor(project, context)}.sorted() /** @@ -173,7 +174,10 @@ open class JvmCompilerPlugin @Inject constructor( if (wi.value.sourceSuffixes.contains("java")) ij = wi.index if (wi.value.sourceSuffixes.contains("kt")) ik = wi.index } - Collections.swap(result, ik, ij) + + if (ik >= 0 && ij >= 0) { + Collections.swap(result, ik, ij) + } return result } @@ -181,9 +185,14 @@ open class JvmCompilerPlugin @Inject constructor( val hasKapt = project.projectProperties.get("kaptConfig") != null val allCompilersSorted = if (hasKapt) swapJavaAndKotlin(allCompilers) else allCompilers var done = false + // The directory where the classes get compiled + val buildDirectory = + if (isTest) File(KFiles.joinDir(project.buildDirectory, KFiles.TEST_CLASSES_DIR)) + else File(KFiles.joinDir(project.classesDir(context))) + allCompilersSorted.doWhile({ ! done }) { compiler -> val compilerResults = compilerUtils.invokeCompiler(project, context, compiler, - sourceDirectories(project, context, isTest), isTest) + sourceDirectories(project, context, isTest), isTest, buildDirectory) results.addAll(compilerResults.successResults) if (failedResult == null) failedResult = compilerResults.failedResult compilerResults.failedResult?.let { failedResult -> @@ -216,10 +225,12 @@ open class JvmCompilerPlugin @Inject constructor( } } - @Task(name = "doc", description = "Generate the documentation for the project", group = GROUP_DOCUMENTATION) + @Task(name = "doc", description = "Generate the documentation for the project", group = GROUP_DOCUMENTATION, + runBefore = arrayOf("assemble"), runAfter = arrayOf("clean")) fun taskJavadoc(project: Project): TaskResult { val docGenerator = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.docContributors) if (docGenerator != null) { + val buildDirectory = File(project.buildDirectory, JvmCompilerPlugin.DOCS_DIRECTORY) val contributors = ActorUtils.selectAffinityActors(project, context, context.pluginInfo.compilerContributors) var result: TaskResult? = null @@ -228,7 +239,7 @@ open class JvmCompilerPlugin @Inject constructor( result = docGenerator.generateDoc(project, context, compilerUtils.createCompilerActionInfo(project, context, compiler, isTest = false, sourceDirectories = sourceDirectories(project, context, false), - sourceSuffixes = compiler.sourceSuffixes)) + sourceSuffixes = compiler.sourceSuffixes, buildDirectory = buildDirectory)) } } return result!! diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt index 1454f0fd..d8ca3555 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltPluginXml.kt @@ -2,7 +2,7 @@ package com.beust.kobalt.internal import com.beust.kobalt.KobaltException import com.beust.kobalt.api.* -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import java.io.ByteArrayInputStream import java.io.InputStream import javax.xml.bind.JAXBContext @@ -72,13 +72,13 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, val plugins = arrayListOf() val projectContributors = arrayListOf() val classpathContributors = arrayListOf() - val initContributors = arrayListOf() + val templateContributors = arrayListOf() val repoContributors = arrayListOf() val compilerFlagContributors = arrayListOf() val compilerInterceptors = arrayListOf() val sourceDirectoriesInterceptors = arrayListOf() val buildDirectoryInterceptors = arrayListOf() - val runnerContributors = arrayListOf() +// val runnerContributors = arrayListOf() val testRunnerContributors = arrayListOf() val classpathInterceptors = arrayListOf() val compilerContributors = arrayListOf() @@ -98,6 +98,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, val localMavenRepoPathInterceptors = arrayListOf() val buildListeners = arrayListOf() val buildReportContributors = arrayListOf() + val docFlagContributors = arrayListOf() // Note: intentionally repeating them here even though they are defined by our base class so // that this class always contains the full list of contributors and interceptors @@ -123,7 +124,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, fun readKobaltPluginXml(): PluginInfo { // Note: use forward slash here since we're looking up this file in a .jar file val url = Kobalt::class.java.classLoader.getResource(PLUGIN_CORE_XML) - log(2, "URL for core kobalt-plugin.xml: $url") + kobaltLog(2, "URL for core kobalt-plugin.xml: $url") if (url != null) { return readPluginXml(url.openConnection().inputStream) } else { @@ -139,7 +140,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, val jaxbContext = JAXBContext.newInstance(KobaltPluginXml::class.java) val kobaltPlugin: KobaltPluginXml = jaxbContext.createUnmarshaller().unmarshal(ins) as KobaltPluginXml - log(2, "Parsed plugin XML file, found: " + kobaltPlugin.name) + kobaltLog(2, "Parsed plugin XML file, found: " + kobaltPlugin.name) val result = try { PluginInfo(kobaltPlugin, pluginClassLoader, classLoader) @@ -171,9 +172,8 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, } val result = loadClass(className, classLoader) - ?: Class.forName(className) ?: loadClass(className, pluginClassLoader) - ?: throw ClassNotFoundException(className) + ?: Class.forName(className) return result } @@ -193,11 +193,11 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, if (this is ICompilerFlagContributor) compilerFlagContributors.add(this) if (this is ICompilerInterceptor) compilerInterceptors.add(this) if (this is IDocContributor) docContributors.add(this) - if (this is ITemplateContributor) initContributors.add(this) + if (this is ITemplateContributor) templateContributors.add(this) if (this is IPlugin) plugins.add(this) if (this is IProjectContributor) projectContributors.add(this) if (this is IRepoContributor) repoContributors.add(this) - if (this is IRunnerContributor) runnerContributors.add(this) +// if (this is IRunnerContributor) runnerContributors.add(this) if (this is ISourceDirectoryContributor) sourceDirContributors.add(this) if (this is ISourceDirectoryInterceptor) sourceDirectoriesInterceptors.add(this) if (this is ITaskContributor) taskContributors.add(this) @@ -216,25 +216,24 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, if (this is ILocalMavenRepoPathInterceptor) localMavenRepoPathInterceptors.add(this) if (this is IBuildListener) buildListeners.add(this) if (this is IBuildReportContributor) buildReportContributors.add(this) + if (this is IDocFlagContributor) docFlagContributors.add(this) } } } fun cleanUp() { - listOf(projectContributors, classpathContributors, initContributors, + listOf(projectContributors, classpathContributors, templateContributors, repoContributors, compilerFlagContributors, compilerInterceptors, sourceDirectoriesInterceptors, buildDirectoryInterceptors, - runnerContributors, testRunnerContributors, classpathInterceptors, + /* runnerContributors, */ testRunnerContributors, classpathInterceptors, compilerContributors, docContributors, sourceDirContributors, testSourceDirContributors, buildConfigFieldContributors, taskContributors, incrementalTaskContributors, assemblyContributors, incrementalAssemblyContributors, testJvmFlagInterceptors, jvmFlagContributors, localMavenRepoPathInterceptors, buildListeners, - buildReportContributors + buildReportContributors, docFlagContributors ).forEach { - it.forEach { - it.cleanUpActors() - } + it.forEach(IPluginActor::cleanUpActors) } } @@ -242,18 +241,18 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, * Add the content of @param[pluginInfo] to this pluginInfo. */ fun addPluginInfo(pluginInfo: PluginInfo) { - log(2, "Found new plug-in, adding it to pluginInfo: $pluginInfo") + kobaltLog(2, "Found new plug-in, adding it to pluginInfo: $pluginInfo") plugins.addAll(pluginInfo.plugins) classpathContributors.addAll(pluginInfo.classpathContributors) projectContributors.addAll(pluginInfo.projectContributors) - initContributors.addAll(pluginInfo.initContributors) + templateContributors.addAll(pluginInfo.templateContributors) repoContributors.addAll(pluginInfo.repoContributors) compilerFlagContributors.addAll(pluginInfo.compilerFlagContributors) compilerInterceptors.addAll(pluginInfo.compilerInterceptors) sourceDirectoriesInterceptors.addAll(pluginInfo.sourceDirectoriesInterceptors) buildDirectoryInterceptors.addAll(pluginInfo.buildDirectoryInterceptors) - runnerContributors.addAll(pluginInfo.runnerContributors) +// runnerContributors.addAll(pluginInfo.runnerContributors) testRunnerContributors.addAll(pluginInfo.testRunnerContributors) classpathInterceptors.addAll(pluginInfo.classpathInterceptors) compilerContributors.addAll(pluginInfo.compilerContributors) @@ -273,6 +272,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, localMavenRepoPathInterceptors.addAll(pluginInfo.localMavenRepoPathInterceptors) buildListeners.addAll(pluginInfo.buildListeners) buildReportContributors.addAll(pluginInfo.buildReportContributors) + docFlagContributors.addAll(pluginInfo.docFlagContributors) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt index f7494a2f..2eb5374c 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KobaltSettingsXml.kt @@ -1,9 +1,11 @@ package com.beust.kobalt.internal +import com.beust.kobalt.BUILD_SCRIPT_CONFIG +import com.beust.kobalt.Constants import com.beust.kobalt.ProxyConfig import com.beust.kobalt.homeDir import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.inject.Inject import com.google.inject.Singleton import java.io.File @@ -23,17 +25,26 @@ class KobaltSettingsXml { @XmlElement(name = "localMavenRepo") @JvmField var localMavenRepo: String = homeDir(KFiles.KOBALT_DOT_DIR, "localMavenRepo") - @XmlElement(name = "defaulRepos") @JvmField + @XmlElement(name = "defaultRepos") @JvmField var defaultRepos: DefaultReposXml? = null @XmlElement(name = "proxies") @JvmField var proxies: ProxiesXml? = null @XmlElement(name = "kobaltCompilerVersion") @JvmField - var kobaltCompilerVersion: String = "1.0.3" + var kobaltCompilerVersion: String = Constants.KOTLIN_COMPILER_VERSION @XmlElement(name = "kobaltCompilerRepo") @JvmField var kobaltCompilerRepo: String? = null + + @XmlElement(name = "kobaltCompilerFlags") @JvmField + var kobaltCompilerFlags: String? = null + + @XmlElement(name = "kobaltCompilerSeparateProcess") @JvmField + var kobaltCompilerSeparateProcess: Boolean = false + + @XmlElement(name = "autoUpdate") @JvmField + var autoUpdate: Boolean = false } class ProxiesXml { @@ -77,6 +88,17 @@ class KobaltSettings @Inject constructor(val xmlFile: KobaltSettingsXml) { */ val localMavenRepo = KFiles.makeDir(xmlFile.localMavenRepo) + /** + * If true, Kobalt will automatically update itself if a new version is found. + */ + val autoUpdate = xmlFile.autoUpdate + + /** + * If true, the Kotlin compiler will always be launched in a separate JVM, even if the requested + * version is the same as the internal version. + */ + val kobaltCompilerSeparateProcess = xmlFile.kobaltCompilerSeparateProcess + val defaultRepos = xmlFile.defaultRepos?.repo val proxyConfigs = with(xmlFile.proxies?.proxy) { @@ -95,8 +117,32 @@ class KobaltSettings @Inject constructor(val xmlFile: KobaltSettingsXml) { } } - var kobaltCompilerVersion = xmlFile.kobaltCompilerVersion - var kobaltCompilerRepo = xmlFile.kobaltCompilerRepo + val kobaltCompilerVersion : String? + get() { + return if (BUILD_SCRIPT_CONFIG != null && BUILD_SCRIPT_CONFIG?.kobaltCompilerVersion != null) { + BUILD_SCRIPT_CONFIG?.kobaltCompilerVersion + } else { + xmlFile.kobaltCompilerVersion + } + } + + val kobaltCompilerRepo : String? + get() { + return if (BUILD_SCRIPT_CONFIG != null && BUILD_SCRIPT_CONFIG?.kobaltCompilerRepo != null) { + BUILD_SCRIPT_CONFIG?.kobaltCompilerRepo + } else { + xmlFile.kobaltCompilerRepo + } + } + + val kobaltCompilerFlags : String? + get() { + return if (BUILD_SCRIPT_CONFIG != null && BUILD_SCRIPT_CONFIG?.kobaltCompilerFlags != null) { + BUILD_SCRIPT_CONFIG?.kobaltCompilerFlags + } else { + xmlFile.kobaltCompilerFlags + } + } companion object { val SETTINGS_FILE_PATH = KFiles.joinDir(KFiles.HOME_KOBALT_DIR.absolutePath, "settings.xml") @@ -112,7 +158,7 @@ class KobaltSettings @Inject constructor(val xmlFile: KobaltSettingsXml) { return result } } else { - log(2, "Couldn't find ${KobaltSettings.SETTINGS_FILE_PATH}, using default settings") + kobaltLog(2, "Couldn't find ${KobaltSettings.SETTINGS_FILE_PATH}, using default settings") return KobaltSettings(KobaltSettingsXml()) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt index 3f29427a..123e8b76 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinJarFiles.kt @@ -16,6 +16,5 @@ class KotlinJarFiles @Inject constructor(val dependencyManager: DependencyManage } val stdlib: File get() = getKotlinCompilerJar("stdlib") - val runtime: File get() = getKotlinCompilerJar("runtime") val compiler: File get() = getKotlinCompilerJar("compiler-embeddable") } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinTestRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinTestRunner.kt new file mode 100644 index 00000000..24e643d5 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/KotlinTestRunner.kt @@ -0,0 +1,21 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project + +/** + * KotlinTestRunner triggers if it finds a dependency on io.kotlintest but other than that, it just + * uses the regular JUnitRunner. + */ +class KotlinTestRunner : JUnitRunner() { + override val dependencyName = "io.kotlintest" + override val runnerName = "Kotlin Test" + + /** + * KotlinTestRunner runs tests in the init{} initializer, so ignore all the extra + * classes generated by the Kotlin compiler. + */ + override fun filterTestClasses(projet: Project, context: KobaltContext, classes: List) + = classes.filter { !it.contains("$") } +} + diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelLogger.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelLogger.kt new file mode 100644 index 00000000..519a94c9 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelLogger.kt @@ -0,0 +1,130 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.Args +import com.beust.kobalt.KobaltException +import com.beust.kobalt.misc.* +import com.google.inject.Inject +import com.google.inject.Singleton +import java.util.* +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.ConcurrentLinkedQueue + +interface ILogger { + fun log(tag: CharSequence, level: Int, message: CharSequence, newLine: Boolean = true) +} + +/** + * This class manages logs for parallel builds. These logs come from multiple projects interwoven as + * they are being scheduled on different threads. This class maintains a "current" project which has + * its logs always displayed instantaneously while logs from other projects are being stored for later display. + * Once the current project is done, this class will catch up all the finished project logs and then + * pick the next current project to be displayed live. + * + * Yes, this code was pretty painful to write and I'm pretty sure it can be made less ugly. + */ +@Singleton +class ParallelLogger @Inject constructor(val args: Args) : ILogger { + enum class Type { LOG, WARN, ERROR } + + class LogLine(val name: CharSequence? = null, val level: Int, val message: CharSequence, val type: Type, + val newLine: Boolean) + private val logLines = ConcurrentHashMap>() + + private val runningProjects = ConcurrentLinkedQueue() + var startTime: Long? = null + + fun onProjectStarted(name: String) { + if (startTime == null) { + startTime = System.currentTimeMillis() + } + runningProjects.add(name) + logLines[name] = arrayListOf() + if (currentName == null) { + currentName = name + } + } + + val stoppedProjects = ConcurrentHashMap() + + fun onProjectStopped(name: String) { + debug("onProjectStopped($name)") + stoppedProjects[name] = name + + if (name == currentName && runningProjects.any()) { + emptyProjectLog(name) + var nextProject = runningProjects.peek() + while (nextProject != null && stoppedProjects.containsKey(nextProject)) { + val sp = runningProjects.remove() + emptyProjectLog(sp) + nextProject = runningProjects.peek() + } + currentName = nextProject + } else { + debug("Non current project $name stopping, not doing anything") + } + } + + private fun debug(s: CharSequence) { + if (args.log >= 3) { + val time = System.currentTimeMillis() - startTime!! + kobaltLog(1, " ### [$time] $s") + } + } + + val LOCK = Any() + var currentName: String? = null + set(newName) { + field = newName + } + + private fun displayLine(ll: LogLine) { + val time = System.currentTimeMillis() - startTime!! + val m = (if (args.dev) "### [$time] " else "") + ll.message + when(ll.type) { + Type.LOG -> kobaltLog(ll.level, m, ll.newLine) + Type.WARN -> kobaltWarn(m) + Type.ERROR -> kobaltError(m) + } + } + + private fun emptyProjectLog(name: CharSequence?) { + val lines = logLines[name] + if (lines != null && lines.any()) { + debug("emptyProjectLog($name)") + lines.forEach { + displayLine(it) + } + lines.clear() + debug("Done emptyProjectLog($name)") +// logLines.remove(name) + } else if (lines == null) { + throw KobaltException("Didn't call onStartProject() for $name") + } + } + + private fun addLogLine(name: CharSequence, ll: LogLine) { + if (name != currentName) { + val list = logLines[name] ?: arrayListOf() + logLines[name] = list + list.add(ll) + } else { + emptyProjectLog(name) + displayLine(ll) + } + } + + override fun log(tag: CharSequence, level: Int, message: CharSequence, newLine: Boolean) { + if (args.sequential) { + kobaltLog(level, message, newLine) + } else { + addLogLine(tag, LogLine(tag, level, message, Type.LOG, newLine)) + } + } + + fun shutdown() { + runningProjects.forEach { + emptyProjectLog(it) + } + kobaltLog(1, "") + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt index 3a5ae654..d98f0d8a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt @@ -3,13 +3,14 @@ package com.beust.kobalt.internal import com.beust.kobalt.Args import com.beust.kobalt.AsciiArt import com.beust.kobalt.TaskResult -import com.beust.kobalt.api.* -import com.beust.kobalt.misc.Strings -import com.beust.kobalt.misc.kobaltError -import com.beust.kobalt.misc.log +import com.beust.kobalt.api.ITask +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.ProjectBuildStatus +import com.beust.kobalt.misc.kobaltLog import com.google.common.collect.ListMultimap import com.google.common.collect.TreeMultimap -import java.util.* +import java.util.concurrent.Callable /** * Build the projects in parallel. @@ -21,82 +22,93 @@ class ParallelProjectRunner(val tasksByNames: (Project) -> ListMultimap, val reverseDependsOn: TreeMultimap, val runBefore: TreeMultimap, val runAfter: TreeMultimap, - val alwaysRunAfter: TreeMultimap, val args: Args, val pluginInfo: PluginInfo) + val alwaysRunAfter: TreeMultimap, val args: Args, val pluginInfo: PluginInfo, + val logger: ParallelLogger) : BaseProjectRunner() { override fun runProjects(taskInfos: List, projects: List) : TaskManager .RunTargetResult { - var result = TaskResult() - val failedProjects = hashSetOf() - val messages = Collections.synchronizedList(arrayListOf()) + class ProjectTask(val project: Project, val dryRun: Boolean) : Callable> { + override fun toString() = "[ProjectTask " + project.name + "]" + override fun hashCode() = project.hashCode() + override fun equals(other: Any?) : Boolean = + if (other is ProjectTask) other.project.name == project.name + else false - fun runProjectListeners(project: Project, context: KobaltContext, start: Boolean, - status: ProjectBuildStatus = ProjectBuildStatus.SUCCESS) { - context.pluginInfo.buildListeners.forEach { - if (start) it.projectStart(project, context) else it.projectEnd(project, context, status) - } - } - - val context = Kobalt.context!! - projects.forEach { project -> - AsciiArt.logBox("Building ${project.name}") - - // Does the current project depend on any failed projects? - val fp = project.dependsOn.filter { - failedProjects.contains(it.name) - }.map { - it.name - } - - if (fp.size > 0) { - log(2, "Marking project ${project.name} as skipped") - failedProjects.add(project.name) - runProjectListeners(project, context, false, ProjectBuildStatus.SKIPPED) - kobaltError("Not building project ${project.name} since it depends on failed " - + Strings.pluralize(fp.size, "project") - + " " + fp.joinToString(",")) - } else { - runProjectListeners(project, context, true) - - // There can be multiple tasks by the same name (e.g. PackagingPlugin and AndroidPlugin both - // define "install"), so use a multimap + override fun call(): TaskResult2 { + val context = Kobalt.context!! + runBuildListenersForProject(project, context, true) val tasksByNames = tasksByNames(project) - - log(3, "Tasks:") - tasksByNames.keys().forEach { - log(3, " $it: " + tasksByNames.get(it)) - } - val graph = createTaskGraph(project.name, taskInfos, tasksByNames, dependsOn, reverseDependsOn, runBefore, runAfter, alwaysRunAfter, - { task: ITask -> task.name }, + ITask::name, { task: ITask -> task.plugin.accept(project) }) + var lastResult = TaskResult() + logger.onProjectStarted(project.name) + context.logger.log(project.name, 1, AsciiArt.logBox("Building ${project.name}", indent = 5)) + while (graph.freeNodes.any()) { + val toProcess = graph.freeNodes + toProcess.forEach { node -> + val tasks = tasksByNames[node.name] + tasks.forEach { task -> - // - // Now that we have a full graph, run it - // - log(2, "About to run graph:\n ${graph.dump()} ") - - val factory = object : IThreadWorkerFactory { - override fun createWorkers(nodes: Collection) - = nodes.map { TaskWorker(listOf(it), args.dryRun, pluginInfo) } + runBuildListenersForTask(project, context, task.name, start = true) + logger.log(project.name, 1, + AsciiArt.taskColor(AsciiArt.horizontalSingleLine + " ${project.name}:${task.name}")) + val thisResult = if (dryRun) TaskResult2(true, value = task) else task.call() + if (lastResult.success) { + lastResult = thisResult + } + runBuildListenersForTask(project, context, task.name, start = false, + success = thisResult.success, testResult = thisResult.testResult) + } + } + graph.freeNodes.forEach { graph.removeNode(it) } } - val executor = DynamicGraphExecutor(graph, factory, 5) - val thisResult = executor.run() - if (! thisResult.success) { - log(2, "Marking project ${project.name} as failed") - failedProjects.add(project.name) + logger.onProjectStopped(project.name) + runBuildListenersForProject(project, context, false, + if (lastResult.success) ProjectBuildStatus.SUCCESS else ProjectBuildStatus.FAILED) + + return TaskResult2(lastResult.success, errorMessage = lastResult.errorMessage, value = this) + } + + } + + val factory = object : IThreadWorkerFactory { + override fun createWorkers(nodes: Collection): List> { + val result = nodes.map { it -> + object: IWorker { + override val priority: Int get() = 0 + override val name: String get() = it.project.name + override fun call(): TaskResult2 { + val tr = it.call() + return tr + } + + } } + return result + } + } - runProjectListeners(project, context, false, - if (thisResult.success) ProjectBuildStatus.SUCCESS else ProjectBuildStatus.FAILED) - - if (result.success) { - result = thisResult + val projectGraph = DynamicGraph().apply { + projects.forEach { project -> + addNode(ProjectTask(project, args.dryRun)) + project.allProjectDependedOn().forEach { + addEdge(ProjectTask(project, args.dryRun), ProjectTask(it, args.dryRun)) } } } - return TaskManager.RunTargetResult(result, messages) + val executor = DynamicGraphExecutor(projectGraph, factory, 5) + kobaltLog(1, "Parallel build starting") + val taskResult = executor.run() + + logger.shutdown() + + if (! args.sequential) { + executor.dumpHistory() + } + return TaskManager.RunTargetResult(taskResult, emptyList()) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt index 82fd9c48..ec99b723 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/SequentialProjectRunner.kt @@ -3,10 +3,12 @@ package com.beust.kobalt.internal import com.beust.kobalt.Args import com.beust.kobalt.AsciiArt import com.beust.kobalt.TaskResult -import com.beust.kobalt.api.* +import com.beust.kobalt.api.ITask +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.Project +import com.beust.kobalt.api.ProjectBuildStatus import com.beust.kobalt.misc.Strings import com.beust.kobalt.misc.kobaltError -import com.beust.kobalt.misc.log import com.google.common.collect.ListMultimap import com.google.common.collect.TreeMultimap import java.util.* @@ -29,52 +31,44 @@ class SequentialProjectRunner(val tasksByNames: (Project) -> ListMultimap() val messages = Collections.synchronizedList(arrayListOf()) - fun runProjectListeners(project: Project, context: KobaltContext, start: Boolean, - status: ProjectBuildStatus = ProjectBuildStatus.SUCCESS) { - context.pluginInfo.buildListeners.forEach { - if (start) it.projectStart(project, context) else it.projectEnd(project, context, status) - } - } - val context = Kobalt.context!! + projects.forEach { project -> - AsciiArt.logBox("Building ${project.name}") + val projectName = project.name + fun klog(level: Int, message: String) = context.logger.log(projectName, level, message) + klog(1, AsciiArt.logBox("Building $projectName", indent = 5)) // Does the current project depend on any failed projects? - val fp = project.dependsOn.filter { - failedProjects.contains(it.name) - }.map { - it.name - } + val fp = project.allProjectDependedOn().filter { failedProjects.contains(it.name) }.map(Project::name) if (fp.size > 0) { - log(2, "Marking project ${project.name} as skipped") + klog(2, "Marking project $projectName as skipped") failedProjects.add(project.name) - runProjectListeners(project, context, false, ProjectBuildStatus.SKIPPED) + runBuildListenersForProject(project, context, false, ProjectBuildStatus.SKIPPED) kobaltError("Not building project ${project.name} since it depends on failed " + Strings.pluralize(fp.size, "project") + " " + fp.joinToString(",")) } else { - runProjectListeners(project, context, true) + runBuildListenersForProject(project, context, true) // There can be multiple tasks by the same name (e.g. PackagingPlugin and AndroidPlugin both // define "install"), so use a multimap val tasksByNames = tasksByNames(project) - log(3, "Tasks:") + klog(3, "Tasks:") tasksByNames.keys().forEach { - log(3, " $it: " + tasksByNames.get(it)) + klog(3, " $it: " + tasksByNames.get(it)) } val graph = createTaskGraph(project.name, taskInfos, tasksByNames, dependsOn, reverseDependsOn, runBefore, runAfter, alwaysRunAfter, - { task: ITask -> task.name }, + ITask::name, { task: ITask -> task.plugin.accept(project) }) // // Now that we have a full graph, run it // - log(2, "About to run graph:\n ${graph.dump()} ") + klog(2, "About to run graph:\n ${graph.dump()} ") val factory = object : IThreadWorkerFactory { override fun createWorkers(nodes: Collection) @@ -84,11 +78,11 @@ class SequentialProjectRunner(val tasksByNames: (Project) -> ListMultimap() private val reverseDependsOn = TreeMultimap.create() private val runBefore = TreeMultimap.create() private val runAfter = TreeMultimap.create() private val alwaysRunAfter = TreeMultimap.create() - companion object { - val LOG_LEVEL = 3 - } - /** * Dependency: task2 depends on task 1. */ @@ -46,7 +42,7 @@ class TaskManager @Inject constructor(val args: Args, /** * Ordering: task2 runs after task 1. */ - fun runAfter(task1: String, task2: String) = runAfter.put(task2, task1) + fun runAfter(task1: String, task2: String) = runAfter.put(task1, task2) /** * Wrapper task: task2 runs after task 1. @@ -84,6 +80,9 @@ class TaskManager @Inject constructor(val args: Args, } } +// @Inject +// lateinit var pluginInfo: PluginInfo + fun runTargets(passedTaskNames: List, allProjects: List): RunTargetResult { // Check whether tasks passed at command line exist passedTaskNames.forEach { @@ -91,6 +90,7 @@ class TaskManager @Inject constructor(val args: Args, throw KobaltException("Unknown task: $it") } + val pluginInfo = Kobalt.INJECTOR.getInstance(PluginInfo::class.java) var taskInfos = calculateDependentTaskNames(passedTaskNames, allProjects) // Remove non existing tasks (e.g. dynamic task defined for a single project) @@ -98,10 +98,13 @@ class TaskManager @Inject constructor(val args: Args, val projectsToRun = findProjectsToRun(taskInfos, allProjects) val projectRunner = - if (args.parallel) ParallelProjectRunner({ p -> tasksByNames(p) }, dependsOn, - reverseDependsOn, runBefore, runAfter, alwaysRunAfter, args, pluginInfo) - else SequentialProjectRunner({ p -> tasksByNames(p) }, dependsOn, - reverseDependsOn, runBefore, runAfter, alwaysRunAfter, args, pluginInfo) + if (args.sequential) { + SequentialProjectRunner({ p -> tasksByNames(p) }, dependsOn, + reverseDependsOn, runBefore, runAfter, alwaysRunAfter, args, pluginInfo) + } else { + ParallelProjectRunner({ p -> tasksByNames(p) }, dependsOn, + reverseDependsOn, runBefore, runAfter, alwaysRunAfter, args, pluginInfo, kobaltLog) + } return projectRunner.runProjects(taskInfos, projectsToRun) } @@ -146,7 +149,7 @@ class TaskManager @Inject constructor(val args: Args, val topological = Topological().apply { projects.forEach { project -> addNode(project) - project.dependsOn.forEach { + project.allProjectDependedOn().forEach { addEdge(project, it) } } @@ -161,7 +164,7 @@ class TaskManager @Inject constructor(val args: Args, return result } else { val rootProject = projects.find { it.name == ti.project }!! - val allProjects = DynamicGraph.transitiveClosure(rootProject, { p -> p.dependsOn }) + val allProjects = DynamicGraph.transitiveClosure(rootProject, Project::allProjectDependedOn) val sortedProjects = sortProjectsTopologically(allProjects) val sortedMaps = sortedProjects.map { TaskInfo(it.name, "compile")} val result = sortedMaps.subList(0, sortedMaps.size - 1) + listOf(ti) @@ -193,6 +196,7 @@ class TaskManager @Inject constructor(val args: Args, = TaskAnnotation(method, plugin, ta.name, ta.description, ta.group, ta.dependsOn, ta.reverseDependsOn, ta.runBefore, ta.runAfter, ta.alwaysRunAfter, { project -> + Kobalt.context?.variant = Variant() method.invoke(plugin, project) as TaskResult }) @@ -240,7 +244,7 @@ class TaskManager @Inject constructor(val args: Args, val method = staticTask.method val methodName = method.declaringClass.toString() + "." + method.name - log(3, " Found task:${staticTask.name} method: $methodName") + kobaltLog(3, " Found task:${staticTask.name} method: $methodName") val plugin = staticTask.plugin projects.filter { plugin.accept(it) }.forEach { project -> @@ -268,7 +272,8 @@ class TaskManager @Inject constructor(val args: Args, object : BasePluginTask(plugin, name, description, group, project) { override fun call(): TaskResult2 { val taskResult = task(project) - return TaskResult2(taskResult.success, taskResult.errorMessage, this) + return TaskResult2(taskResult.success, errorMessage = taskResult.errorMessage, value = this, + testResult = taskResult.testResult) } }) dependsOn.forEach { dependsOn(it, name) } @@ -300,17 +305,10 @@ class TaskManager @Inject constructor(val args: Args, class TaskWorker(val tasks: List, val dryRun: Boolean, val pluginInfo: PluginInfo) : IWorker { - private fun runBuildListeners(project: Project, context: KobaltContext, taskName: String, start: Boolean, - success: Boolean = false) { - context.pluginInfo.buildListeners.forEach { - if (start) it.taskStart(project, context, taskName) else it.taskEnd(project, context, taskName, success) - } - } - override fun call() : TaskResult2 { if (tasks.size > 0) { tasks[0].let { - log(1, AsciiArt.taskColor(AsciiArt.horizontalSingleLine + " ${it.project.name}:${it.name}")) + kobaltLog(1, AsciiArt.taskColor(AsciiArt.horizontalSingleLine + " ${it.project.name}:${it.name}")) } } var success = true @@ -318,16 +316,19 @@ class TaskWorker(val tasks: List, val dryRun: Boolean, val pluginInfo: Pl val context = Kobalt.context!! tasks.forEach { val name = it.project.name + ":" + it.name - runBuildListeners(it.project, context, name, start = true) + BaseProjectRunner.runBuildListenersForTask(it.project, context, name, start = true) val tr = if (dryRun) TaskResult() else it.call() - runBuildListeners(it.project, context, name, start = false, success = tr.success) + BaseProjectRunner.runBuildListenersForTask(it.project, context, name, start = false, success = tr.success) success = success and tr.success - if (tr.errorMessage != null) errorMessages.add(tr.errorMessage) + tr.errorMessage?.let { + errorMessages.add(it) + } } - return TaskResult2(success, errorMessages.joinToString("\n"), tasks[0]) + return TaskResult2(success, errorMessage = errorMessages.joinToString("\n"), value = tasks[0]) } // override val timeOut : Long = 10000 override val priority: Int = 0 + override val name: String get() = "[Taskworker " + tasks.map(ITask::toString).joinToString(",") + "]" } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt index 008f2291..f4ee96f8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TestNgRunner.kt @@ -1,28 +1,53 @@ package com.beust.kobalt.internal +import com.beust.kobalt.AsciiArt import com.beust.kobalt.TestConfig +import com.beust.kobalt.TestResult import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project -import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.warn +import com.beust.kobalt.maven.aether.AetherDependency +import com.beust.kobalt.misc.* +import org.testng.remote.RemoteArgs +import org.testng.remote.strprotocol.JsonMessageSender +import org.testng.remote.strprotocol.MessageHelper +import org.testng.remote.strprotocol.MessageHub +import org.testng.remote.strprotocol.TestResultMessage +import org.w3c.dom.Attr +import org.w3c.dom.NodeList +import org.xml.sax.InputSource import java.io.File +import java.io.FileReader +import java.io.IOException +import javax.xml.parsers.DocumentBuilderFactory +import javax.xml.xpath.XPathConstants +import javax.xml.xpath.XPathFactory class TestNgRunner : GenericTestRunner() { override val mainClass = "org.testng.TestNG" - override val dependencyName = "testng" - override val annotationPackage = "org.testng" + override val runnerName = "TestNG" - fun defaultOutput(project: Project) = KFiles.joinDir(project.buildDirectory, "test-output") + private fun defaultOutputWithoutProjectDir(project: Project) + = KFiles.joinDir(project.buildDirectory, "test-output") + private fun defaultOutput(project: Project) + = KFiles.joinDir(project.directory, project.buildDirectory, "test-output") override fun args(project: Project, context: KobaltContext, classpath: List, testConfig: TestConfig) = arrayListOf().apply { - var addOutput = true - testConfig.testArgs.forEach { arg -> - if (arg == "-d") addOutput = false + + if (KobaltLogger.isQuiet) { + add("-log") + add("0") + } + + if (testConfig.testArgs.none { it == "-d" }) { + add("-d") + // Don't include the project directory here since the generic runner will cd to that directory before + // running the tests + add(defaultOutputWithoutProjectDir(project)) } if (testConfig.testArgs.size == 0) { @@ -32,27 +57,212 @@ class TestNgRunner : GenericTestRunner() { add(testngXml.absolutePath) } else { val testClasses = findTestClasses(project, context, testConfig) - if (testClasses.size > 0) { - if (addOutput) { - add("-d") - add(defaultOutput(project)) - } + if (testClasses.isNotEmpty()) { addAll(testConfig.testArgs) add("-testclass") add(testClasses.joinToString(",")) } else { - if (! testConfig.isDefault) warn("Couldn't find any test classes for ${project.name}") + if (!testConfig.isDefault) warn("Couldn't find any test classes for ${project.name}") // else do nothing: since the user didn't specify an explicit test{} directive, not finding // any test sources is not a problem } } } else { - if (addOutput) { - add("-d") - add(defaultOutput(project)) - } addAll(testConfig.testArgs) } } + + /** + * Extract test results from testng-results.xml and initialize shortMessage. + */ + override fun onFinish(project: Project) { + File(defaultOutput(project), "testng-results.xml").let { file -> + val ins = InputSource(FileReader(file)) + val doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(ins) + + val root = doc.documentElement + var failed = 0 + var skipped = 0 + var passed = 0 + val xp = XPathFactory.newInstance().newXPath() + val testMethods = xp.compile("/testng-results/suite/test/class/test-method[@status='FAIL']") + .evaluate(doc, XPathConstants.NODESET) + as NodeList + val failedMethods = arrayListOf() + repeat(testMethods.length) { + val tm = testMethods.item(it) + failedMethods.add(tm.attributes.getNamedItem("signature").textContent) + } + repeat(root.attributes.length) { + val attribute = root.attributes.item(it) + if (attribute is Attr) when (attribute.name) { + "failed" -> failed = Integer.parseInt(attribute.value) + "skipped" -> skipped = Integer.parseInt(attribute.value) + "passed" -> passed = Integer.parseInt(attribute.value) + } + } + + if (failed == 0) { + shortMessage = "$passed tests" + } else if (failed > 0) { + shortMessage = "$failed failed" + (if (skipped > 0) ", $skipped skipped" else "") + " tests" + longMessage = "Failed tests:\n " + failedMethods.joinToString("\n ") + } + } + } + + val VERSION_6_10 = StringVersion("6.10") + + fun _runTests(project: Project, context: KobaltContext, classpath: List, +// override fun runTests(project: Project, context: KobaltContext, classpath: List, + configName: String): TestResult { + + val testConfig = project.testConfigs.firstOrNull { it.name == configName } + + if (testConfig != null) { + context.logger.log(project.name, 1, "Running enhanced TestNG runner") + + val testngDependency = (project.testDependencies.filter { it.id.contains("testng") } + .firstOrNull() as AetherDependency).version + val versions = findRemoteRunnerVersion(testngDependency) + val useOldRunner = System.getProperty("testng.oldRunner") != null + val result = + if (versions != null && ! useOldRunner) { + context.logger.log(project.name, 1, "Modern TestNG, displaying colors") + displayPrettyColors(project, context, classpath, testConfig, versions) + } else { + context.logger.log(project.name, 1, "Older TestNG ($testngDependency), using the old runner") + super.runTests(project, context, classpath, configName) + } + return result + } else { + return TestResult(true) + } + } + + private fun findRemoteRunnerVersion(testngVersion: String) : Pair? { + val tng = StringVersion(testngVersion) + val result = + if (tng >= VERSION_6_10) Pair(testngVersion, "testng-remote6_10") + else if (tng >= StringVersion("6.9.10")) Pair("6.9.10", "testng-remote6_9_10") + else if (tng >= StringVersion("6.9.7")) Pair("6.9.7", "testng-remote6_9_7") + else if (tng >= StringVersion("6.5.1")) Pair("6.5.1", "testng-remote6_5_0") + else if (tng >= StringVersion("6.0")) Pair("6.0", "testng-remote6_0") + else null + return result + } + + private fun displayPrettyColors(project: Project, context: KobaltContext, + classpath: List, testConfig: TestConfig, versions: Pair) + : TestResult { + val port = 2345 +// launchRemoteServer(project, context, classpath, testConfig, versions, port) + + val mh = MessageHub(JsonMessageSender("localhost", port, true)) + mh.setDebug(true) + mh.initReceiver() + val passed = arrayListOf() + + data class FailedTest(val method: String, val cls: String, val stackTrace: String) + + val failed = arrayListOf() + val skipped = arrayListOf() + + fun d(n: Int, color: String) + = AsciiArt.wrap(String.format("%4d", n), color) + + fun red(s: String) = AsciiArt.wrap(s, AsciiArt.RED) + fun green(s: String) = AsciiArt.wrap(s, AsciiArt.GREEN) + fun yellow(s: String) = AsciiArt.wrap(s, AsciiArt.YELLOW) + + try { + var message = mh.receiveMessage() + kobaltLog(1, "") + kobaltLog(1, green("PASSED") + " | " + red("FAILED") + " | " + yellow("SKIPPED")) + while (message != null) { + message = mh.receiveMessage() + if (message is TestResultMessage) { + when (message.result) { + MessageHelper.PASSED_TEST -> passed.add(message.name) + MessageHelper.FAILED_TEST -> failed.add(FailedTest(message.testClass, + message.method, message.stackTrace)) + MessageHelper.SKIPPED_TEST -> skipped.add(message.name) + } + } + if (!KobaltLogger.isQuiet) { + print("\r " + d(passed.size, AsciiArt.GREEN) + + " | " + d(failed.size, AsciiArt.RED) + + " | " + d(skipped.size, AsciiArt.YELLOW)) + } + } + } catch(ex: IOException) { + kobaltLog(1, "Exception: ${ex.message}") + } + kobaltLog(1, "\nPassed: " + passed.size + ", Failed: " + failed.size + ", Skipped: " + skipped.size) + failed.forEach { + val top = it.stackTrace.substring(0, it.stackTrace.indexOf("\n")) + kobaltLog(1, " " + it.cls + "." + it.method + "\n " + top) + } + return TestResult(failed.isEmpty() && skipped.isEmpty()) + } + + fun launchRemoteServer(project: Project, context: KobaltContext, classpath: List, + testConfig: TestConfig, versions: Pair, port: Int) { + val testngVersion = versions.first + val remoteRunnerVersion = versions.second + val dep = with(context.dependencyManager) { + val jf = create("org.testng.testng-remote:testng-remote:1.3.0") + val tr = create("org.testng.testng-remote:$remoteRunnerVersion:1.3.0") + val testng = create("org.testng:testng:6.11") + transitiveClosure(kotlin.collections.listOf(jf, tr /*, testng */)) + } + + val cp = (classpath + dep).distinct().map { it.jarFile.get() } + .joinToString(File.pathSeparator) + val calculatedArgs = args(project, context, classpath, testConfig) + + val jvmArgs = arrayListOf("-classpath", cp) + if (testConfig.jvmArgs.any()) { + jvmArgs.addAll(testConfig.jvmArgs) + } + val remoteArgs = listOf( + "org.testng.remote.RemoteTestNG", + "-serport", port.toString(), + "-version", testngVersion, + "-dontexit", + RemoteArgs.PROTOCOL, + "json") + + val passedArgs = jvmArgs + remoteArgs + calculatedArgs + + Thread { + runCommand { + command = "java" + directory = File(project.directory) + args = passedArgs + } + }.start() + +// Thread { +// val args2 = arrayOf("-serport", port.toString(), "-dontexit", RemoteArgs.PROTOCOL, "json", +// "-version", "6.10", +// "src/test/resources/testng.xml") +// RemoteTestNG.main(args2) +// }.start() + } +} + +fun main(args: Array) { + fun d(n: Int, color: String) + = AsciiArt.wrap(String.format("%4d", n), color) + + if (!KobaltLogger.isQuiet) { + println("PASSED | FAILED | SKIPPED") + repeat(20) { i -> + print("\r " + d(i, AsciiArt.GREEN) + " | " + d(i * 2, AsciiArt.RED) + " | " + d(i, AsciiArt.YELLOW)) + Thread.sleep(500) + } + println("") + } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt index b860f446..a2eb91e9 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildFile.kt @@ -1,10 +1,8 @@ package com.beust.kobalt.internal.build -import com.beust.kobalt.misc.KFiles import java.io.File import java.nio.file.Files import java.nio.file.Path -import java.nio.file.attribute.BasicFileAttributes /** * Sometimes, build files are moved to temporary files, so we give them a specific name for clarity. * @param path is the path where that file was moved, @param realPath is where the actual file is. @@ -12,23 +10,5 @@ import java.nio.file.attribute.BasicFileAttributes class BuildFile(val path: Path, val name: String, val realPath: Path = path) { fun exists() : Boolean = Files.exists(path) - val lastModified : Long - get() = Files.readAttributes(realPath, BasicFileAttributes::class.java).lastModifiedTime().toMillis() - val directory : File get() = path.toFile().parentFile - - /** - * @return the .kobalt directory where this build file will be compiled. - */ - val dotKobaltDir: File get() = File(directory.parentFile.parentFile, KFiles.KOBALT_DOT_DIR).apply { - mkdirs() - } - - /** - * @return the absolute directory of this project's location, assuming the build file is in - * $project/kobalt/src/Build.kt. - */ - val absoluteDir : File? get() { - return path.parent?.parent?.parent?.toFile() - } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildSources.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildSources.kt new file mode 100644 index 00000000..78425f18 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/build/BuildSources.kt @@ -0,0 +1,61 @@ +package com.beust.kobalt.internal.build + +import com.beust.kobalt.homeDir +import java.io.File +import java.nio.file.* +import java.nio.file.attribute.BasicFileAttributes + +/** + * The abstraction to represent a directory that contains source files. @param{root} is typically + * the root of the project and build files are searched under root/kobalt/src/ *kt. + */ +interface IBuildSources { + fun findSourceFiles() : List + val root: File + fun exists(): Boolean +} + +class SingleFileBuildSources(val file: File) : IBuildSources { + override fun exists() = file.exists() + override fun findSourceFiles() = listOf(file) + override val root: File = file.parentFile.parentFile.parentFile + override fun toString() : String = file.path +} + +class BuildSources(val file: File = File("")) : IBuildSources { + + override val root = file + + override fun findSourceFiles() : List { + return findBuildFiles(listOf(file)) + } + + override fun exists() = findSourceFiles().isNotEmpty() + + override fun toString() = "{BuildSources " + findSourceFiles().joinToString(", ") + "}" + + fun findBuildFiles(roots: List) : List { + val result = arrayListOf() + roots.forEach { file -> + Files.walkFileTree(Paths.get(file.path), object : SimpleFileVisitor() { + override fun preVisitDirectory(dir: Path?, attrs: BasicFileAttributes?): FileVisitResult { + if (dir != null) { + val path = dir.toFile() + if (path.name == "src" && path.parentFile.name == "kobalt") { + val sources = path.listFiles().filter { it.name.endsWith(".kt") } + result.addAll(sources) + } + } + + return FileVisitResult.CONTINUE + } + }) + } + return result + } +} + +fun main(args: Array) { + val sources = BuildSources(File(homeDir("kotlin/kobalt"))).findSourceFiles() + println("sources: " + sources) +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/GetDependenciesCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/GetDependenciesCommand.kt deleted file mode 100644 index 7422c493..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/remote/GetDependenciesCommand.kt +++ /dev/null @@ -1,14 +0,0 @@ -package com.beust.kobalt.internal.remote - -import com.beust.kobalt.Constants -import java.io.PrintWriter -import java.net.Socket - -fun main(argv: Array) { - Socket("localhost", 1234).use { socket -> - (PrintWriter(socket.outputStream, true)).use { out -> - out.println("""{ "name" : "getDependencies", "buildFile": - "/Users/beust/kotlin/kobalt/kobalt/src/${Constants.BUILD_FILE_NAME}"}""") - } - } -} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt index 10269d52..6d5fa9d2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/kotlin/ParentLastClassLoader.kt @@ -9,7 +9,7 @@ import java.net.URLClassLoader * Will probably be made obsolete by making the wrapper a standalone module instead of * being inside Kobalt itself. */ -public class ParentLastClassLoader(val classpath: List) +class ParentLastClassLoader(val classpath: List) : ClassLoader(Thread.currentThread().contextClassLoader) { private val childClassLoader: ChildURLClassLoader @@ -22,7 +22,7 @@ public class ParentLastClassLoader(val classpath: List) * This class makes it possible to call findClass on a classloader */ private class FindClassClassLoader(parent: ClassLoader) : ClassLoader(parent) { - override public fun findClass(name: String) = super.findClass(name) + override fun findClass(name: String) = super.findClass(name) } /** @@ -43,7 +43,7 @@ public class ParentLastClassLoader(val classpath: List) } } - override public @Synchronized fun loadClass(name: String, resolve: Boolean) : Class<*> { + override @Synchronized fun loadClass(name: String, resolve: Boolean) : Class<*> { try { // first we try to find a class inside the child classloader return childClassLoader.findClass(name) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt index f64c32b5..1e24cd8e 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/CompletedFuture.kt @@ -3,7 +3,7 @@ package com.beust.kobalt.maven import java.util.concurrent.Future import java.util.concurrent.TimeUnit -public class CompletedFuture(val value: T) : Future { +class CompletedFuture(val value: T) : Future { override fun cancel(mayInterruptIfRunning: Boolean) = true override fun get(): T = value override fun get(timeout: Long, unit: TimeUnit): T = value diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt index 236340c4..ff2d9fd9 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager.kt @@ -2,30 +2,33 @@ package com.beust.kobalt.maven import com.beust.kobalt.KobaltException import com.beust.kobalt.api.* -import com.beust.kobalt.maven.aether.KobaltAether +import com.beust.kobalt.maven.aether.Filters +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.maven.aether.Scope import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors import com.google.common.collect.ArrayListMultimap +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.util.filter.OrDependencyFilter import java.io.File import java.util.* import javax.inject.Inject import javax.inject.Singleton @Singleton -class DependencyManager @Inject constructor(val executors: KobaltExecutors, val aether: KobaltAether) - : IDependencyManager { +class DependencyManager @Inject constructor(val executors: KobaltExecutors, + val resolver: KobaltMavenResolver) : IDependencyManager { companion object { - fun create(id: String, projectDirectory: String? = null) = - Kobalt.INJECTOR.getInstance(DependencyManager::class.java).create(id, projectDirectory) + fun create(id: String, optional: Boolean = false, projectDirectory: String? = null) = + Kobalt.INJECTOR.getInstance(DependencyManager::class.java).create(id, optional, projectDirectory) } /** * Parse the id and return the correct IClasspathDependency */ - override fun create(id: String, projectDirectory: String?) : IClasspathDependency { + override fun create(id: String, optional: Boolean, projectDirectory: String?) : IClasspathDependency { if (id.startsWith(FileDependency.PREFIX_FILE)) { val path = if (projectDirectory != null) { val idPath = id.substring(FileDependency.PREFIX_FILE.length) @@ -50,14 +53,14 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val } else { // Convert to a Kobalt id first (so that if it doesn't have a version, it gets translated to // an Aether ranged id "[0,)") - return createMaven(MavenId.create(id).toId) + return createMaven(MavenId.create(id).toId, optional) } } /** * Create an IClasspathDependency from a Maven id. */ - override fun createMaven(id: String) : IClasspathDependency = aether.create(id) + override fun createMaven(id: String, optional: Boolean) : IClasspathDependency = resolver.create(id, optional) /** * Create an IClasspathDependency from a path. @@ -67,12 +70,14 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val /** * @return the source dependencies for this project, including the contributors. */ - override fun dependencies(project: Project, context: KobaltContext) = dependencies(project, context, false) + override fun dependencies(project: Project, context: KobaltContext, scopes: List) + = privateDependencies(project, context, listOf(Scope.COMPILE)) /** * @return the test dependencies for this project, including the contributors. */ - override fun testDependencies(project: Project, context: KobaltContext) = dependencies(project, context, true) + override fun testDependencies(project: Project, context: KobaltContext) + = privateDependencies(project, context, listOf(Scope.COMPILE, Scope.TEST)) /** * Transitive dependencies for the compilation of this project. @@ -82,12 +87,15 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val // project.compileDependencies + project.compileRuntimeDependencies) /** - * @return the classpath for this project, including the IClasspathContributors. - * allDependencies is typically either compileDependencies or testDependencies. If no dependencies + * @return the classpath for this project, including the IClasspathContributors. Excluded dependencies + * are removed from the result. + * + * @param{allDependencies} is typically either compileDependencies or testDependencies. If no dependencies * are passed, they are calculated from the scope filters. */ override fun calculateDependencies(project: Project?, context: KobaltContext, - scopeFilters: Collection, + dependencyFilter: DependencyFilter, + scopes: List, vararg passedDependencies: List): List { val result = arrayListOf() @@ -95,9 +103,13 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val * Extract the correct dependencies from the project based on the scope filters. */ fun filtersToDependencies(project: Project, scopes: Collection): List { - return arrayListOf().apply { + val result = arrayListOf().apply { if (scopes.contains(Scope.COMPILE)) { addAll(project.compileDependencies) + addAll(project.compileProvidedDependencies) + } + if (scopes.contains(Scope.COMPILEONLY)) { + addAll(project.compileOnlyDependencies) } if (scopes.contains(Scope.RUNTIME)) { addAll(project.compileRuntimeDependencies) @@ -106,22 +118,50 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val addAll(project.testDependencies) } } + return result.filter { ! it.optional } } val allDependencies : Array> = if (project == null || passedDependencies.any()) passedDependencies - else arrayOf(filtersToDependencies(project, scopeFilters)) + else arrayOf(filtersToDependencies(project, scopes)) + + // Make sure that classes/ and test-classes/ are always at the top of this classpath, + // so that older versions of that project on the classpath don't shadow them + if (project != null && scopes.contains(Scope.TEST)) { + result.add(FileDependency(KFiles.makeOutputDir(project).path)) + result.add(FileDependency(KFiles.makeOutputTestDir(project).path)) + } allDependencies.forEach { dependencies -> - result.addAll(transitiveClosure(dependencies, scopeFilters, project?.name)) + result.addAll(transitiveClosure(dependencies, dependencyFilter, project?.name)) } result.addAll(runClasspathContributors(project, context)) - result.addAll(dependentProjectDependencies(project, context, scopeFilters)) + result.addAll(dependentProjectDependencies(project, context, dependencyFilter, scopes)) + + /** + * Naïve implementation: just exclude all dependencies that start with one of the excluded dependencies. + * Should probably make exclusion more generic (full on string) or allow exclusion to be specified + * formally by groupId or artifactId. + */ + fun isDependencyExcluded(dep: IClasspathDependency, excluded: List): Boolean { + excluded.any { excluded -> dep.id == excluded.id }.let { result -> + if (result) { + context.logger.log(project?.name ?: "", 2, " Excluding dependency $dep") + } + return result + } + } // Dependencies get reordered by transitiveClosure() but since we just added a bunch of new ones, // we need to reorder them again in case we're adding dependencies that are already present // but with a different version - val reordered = reorderDependencies(result) + val shortResult = + if (project != null) { + result.filter { ! isDependencyExcluded(it, project.excludedDependencies) } + } else { + result + }.toHashSet() + val reordered = reorderDependencies(shortResult) return reordered } @@ -139,14 +179,14 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val * TODO: This should be private, everyone should be calling calculateDependencies(). */ fun transitiveClosure(dependencies : List, - scopeFilter: Collection = emptyList(), + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, requiredBy: String? = null): List { val result = arrayListOf() - dependencies.forEach { - result.add(it) - if (it.isMaven) { - val resolved = aether.resolveAll(it.id, null, scopeFilter).map { it.toString() } - result.addAll(resolved.map { create(it) }) + dependencies.forEach { dependency -> + result.add(dependency) + if (dependency.isMaven) { + val resolved = resolver.resolveToIds(dependency.id, null, filter).map { create(it) } + result.addAll(resolved) } } val reordered = reorderDependencies(result) @@ -178,7 +218,7 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val * their own dependencies */ private fun dependentProjectDependencies(project: Project?, context: KobaltContext, - scopeFilters: Collection): List { + dependencyFilter: DependencyFilter, scopes: List): List { if (project == null) { return emptyList() } else { @@ -192,36 +232,57 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, val } } + val isTest = scopes.contains(Scope.TEST) + project.dependsOn.forEach { p -> maybeAddClassDir(KFiles.joinDir(p.directory, p.classesDir(context))) - maybeAddClassDir(KFiles.makeOutputTestDir(project).path) - val otherDependencies = calculateDependencies(p, context, scopeFilters) + if (isTest) maybeAddClassDir(KFiles.makeOutputTestDir(project).path) + val otherDependencies = calculateDependencies(p, context, dependencyFilter, scopes) result.addAll(otherDependencies) + } + if (isTest) { + project.testsDependOn.forEach { p -> + val otherDependencies = calculateDependencies(p, context, dependencyFilter, scopes) + result.addAll(otherDependencies) + } } return result } } - private fun dependencies(project: Project, context: KobaltContext, isTest: Boolean) + private fun privateDependencies(project: Project, context: KobaltContext, passedScopes: List) : List { + val isTest = passedScopes.contains(Scope.TEST) val transitive = hashSetOf() with(project) { - val scopeFilters = arrayListOf(Scope.COMPILE) + val scopeFilters : ArrayList = arrayListOf(Scope.COMPILE) context.variant.let { variant -> - val deps = arrayListOf(compileDependencies, compileProvidedDependencies, - variant.buildType.compileDependencies, - variant.buildType.compileProvidedDependencies, - variant.productFlavor.compileDependencies, - variant.productFlavor.compileProvidedDependencies - ) + val deps: ArrayList> = + if (passedScopes.contains(Scope.COMPILE)) { + arrayListOf(compileDependencies, compileProvidedDependencies, + variant.buildType.compileDependencies, + variant.buildType.compileProvidedDependencies, + variant.productFlavor.compileDependencies, + variant.productFlavor.compileProvidedDependencies) + } else if (passedScopes.contains(Scope.RUNTIME)) { + arrayListOf(compileRuntimeDependencies) + } else { + arrayListOf(arrayListOf()) + } + val runtimeDeps = arrayListOf(compileRuntimeDependencies) if (isTest) { deps.add(testDependencies) deps.add(testProvidedDependencies) scopeFilters.add(Scope.TEST) } - deps.filter { it.any() }.forEach { - transitive.addAll(calculateDependencies(project, context, scopeFilters, it)) + val filter = + if (isTest) OrDependencyFilter(Filters.COMPILE_FILTER, Filters.TEST_FILTER) + else Filters.COMPILE_FILTER + runtimeDeps.filter { it.any() }.forEach { + transitive.addAll(calculateDependencies(project, context, filter, + passedScopes, // scopes = Scope.toScopes(isTest), + passedDependencies = it)) } } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager2.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager2.kt deleted file mode 100644 index 0972dac4..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/DependencyManager2.kt +++ /dev/null @@ -1,181 +0,0 @@ -package com.beust.kobalt.maven - -import com.beust.kobalt.KobaltException -import com.beust.kobalt.api.* -import com.beust.kobalt.internal.DynamicGraph -import com.beust.kobalt.maven.aether.KobaltAether -import com.beust.kobalt.maven.aether.Scope -import com.beust.kobalt.maven.dependency.FileDependency -import com.beust.kobalt.misc.KFiles -import com.google.common.collect.ArrayListMultimap -import com.google.inject.Inject -import java.io.File -import java.util.* - -class DependencyManager2 @Inject constructor(val aether: KobaltAether) { - /** - * Create an IClasspathDependency from a Maven id. - */ - fun createMaven(id: String) : IClasspathDependency = aether.create(id) - - /** - * Create an IClasspathDependency from a path. - */ - fun createFile(path: String) : IClasspathDependency = FileDependency(path) - - /** - * Parse the id and return the correct IClasspathDependency - */ - fun create(id: String, projectDirectory: String?) : IClasspathDependency { - if (id.startsWith(FileDependency.PREFIX_FILE)) { - val path = if (projectDirectory != null) { - val idPath = id.substring(FileDependency.PREFIX_FILE.length) - if (! File(idPath).isAbsolute) { - // If the project directory is relative, we might not be in the correct directory to locate - // that file, so we'll use the absolute directory deduced from the build file path. Pick - // the first one that produces an actual file - val result = listOf(File(projectDirectory), Kobalt.context?.internalContext?.absoluteDir).map { - File(it, idPath) - }.firstOrNull { - it.exists() - } - result ?: throw KobaltException("Couldn't find $id") - - } else { - File(idPath) - } - } else { - File(id.substring(FileDependency.PREFIX_FILE.length)) - } - return createFile(path.path) - } else { - // Convert to a Kobalt id first (so that if it doesn't have a version, it gets translated to - // an Aether ranged id "[0,)") - return createMaven(MavenId.create(id).toId) - } - } - - /** - * Resolve the dependencies for the give project based on the scope filters. - */ - fun resolve(project: Project, context: KobaltContext, isTest: Boolean, - passedScopeFilters : List = emptyList(), - passedIds: List = emptyList()): List { - val result = hashSetOf() - val nonMavenDependencies = hashSetOf() - - val scopeFilters = - if (passedScopeFilters.isEmpty()) - if (isTest) listOf(Scope.TEST) - else listOf(Scope.COMPILE) - else passedScopeFilters - - val toDependencies = Scope.toDependencyLambda(scopeFilters) - - // Make sure that classes/ and test-classes/ are always at the top of this classpath, - // so that older versions of that project on the classpath don't shadow them - if (isTest) { - result.add(FileDependency(KFiles.makeOutputDir(project).path)) - result.add(FileDependency(KFiles.makeOutputTestDir(project).path)) - } - - // Passed and direct ids - val ids = hashSetOf().apply { - addAll(passedIds) - addAll(toDependencies(project)) - } - - // Contributed id's - val contributedIds = runClasspathContributors(project, context) - contributedIds.forEach { - if (it.isMaven) ids.add(it) - else nonMavenDependencies.add(it) - } - - // Dependent project id's - val dependentIds = dependentProjectDependencies(project, context, toDependencies) - dependentIds.forEach { - if (it.isMaven) ids.add(it) - else nonMavenDependencies.add(it) - } - - // - // Now we have all the id's, resolve them - // - var i = 0 - ids.forEach { - val resolved = aether.resolveAll(it.id, filterScopes = scopeFilters) - .map { create(it.toString(), project.directory) } - i++ - result.addAll(resolved) - } - - result.addAll(nonMavenDependencies) - - return reorderDependencies(result) - } - - /** - * Reorder dependencies so that if an artifact appears several times, only the one with the higest version - * is included. - */ - private fun reorderDependencies(dependencies: Collection): List { - val result = arrayListOf() - val map : ArrayListMultimap = ArrayListMultimap.create() - // The multilist maps each artifact to a list of all the versions found - // (e.g. {org.testng:testng -> (6.9.5, 6.9.4, 6.1.1)}), then we return just the first one - dependencies.forEach { - map.put(it.shortId, it) - } - for (k in map.keySet()) { - val l = map.get(k) - Collections.sort(l, Collections.reverseOrder()) - result.add(l[0]) - } - return result - } - - private fun runClasspathContributors(project: Project?, context: KobaltContext) : - Set { - val result = hashSetOf() - context.pluginInfo.classpathContributors.forEach { it: IClasspathContributor -> - result.addAll(it.classpathEntriesFor(project, context)) - } - return result - } - - /** - * If this project depends on other projects, we need to include their jar file and also - * their own dependencies - */ - private fun dependentProjectDependencies(project: Project?, context: KobaltContext, - toDependencies: (Project) -> List) - : List { - // Get the transitive closure of all the projects this project depends on - val transitiveProjects = - if (project == null) emptyList() - else DynamicGraph.transitiveClosure(project) { project -> project.dependsOn } - - val result = arrayListOf() - - /** - * Add the class directories of projects depended upon - */ - fun maybeAddClassDir(classDir: String) { - // A project is allowed not to have any kobaltBuild/classes or test-classes directory if it doesn't have - // any sources - if (File(classDir).exists()) { - result.add(FileDependency(classDir)) - } - } - transitiveProjects.forEach { p -> - maybeAddClassDir(KFiles.joinDir(p.directory, p.classesDir(context))) - maybeAddClassDir(KFiles.makeOutputTestDir(p).path) - } - - // And add all the transitive projects - result.addAll(transitiveProjects.flatMap { toDependencies(it) }) - return result - } - -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt index 7078abb9..60a4335c 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Gpg.kt @@ -1,16 +1,18 @@ package com.beust.kobalt.maven import com.beust.kobalt.OperatingSystem +import com.beust.kobalt.misc.LocalProperties import com.beust.kobalt.misc.error -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.beust.kobalt.misc.warn +import com.google.inject.Inject import com.google.inject.Singleton import java.io.BufferedReader import java.io.File import java.io.InputStreamReader @Singleton -public class Gpg { +class Gpg @Inject constructor(val localProperties: LocalProperties) { val COMMANDS = listOf("gpg", "gpg2") fun findGpgCommand() : String? { @@ -42,12 +44,27 @@ public class Gpg { ascFile.delete() val allArgs = arrayListOf() allArgs.add(gpg) + + fun maybeAdd(prop: String, f: (String) -> Unit) = localProperties.getNoThrows(prop)?.let { + f(it) + } + + maybeAdd("gpg.password") { + allArgs.addAll(listOf("--passphrase", it, "--batch", "--yes")) + } + maybeAdd("gpg.keyId") { + allArgs.addAll(listOf("--local-user", it)) + } + maybeAdd("gpg.secretKeyRingFile") { + allArgs.addAll(listOf("--secret-keyring", "\"$it\"")) + } + allArgs.add("-ab") allArgs.add(file.absolutePath) val pb = ProcessBuilder(allArgs) pb.directory(directory) - log(2, "Signing file: " + allArgs.joinToString(" ")) + kobaltLog(2, "Signing file: " + allArgs.joinToString(" ")) val process = pb.start() val br = BufferedReader(InputStreamReader(process.errorStream)) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt index 672d10b2..df286a47 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Http.kt @@ -3,6 +3,7 @@ package com.beust.kobalt.maven import com.beust.kobalt.KobaltException import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.misc.CountingFileRequestBody +import com.beust.kobalt.misc.kobaltLog import com.beust.kobalt.misc.log import com.google.inject.Inject import okhttp3.* @@ -41,7 +42,7 @@ class Http @Inject constructor(val settings:KobaltSettings) { fun percentProgressCallback(totalSize: Long) : (Long) -> Unit { return { num: Long -> val progress = num * 100 / totalSize - log(1, "\rUploaded: $progress%", newLine = false) + kobaltLog(1, "\rUploaded: $progress%", newLine = false) } } @@ -74,7 +75,7 @@ class Http @Inject constructor(val settings:KobaltSettings) { requestBuilder.put(CountingFileRequestBody(file.file, file.mimeType, progressCallback))) .build() - log(2, "Uploading $file to $url") + kobaltLog(2, "Uploading $file to $url") val response = OkHttpClient.Builder().proxy(settings.proxyConfigs?.firstOrNull()?.toProxy()).build().newCall(request).execute() if (! response.isSuccessful) { error(response) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt index 6b9c0a62..909c18c5 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Kurl.kt @@ -1,9 +1,8 @@ package com.beust.kobalt.maven import com.beust.kobalt.HostConfig -import com.beust.kobalt.KobaltException +import com.beust.kobalt.maven.aether.KobaltMavenResolver import com.beust.kobalt.maven.dependency.FileDependency -import com.beust.kobalt.misc.LocalProperties import java.io.* import java.net.HttpURLConnection import java.net.URL @@ -21,27 +20,7 @@ class Kurl(val hostInfo: HostConfig) { } init { - // See if the URL needs to be authenticated. Look in local.properties for keys - // of the format authUrl..user=xxx and authUrl..password=xxx - val properties = LocalProperties().localProperties - val host = java.net.URL(hostInfo.url).host - properties.entries.forEach { - val key = it.key.toString() - if (key == "$KEY.$host.$VALUE_USER") { - hostInfo.username = properties.getProperty(key) - } else if (key == "$KEY.$host.$VALUE_PASSWORD") { - hostInfo.password = properties.getProperty(key) - } - } - fun error(s1: String, s2: String) { - throw KobaltException("Found \"$s1\" but not \"$s2\" in local.properties for $KEY.$host", - docUrl = "http://beust.com/kobalt/documentation/index.html#maven-repos-authenticated") - } - if (! hostInfo.username.isNullOrBlank() && hostInfo.password.isNullOrBlank()) { - error("username", "password") - } else if(hostInfo.username.isNullOrBlank() && ! hostInfo.password.isNullOrBlank()) { - error("password", "username") - } + KobaltMavenResolver.initAuthentication(hostInfo) } override fun toString() = hostInfo.toString() diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt index baebac31..53cb1c89 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalDep.kt @@ -1,6 +1,6 @@ package com.beust.kobalt.maven -open public class LocalDep(override val mavenId: MavenId, open val localRepo: LocalRepo) +open class LocalDep(override val mavenId: MavenId, open val localRepo: LocalRepo) : SimpleDep(mavenId) { fun toAbsoluteJarFilePath(v: String) = localRepo.toFullPath(toJarFile(v)) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt index 21d36172..35f8c50a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/LocalRepo.kt @@ -1,11 +1,8 @@ package com.beust.kobalt.maven import com.beust.kobalt.internal.KobaltSettings -import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.Versions import com.google.inject.Inject import java.io.File -import java.util.* import javax.inject.Singleton @Singleton @@ -13,42 +10,7 @@ open class LocalRepo @Inject constructor(val kobaltSettings: KobaltSettings) { val localRepo: File get() = kobaltSettings.localCache - fun existsPom(d: LocalDep, v: String) : Boolean { - return File(d.toAbsolutePomFile(v)).exists() - } - - fun existsJar(d: LocalDep, v: String) : Boolean { - return File(d.toAbsoluteJarFilePath(v)).exists() - } - - /** - * If the dependency is local, return the correct version for it - */ - fun findLocalVersion(groupId: String, artifactId: String, packaging: String? = null) : String? { - // No version: look at all the directories under group/artifactId, pick the latest and see - // if it contains a maven and jar file - val dir = toFullPath(KFiles.joinDir(groupId.replace(".", File.separator), artifactId)) - val files = File(dir).listFiles() - - if (files != null) { - val directories = files.filter { it.isDirectory } - if (directories.size > 0) { - Collections.sort(directories, { f1, f2 -> - val v1 = Versions.toLongVersion(f1.name) - val v2 = Versions.toLongVersion(f2.name) - v2.compareTo(v1) // we want the most recent at position 0 - }) - val result = directories[0].name - val newDep = LocalDep(MavenId.create(groupId, artifactId, packaging, null, result), this) - if (existsPom(newDep, result) && existsJar(newDep, result)) { - return result - } - } - } - return null - } - - fun toFullPath(path: String) = File(localRepo, path).absolutePath + fun toFullPath(path: String): String = File(localRepo, path).absolutePath } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt index 21201f99..13fff154 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/MavenId.kt @@ -17,8 +17,12 @@ class MavenId private constructor(val groupId: String, val artifactId: String, v val classifier: String?, val version: String?) { companion object { - fun isMavenId(id: String) = with(id.split(':')) { - size >= 3 && size <= 5 + fun isMavenId(id: String) = if (id.startsWith("file://")) { + false + } else { + with(id.split(':')) { + size >= 3 && size <= 5 + } } fun isRangedVersion(s: String): Boolean { @@ -32,14 +36,14 @@ class MavenId private constructor(val groupId: String, val artifactId: String, v MavenId(groupId, artifactId, extension, classifier, version) } - fun toKobaltId(id: String) = if (id.endsWith(":")) id + "(0,]" else id + fun toMavenId(id: String) = if (id.endsWith(":")) id + "(0,]" else id /** * The main entry point to create Maven Id's. Id's created by this function * will run through IMavenIdInterceptors. */ fun create(originalId: String) : MavenId { - val id = toKobaltId(originalId) + val id = toMavenId(originalId) var originalMavenId = createNoInterceptors(id) var interceptedMavenId = originalMavenId val interceptors = Kobalt.context?.pluginInfo?.mavenIdInterceptors diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt index f2b0f4b8..efa34944 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Md5.kt @@ -1,12 +1,12 @@ package com.beust.kobalt.maven import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import java.io.File import java.security.MessageDigest import javax.xml.bind.DatatypeConverter -public class Md5 { +class Md5 { companion object { // private fun md5(file: File) : String { // if (file.isDirectory) { @@ -26,18 +26,18 @@ public class Md5 { fun toMd5Directories(filesOrDirectories: List, toBytes: (File) -> ByteArray = { "${it.path} ${it.lastModified()} ${it.length()}".toByteArray() } ) : String? { - if (filesOrDirectories.any { it.exists() }) { + if (filesOrDirectories.any(File::exists)) { MessageDigest.getInstance("MD5").let { md5 -> var fileCount = 0 - filesOrDirectories.filter { it.exists() }.forEach { file -> + filesOrDirectories.filter(File::exists).forEach { file -> if (file.isFile) { - log(2, " Calculating checksum of $file") + kobaltLog(3, " Calculating checksum of $file") val bytes = toBytes(file) md5.update(bytes, 0, bytes.size) fileCount++ } else { val files = KFiles.findRecursively(file) // , { f -> f.endsWith("java")}) - log(2, " Calculating checksum of ${files.size} files in $file") + kobaltLog(3, " Calculating checksum of ${files.size} files in $file") files.map { File(file, it) }.filter { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt index d7457529..879f6d51 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/Pom2.kt @@ -1,13 +1,12 @@ package com.beust.kobalt.maven +import com.beust.kobalt.misc.kobaltLog import org.w3c.dom.Element import org.xml.sax.InputSource import java.io.File import java.io.FileReader import javax.xml.bind.JAXBContext -import javax.xml.bind.annotation.XmlAnyElement -import javax.xml.bind.annotation.XmlElement -import javax.xml.bind.annotation.XmlRootElement +import javax.xml.bind.annotation.* import javax.xml.parsers.SAXParserFactory import javax.xml.transform.sax.SAXSource @@ -147,7 +146,7 @@ class Dependency { private fun expandVariable(s: String, pom: Pom2) : String { val variable = extractVariable(s) if (variable != null) { - println("Expanding variable $variable") + kobaltLog(2, "Expanding variable $variable") val value = pom.pomProject.propertyValue(variable) return s } else { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt index 8f349c99..79c5e4b8 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/PomGenerator.kt @@ -1,9 +1,10 @@ package com.beust.kobalt.maven import com.beust.kobalt.SystemProperties +import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.Project import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.inject.assistedinject.Assisted import org.apache.maven.model.Developer import org.apache.maven.model.Model @@ -22,6 +23,10 @@ class PomGenerator @Inject constructor(@Assisted val project: Project) { * Generate the POM file and save it. */ fun generateAndSave() { + requireNotNull(project.version, { "version is mandatory on project ${project.name}" }) + requireNotNull(project.group, { "group is mandatory on project ${project.name}" }) + requireNotNull(project.artifactId, { "artifactId is mandatory on project ${project.name}" }) + val buildDir = KFiles.makeDir(project.directory, project.buildDirectory) val outputDir = KFiles.makeDir(buildDir.path, "libs") val NO_CLASSIFIER = null @@ -30,17 +35,13 @@ class PomGenerator @Inject constructor(@Assisted val project: Project) { val pomFile = SimpleDep(mavenId).toPomFileName() val outputFile = File(outputDir, pomFile) outputFile.writeText(generate(), Charset.defaultCharset()) - log(1, " Created $outputFile") + kobaltLog(1, " Created $outputFile") } /** * @return the text content of the POM file. */ fun generate() : String { - requireNotNull(project.version, { "version mandatory on project ${project.name}" }) - requireNotNull(project.group, { "group mandatory on project ${project.name}" }) - requireNotNull(project.artifactId, { "artifactId mandatory on project ${project.name}" }) - val pom = (project.pom ?: Model()).apply { // Make sure the pom has reasonable default values if (name == null) name = project.name @@ -62,12 +63,41 @@ class PomGenerator @Inject constructor(@Assisted val project: Project) { // pom.dependencies = arrayListOf() - // 1. Compile dependencies - project.compileDependencies.forEach { dep -> + /** + * optional and provided dependencies are added both to the compile dependencies (since they are needed + * to build the project) and to their respective list as well (for POM generation). Make sure they + * don't get added twice to the .pom in such cases. + */ + fun providedOrOptional(dep: IClasspathDependency) = + project.compileProvidedDependencies.contains(dep) || + project.optionalDependencies.contains(dep) + + // Compile dependencies + project.compileDependencies.filterNot(::providedOrOptional).forEach { dep -> pom.dependencies.add(dep.toMavenDependencies()) } - // 2. Project dependencies + // Optional compile dependencies + project.optionalDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies()) + } + + // Provided dependencies + project.compileProvidedDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies("provided")) + } + + // Test dependencies + project.testDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies("test")) + } + + // Test provided dependencies + project.testProvidedDependencies.forEach { dep -> + pom.dependencies.add(dep.toMavenDependencies("test")) + } + + // Project dependencies project.dependsOn.forEach { pom.dependencies.add(org.apache.maven.model.Dependency().apply { version = it.version diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Aether.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Aether.kt deleted file mode 100644 index cd6bd0f4..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Aether.kt +++ /dev/null @@ -1,315 +0,0 @@ -package com.beust.kobalt.maven.aether - -import com.beust.kobalt.KobaltException -import com.beust.kobalt.api.IClasspathDependency -import com.beust.kobalt.api.Kobalt -import com.beust.kobalt.api.Project -import com.beust.kobalt.internal.KobaltSettings -import com.beust.kobalt.internal.KobaltSettingsXml -import com.beust.kobalt.internal.getProxy -import com.beust.kobalt.maven.CompletedFuture -import com.beust.kobalt.maven.LocalDep -import com.beust.kobalt.maven.LocalRepo -import com.beust.kobalt.maven.MavenId -import com.beust.kobalt.misc.Versions -import com.beust.kobalt.misc.log -import com.beust.kobalt.misc.warn -import com.google.common.eventbus.EventBus -import com.google.inject.Inject -import com.google.inject.Singleton -import org.eclipse.aether.artifact.Artifact -import org.eclipse.aether.artifact.DefaultArtifact -import org.eclipse.aether.collection.CollectRequest -import org.eclipse.aether.collection.CollectResult -import org.eclipse.aether.graph.Dependency -import org.eclipse.aether.graph.DependencyFilter -import org.eclipse.aether.graph.DependencyNode -import org.eclipse.aether.repository.RemoteRepository -import org.eclipse.aether.resolution.* -import org.eclipse.aether.transfer.ArtifactNotFoundException -import org.eclipse.aether.util.artifact.JavaScopes -import org.eclipse.aether.util.filter.AndDependencyFilter -import org.eclipse.aether.util.filter.DependencyFilterUtils -import java.io.File -import java.util.* -import java.util.concurrent.Future - -enum class Scope(val scope: String, val dependencyLambda: (Project) -> List) { - COMPILE(JavaScopes.COMPILE, { project : Project -> project.compileDependencies }), - PROVIDED(JavaScopes.PROVIDED, { project : Project -> project.compileProvidedDependencies }), - SYSTEM(JavaScopes.SYSTEM, { project : Project -> emptyList() }), - RUNTIME(JavaScopes.RUNTIME, { project : Project -> project.compileRuntimeDependencies }), - TEST(JavaScopes.TEST, { project : Project -> project.testDependencies }) - ; - - companion object { - /** - * @return a filter that excludes optional dependencies and allows all the scopes passed in parameter. - */ - fun toFilter(scopes: Collection): DependencyFilter { - val javaScopes = scopes.map { DependencyFilterUtils.classpathFilter(it.scope) }.toTypedArray() - return AndDependencyFilter(KobaltAether.ExcludeOptionalDependencyFilter(), *javaScopes) - } - - /** - * @return a lambda that extracts the correct dependencies from a project based on the scope - * filters passed. - */ - fun toDependencyLambda(scopes: Collection) : (Project) -> List { - val result = { project : Project -> - scopes.fold(arrayListOf(), - { list: ArrayList, scope: Scope -> - list.addAll(scope.dependencyLambda(project)) - list - }) - } - return result - } - } -} - -class DependencyResult(val dependency: IClasspathDependency, val repoUrl: String) - -class KobaltAether @Inject constructor (val settings: KobaltSettings, val aether: Aether) { - /** - * Create an IClasspathDependency from a Kobalt id. - */ - fun create(id: String) = AetherDependency(DefaultArtifact(id)) - - /** - * @return the latest artifact for the given group and artifactId. - */ - fun latestArtifact(group: String, artifactId: String, extension: String = "jar"): DependencyResult - = aether.latestArtifact(group, artifactId, extension).let { - DependencyResult(AetherDependency(it.artifact), it.repository.toString()) - } - - fun resolveAll(id: String, artifactScope: Scope? = null, filterScopes: Collection = emptyList()) - : List { - val results = aether.resolve(DefaultArtifact(id), artifactScope, filterScopes) - return results.map { it.artifact.toString() } - } - - fun resolve(id: String, artifactScope: Scope? = null, filterScopes: Collection = emptyList()) - : DependencyResult { - log(ConsoleRepositoryListener.LOG_LEVEL, "Resolving $id") - val result = resolveToArtifact(id, artifactScope, filterScopes) - if (result != null) { - return DependencyResult(AetherDependency(result.artifact), result.repository.toString()) - } else { - throw KobaltException("Couldn't resolve $id") - } - } - - fun resolveToArtifact(id: String, artifactScope: Scope? = null, filterScopes: Collection = emptyList()) - : ArtifactResult? { - log(ConsoleRepositoryListener.LOG_LEVEL, "Resolving $id") - val results = aether.resolve(DefaultArtifact(MavenId.toKobaltId(id)), artifactScope, filterScopes) - if (results.size > 0) { - return results[0] - } else { - return null - } - } - - class ExcludeOptionalDependencyFilter : DependencyFilter { - override fun accept(node: DependencyNode?, p1: MutableList?): Boolean { -// val result = node != null && ! node.dependency.isOptional - val accept1 = node == null || node.artifact.artifactId != "srczip" - val accept2 = node != null && !node.dependency.isOptional - val result = accept1 && accept2 - return result - } - } -} - -@Singleton -class Aether(localRepo: File, val settings: KobaltSettings, val eventBus: EventBus) { - private val system = Booter.newRepositorySystem() - private val session = Booter.newRepositorySystemSession(system, localRepo, settings, eventBus) -// private val classpathFilter = Scopes.toFilter(Scopes.COMPILE, Scopes.TEST) -// private val testClasspathFilter = Scopes.toFilter(Scopes.TEST) - - private val kobaltRepositories: List - get() = Kobalt.repos.map { - RemoteRepository.Builder("maven", "default", it.url) -// .setSnapshotPolicy(RepositoryPolicy(false, null, null)) - .build().let { repository -> - val proxyConfigs = settings.proxyConfigs ?: return@map repository - RemoteRepository.Builder(repository).apply { - setProxy(proxyConfigs.getProxy(repository.protocol)?.toAetherProxy()) - }.build() - } - } - - private fun collectRequest(artifact: Artifact, scope: Scope?): CollectRequest { - with(CollectRequest()) { - root = Dependency(artifact, scope?.scope) - repositories = kobaltRepositories - - return this - } - } - - fun latestArtifact(group: String, artifactId: String, extension: String = "jar"): ArtifactResult { - val artifact = DefaultArtifact(group, artifactId, extension, "(0,]") - val resolved = resolveVersion(artifact) - if (resolved != null) { - val newArtifact = DefaultArtifact(artifact.groupId, artifact.artifactId, artifact.extension, - resolved.highestVersion.toString()) - val artifactResult = resolve(newArtifact, null, emptyList()) - if (artifactResult.any()) { - return artifactResult[0] - } else { - throw KobaltException("Couldn't find latest artifact for $group:$artifactId") - } - } else { - throw KobaltException("Couldn't find latest artifact for $group:$artifactId") - } - } - - fun resolveVersion(artifact: Artifact): VersionRangeResult? { - val request = VersionRangeRequest(artifact, kobaltRepositories, null) - val result = system.resolveVersionRange(session, request) - return result - } - - fun resolve(artifact: Artifact, artifactScope: Scope?, filterScopes: Collection): List { - fun manageException(ex: Exception, artifact: Artifact): List { - if (artifact.extension == "pom") { - // Only display a warning for .pom files. Not resolving a .jar or other artifact - // is not necessarily an error as long as there is a pom file. - warn("Couldn't resolve $artifact") - } - return emptyList() - } - - try { - val scopeFilter = Scope.toFilter(filterScopes) - val dependencyRequest = DependencyRequest(collectRequest(artifact, artifactScope), scopeFilter) - val result = system.resolveDependencies(session, dependencyRequest).artifactResults - return result - } catch(ex: ArtifactNotFoundException) { - return manageException(ex, artifact) - } catch(ex: DependencyResolutionException) { - return manageException(ex, artifact) - } - } - -// fun transitiveDependencies(artifact: Artifact) = directDependencies(artifact) - - fun directDependencies(artifact: Artifact, artifactScope: Scope? = null): CollectResult? - = system.collectDependencies(session, collectRequest(artifact, artifactScope)) -} - -class AetherDependency(val artifact: Artifact) : IClasspathDependency, Comparable { - val aether: Aether get() = Kobalt.INJECTOR.getInstance(Aether::class.java) - - constructor(node: DependencyNode) : this(node.artifact) { - } - - override val id: String = toId(artifact) - - override val version: String = artifact.version - - override val isMaven = true - - private fun toId(a: Artifact) = a.toString() - - override val jarFile: Future - get() = if (artifact.file != null) { - CompletedFuture(artifact.file) - } else { - val localRepo = Kobalt.INJECTOR.getInstance(LocalRepo::class.java) - val file = File(LocalDep(MavenId.create(id), localRepo).toAbsoluteJarFilePath(version)) - if (file.exists()) { - CompletedFuture(file) - } else { - val td = aether.resolve(artifact, null, emptyList()) - if (td.any()) { - val newFile = td[0].artifact.file - if (newFile != null) { - CompletedFuture(newFile) - } else { - CompletedFuture(File("DOESNOTEXIST $id")) // will be filtered out - } - } else { - CompletedFuture(File("DOESNOTEXIST $id")) - } - } - } - - override fun toMavenDependencies() = let { md -> - org.apache.maven.model.Dependency().apply { - artifact.let { md -> - groupId = md.groupId - artifactId = md.artifactId - version = md.version - } - } - } - - override fun directDependencies(): List { - val result = arrayListOf() - val deps = aether.directDependencies(artifact) - if (deps != null) { - if (!deps.root.dependency.optional) { - deps.root.children.forEach { - if (!it.dependency.isOptional) { - result.add(AetherDependency(it.artifact)) - } else { - log(ConsoleRepositoryListener.LOG_LEVEL, "Skipping optional dependency " + deps.root.artifact) - } - } - } else { - log(ConsoleRepositoryListener.LOG_LEVEL, "Skipping optional dependency " + deps.root.artifact) - } - } else { - warn("Couldn't resolve $artifact") - } - return result - } - - override val shortId = artifact.groupId + ":" + artifact.artifactId + ":" + artifact.classifier - - override fun compareTo(other: AetherDependency): Int { - return Versions.toLongVersion(artifact.version).compareTo(Versions.toLongVersion( - other.artifact.version)) - } - - override fun hashCode() = id.hashCode() - - override fun equals(other: Any?) = if (other is AetherDependency) other.id == id else false - - override fun toString() = id -} - -fun main(argv: Array) { - val request = CollectRequest().apply { - root = Dependency(DefaultArtifact("org.testng:testng:6.9.11"), JavaScopes.COMPILE) - repositories = listOf( - RemoteRepository.Builder("Maven", "default", "http://repo1.maven.org/maven2/").build(), - RemoteRepository.Builder("JCenter", "default", "https://jcenter.bintray.com").build()) - } - val dependencyRequest = DependencyRequest().apply { - collectRequest = request - } - val system = Booter.newRepositorySystem() - val session = Booter.newRepositorySystemSession(system, File("/tmp"), KobaltSettings(KobaltSettingsXml()), - EventBus()) -// val session = MavenRepositorySystemUtils.newSession(KobaltSettings(KobaltSettingsXml())) - val result = system.resolveDependencies(session, dependencyRequest).artifactResults - println("RESULT: " + result) - -// KobaltLogger.LOG_LEVEL = 1 -// val id = "org.testng:testng:6.9.11" -// val aether = KobaltAether(KobaltSettings(KobaltSettingsXml()), Aether(File(homeDir(".aether")), -// KobaltSettings(KobaltSettingsXml()), EventBus())) -// val r = aether.resolve(id) -// val r2 = aether.resolve(id) -// val d = org.eclipse.aether.artifact.DefaultArtifact("org.testng:testng:6.9") -// -// println("Artifact: " + d) -} - - diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt new file mode 100644 index 00000000..825a8ae8 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt @@ -0,0 +1,94 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.Args +import com.beust.kobalt.api.Dependencies +import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.maven.CompletedFuture +import com.beust.kobalt.misc.StringVersion +import com.beust.kobalt.misc.warn +import org.eclipse.aether.artifact.Artifact +import org.eclipse.aether.artifact.DefaultArtifact +import org.eclipse.aether.resolution.DependencyResolutionException +import java.io.File +import java.util.concurrent.Future + +class AetherDependency(val artifact: Artifact, override val optional: Boolean = false, val args: Args? = null) + : IClasspathDependency, Comparable { + val aether: KobaltMavenResolver get() = Kobalt.INJECTOR.getInstance(KobaltMavenResolver::class.java) + + override val id: String = toId(artifact) + + override val version: String = artifact.version + + override val isMaven = true + + private fun toId(a: Artifact) = a.toString() + + override val jarFile: Future + get() { + resolveSourcesIfNeeded() + return if (artifact.file != null) { + CompletedFuture(artifact.file) + } else { + val td = aether.resolve(artifact) + CompletedFuture(td.root.artifact.file) + } + } + + private fun resolveSourcesIfNeeded() { + if (args?.downloadSources ?: false) { + listOf(artifact.toSourcesArtifact(), artifact.toJavaDocArtifact()).forEach { artifact -> + if (artifact.file == null) { + try { + aether.resolve(artifact) + } catch(e: DependencyResolutionException) { + // Ignore + } + } + } + } + } + + override fun toMavenDependencies(scope: String?) : org.apache.maven.model.Dependency { + val passedScope = scope + val op = this.optional + return org.apache.maven.model.Dependency().apply { + groupId = artifact.groupId + artifactId = artifact.artifactId + version = artifact.version + if (op) optional = op.toString() + if (passedScope != null) this.scope = passedScope + } + } + + override fun directDependencies(): List { + val result = arrayListOf() + val deps = aether.directDependencies(artifact) + if (deps != null) { + deps.root.children.forEach { + result.add(AetherDependency(it.artifact, it.dependency.optional)) + } + } else { + warn("Couldn't resolve $artifact") + } + return result + } + + override val shortId = artifact.groupId + ":" + artifact.artifactId + ":" + artifact.classifier + + override val excluded = arrayListOf() + + override fun compareTo(other: AetherDependency): Int { + return StringVersion(artifact.version).compareTo(StringVersion(other.artifact.version)) + } + + override fun hashCode() = id.hashCode() + + override fun equals(other: Any?) = if (other is AetherDependency) other.id == id else false + + override fun toString() = id + + fun Artifact.toSourcesArtifact() = DefaultArtifact(groupId, artifactId, "sources", extension, version) + fun Artifact.toJavaDocArtifact() = DefaultArtifact(groupId, artifactId, "javadoc", extension, version) +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt index 0190eee6..02917929 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Booter.kt @@ -2,6 +2,7 @@ package com.beust.kobalt.maven.aether import com.beust.kobalt.internal.KobaltSettings import com.google.common.eventbus.EventBus +import com.beust.kobalt.Args import org.eclipse.aether.DefaultRepositorySystemSession import org.eclipse.aether.RepositorySystem import org.eclipse.aether.repository.LocalRepository @@ -16,9 +17,25 @@ object Booter { // return org.eclipse.aether.examples.plexus.PlexusRepositorySystemFactory.newRepositorySystem(); } +// fun newRepositorySystemSession(system: RepositorySystem): DefaultRepositorySystemSession { +// val session = org.apache.maven.repository.internal.MavenRepositorySystemUtils.newSession() +// +// val localRepo = LocalRepository("target/local-repo") +// session.localRepositoryManager = system.newLocalRepositoryManager(session, localRepo) +// +// session.transferListener = ConsoleTransferListener() +// session.repositoryListener = ConsoleRepositoryListener(System.out, EventBus()) +// +// // uncomment to generate dirty trees +// // session.setDependencyGraphTransformer( null ); +// +// return session +// } + fun newRepositorySystemSession(system: RepositorySystem, repo: File, settings: KobaltSettings, - eventBus: EventBus): DefaultRepositorySystemSession { + args: Args, eventBus: EventBus): DefaultRepositorySystemSession { val session = MavenRepositorySystemUtils.newSession(settings) + session.isOffline = args.offline val localRepo = LocalRepository(repo.absolutePath) session.localRepositoryManager = system.newLocalRepositoryManager(session, localRepo) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt index 0fa2b981..fdbdbac7 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleRepositoryListener.kt @@ -1,7 +1,7 @@ package com.beust.kobalt.maven.aether import com.beust.kobalt.internal.eventbus.ArtifactDownloadedEvent -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import com.google.common.eventbus.EventBus import org.eclipse.aether.AbstractRepositoryListener import org.eclipse.aether.RepositoryEvent @@ -16,83 +16,77 @@ class ConsoleRepositoryListener @JvmOverloads constructor(out: PrintStream? = nu val LOG_LEVEL = 4 } - private val out: PrintStream - - init { - this.out = out ?: System.out - } - override fun artifactDeployed(event: RepositoryEvent?) { - log(LOG_LEVEL, "Deployed " + event!!.artifact + " to " + event.repository) + kobaltLog(LOG_LEVEL, "Deployed " + event!!.artifact + " to " + event.repository) } override fun artifactDeploying(event: RepositoryEvent?) { - log(LOG_LEVEL, "Deploying " + event!!.artifact + " to " + event.repository) + kobaltLog(LOG_LEVEL, "Deploying " + event!!.artifact + " to " + event.repository) } override fun artifactDescriptorInvalid(event: RepositoryEvent?) { - log(LOG_LEVEL, "Invalid artifact descriptor for " + event!!.artifact + ": " + kobaltLog(LOG_LEVEL, "Invalid artifact descriptor for " + event!!.artifact + ": " + event.exception.message) } override fun artifactDescriptorMissing(event: RepositoryEvent?) { - log(LOG_LEVEL, "Missing artifact descriptor for " + event!!.artifact) + kobaltLog(LOG_LEVEL, "Missing artifact descriptor for " + event!!.artifact) } override fun artifactInstalled(event: RepositoryEvent?) { - log(LOG_LEVEL, "Installed " + event!!.artifact + " to " + event.file) + kobaltLog(LOG_LEVEL, "Installed " + event!!.artifact + " to " + event.file) } override fun artifactInstalling(event: RepositoryEvent?) { - log(LOG_LEVEL, "Installing " + event!!.artifact + " to " + event.file) + kobaltLog(LOG_LEVEL, "Installing " + event!!.artifact + " to " + event.file) } override fun artifactResolved(event: RepositoryEvent?) { - log(LOG_LEVEL, "Resolved artifact " + event!!.artifact + " from " + event.repository) + kobaltLog(LOG_LEVEL, "Resolved artifact " + event!!.artifact + " from " + event.repository) } override fun artifactDownloading(event: RepositoryEvent?) { - log(LOG_LEVEL, "Downloading artifact " + event!!.artifact + " from " + event.repository) + kobaltLog(LOG_LEVEL, "Downloading artifact " + event!!.artifact + " from " + event.repository) } override fun artifactDownloaded(event: RepositoryEvent?) { if (event?.file != null && event?.artifact != null) { val artifact = event!!.artifact - log(1, "Downloaded artifact " + artifact + " from " + event.repository) + kobaltLog(1, "Downloaded artifact " + artifact + " from " + event.repository) eventBus.post(ArtifactDownloadedEvent(artifact.toString(), event.repository)) } } override fun artifactResolving(event: RepositoryEvent?) { - log(LOG_LEVEL, "Resolving artifact " + event!!.artifact) + kobaltLog(LOG_LEVEL, "Resolving artifact " + event!!.artifact) } override fun metadataDeployed(event: RepositoryEvent?) { - log(LOG_LEVEL, "Deployed " + event!!.metadata + " to " + event.repository) + kobaltLog(LOG_LEVEL, "Deployed " + event!!.metadata + " to " + event.repository) } override fun metadataDeploying(event: RepositoryEvent?) { - log(LOG_LEVEL, "Deploying " + event!!.metadata + " to " + event.repository) + kobaltLog(LOG_LEVEL, "Deploying " + event!!.metadata + " to " + event.repository) } override fun metadataInstalled(event: RepositoryEvent?) { - log(LOG_LEVEL, "Installed " + event!!.metadata + " to " + event.file) + kobaltLog(LOG_LEVEL, "Installed " + event!!.metadata + " to " + event.file) } override fun metadataInstalling(event: RepositoryEvent?) { - log(LOG_LEVEL, "Installing " + event!!.metadata + " to " + event.file) + kobaltLog(LOG_LEVEL, "Installing " + event!!.metadata + " to " + event.file) } override fun metadataInvalid(event: RepositoryEvent?) { - log(LOG_LEVEL, "Invalid metadata " + event!!.metadata) + kobaltLog(LOG_LEVEL, "Invalid metadata " + event!!.metadata) } override fun metadataResolved(event: RepositoryEvent?) { - log(LOG_LEVEL, "Resolved metadata " + event!!.metadata + " from " + event.repository) + kobaltLog(LOG_LEVEL, "Resolved metadata " + event!!.metadata + " from " + event.repository) } override fun metadataResolving(event: RepositoryEvent?) { - log(LOG_LEVEL, "Resolving metadata " + event!!.metadata + " from " + event.repository) + kobaltLog(LOG_LEVEL, "Resolving metadata " + event!!.metadata + " from " + event.repository) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt index ebd21a2c..46d8eb15 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ConsoleTransferListener.kt @@ -1,7 +1,7 @@ package com.beust.kobalt.maven.aether import com.beust.kobalt.misc.KobaltLogger -import com.beust.kobalt.misc.log +import com.beust.kobalt.misc.kobaltLog import org.eclipse.aether.transfer.AbstractTransferListener import org.eclipse.aether.transfer.MetadataNotFoundException import org.eclipse.aether.transfer.TransferEvent @@ -27,10 +27,15 @@ class ConsoleTransferListener @JvmOverloads constructor(out: PrintStream? = null override fun transferInitiated(event: TransferEvent?) { val message = if (event!!.requestType == TransferEvent.RequestType.PUT) "Uploading" else "Downloading" - log(2, message + ": " + event.resource.repositoryUrl + event.resource.resourceName) + kobaltLog(2, message + ": " + event.resource.repositoryUrl + event.resource.resourceName) } + val PROPERTY_NO_ANIMATIONS = "com.beust.kobalt.noAnimations" + override fun transferProgressed(event: TransferEvent?) { + // Not on a terminal: don't display the progress + if (System.console() == null || System.getProperty(PROPERTY_NO_ANIMATIONS) != null) return + val resource = event!!.resource downloads.put(resource, java.lang.Long.valueOf(event.transferredBytes)) @@ -38,7 +43,7 @@ class ConsoleTransferListener @JvmOverloads constructor(out: PrintStream? = null for (entry in downloads.entries) { val total = entry.key.contentLength - val complete = entry.value.toLong() + val complete = entry.value buffer.append(getStatus(complete, total)).append(" ") } @@ -92,7 +97,7 @@ class ConsoleTransferListener @JvmOverloads constructor(out: PrintStream? = null throughput = " at " + format.format(kbPerSec) + " KB/sec" } - log(2, type + ": " + resource.repositoryUrl + resource.resourceName + " (" + len + kobaltLog(2, type + ": " + resource.repositoryUrl + resource.resourceName + " (" + len + throughput + ")") } } @@ -102,7 +107,7 @@ class ConsoleTransferListener @JvmOverloads constructor(out: PrintStream? = null if (event.exception !is MetadataNotFoundException) { if (KobaltLogger.LOG_LEVEL > 2) { - event.exception.printStackTrace(out) + Exceptions.printStackTrace(event.exception) } } } @@ -117,10 +122,10 @@ class ConsoleTransferListener @JvmOverloads constructor(out: PrintStream? = null } override fun transferCorrupted(event: TransferEvent?) { - event!!.exception.printStackTrace(out) + Exceptions.printStackTrace(event!!.exception) } - protected fun toKB(bytes: Long): Long { + fun toKB(bytes: Long): Long { return (bytes + 1023) / 1024 } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Exceptions.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Exceptions.kt new file mode 100644 index 00000000..37fcda39 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Exceptions.kt @@ -0,0 +1,14 @@ +package com.beust.kobalt.maven.aether + +object Exceptions { + fun printStackTrace(t: Throwable) { + t.printStackTrace(System.out) + +// println("PRINT STACK TRACE FOR $t") +// t.printStackTrace(System.out) +// println(t.message) +// t.stackTrace.forEach { +// println(" " + it) +// } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Filters.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Filters.kt new file mode 100644 index 00000000..0a661c2c --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Filters.kt @@ -0,0 +1,25 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.misc.kobaltLog +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.graph.DependencyNode +import org.eclipse.aether.util.artifact.JavaScopes + +object Filters { + val COMPILE_FILTER = DependencyFilter { p0, p1 -> + p0.dependency.scope == "" || p0.dependency.scope == JavaScopes.COMPILE + } + val TEST_FILTER = DependencyFilter { p0, p1 -> p0.dependency.scope == JavaScopes.TEST } + + val EXCLUDE_OPTIONAL_FILTER = object: DependencyFilter { + override fun accept(p0: DependencyNode, p1: MutableList): Boolean { + val result = p0.dependency != null && ! p0.dependency.optional + if (! result) { + kobaltLog(3, "Excluding from optional filter: $p0") + } + return result + } + + override fun toString() = "EXCLUDE_OPTIONAL_FILTER" + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/KobaltMavenResolver.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/KobaltMavenResolver.kt new file mode 100644 index 00000000..7c8b705f --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/KobaltMavenResolver.kt @@ -0,0 +1,180 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.Args +import com.beust.kobalt.HostConfig +import com.beust.kobalt.KobaltException +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.internal.KobaltSettings +import com.beust.kobalt.internal.getProxy +import com.beust.kobalt.maven.Kurl +import com.beust.kobalt.maven.LocalRepo +import com.beust.kobalt.maven.MavenId +import com.beust.kobalt.misc.LocalProperties +import com.google.common.eventbus.EventBus +import com.google.inject.Inject +import org.eclipse.aether.artifact.Artifact +import org.eclipse.aether.artifact.DefaultArtifact +import org.eclipse.aether.collection.CollectRequest +import org.eclipse.aether.collection.CollectResult +import org.eclipse.aether.graph.DefaultDependencyNode +import org.eclipse.aether.graph.Dependency +import org.eclipse.aether.graph.DependencyFilter +import org.eclipse.aether.repository.RemoteRepository +import org.eclipse.aether.resolution.DependencyRequest +import org.eclipse.aether.resolution.DependencyResult +import org.eclipse.aether.resolution.VersionRangeRequest +import org.eclipse.aether.resolution.VersionRangeResult +import org.eclipse.aether.util.repository.AuthenticationBuilder +import java.util.* + +class KobaltMavenResolver @Inject constructor(val settings: KobaltSettings, + val args: Args, + localRepo: LocalRepo, eventBus: EventBus) { + + companion object { + fun artifactToId(artifact: Artifact) = artifact.let { + MavenId.toId(it.groupId, it.artifactId, it.extension, it.classifier, it.version) + } + fun isRangeVersion(id: String) = id.contains(",") + + fun initAuthentication(hostInfo: HostConfig) { + // See if the URL needs to be authenticated. Look in local.properties for keys + // of the format authUrl..user=xxx and authUrl..password=xxx + val properties = LocalProperties().localProperties + val host = java.net.URL(hostInfo.url).host + properties.entries.forEach { + val key = it.key.toString() + if (key == "${Kurl.KEY}.$host.${Kurl.VALUE_USER}") { + hostInfo.username = properties.getProperty(key) + } else if (key == "${Kurl.KEY}.$host.${Kurl.VALUE_PASSWORD}") { + hostInfo.password = properties.getProperty(key) + } + } + fun error(s1: String, s2: String) { + throw KobaltException("Found \"$s1\" but not \"$s2\" in local.properties for ${Kurl.KEY}.$host", + docUrl = "https://beust.com/kobalt/documentation/index.html#maven-repos-authenticated") + } + if (! hostInfo.username.isNullOrBlank() && hostInfo.password.isNullOrBlank()) { + error("username", "password") + } else if(hostInfo.username.isNullOrBlank() && ! hostInfo.password.isNullOrBlank()) { + error("password", "username") + } + + } + } + + fun resolveToArtifact(id: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER) : Artifact + = resolve(id, scope, filter).root.artifact + + fun resolve(passedId: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, + repos: List = emptyList()): DependencyResult { + val mavenId = MavenId.toMavenId(passedId) + val id = + if (isRangeVersion(mavenId)) { + val artifact = DefaultArtifact(mavenId) + val request = VersionRangeRequest(artifact, createRepos(repos), null) + val rr = system.resolveVersionRange(session, request) + if (rr.highestVersion != null) { + val newArtifact = DefaultArtifact(artifact.groupId, artifact.artifactId, artifact.classifier, + artifact.extension, rr.highestVersion.toString()) + artifactToId(newArtifact) + } else { + throw KobaltException("Couldn't resolve $passedId") + } + } else { + passedId + } + + val collectRequest = createCollectRequest(id, scope, repos) + val dependencyRequest = DependencyRequest(collectRequest, filter) + val result = system.resolveDependencies(session, dependencyRequest) + // GraphUtil.displayGraph(listOf(result.root), { it -> it.children }, + // { it: DependencyNode, indent: String -> println(indent + it.toString()) }) + return result + } + + fun resolve(artifact: Artifact, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER) + = resolve(artifactToId(artifact), scope, filter) + + fun resolveToIds(id: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, + seen: HashSet = hashSetOf()) : List { + val rr = resolve(id, scope, filter) + val children = + rr.root.children.filter { + filter.accept(DefaultDependencyNode(it.dependency), emptyList()) + }.filter { + it.dependency.scope != Scope.SYSTEM.scope + } + val result = listOf(artifactToId(rr.root.artifact)) + children.flatMap { + val thisId = artifactToId(it.artifact) + if (! seen.contains(thisId)) { + seen.add(thisId) + resolveToIds(thisId, scope, filter, seen) + } else { + emptyList() + } + } + return result + } + + fun directDependencies(id: String, scope: Scope? = null): CollectResult? + = system.collectDependencies(session, createCollectRequest(id, scope)) + + fun directDependencies(artifact: Artifact, scope: Scope? = null): CollectResult? + = artifactToId(artifact).let { id -> + directDependencies(id, scope) + } + + fun resolveRange(artifact: Artifact): VersionRangeResult? { + val request = VersionRangeRequest(artifact, kobaltRepositories, null) + val result = system.resolveVersionRange(session, request) + return result + } + + /** + * Create an IClasspathDependency from a Kobalt id. + */ + fun create(id: String, optional: Boolean) = AetherDependency(DefaultArtifact(id), optional, args) + + private val system = Booter.newRepositorySystem() + private val session = Booter.newRepositorySystemSession(system, localRepo.localRepo, settings, args, eventBus) + + private fun createRepo(hostConfig: HostConfig) : RemoteRepository { + val builder = RemoteRepository.Builder(hostConfig.name, "default", hostConfig.url) + if (hostConfig.hasAuth()) { + val auth = AuthenticationBuilder() + .addUsername(hostConfig.username) + .addPassword(hostConfig.password) + .build() + builder.setAuthentication(auth) + } + return builder.build() + } + + private val kobaltRepositories: List + get() = Kobalt.repos.map { + createRepo(it).let { repository -> + val proxyConfigs = settings.proxyConfigs ?: return@map repository + RemoteRepository.Builder(repository).apply { + setProxy(proxyConfigs.getProxy(repository.protocol)?.toAetherProxy()) + }.build() + } + } + + private fun createRepos(repos: List) : List + = kobaltRepositories + repos.map { createRepo(HostConfig(it)) } + + private fun createCollectRequest(id: String, scope: Scope? = null, repos: List = emptyList()) + = CollectRequest().apply { + val allIds = arrayListOf(MavenId.toMavenId(id)) + + dependencies = allIds.map { Dependency(DefaultArtifact(it), scope?.scope) } + + root = Dependency(DefaultArtifact(MavenId.toMavenId(id)), scope?.scope) + repositories = createRepos(repos) + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt index fc21c0de..7f019533 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/ManualRepositorySystemFactory.kt @@ -27,7 +27,7 @@ object ManualRepositorySystemFactory { locator.setErrorHandler(object : DefaultServiceLocator.ErrorHandler() { override fun serviceCreationFailed(type: Class<*>, impl: Class<*>, exception: Throwable) { - exception.printStackTrace() + Exceptions.printStackTrace(exception) } }) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Scope.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Scope.kt new file mode 100644 index 00000000..7822159e --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/Scope.kt @@ -0,0 +1,19 @@ +package com.beust.kobalt.maven.aether + +import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.Project +import org.eclipse.aether.util.artifact.JavaScopes + +sealed class Scope(val scope: String, val dependencyLambda: (Project) -> List) { + + companion object { + fun toScopes(isTest: Boolean) = if (isTest) listOf(TEST, COMPILE) else listOf(COMPILE) + } + + object COMPILE : Scope(JavaScopes.COMPILE, Project::compileDependencies) + object PROVIDED : Scope(JavaScopes.PROVIDED, Project::compileProvidedDependencies) + object COMPILEONLY : Scope("compileOnly", Project::compileOnlyDependencies) + object SYSTEM : Scope(JavaScopes.SYSTEM, { project -> emptyList() }) + object RUNTIME : Scope(JavaScopes.RUNTIME, Project::compileRuntimeDependencies) + object TEST : Scope(JavaScopes.TEST, Project::testDependencies) +} \ No newline at end of file diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt index 7099ed45..047754e2 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/dependency/FileDependency.kt @@ -1,11 +1,13 @@ package com.beust.kobalt.maven.dependency +import com.beust.kobalt.api.Dependencies import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.maven.CompletedFuture import org.apache.maven.model.Dependency import java.io.File -open class FileDependency(open val fileName: String) : IClasspathDependency, Comparable { +open class FileDependency(open val fileName: String, override val optional: Boolean = false) + : IClasspathDependency, Comparable { companion object { val PREFIX_FILE: String = "file://" } @@ -18,9 +20,10 @@ open class FileDependency(open val fileName: String) : IClasspathDependency, Com override val jarFile = CompletedFuture(File(fileName)) - override fun toMavenDependencies(): Dependency { + override fun toMavenDependencies(scope: String?): Dependency { with(Dependency()) { systemPath = jarFile.get().absolutePath + this.scope = scope return this } } @@ -29,6 +32,8 @@ open class FileDependency(open val fileName: String) : IClasspathDependency, Com override fun directDependencies() = arrayListOf() + override val excluded = arrayListOf() + override fun compareTo(other: FileDependency) = fileName.compareTo(other.fileName) override fun toString() = fileName diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/BlockExtractor.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/BlockExtractor.kt new file mode 100644 index 00000000..a854156a --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/BlockExtractor.kt @@ -0,0 +1,119 @@ +package com.beust.kobalt.misc + +import java.io.File +import java.util.regex.Pattern + +class Section(val start: Int, val end: Int) { + override fun toString() = "$start-$end" +} + +class IncludedBuildSourceDir(val line: Int, val dirs: List) + +class BuildScriptInfo(val file: File, val fullBuildFile: List, val sections: List
, + val imports: List, val topLines: List) { + fun isInSection(lineNumber: Int): Boolean { + sections.forEach { + if (lineNumber >= it.start && lineNumber <= it.end) return true + } + return false + } + + val includedBuildSourceDirs = arrayListOf() + + fun addBuildSourceDir(dir: IncludedBuildSourceDir) = includedBuildSourceDirs.add(dir) + + fun includedBuildSourceDirsForLine(line: Int): List { + val result = includedBuildSourceDirs.find { it.line == line }?.dirs + return result ?: emptyList() + } +} + +/** + * Used to extract a keyword followed by opening and closing tags out of a list of strings, + * e.g. buildScript { ... }. + */ +class BlockExtractor(val regexp: Pattern, val opening: Char, val closing: Char) { + fun extractBlock(file: File, lines: List): BuildScriptInfo? { + var currentLineNumber = 0 + // First line of the buildScript block + var startLine = 0 + // Last line of the buildScript block + var endLine = 0 + var foundKeyword = false + var foundClosing = false + var count = 0 + val buildScript = arrayListOf() + val topLines = arrayListOf() + val finalTopLines = arrayListOf() + + fun updateCount(line: String) { + val currentLine = StringBuffer() + line.toCharArray().forEach { c -> + if (c == opening) { + count++ + } + if (c == closing) { + count-- + if (count == 0) { + currentLine.append(closing).append("\n") + foundClosing = true + endLine = currentLineNumber + } + } + if (foundKeyword && count > 0) currentLine.append(c) + } + + if (currentLine.isNotEmpty() && foundKeyword) buildScript.add(currentLine.toString()) + } + + val imports = arrayListOf() + val sections = arrayListOf
() + lines.forEach { line -> + val found = regexp.matcher(line).matches() + if (found) { + startLine = currentLineNumber + foundKeyword = true + count = 1 + buildScript.add(line) + finalTopLines.addAll(topLines) + } else { + if (line.startsWith("import")) { + if (isAllowedImport(line)) { + imports.add(line) + } + } else { + topLines.add(line) + } + updateCount(line) + } + + if (foundKeyword && foundClosing && count == 0) { + sections.add(Section(startLine, endLine)) + foundKeyword = false + foundClosing = false + count = 0 + startLine = 0 + endLine = 0 + } + + currentLineNumber++ + } + + if (sections.isNotEmpty()) { + val result = (imports.distinct() + buildScript).joinToString("\n") + "\n" + + return BuildScriptInfo(file, lines, sections, imports, finalTopLines) + } else { + return null + } + } + + companion object { + private val allowedImports = listOf("com.beust", "java") + private val disallowedImports = listOf("com.beust.kobalt.plugin") + + fun isAllowedImport(line: String) : Boolean { + return allowedImports.any { line.contains(it) } && !disallowedImports.any { line.contains(it) } + } + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt index 106dfcad..d15e8056 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/CheckVersions.kt @@ -4,15 +4,15 @@ import com.beust.kobalt.KobaltException import com.beust.kobalt.api.Project import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.MavenId -import com.beust.kobalt.maven.aether.Aether import com.beust.kobalt.maven.aether.AetherDependency +import com.beust.kobalt.maven.aether.KobaltMavenResolver import javax.inject.Inject /** * Find out if any newer versions of the dependencies are available. */ class CheckVersions @Inject constructor(val depManager: DependencyManager, - val executors : KobaltExecutors, val aether: Aether) { + val executors : KobaltExecutors, val resolver: KobaltMavenResolver) { fun run(projects: List) = projects.forEach { run(it) } @@ -24,31 +24,29 @@ class CheckVersions @Inject constructor(val depManager: DependencyManager, cds.forEach { dep -> if (MavenId.isMavenId(dep.id)) { try { - val latestDep = depManager.create(dep.shortId, project.directory) + val latestDep = depManager.create(dep.shortId, false, project.directory) val artifact = (latestDep as AetherDependency).artifact - val versions = aether.resolveVersion(artifact) - val releases = versions?.versions?.filter { !it.toString().contains("SNAP")} - val highest = if (releases != null && releases.any()) { - releases.last().toString() - } else { - versions?.highestVersion.toString() + val rangeResult = resolver.resolveRange(artifact) + + if (rangeResult != null) { + val highest = rangeResult.highestVersion?.toString() + if (highest != null && highest != dep.id + && StringVersion(highest) > StringVersion(dep.version)) { + newVersions.add(artifact.groupId + ":" + artifact.artifactId + ":" + highest) } - if (highest != dep.id - && Versions.toLongVersion(highest) > Versions.toLongVersion(dep.version)) { - newVersions.add(artifact.groupId + ":" + artifact.artifactId + ":" + highest) } } catch(e: KobaltException) { - log(1, " Cannot resolve ${dep.shortId}. ignoring") + kobaltLog(1, " Cannot resolve ${dep.shortId}. ignoring") } } } } if (newVersions.size > 0) { - log(1, " New versions found:") - newVersions.forEach { log(1, " $it") } + kobaltLog(1, " New versions found:") + newVersions.forEach { kobaltLog(1, " $it") } } else { - log(1, " All dependencies up to date") + kobaltLog(1, " All dependencies up to date") } executor.shutdown() } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Git.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Git.kt new file mode 100644 index 00000000..cf6b5885 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Git.kt @@ -0,0 +1,52 @@ +package com.beust.kobalt.misc + +import com.beust.kobalt.TaskResult +import com.beust.kobalt.api.Project +import com.google.inject.Inject +import java.io.File + +class Git @Inject constructor() { + fun maybeTagRelease(project: Project, uploadResult: TaskResult, enabled: Boolean, annotated: Boolean, + push: Boolean, tag: String, message: String) : TaskResult { + val result = + if (uploadResult.success && enabled) { + val tagSuccess = tagRelease(project, annotated, push, tag, message) + if (! tagSuccess) { + TaskResult(false, errorMessage = "Couldn't tag the project") + } else { + TaskResult() + } + } else { + TaskResult() + } + return result + } + + private fun tagRelease(project: Project, annotated: Boolean, push: Boolean, tag: String, message: String) : Boolean { + val version = if (tag.isNullOrBlank()) project.version else tag + val success = try { + log(2, "Tagging this release as \"$version\"") + val repo = org.eclipse.jgit.storage.file.FileRepositoryBuilder() + .setGitDir(File(KFiles.joinDir(project.directory, ".git"))) + .readEnvironment() + .findGitDir() + .build() + val git = org.eclipse.jgit.api.Git(repo) + // jGit library will complain and not tag if setAnnotated(false) + var ref = if (annotated) { + git.tag().setAnnotated(annotated).setName(version).setMessage(message).call() + } else { + git.tag().setName(version).setMessage(message).call() + } + if (push) { + git.push().setPushTags().call() + } + true + } catch(ex: Exception) { + warn("Couldn't create tag ${version}: ${ex.message}", ex) + false + } + + return success + } +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt index ad9b2095..b33286e0 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/GithubApi2.kt @@ -1,10 +1,15 @@ package com.beust.kobalt.misc +import com.beust.kobalt.Args import com.beust.kobalt.KobaltException +import com.beust.kobalt.api.Kobalt import com.beust.kobalt.internal.DocUrl import com.beust.kobalt.internal.KobaltSettings +import com.beust.kobalt.internal.build.VersionCheckTimestampFile import com.beust.kobalt.maven.Http +import com.beust.kobalt.maven.aether.Exceptions import com.google.gson.Gson +import com.google.gson.JsonParser import com.google.gson.annotations.SerializedName import com.google.inject.Inject import okhttp3.OkHttpClient @@ -14,12 +19,15 @@ import retrofit2.converter.gson.GsonConverterFactory import retrofit2.http.* import rx.Observable import java.io.File +import java.time.Duration +import java.time.Instant import java.util.* import java.util.concurrent.Callable import java.util.concurrent.Future class GithubApi2 @Inject constructor( - val executors: KobaltExecutors, val localProperties: LocalProperties, val http: Http, val settings:KobaltSettings) { + val executors: KobaltExecutors, val localProperties: LocalProperties, val http: Http, + val settings:KobaltSettings, val args: Args) { companion object { const val PROPERTY_ACCESS_TOKEN = "github.accessToken" @@ -70,7 +78,7 @@ class GithubApi2 @Inject constructor( class RetrofitError(var message: String = "", var errors : List = arrayListOf()) fun uploadRelease(packageName: String, tagName: String, zipFile: File) { - log(1, "Uploading release ${zipFile.name}") + kobaltLog(1, "Uploading release ${zipFile.name}") val username = localProperties.get(PROPERTY_USERNAME, DOC_URL) val accessToken = localProperties.get(PROPERTY_ACCESS_TOKEN, DOC_URL) @@ -78,15 +86,15 @@ class GithubApi2 @Inject constructor( .execute() val code = response.code() if (code != Http.CREATED) { - val error = Gson().fromJson(response.errorBody().string(), RetrofitError::class.java) + val error = Gson().fromJson(response.errorBody()?.string(), RetrofitError::class.java) throw KobaltException("Couldn't upload release, ${error.message}: " + error.errors[0].code) } else { val body = response.body() - uploadAsset(accessToken, body.uploadUrl!!, Http.TypedFile("application/zip", zipFile), tagName) + uploadAsset(accessToken, body?.uploadUrl!!, Http.TypedFile("application/zip", zipFile), tagName) .toBlocking() .forEach { action -> - log(1, "\n${zipFile.name} successfully uploaded") + kobaltLog(1, "\n${zipFile.name} successfully uploaded") } } } @@ -107,32 +115,42 @@ class GithubApi2 @Inject constructor( val latestKobaltVersion: Future get() { val callable = Callable { - var result = "0" - - val username = localProperties.getNoThrows(PROPERTY_USERNAME, DOC_URL) - val accessToken = localProperties.getNoThrows(PROPERTY_ACCESS_TOKEN, DOC_URL) - try { - val req = - if (username != null && accessToken != null) { - service.getReleases(username, "kobalt", accessToken) + var result = Kobalt.version + if (! args.dev && Duration.ofMinutes(10L) > + Duration.between(VersionCheckTimestampFile.timestamp, Instant.now())) { + kobaltLog(2, "Skipping GitHub latest release check, too soon.") + } else { + val username = localProperties.getNoThrows(PROPERTY_USERNAME) + val accessToken = localProperties.getNoThrows(PROPERTY_ACCESS_TOKEN) + try { + val req = + if (username != null && accessToken != null) { + service.getReleases(username, "kobalt", accessToken) + } else { + service.getReleasesNoAuth("cbeust", "kobalt") + } + val ex = req.execute() + val errorBody = ex.errorBody() + if (errorBody != null) { + val jsonError = JsonParser().parse(errorBody.string()) + warn("Couldn't call Github.getReleases(): $jsonError") + } else { + val releases = ex.body() + if (releases != null) { + releases.firstOrNull()?.let { + result = try { + listOf(it.name, it.tagName).filterNotNull().first { !it.isBlank() } + } catch(ex: NoSuchElementException) { + throw KobaltException("Couldn't find the latest release") + } + } } else { - service.getReleasesNoAuth("cbeust", "kobalt") - } - val releases = req.execute().body() - if (releases != null) { - releases.firstOrNull()?.let { - try { - result = listOf(it.name, it.tagName).filterNotNull().first { !it.isBlank() } - } catch(ex: NoSuchElementException) { - throw KobaltException("Couldn't find the latest release") + warn("Didn't receive any body in the response to GitHub.getReleases()") } } - } else { - warn("Didn't receive any body in the response to GitHub.getReleases()") - } - } catch(e: Exception) { - log(1, "Couldn't retrieve releases from github: " + e.message) - e.printStackTrace() + } catch(e: Exception) { + kobaltLog(1, "Couldn't retrieve releases from github: " + e.message) + Exceptions.printStackTrace(e) // val error = parseRetrofitError(e) // val details = if (error.errors != null) { // error.errors[0] @@ -141,8 +159,9 @@ class GithubApi2 @Inject constructor( // } // // TODO: If the credentials didn't work ("bad credentials"), should start again // // using cbeust/kobalt, like above. Right now, just bailing. -// log(2, "Couldn't retrieve releases from github, ${error.message ?: e}: " +// kobaltLog(2, "Couldn't retrieve releases from github, ${error.message ?: e}: " // + details?.code + " field: " + details?.field) + } } result } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt index a354043e..8d2b0580 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Io.kt @@ -1,20 +1,18 @@ package com.beust.kobalt.misc import java.io.File -import java.nio.file.Files -import java.nio.file.Paths -import java.nio.file.StandardCopyOption +import java.nio.file.* class Io(val dryRun: Boolean = false) { fun mkdirs(dir: String) { - log("mkdirs $dir") + kobaltLog("mkdirs $dir") if (! dryRun) { File(dir).mkdirs() } } fun rm(path: String) { - log("rm $path") + kobaltLog("rm $path") if (! dryRun) { File(path).deleteRecursively() @@ -22,7 +20,7 @@ class Io(val dryRun: Boolean = false) { } fun moveFile(from: File, toDir: File) { - log("mv $from $toDir") + kobaltLog("mv $from $toDir") if (! dryRun) { require(from.exists(), { -> "$from should exist" }) require(from.isFile, { -> "$from should be a file" }) @@ -34,7 +32,7 @@ class Io(val dryRun: Boolean = false) { } fun rename(from: File, to: File) { - log("rename $from $to") + kobaltLog("rename $from $to") moveFile(from, to.parentFile) if (from.name != to.name) { File(to, from.name).renameTo(to) @@ -42,13 +40,13 @@ class Io(val dryRun: Boolean = false) { } fun copyDirectory(from: File, toDir: File) { - log("cp -r $from $toDir") + kobaltLog("cp -r $from $toDir") if (! dryRun) { KFiles.copyRecursively(from, toDir) require(from.exists(), { -> "$from should exist" }) - require(from.isDirectory, { -> println("$from should be a directory")}) - require(toDir.isDirectory, { -> println("$toDir should be a file")}) + require(from.isDirectory, { -> kobaltLog(1, "$from should be a directory")}) + require(toDir.isDirectory, { -> kobaltLog(1, "$toDir should be a file")}) } } @@ -56,9 +54,9 @@ class Io(val dryRun: Boolean = false) { fun rmDir(dir: File, keep: (File) -> Boolean = { t -> false }) = rmDir(dir, keep, " ") private fun rmDir(dir: File, keep: (File) -> Boolean, indent : String) { - log("rm -rf $dir") + kobaltLog("rm -rf $dir") - require(dir.isDirectory, { -> println("$dir should be a directory")}) + require(dir.isDirectory, { -> kobaltLog(1, "$dir should be a directory")}) dir.listFiles({ p0 -> ! keep(p0!!) }).forEach { if (it.isDirectory) { @@ -66,21 +64,21 @@ class Io(val dryRun: Boolean = false) { it.deleteRecursively() } else { - log(indent + "rm $it") + kobaltLog(indent + "rm $it") if (! dryRun) it.delete() } } } fun mkdir(dir: File) { - log("mkdir $dir") + kobaltLog("mkdir $dir") if (! dryRun) { dir.mkdirs() } } - private fun log(s: String) { - log(1, "[Io] $s") + private fun kobaltLog(s: String) { + kobaltLog(1, "[Io] $s") } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt index a17c2196..ba83b0a6 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/JarUtils.kt @@ -1,18 +1,18 @@ package com.beust.kobalt.misc -import com.beust.kobalt.Glob +import com.beust.kobalt.From import com.beust.kobalt.IFileSpec +import com.beust.kobalt.IncludedFile +import com.beust.kobalt.To +import com.beust.kobalt.archive.MetaArchive import com.google.common.io.CharStreams -import java.io.* -import java.nio.file.Paths -import java.util.jar.JarEntry +import java.io.File +import java.io.FileOutputStream +import java.io.InputStreamReader import java.util.jar.JarFile -import java.util.jar.JarInputStream -import java.util.zip.ZipEntry import java.util.zip.ZipFile -import java.util.zip.ZipOutputStream -public class JarUtils { +class JarUtils { companion object { val DEFAULT_HANDLER: (Exception) -> Unit = { ex: Exception -> // Ignore duplicate entry exceptions @@ -21,18 +21,15 @@ public class JarUtils { } } - fun addFiles(directory: String, files: List, target: ZipOutputStream, + fun addFiles(directory: String, files: List, metaArchive: MetaArchive, expandJarFiles: Boolean, onError: (Exception) -> Unit = DEFAULT_HANDLER) { files.forEach { - addSingleFile(directory, it, target, expandJarFiles, onError) + addSingleFile(directory, it, metaArchive, expandJarFiles, onError) } } - private val DEFAULT_JAR_EXCLUDES = - Glob("META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA") - - fun addSingleFile(directory: String, file: IncludedFile, outputStream: ZipOutputStream, + fun addSingleFile(directory: String, file: IncludedFile, metaArchive: MetaArchive, expandJarFiles: Boolean, onError: (Exception) -> Unit = DEFAULT_HANDLER) { val foundFiles = file.allFromFiles(directory) foundFiles.forEach { foundFile -> @@ -47,60 +44,34 @@ public class JarUtils { } if (foundFile.isDirectory) { - log(2, " Writing contents of directory $foundFile") + kobaltLog(2, " Writing contents of directory $foundFile") // Directory val includedFile = IncludedFile(From(""), To(""), listOf(IFileSpec.GlobSpec("**"))) - addSingleFile(localFile.path, includedFile, outputStream, expandJarFiles) + addSingleFile(localFile.path, includedFile, metaArchive, expandJarFiles) } else { - if (file.expandJarFiles && foundFile.name.endsWith(".jar") && ! file.from.contains("resources")) { - log(2, " Writing contents of jar file $foundFile") - val stream = JarInputStream(FileInputStream(localFile)) - var entry = stream.nextEntry - while (entry != null) { - if (!entry.isDirectory && !KFiles.isExcluded(entry.name, DEFAULT_JAR_EXCLUDES)) { - val ins = JarFile(localFile).getInputStream(entry) - addEntry(ins, JarEntry(entry), outputStream, onError) - } - entry = stream.nextEntry + try { + if (file.expandJarFiles && foundFile.name.endsWith(".jar") && !file.from.contains("resources")) { + kobaltLog(2, " Writing contents of jar file $foundFile") + metaArchive.addArchive(foundFile) + } else { + val toPath = File(file.to).normalize().path + val finalPath = if (toPath.isEmpty()) null else (toPath + "/") + metaArchive.addFile(File(directory, fromFile.path), foundFile, finalPath) } - } else { - val entryFileName = file.to(foundFile.path).path.replace("\\", "/") - val entry = JarEntry(entryFileName) - entry.time = localFile.lastModified() - addEntry(FileInputStream(localFile), entry, outputStream, onError) + } catch(ex: Exception) { + onError(ex) } } } } - private fun addEntry(inputStream: InputStream, entry: ZipEntry, outputStream: ZipOutputStream, - onError: (Exception) -> Unit = DEFAULT_HANDLER) { - var bis: BufferedInputStream? = null - try { - outputStream.putNextEntry(entry) - bis = BufferedInputStream(inputStream) - - val buffer = ByteArray(50 * 1024) - while (true) { - val count = bis.read(buffer) - if (count == -1) break - outputStream.write(buffer, 0, count) - } - outputStream.closeEntry() - } catch(ex: Exception) { - onError(ex) - } finally { - bis?.close() - } - } - fun extractTextFile(zip : ZipFile, fileName: String) : String? { val enumEntries = zip.entries() while (enumEntries.hasMoreElements()) { val file = enumEntries.nextElement() if (file.name == fileName) { - log(2, "Found $fileName in ${zip.name}") + kobaltLog(2, "Found $fileName in ${zip.name}") zip.getInputStream(file).use { ins -> return CharStreams.toString(InputStreamReader(ins, "UTF-8")) } @@ -134,39 +105,3 @@ public class JarUtils { } } -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 IncludedFile(val fromOriginal: From, val toOriginal: To, val specs: List, - val expandJarFiles: Boolean = false) { - constructor(specs: List, 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 public fun toString() = toString("IncludedFile", - "files - ", specs.map { it.toString() }, - "from", from, - "to", to) - - fun allFromFiles(directory: String? = null): List { - val result = arrayListOf() - 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()} - } -} - -class From(override val p: String) : Direction(p) - -class To(override val p: String) : Direction(p) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt index 36f242d8..fcf5b86a 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KFiles.kt @@ -3,24 +3,39 @@ package com.beust.kobalt.misc import com.beust.kobalt.* import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project -import com.beust.kobalt.internal.build.BuildFile import com.beust.kobalt.maven.Md5 -import java.io.File -import java.io.IOException -import java.io.InputStream -import java.io.OutputStream +import org.apache.commons.io.FileUtils +import java.io.* import java.nio.file.Files import java.nio.file.Path import java.nio.file.Paths import java.nio.file.StandardCopyOption +import java.util.* +import java.util.jar.JarInputStream +import java.util.regex.Pattern + class KFiles { /** * This actually returns a list of strings because in development mode, we are not pointing to a single - * jar file but to a set of /classes directories. + * jar file but to a set of classes/directories. */ val kobaltJar : List get() { + val PATTERN = Pattern.compile("kobalt-([-.0-9]+)") + + fun latestInstalledVersion() : StringVersion { + val versions = File(distributionsDir).listFiles().map { it.name }.map { + val matcher = PATTERN.matcher(it) + val result = + if (matcher.matches()) matcher.group(1) + else null + result + }.filterNotNull().map(::StringVersion) + Collections.sort(versions, reverseOrder()) + return versions[0] + } + val envJar = System.getenv("KOBALT_JAR") if (envJar != null) { debug("Using kobalt jar $envJar") @@ -32,17 +47,21 @@ class KFiles { if (jarFile.exists()) { return listOf(jarFile.absolutePath) } else { - // In development mode, keep your kobalt.properties version one above kobalt-wrapper.properties: + // In development mode, keep your kobalt.properties version to a nonexistent version // kobalt.properties: kobalt.version=0.828 // kobalt-wrapper.properties: kobalt.version=0.827 // When Kobalt can't find the newest jar file, it will instead use the classes produced by IDEA // in the directories specified here: - val previousVersion = "0." + (Kobalt.version.split(".")[1].toInt() - 1).toString() + val previousVersion = latestInstalledVersion().version val previousJar = joinDir(distributionsDir, "kobalt-" + previousVersion, - "kobalt/wrapper/kobalt-" + previousVersion + ".jar") + "kobalt/wrapper/kobalt-$previousVersion.jar") + latestInstalledVersion() val result = listOf("", "modules/kobalt-plugin-api", "modules/wrapper").map { - File(homeDir(KFiles.joinDir("kotlin", "kobalt", it, "kobaltBuild", "classes"))) - .absolutePath + File(homeDir(KFiles.joinDir("kotlin", "kobalt", it, "kobaltBuild", "classes"))) //kobalt build dirs + .absolutePath + } + listOf("modules/kobalt", "modules/kobalt-plugin-api", "modules/wrapper").map { + File(homeDir(KFiles.joinDir("kotlin", "kobalt", it, "target", "classes"))) //maven build dirs + .absolutePath } + listOf(previousJar) debug("Couldn't find ${jarFile.absolutePath}, using\n " + result.joinToString(" ")) return result.filter { File(it).exists() } @@ -92,10 +111,12 @@ class KFiles { */ fun joinDir(vararg ts: String): String = ts.toMutableList().joinToString(File.separator) + val LIBS_DIR = "libs" + /** * Where assemblies get generated ("kobaltBuild/libs") */ - fun libsDir(project: Project) = KFiles.makeDir(KFiles.buildDir(project).path, "libs").path + fun libsDir(project: Project): String = KFiles.makeDir(KFiles.buildDir(project).path, LIBS_DIR).path /** * The paths elements are expected to be a directory. Make that directory and join the @@ -115,15 +136,18 @@ class KFiles { */ fun joinFileAndMakeDir(vararg ts: String) = joinDir(joinAndMakeDir(ts.slice(0..ts.size - 2)), ts[ts.size - 1]) + fun fixSlashes(f: File) = f.normalize().path.replace('\\', '/') + fun fixSlashes(s: String) = s.replace('\\', '/') + fun makeDir(dir: String, s: String? = null) = (if (s != null) File(dir, s) else File(dir)).apply { mkdirs() } fun findRecursively(rootDir: File) : List = - findRecursively(rootDir, arrayListOf(), { s -> true }) + findRecursively(rootDir, arrayListOf(), { _ -> true }) fun findRecursively(rootDir: File, directories: List, function: Function1): List { - var result = arrayListOf() + val result = arrayListOf() val allDirs = arrayListOf() if (directories.isEmpty()) { @@ -135,7 +159,9 @@ class KFiles { val seen = hashSetOf() allDirs.forEach { dir -> if (! dir.exists()) { - log(2, "Couldn't find directory $dir") + kobaltLog(2, "Couldn't find directory $dir") + } else if (! dir.isDirectory) { + throw IllegalArgumentException("$dir is not a directory") } else { val files = findRecursively(dir, function) files.map { Paths.get(it) }.forEach { @@ -144,7 +170,7 @@ class KFiles { result.add(File(dir, rel.toFile().path).path) seen.add(rel) } else { - log(2, "Skipped file already seen in previous flavor: $rel") + kobaltLog(2, "Skipped file already seen in previous flavor: $rel") } } } @@ -155,7 +181,7 @@ class KFiles { } fun findRecursively(directory: File, function: Function1): List { - var result = arrayListOf() + val result = arrayListOf() directory.listFiles().forEach { if (it.isFile && function(it.path)) { result.add(it.path) @@ -166,111 +192,71 @@ class KFiles { return result } - fun copyRecursively(from: File, to: File, replaceExisting: Boolean = true, deleteFirst: Boolean = false, - onError: (File, IOException) -> OnErrorAction = { file, exception -> throw exception }) { - // Need to wait until copyRecursively supports an overwrite: Boolean = false parameter - // Until then, wipe everything first - if (deleteFirst) to.deleteRecursively() -// to.mkdirs() - hackCopyRecursively(from, to, replaceExisting = replaceExisting, onError = onError) - } - - /** Private exception class, used to terminate recursive copying */ - private class TerminateException(file: File) : FileSystemException(file) {} - /** - * Copy/pasted from kotlin/io/Utils.kt to add support for overwriting. + * List the files contained in a directory or a jar file. */ - private fun hackCopyRecursively(from: File, dst: File, - replaceExisting: Boolean, - checkTimestamp: Boolean = false, - onError: (File, IOException) -> OnErrorAction = - { file, exception -> throw exception } - ): Boolean { - if (!from.exists()) { - return onError(from, NoSuchFileException(file = from, reason = "The source file doesn't exist")) != - OnErrorAction.TERMINATE - } - try { - // We cannot break for loop from inside a lambda, so we have to use an exception here - for (src in from.walkTopDown().onFail { f, e -> - if (onError(f, e) == OnErrorAction.TERMINATE) throw TerminateException(f) - }) { - if (!src.exists()) { - if (onError(src, NoSuchFileException(file = src, reason = "The source file doesn't exist")) == - OnErrorAction.TERMINATE) - return false - } else { - val relPath = src.relativeTo(from) - val dstFile = File(KFiles.joinDir(dst.path, relPath.path)) - if (dstFile.exists() && !replaceExisting && !(src.isDirectory && dstFile.isDirectory)) { - if (onError(dstFile, FileAlreadyExistsException(file = src, - other = dstFile, - reason = "The destination file already exists")) == OnErrorAction.TERMINATE) - return false - } else if (src.isDirectory) { - dstFile.mkdirs() - } else { - if (Features.USE_TIMESTAMPS && dstFile.exists() && Md5.toMd5(src) == Md5.toMd5(dstFile)) { - log(3, " Identical files, not copying $src to $dstFile") - } else { - val target = src.copyTo(dstFile, true) - if (target.length() != src.length()) { - if (onError(src, - IOException("src.length() != dst.length()")) == OnErrorAction.TERMINATE) - return false - } - } + fun listFiles(file: File, block: (String) -> Unit) { + if (file.isDirectory) { + KFiles.findRecursively(file).forEach { + block(it) + } + } else if (file.name.endsWith(".jar")) { + FileInputStream(file).use { + JarInputStream(it).use { stream -> + var entry = stream.nextJarEntry + while (entry != null) { + block(entry.name) + entry = stream.nextJarEntry; } } } - return true - } catch (e: TerminateException) { - return false - } - } - private fun findDotDir(buildFile: BuildFile) : File { - val result = File(buildFile.directory.parentFile.parentFile, KOBALT_DOT_DIR).apply { - mkdirs() + } else { + throw KobaltException("Can't list files of a file: " + file) } - return result } /** * The build location for build scripts is .kobalt/build */ - fun findBuildScriptLocation(buildFile: BuildFile, jarFile: String) : String { - val result = joinDir(buildFile.dotKobaltDir.absolutePath, KFiles.SCRIPT_BUILD_DIR, jarFile) - log(2, "Script jar file: $result") + fun findBuildScriptDir(parent: String = ".") : File { + val result = File(joinAndMakeDir(parent, KFiles.dotKobaltDir.path, KFiles.SCRIPT_BUILD_DIR)) + kobaltLog(2, " Script jar files in: $result") return result } fun saveFile(file: File, text: String) { - file.absoluteFile.parentFile.mkdirs() - file.writeText(text) - log(2, "Created $file") + var canCreate = true + with(file.absoluteFile.parentFile) { + if (!exists()) { + val success = mkdirs() + if (!success) { + warn("Couldn't create directory to save $file") + canCreate = false + } + } + } + if (canCreate) { + file.writeText(text) + kobaltLog(2, "Created $file") + } } - private fun isWindows() = System.getProperty("os.name").contains("Windows"); + private fun isWindows() = System.getProperty("os.name").contains("Windows") fun copy(from: Path?, to: Path?, option: StandardCopyOption = StandardCopyOption.REPLACE_EXISTING) { - if (isWindows() && to!!.toFile().exists()) { - log(2, "Windows detected, not overwriting $to") - } else { - try { - if (from != null && to != null) { - if (!Files.exists(to) || Md5.toMd5(from.toFile()) != Md5.toMd5(to.toFile())) { - log(3, "Copy from $from to $to") - Files.copy(from, to, option) - } else { - log(3, " Not copying, indentical files: $from $to") - } + try { + if (from != null && to != null) { + if (!Files.exists(to) || Md5.toMd5(from.toFile()) != Md5.toMd5(to.toFile())) { + kobaltLog(3, "Copy from $from to $to") + Files.copy(from, to, option) + } else { + kobaltLog(3, " Not copying, indentical files: $from $to") } - } catch(ex: IOException) { - // Windows is anal about this - log(1, "Couldn't copy $from to $to: ${ex.message}") } + } catch(ex: IOException) { + // Windows is anal about this + kobaltLog(1, "Couldn't copy $from to $to: ${ex.message}") } } @@ -282,12 +268,18 @@ class KFiles { } } - fun createTempFile(suffix : String = "", deleteOnExit: Boolean = false) : File = - File.createTempFile("kobalt", suffix, File(SystemProperties.tmpDir)).let { + fun createTempBuildFileInTempDirectory(deleteOnExit: Boolean = false) : File = + File(createTempDirectory("kobalt", deleteOnExit), Constants.BUILD_FILE_NAME).let { if (deleteOnExit) it.deleteOnExit() return it } + fun createTempDirectory(prefix : String = "kobalt", deleteOnExit: Boolean = false) : File = + Files.createTempDirectory(prefix).let { + if (deleteOnExit) it.toFile().deleteOnExit() + return it.toFile() + } + fun src(filePath: String): String = KFiles.joinDir(KOBALT_DIR, SRC, filePath) fun makeDir(project: Project, suffix: String) : File { @@ -300,8 +292,6 @@ class KFiles { fun isExcluded(file: String, excludes: Glob) = isExcluded(file, listOf(excludes)) - fun isExcluded(file: File, excludes: Glob) = isExcluded(file.path, listOf(excludes)) - fun isExcluded(file: File, excludes: List) = isExcluded(file.path, excludes) fun isExcluded(file: String, excludes: List): Boolean = excludes.any { it.matches(file) } @@ -326,7 +316,7 @@ class KFiles { false }) } else { - log(3, "Skipping nonexistent source directory $sourceDir") + kobaltLog(3, "Skipping nonexistent source directory $sourceDir") } } return result @@ -349,6 +339,37 @@ class KFiles { return false } } + + val dotKobaltDir = File(KFiles.joinAndMakeDir(KFiles.KOBALT_DOT_DIR)) + + /** + * Turn the IncludedFiles into actual Files + */ + fun materializeIncludedFiles(project: Project, includedFiles: List) : List { + val result = includedFiles.fold(arrayListOf()) { files, includedFile: IncludedFile -> + val foundFiles = includedFile.allFromFiles(project.directory) + val absFiles = foundFiles.map { + if (it.isAbsolute) { + it + } else if (File(includedFile.from).isAbsolute) { + File(includedFile.from, it.path) + } else { + File(KFiles.joinDir(project.directory, includedFile.from, it.path)) + } + } + files.addAll(absFiles) + files + } + return result + } + + fun copyRecursively(from: File, to: File, replaceExisting: Boolean = true, deleteFirst: Boolean = false) { +// fun copy(relativePath: String, sourceDir: File, targetDir: File) = +// sourceDir.resolve(relativePath).copyRecursively(targetDir.resolve(relativePath), overwrite = true) + if (from.isFile) FileUtils.copyFileToDirectory(from, to) + else FileUtils.copyDirectory(from, to) + } + } fun findRecursively(directory: File, function: Function1): List { diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt index 9e0ac2d6..1dc9ab41 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltExecutors.kt @@ -66,14 +66,14 @@ class KobaltExecutors { progress(r) result.add(r) remainingMs -= (System.currentTimeMillis() - start) - log(3, "Received $r, remaining: $remainingMs ms") + kobaltLog(3, "Received $r, remaining: $remainingMs ms") i++ } if (remainingMs < 0) { warn("Didn't receive all the results in time: $i / ${tasks.size}") } else { - log(2, "Received all results in ${maxMs - remainingMs} ms") + kobaltLog(2, "Received all results in ${maxMs - remainingMs} ms") } executor.shutdown() diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt index 595a635c..e2bd89de 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt @@ -1,23 +1,36 @@ package com.beust.kobalt.misc +import com.beust.kobalt.Args import com.beust.kobalt.AsciiArt +import com.beust.kobalt.Constants import com.beust.kobalt.KobaltException import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.maven.aether.Exceptions +import java.lang.Exception import java.time.LocalDateTime import java.time.format.DateTimeFormatter fun Any.log(level: Int, text: CharSequence, newLine : Boolean = true) { - if (level <= KobaltLogger.LOG_LEVEL) { + if (level <= KobaltLogger.LOG_LEVEL && !KobaltLogger.isQuiet) { KobaltLogger.logger.log(javaClass.simpleName, text, newLine) } } +fun Any.kobaltLog(level: Int, text: CharSequence, newLine : Boolean = true) = log(level, text, newLine) +fun Any.kobaltWarn(text: CharSequence) = warn(text) +fun Any.kobaltError(text: CharSequence) = error(text) +fun Any.kobaltLog(tag: String, text: CharSequence, newLine : Boolean = true) { + if (Kobalt.INJECTOR.getInstance(Args::class.java).logTags.split(',').contains(tag)) { + log(1, text, newLine) + } +} + fun Any.logWrap(level: Int, text1: CharSequence, text2: CharSequence, function: () -> Unit) { - if (level <= KobaltLogger.LOG_LEVEL) { + if (level <= KobaltLogger.LOG_LEVEL && !KobaltLogger.isQuiet) { KobaltLogger.logger.log(javaClass.simpleName, text1, newLine = false) } function() - if (level <= KobaltLogger.LOG_LEVEL) { + if (level <= KobaltLogger.LOG_LEVEL && !KobaltLogger.isQuiet) { KobaltLogger.logger.log(javaClass.simpleName, text2, newLine = true) } } @@ -39,11 +52,21 @@ fun Any.error(text: CharSequence, e: Throwable? = null) { object KobaltLogger { var LOG_LEVEL: Int = 1 + val isQuiet: Boolean get() = (LOG_LEVEL == Constants.LOG_QUIET_LEVEL) + val logger: Logger get() = - if (Kobalt.context != null) { - Logger(Kobalt.context!!.args.dev) - } else { - Logger(false) + if (Kobalt.context != null) { + Logger(Kobalt.context!!.args.dev) + } else { + Logger(false) + } + + fun setLogLevel(args: Args) { + LOG_LEVEL = when { + args.log < Constants.LOG_QUIET_LEVEL -> Constants.LOG_DEFAULT_LEVEL + args.log > Constants.LOG_MAX_LEVEL -> Constants.LOG_MAX_LEVEL + else -> args.log + } } } @@ -58,32 +81,36 @@ class Logger(val dev: Boolean) { longMessage } - final fun debug(tag: String, message: CharSequence) = + fun debug(tag: String, message: CharSequence) = println(getPattern("D", message, message, tag)) - final fun error(tag: String, message: CharSequence, e: Throwable? = null) { + fun error(tag: String, message: CharSequence, e: Throwable? = null) { val docUrl = if (e is KobaltException && e.docUrl != null) e.docUrl else null - val text = if (! message.isBlank()) message + val text = + if (message.isNotBlank()) message else if (e != null && (! e.message.isNullOrBlank())) e.message - else { "" } + else { e?.toString() } val shortMessage = "***** E $text " + if (docUrl != null) " Documentation: $docUrl" else "" val longMessage = "*****\n***** ERROR $text\n*****" println(AsciiArt.errorColor(getPattern("E", shortMessage, longMessage, tag))) - if (KobaltLogger.LOG_LEVEL > 1) { - e?.printStackTrace() + if (KobaltLogger.LOG_LEVEL > 1 && e != null) { + Exceptions.printStackTrace(e) } } - final fun warn(tag: String, message: CharSequence, e: Throwable? = null) { - val fullMessage = "***** WARNING " + (e?.message ?: message) + fun warn(tag: String, message: CharSequence, e: Throwable? = null) { + val fullMessage = "***** WARNING " + + if (message.isNotBlank()) message + else if (e != null && (!e.message.isNullOrBlank())) e.message + else e?.toString() println(AsciiArt.Companion.warnColor(getPattern("W", fullMessage, fullMessage, tag))) - if (KobaltLogger.LOG_LEVEL > 1) { - e?.printStackTrace() + if (KobaltLogger.LOG_LEVEL > 1 && e != null) { + Exceptions.printStackTrace(e) } } - final fun log(tag: String, message: CharSequence, newLine: Boolean) = + fun log(tag: String, message: CharSequence, newLine: Boolean) = with(getPattern("L", message, message, tag)) { if (newLine) println(this) else print("\r" + this) diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt index 8af0da44..a7b5177d 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltWrapperProperties.kt @@ -16,7 +16,7 @@ class KobaltWrapperProperties @Inject constructor() { private val PROPERTY_DOWNLOAD_URL = "kobalt.downloadUrl" fun create(version: String) { - log(2, "Creating $file with $version and ${defaultUrlFor(version)}") + kobaltLog(2, "Creating $file with $version and ${defaultUrlFor(version)}") KFiles.saveFile(file, listOf( "$PROPERTY_VERSION=$version" // "$PROPERTY_DOWNLOAD_URL=${defaultUrlFor(version)}" @@ -24,7 +24,7 @@ class KobaltWrapperProperties @Inject constructor() { } private fun defaultUrlFor(version: String) = - "http://beust.com/kobalt/kobalt-$version.zip" + "https://beust.com/kobalt/kobalt-$version.zip" private val file: File get() = File("$WRAPPER_DIR/$KOBALT_WRAPPER_PROPERTIES") diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt index 4fe16a5c..2cf0775e 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/LocalProperties.kt @@ -6,6 +6,9 @@ import java.nio.file.Files import java.nio.file.Paths import java.util.* +/** + * Encapsulate read access to local.properties. + */ @Singleton class LocalProperties { val localProperties: Properties by lazy { @@ -22,11 +25,11 @@ class LocalProperties { result } - fun getNoThrows(name: String, docUrl: String? = null) = localProperties.getProperty(name) + fun getNoThrows(name: String): String? = localProperties.getProperty(name) fun get(name: String, docUrl: String? = null) : String { - val result = getNoThrows(name, docUrl) + val result = getNoThrows(name) ?: throw KobaltException("Couldn't find $name in local.properties", docUrl = docUrl) - return result as String + return result } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt index a0178c68..e105133b 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/NewRunCommand.kt @@ -19,6 +19,7 @@ class RunCommandInfo { */ var useErrorStreamAsErrorIndicator : Boolean = true var useInputStreamAsErrorIndicator : Boolean = false + var ignoreExitValue : Boolean = false var errorCallback: Function1, Unit> = NewRunCommand.DEFAULT_ERROR var successCallback: Function1, Unit> = NewRunCommand.DEFAULT_SUCCESS @@ -37,6 +38,8 @@ class RunCommandInfo { ! hasErrors } + + var containsErrors: ((List) -> Boolean)? = null } fun runCommand(init: RunCommandInfo.() -> Unit) = NewRunCommand(RunCommandInfo().apply { init() }).invoke() @@ -45,11 +48,11 @@ open class NewRunCommand(val info: RunCommandInfo) { companion object { val DEFAULT_SUCCESS = { output: List -> } - // val DEFAULT_SUCCESS_VERBOSE = { output: List -> log(2, "Success:\n " + output.joinToString("\n"))} + // val DEFAULT_SUCCESS_VERBOSE = { output: List -> kobaltLog(2, "Success:\n " + output.joinToString + // ("\n"))} // val defaultSuccess = DEFAULT_SUCCESS - val DEFAULT_ERROR = { - output: List -> - kotlin.error(output.joinToString("\n ")) + val DEFAULT_ERROR = { output: List -> + kobaltError(output.joinToString("\n ")) } } @@ -65,7 +68,7 @@ open class NewRunCommand(val info: RunCommandInfo) { val pb = ProcessBuilder(allArgs) pb.directory(info.directory) - log(2, "Running command in directory ${info.directory.absolutePath}" + + kobaltLog(2, "Running command in directory ${info.directory.absolutePath}" + "\n " + allArgs.joinToString(" ").replace("\\", "/")) pb.environment().let { pbEnv -> info.env.forEach { @@ -76,17 +79,31 @@ open class NewRunCommand(val info: RunCommandInfo) { val process = pb.start() // Run the command and collect the return code and streams - val returnCode = process.waitFor(30, TimeUnit.SECONDS) - val input = if (process.inputStream.available() > 0) fromStream(process.inputStream) - else listOf() - val error = if (process.errorStream.available() > 0) fromStream(process.errorStream) - else listOf() + val processFinished = process.waitFor(120, TimeUnit.SECONDS) + + if (!processFinished) + kobaltError("process timed out!") + + val input = + if (process.inputStream.available() > 0) fromStream(process.inputStream) + else listOf() + val error = + if (process.errorStream.available() > 0) fromStream(process.errorStream) + else listOf() + + kobaltLog(3, "info contains errors: " + (info.containsErrors != null)) // Check to see if the command succeeded - val isSuccess = isSuccess(returnCode, input, error) + val isSuccess = + if (info.containsErrors != null) ! info.containsErrors!!(error) + else isSuccess(if (info.ignoreExitValue) true else processFinished, input, error) if (isSuccess) { - info.successCallback(input) + if (!info.useErrorStreamAsErrorIndicator) { + info.successCallback(error + input) + } else { + info.successCallback(input) + } } else { info.errorCallback(error + input) } @@ -99,12 +116,12 @@ open class NewRunCommand(val info: RunCommandInfo) { * have various ways to signal errors. */ open protected fun isSuccess(isSuccess: Boolean, input: List, error: List) : Boolean { - var hasErrors = ! isSuccess + var hasErrors: Boolean = ! isSuccess if (info.useErrorStreamAsErrorIndicator && ! hasErrors) { - hasErrors = hasErrors || error.size > 0 + hasErrors = hasErrors || error.isNotEmpty() } if (info.useInputStreamAsErrorIndicator && ! hasErrors) { - hasErrors = hasErrors || input.size > 0 + hasErrors = hasErrors || input.isNotEmpty() } return ! hasErrors diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt index 4fd2f216..26707f03 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Node.kt @@ -1,10 +1,10 @@ package com.beust.kobalt.misc -public data class Node(val value: T) { +data class Node(val value: T) { val children = arrayListOf>() var parent: Node? = null - public fun addChildren(values: List>) { + fun addChildren(values: List>) { values.forEach { it.parent = this children.add(it) @@ -12,15 +12,15 @@ public data class Node(val value: T) { } private fun p(s: String) { - println(s) + kobaltLog(1, s) } - public fun dump(r: T, children: List>, indent: Int) { + fun dump(r: T, children: List>, indent: Int) { p(" ".repeat(indent) + r) children.forEach { dump(it.value, it.children, indent + 2) } } - public fun dump(indent: Int = 0) { + fun dump(indent: Int = 0) { dump(value, children, indent) } } diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt deleted file mode 100644 index 76231527..00000000 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt +++ /dev/null @@ -1,90 +0,0 @@ -package com.beust.kobalt.misc - -import java.io.BufferedReader -import java.io.File -import java.io.InputStream -import java.io.InputStreamReader -import java.util.concurrent.TimeUnit - -open class RunCommand(val command: String) { - val DEFAULT_SUCCESS = { output: List -> } -// val DEFAULT_SUCCESS_VERBOSE = { output: List -> log(2, "Success:\n " + output.joinToString("\n"))} - val defaultSuccess = DEFAULT_SUCCESS - val DEFAULT_ERROR = { - output: List -> error(output.joinToString("\n ")) - } - - var directory = File(".") - var env = hashMapOf() - - /** - * Some commands fail but return 0, so the only way to find out if they failed is to look - * at the error stream. However, some commands succeed but output text on the error stream. - * This field is used to specify how errors are caught. - */ - var useErrorStreamAsErrorIndicator = true - var useInputStreamAsErrorIndicator = false - - fun useErrorStreamAsErrorIndicator(f: Boolean) : RunCommand { - useErrorStreamAsErrorIndicator = f - return this - } - - open fun run(args: List, - errorCallback: Function1, Unit> = DEFAULT_ERROR, - successCallback: Function1, Unit> = defaultSuccess) : Int { - val allArgs = arrayListOf() - allArgs.add(command) - allArgs.addAll(args) - - val pb = ProcessBuilder(allArgs) - pb.directory(directory) - log(2, "Running command in directory ${directory.absolutePath}" + - "\n " + allArgs.joinToString(" ")) - val process = pb.start() - pb.environment().let { pbEnv -> - env.forEach {it -> - pbEnv.put(it.key, it.value) - } - } - val callSucceeded = process.waitFor(30, TimeUnit.SECONDS) - val input = if (process.inputStream.available() > 0) fromStream(process.inputStream) else emptyList() - val error = if (process.errorStream.available() > 0) fromStream(process.errorStream) else emptyList() - val isSuccess = isSuccess(callSucceeded, input, error) - - if (isSuccess) { - successCallback(input) - } else { - errorCallback(error + input) - } - - return if (isSuccess) 0 else 1 - } - - open protected fun isSuccess(callSucceeded: Boolean, input: List, error: List) : Boolean { - var hasErrors = ! callSucceeded - if (useErrorStreamAsErrorIndicator && ! hasErrors) { - hasErrors = hasErrors || error.size > 0 - } - if (useInputStreamAsErrorIndicator && ! hasErrors) { - hasErrors = hasErrors || input.size > 0 - } - - return ! hasErrors - } - - private fun fromStream(ins: InputStream) : List { - val result = arrayListOf() - val br = BufferedReader(InputStreamReader(ins)) - var line = br.readLine() - - while (line != null) { - result.add(line) - line = br.readLine() - } - return result - -// val result = CharStreams.toString(InputStreamReader(ins, Charset.defaultCharset())) -// return result.split("\n") - } -} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/StringVersion.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/StringVersion.kt new file mode 100644 index 00000000..b421e558 --- /dev/null +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/StringVersion.kt @@ -0,0 +1,50 @@ +package com.beust.kobalt.misc + +import java.lang.Long +import java.lang.NumberFormatException +import java.util.* + +/** + * Compare string versions, e.g. "1.2.0", "0.9", etc... + */ +class StringVersion(val version: String) : Comparable { + override fun compareTo(other: StringVersion): Int { + val s1 = arrayListOf().apply { addAll(version.split('.')) } + val s2 = arrayListOf().apply { addAll(other.version.split('.')) } + + // Normalize both strings, so they have the same length, e.g. 1 -> 1.0.0 + val max = Math.max(s1.size, s2.size) + val shorterList : ArrayList = if (s1.size == max) s2 else s1 + repeat(max - shorterList.size) { + shorterList.add("0") + } + + // Compare each section + repeat(max) { index -> + try { + fun parse(s: String) = Long.parseLong(s.filter(Char::isDigit)) + + val v1 = parse(s1[index]) + val v2 = parse(s2[index]) + if (v1 < v2) return -1 + else if (v1 > v2) return 1 + } catch(ex: NumberFormatException) { + if (version == other.toString()) { + return 0 + } else { + log(2, "Couldn't parse version $version or $other") + return -1 + } + } + } + return 0 + } + + override fun equals(other: Any?) = + if (other is StringVersion) this.compareTo(other) == 0 + else false + + override fun hashCode() = version.hashCode() + + override fun toString() = version +} diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt index 70e61690..205c2ced 100644 --- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt +++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/Versions.kt @@ -1,41 +1,10 @@ package com.beust.kobalt.misc import com.beust.kobalt.maven.MavenId -import com.google.common.base.CharMatcher +import java.lang.* import java.math.BigInteger import java.util.* -public class Versions { - companion object { - /** - * Turn "6.9.4" into 600090004 - */ - public fun toLongVersion(version: String) : Long { - val count = version.countChar('.') - val normalizedVersion = if (count == 2) version else if (count == 1) version + ".0" - else version + ".0.0" - - fun parseLong(s: String, radix: Int) : Long { - try { - return java.lang.Long.parseLong(s, radix) - } catch(ex: NumberFormatException) { - warn("Couldn't parse version \"${version}\"") - return 0L - } - } - - return normalizedVersion - .split('.') - .take(3) - .map { - val s = CharMatcher.inRange('0', '9').or(CharMatcher.`is`('.')).retainFrom(it) - parseLong(s, 10) - } - .fold(0L, { n, s -> s + n * 10000 }) - } - } -} - class Version(val version: String, val snapshotTimestamp: String? = null): Comparable { companion object { diff --git a/modules/kobalt/build.gradle b/modules/kobalt/build.gradle new file mode 100644 index 00000000..57e009c7 --- /dev/null +++ b/modules/kobalt/build.gradle @@ -0,0 +1,79 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' version '1.2.71' + id 'com.github.johnrengelman.shadow' version '5.0.0' +} + +dependencies { + implementation project(':wrapper') + implementation project(':kobalt-plugin-api') + implementation "biz.aQute.bnd:biz.aQute.bndlib:$bndlib" + implementation 'com.github.spullara.mustache.java:compiler:0.9.5' + implementation "com.google.code.findbugs:jsr305:$findbugs" + implementation "com.sparkjava:spark-core:$spark" + implementation "com.squareup.okhttp3:logging-interceptor:$okhttp" + implementation 'com.sun.activation:javax.activation:1.2.0' + implementation "com.sun.xml.bind:jaxb-core:$jaxb" + implementation "com.sun.xml.bind:jaxb-impl:$jaxb" + implementation "javax.inject:javax.inject:$inject" + implementation "javax.xml.bind:jaxb-api:$jaxb" + implementation "org.apache.maven.resolver:maven-resolver-spi:$mavenResolver" + implementation "org.codehaus.groovy:groovy:$groovy" + 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.retrofit2:converter-gson:$retrofit" + implementation "com.squareup.retrofit2:retrofit:$retrofit" + implementation "org.apache.maven:maven-model:$maven" + implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:$kotlin" + implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin" + testImplementation 'org.assertj:assertj-core:3.8.0' + testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin" + testImplementation "org.testng:testng:$testng" +} + +sourceSets { + main.kotlin.srcDirs += "${rootProject.projectDir}../../src/main/kotlin" + test.kotlin.srcDirs += "${rootProject.projectDir}../../src/test/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' + } + } + } + } +} diff --git a/modules/kobalt/pom.xml b/modules/kobalt/pom.xml new file mode 100644 index 00000000..44dc799c --- /dev/null +++ b/modules/kobalt/pom.xml @@ -0,0 +1,231 @@ + + 4.0.0 + + com.beust + kobalt-pom + 1.1.0 + ../.. + + + kobalt + jar + 1.1.0 + + + + com.beust + kobalt-plugin-api + 1.1.0 + + + com.beust + wrapper + 1.1.0 + + + org.jetbrains.kotlin + kotlin-compiler-embeddable + ${kotlin.version} + + + org.jetbrains.kotlin + kotlin-stdlib + ${kotlin.version} + + + com.github.spullara.mustache.java + compiler + 0.9.5 + compile + + + javax.inject + javax.inject + 1 + compile + + + com.google.inject + guice + 4.2.2 + + + com.google.inject.extensions + guice-assistedinject + 4.2.2 + + + com.beust + jcommander + 1.72 + + + org.apache.maven + maven-model + 3.5.2 + + + com.google.code.findbugs + jsr305 + 3.0.2 + + + com.google.code.gson + gson + 2.8.2 + + + com.squareup.retrofit2 + retrofit + 2.3.0 + + + com.squareup.retrofit2 + converter-gson + 2.3.0 + + + biz.aQute.bnd + biz.aQute.bndlib + 3.5.0 + + + com.squareup.okhttp3 + logging-interceptor + ${okhttp3.version} + + + com.sparkjava + spark-core + 2.6.0 + + + org.codehaus.groovy + groovy + 2.4.12 + + + org.apache.maven.resolver + maven-resolver-spi + ${mavenresolver.version} + + + + 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.assertj + assertj-core + 3.8.0 + test + + + org.jetbrains.kotlin + kotlin-test + ${kotlin.version} + test + + + org.testng + testng + ${testng.version} + test + + + + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + + ${project.basedir}../../src/main/kotlin + + + + + test-compile + test-compile + + + ${project.basedir}../../src/test/kotlin + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + + + default-compile + none + + + + default-testCompile + none + + + java-compile + compile + compile + + + java-test-compile + test-compile + testCompile + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.1 + + + + com.beust.kobalt.MainKt + + + + + + package + + shade + + + + + + + \ No newline at end of file diff --git a/modules/wrapper/build.gradle b/modules/wrapper/build.gradle new file mode 100644 index 00000000..c0b5dafe --- /dev/null +++ b/modules/wrapper/build.gradle @@ -0,0 +1,38 @@ +jar { + manifest { + attributes 'Main-Class': 'com.beust.kobalt.wrapper.Main' + } +} + +publishing { + publications { + maven(MavenPublication) { + from(components.java) + artifact sourcesJar + artifact javadocJar + + pom { + name = project.name + description = 'Wrapper for Kobalt' + 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' + } + } + } + } +} diff --git a/modules/wrapper/kobalt-wrapper.iml b/modules/wrapper/kobalt-wrapper.iml deleted file mode 100644 index 3b541c0f..00000000 --- a/modules/wrapper/kobalt-wrapper.iml +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/modules/wrapper/pom.xml b/modules/wrapper/pom.xml new file mode 100644 index 00000000..a9dc8796 --- /dev/null +++ b/modules/wrapper/pom.xml @@ -0,0 +1,28 @@ + + 4.0.0 + + com.beust + kobalt-pom + 1.1.0 + ../.. + + + wrapper + jar + 1.1.0 + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.0 + + 1.7 + 1.7 + + + + + \ No newline at end of file diff --git a/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Config.java b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Config.java new file mode 100644 index 00000000..f6eb4b09 --- /dev/null +++ b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Config.java @@ -0,0 +1,72 @@ +package com.beust.kobalt.wrapper; + + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.Proxy; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +class Config { + + static Proxy getProxy() { + String configFilePath = getConfigFilePath(); + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + try { + DocumentBuilder builder = factory.newDocumentBuilder(); + ByteArrayInputStream input = new ByteArrayInputStream(getConfigFileContent(configFilePath)); + Document doc = builder.parse(input); + NodeList proxies =doc.getElementsByTagName("proxies"); + for (int temp = 0; temp < proxies.getLength(); temp++) { + Node node = proxies.item(temp); + if (node.getNodeType() == Node.ELEMENT_NODE) { + Element element = (Element) node; + String type = element.getElementsByTagName("type").item(0).getTextContent(); + if (type.toLowerCase().equals("http")) { + String host = element.getElementsByTagName("host").item(0).getTextContent(); + String portString = element.getElementsByTagName("port").item(0).getTextContent(); + try { + int port = Integer.parseInt(portString); + Main.log(2, String.format("Using HTTP proxy: %s:%s", host, port)); + return new Proxy(java.net.Proxy.Type.HTTP, new InetSocketAddress(host, port)); + } catch (NumberFormatException e) { + Main.log(1, String.format("Invalid proxy port number: %s in config file: %s", portString, configFilePath)); + } + } + } + } + } catch (Exception e) { + Main.log(2, String.format("%s while parsing config file: %s", e.getMessage(), configFilePath)); + return null; + } + Main.log(2, String.format("No HTTP proxy found in config file: %s", configFilePath)); + return null; + } + + private static String getConfigFilePath() { + String userHome = System.getProperty("user.home"); + String fileSeparator = System.getProperty("file.separator"); + String configDir = ".config"; + String appName = "kobalt"; + String configFileName = "settings.xml"; + return userHome + + fileSeparator + configDir + + fileSeparator + appName + + fileSeparator + configFileName; + } + + private static byte[] getConfigFileContent(String configFilePath) throws IOException { + Path path = Paths.get(configFilePath); + return Files.readAllBytes(path); + } + +} diff --git a/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java index 9e7b1929..f31bbc3f 100644 --- a/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java +++ b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java @@ -2,6 +2,7 @@ package com.beust.kobalt.wrapper; import java.io.*; import java.net.HttpURLConnection; +import java.net.Proxy; import java.net.URL; import java.nio.charset.Charset; import java.nio.file.*; @@ -35,6 +36,7 @@ public class Main { private final Properties wrapperProperties = new Properties(); + private static int logQuietLevel = 0; private static int logLevel = 1; private boolean noOverwrite = false; @@ -45,7 +47,6 @@ public class Main { private int installAndLaunchMain(String[] argv) throws IOException, InterruptedException { String version = getVersion(); - initWrapperFile(version); List kobaltArgv = new ArrayList<>(); boolean noLaunch = false; @@ -76,6 +77,7 @@ public class Main { } int result = 0; if (! exit) { + initWrapperFile(version); Path kobaltJarFile = installDistribution(); if (!noLaunch) { result = launchMain(kobaltJarFile, kobaltArgv); @@ -116,7 +118,7 @@ public class Main { } private static String downloadUrl(String version) { - return "http://beust.com/kobalt/kobalt-" + version + ".zip"; + return "https://beust.com/kobalt/kobalt-" + version + ".zip"; } private void initWrapperFile(String version) throws IOException { @@ -131,7 +133,7 @@ public class Main { } private String getWrapperVersion() { - return wrapperProperties.getProperty(PROPERTY_VERSION); + return wrapperProperties.getProperty(PROPERTY_VERSION, "N/A"); } private String getWrapperDownloadUrl(String version) { @@ -166,11 +168,9 @@ public class Main { log(2, "Wrapper version: " + wrapperVersion); - boolean isNew = Float.parseFloat(version) * 1000 >= 650; - String toZipOutputDir = DISTRIBUTIONS_DIR; Path kobaltJarFile = Paths.get(toZipOutputDir, - isNew ? "kobalt-" + wrapperVersion : "", + "kobalt-" + wrapperVersion, getWrapperDir().getPath() + "/" + FILE_NAME + "-" + wrapperVersion + ".jar"); boolean downloadedZipFile = false; if (! Files.exists(localZipFile) || ! Files.exists(kobaltJarFile)) { @@ -220,6 +220,20 @@ public class Main { log(2, " Couldn't find $VERSION_TEXT, overwriting the installed wrapper"); installWrapperFiles(version, wrapperVersion); } + + // + // Install the launcher(s) if not already found. + // + File kobaltw = new File(KOBALTW); + File kobaltwBat = new File(KOBALTW_BAT); + + if (!kobaltw.exists()) { + generateKobaltW(kobaltw.toPath()); + } + + if (!kobaltwBat.exists()) { + generateKobaltWBat(kobaltwBat.toPath()); + } } return kobaltJarFile; @@ -331,6 +345,11 @@ public class Main { try { Files.createDirectories(entryPath.getParent()); Files.copy(zipFile.getInputStream(entry), entryPath, StandardCopyOption.REPLACE_EXISTING); + if (!isWindows() && entry.getName().endsWith(KOBALTW)) { + if (!entryPath.toFile().setExecutable(true)) { + log(1, "Couldn't make distribution " + KOBALTW + " executable"); + } + } } catch (FileSystemException ex) { log(2, "Couldn't copy to " + entryPath); } @@ -364,13 +383,18 @@ public class Main { log(2, "Downloading " + fileUrl); boolean done = false; + Proxy proxy = Config.getProxy(); HttpURLConnection httpConn = null; try { int responseCode = 0; URL url = null; while (!done) { url = new URL(fileUrl); - httpConn = (HttpURLConnection) url.openConnection(); + if (proxy != null) { + httpConn = (HttpURLConnection) url.openConnection(proxy); + } else { + httpConn = (HttpURLConnection) url.openConnection(); + } responseCode = httpConn.getResponseCode(); if (responseCode == HttpURLConnection.HTTP_MOVED_TEMP || responseCode == HttpURLConnection.HTTP_MOVED_PERM) { @@ -425,12 +449,14 @@ public class Main { } } + private static String PROPERTY_NO_ANIMATIONS = "com.beust.kobalt.noAnimations"; + private void copyToStreamWithProgress(InputStream inputStream, OutputStream outputStream, long contentLength, String url) throws IOException { int bytesRead; long bytesSoFar = 0; byte[] buffer = new byte[100_000]; - boolean hasTerminal = System.console() != null; + boolean hasTerminal = System.console() != null && System.getProperty(PROPERTY_NO_ANIMATIONS) == null; if (! hasTerminal) { log2(1, "\rDownloading " + url); } @@ -467,7 +493,7 @@ public class Main { } private static void p(int level, String s, boolean newLine) { - if (level <= logLevel) { + if (level != logQuietLevel && level <= logLevel) { if (newLine) System.out.println(s); else System.out.print(s); } diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..3a87c7ac --- /dev/null +++ b/pom.xml @@ -0,0 +1,34 @@ + + 4.0.0 + + com.beust + kobalt-pom + pom + 1.1.0 + + + modules/kobalt-plugin-api + modules/wrapper + modules/kobalt + + + + + testng + https://dl.bintray.com/cbeust/maven + + + + + 1.2.71 + 1.13.0 + 3.9.1 + 1.1.0 + 1.1.0 + 5.1.0 + 6.12 + 1.7.3 + + + \ No newline at end of file diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 00000000..c36e45fd --- /dev/null +++ b/settings.gradle @@ -0,0 +1,5 @@ +rootProject.name = 'kobalt-pom' +include(':kobalt-plugin-api', ':wrapper', ':kobalt') +project(':kobalt-plugin-api').projectDir = file('modules/kobalt-plugin-api') +project(':wrapper').projectDir = file('modules/wrapper') +project(':kobalt').projectDir = file('modules/kobalt') diff --git a/src/main/kotlin/com/beust/kobalt/Main.kt b/src/main/kotlin/com/beust/kobalt/Main.kt index 0c1117bb..19b85404 100644 --- a/src/main/kotlin/com/beust/kobalt/Main.kt +++ b/src/main/kotlin/com/beust/kobalt/Main.kt @@ -3,72 +3,74 @@ package com.beust.kobalt import com.beust.jcommander.JCommander import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.Kobalt -import com.beust.kobalt.api.PluginTask -import com.beust.kobalt.app.* +import com.beust.kobalt.app.MainModule +import com.beust.kobalt.app.UpdateKobalt import com.beust.kobalt.app.remote.KobaltClient -import com.beust.kobalt.app.remote.KobaltServer -import com.beust.kobalt.internal.Gc import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.internal.PluginInfo -import com.beust.kobalt.internal.TaskManager -import com.beust.kobalt.internal.build.BuildFile import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.Http import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.misc.* -import com.google.common.collect.HashMultimap import java.io.File import java.net.URLClassLoader -import java.nio.file.Paths import javax.inject.Inject fun main(argv: Array) { - val result = mainNoExit(argv) + val result = Main.mainNoExit(argv) if (result != 0) { System.exit(result) } } -private fun parseArgs(argv: Array): Main.RunInfo { - val args = Args() - val result = JCommander(args) - result.parse(*argv) - KobaltLogger.LOG_LEVEL = if (args.log < 0) { - Constants.LOG_DEFAULT_LEVEL - } else if (args.log > Constants.LOG_MAX_LEVEL) { - Constants.LOG_MAX_LEVEL - } else args.log - return Main.RunInfo(result, args) -} - -fun mainNoExit(argv: Array): Int { - val (jc, args) = parseArgs(argv) - Kobalt.init(MainModule(args, KobaltSettings.readSettingsXml())) - val result = Kobalt.INJECTOR.getInstance(Main::class.java).run { - val runResult = run(jc, args, argv) - pluginInfo.cleanUp() - executors.shutdown() - runResult - } - return result -} - -private class Main @Inject constructor( +class Main @Inject constructor( val plugins: Plugins, - val taskManager: TaskManager, val http: Http, val files: KFiles, val executors: KobaltExecutors, val dependencyManager: DependencyManager, - val checkVersions: CheckVersions, val github: GithubApi2, val updateKobalt: UpdateKobalt, val client: KobaltClient, val pluginInfo: PluginInfo, - val projectGenerator: ProjectGenerator, - val serverFactory: KobaltServer.IFactory, - val projectFinder: ProjectFinder, - val resolveDependency: ResolveDependency) { + val options: Options) { + + companion object { + fun mainNoExit(argv: Array): Int { + val (jc, args) = parseArgs(argv) + if (args.usage) { + jc.usage() + return 0 + } + if (args.version) { + println("Kobalt ${Kobalt.version}") + return 0 + } + Kobalt.init(MainModule(args, KobaltSettings.readSettingsXml())) + val result = launchMain(Kobalt.INJECTOR.getInstance(Main::class.java), jc, args, argv) + return result + } + + private fun parseArgs(argv: Array): Main.RunInfo { + val args = Args() + val result = JCommander(args) + result.parse(*argv) + KobaltLogger.setLogLevel(args) + return Main.RunInfo(result, args) + } + + /** + * Entry point for tests, which can instantiate their main object with their own module and injector. + */ + fun launchMain(main: Main, jc: JCommander, args: Args, argv: Array) : Int { + return main.run { + val runResult = run(jc, args, argv) + pluginInfo.cleanUp() + executors.shutdown() + runResult + } + } + } data class RunInfo(val jc: JCommander, val args: Args) @@ -96,173 +98,39 @@ private class Main @Inject constructor( // // Install plug-ins requested from the command line // - val pluginClassLoader = installCommandLinePlugins(args) - - // --listTemplates - if (args.listTemplates) { - Templates().displayTemplates(pluginInfo) - return 0 - } + installCommandLinePlugins(args) if (args.client) { client.run() return 0 } - var result = 0 + var result = 1 + val latestVersionFuture = github.latestKobaltVersion - val timing = benchmarkSeconds { - try { - result = runWithArgs(jc, args, argv, pluginClassLoader) - } catch(ex: Throwable) { - error("", ex.cause ?: ex) - result = 1 - } + try { + result = runWithArgs(jc, args, argv) + } catch(ex: Throwable) { + error("", ex.cause ?: ex) } if (!args.update) { - log(1, if (result != 0) "BUILD FAILED: $result" else "BUILD SUCCESSFUL (${timing.first} seconds)") - updateKobalt.checkForNewVersion(latestVersionFuture) } return result } - // public fun runTest() { - // val file = File("src\\main\\resources\\META-INF\\plugin.ml") - // } - - private fun runWithArgs(jc: JCommander, args: Args, argv: Array, pluginClassLoader: ClassLoader): Int { -// val file = File("/Users/beust/.kobalt/repository/com/google/guava/guava/19.0-rc2/guava-19.0-rc2.pom") -// val md5 = Md5.toMd5(file) -// val md52 = MessageDigest.getInstance("MD5").digest(file.readBytes()).toHexString() - var result = 0 - val p = if (args.buildFile != null) File(args.buildFile) else findBuildFile() + private fun runWithArgs(jc: JCommander, args: Args, argv: Array): Int { + val p = if (args.buildFile != null) File(args.buildFile) else File(".") args.buildFile = p.absolutePath - val buildFile = BuildFile(Paths.get(p.absolutePath), p.name) - + if (!args.update) { - println(AsciiArt.banner + Kobalt.version + "\n") + kobaltLog(1, AsciiArt.banner + Kobalt.version + "\n") } - if (args.templates != null) { - // - // --init: create a new build project and install the wrapper - // Make sure the wrapper won't call us back with --noLaunch - // - projectGenerator.run(args, pluginClassLoader) - // The wrapper has to call System.exit() in order to set the exit code, - // so make sure we call it last (or possibly launch it in a separate JVM). - com.beust.kobalt.wrapper.Main.main(arrayOf("--noLaunch") + argv) - } else if (args.usage) { - jc.usage() - } else if (args.serverMode) { - // --server - val port = serverFactory.create(args.force, args.port, - { buildFile -> projectFinder.initForBuildFile(BuildFile(Paths.get(buildFile), buildFile), args) }, - { cleanUp() }) - .call() - } else { - // Options that don't need Build.kt to be parsed first - if (args.gc) { - Gc().run() - } else if (args.update) { - // --update - updateKobalt.updateKobalt() - } else { - // - // Everything below requires to parse the build file first - // - if (!buildFile.exists()) { - error(buildFile.path.toFile().path + " does not exist") - } else { - - val allProjects = projectFinder.initForBuildFile(buildFile, args) - - // DONOTCOMMIT -// val data = dependencyData.dependenciesDataFor(homeDir("kotlin/klaxon/kobalt/src/Build.kt"), Args()) -// println("Data: $data") - - if (args.projectInfo) { - // --projectInfo - allProjects.forEach { - resolveDependency.run(it.compileDependencies.map { it.id }) - } - } else if (args.dependencies != null) { - // --resolve - resolveDependency.run(args.dependencies!!.split(',').toList()) - } else if (args.tasks) { - // --tasks - displayTasks() - } else if (args.checkVersions) { - // --checkVersions - checkVersions.run(allProjects) - } else if (args.download) { - // --download - updateKobalt.downloadKobalt() - } else { - // - // Launch the build - // - val runTargetResult = taskManager.runTargets(args.targets, allProjects) - if (result == 0) { - result = if (runTargetResult.taskResult.success) 0 else 1 - } - - // Shutdown all plug-ins - plugins.shutdownPlugins() - - // Run the build report contributors - pluginInfo.buildReportContributors.forEach { - it.generateReport(Kobalt.context!!) - } - } - } - } - } - return result + return options.run(jc, args, argv) } - private fun findBuildFile(): File { - val deprecatedLocation = File(Constants.BUILD_FILE_NAME) - val result: File = - if (deprecatedLocation.exists()) { - warn(Constants.BUILD_FILE_NAME + " is in a deprecated location, please move it to " - + Constants.BUILD_FILE_DIRECTORY) - deprecatedLocation - } else { - File(KFiles.joinDir(Constants.BUILD_FILE_DIRECTORY, Constants.BUILD_FILE_NAME)) - } - return result - } - private fun cleanUp() { - pluginInfo.cleanUp() - taskManager.cleanUp() - } - - private fun displayTasks() { - // - // List of tasks, --tasks - // - val tasksByPlugins = HashMultimap.create() - taskManager.annotationTasks.forEach { - tasksByPlugins.put(it.plugin.name, it) - } - val sb = StringBuffer("List of tasks\n") - tasksByPlugins.keySet().forEach { name -> - sb.append("\n " + AsciiArt.horizontalDoubleLine + " $name " - + AsciiArt.horizontalDoubleLine + "\n") - tasksByPlugins[name].distinctBy { - it.name - }.sortedBy { - it.name - }.forEach { task -> - sb.append(" ${task.name}\t\t${task.doc}\n") - } - } - - println(sb.toString()) - } } diff --git a/src/main/kotlin/com/beust/kobalt/Options.kt b/src/main/kotlin/com/beust/kobalt/Options.kt new file mode 100644 index 00000000..ef4cbfd4 --- /dev/null +++ b/src/main/kotlin/com/beust/kobalt/Options.kt @@ -0,0 +1,210 @@ +package com.beust.kobalt + +import com.beust.jcommander.JCommander +import com.beust.kobalt.api.ITask +import com.beust.kobalt.api.Kobalt +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project +import com.beust.kobalt.app.ProjectFinder +import com.beust.kobalt.app.ProjectGenerator +import com.beust.kobalt.app.Templates +import com.beust.kobalt.app.UpdateKobalt +import com.beust.kobalt.app.remote.KobaltServer +import com.beust.kobalt.internal.PluginInfo +import com.beust.kobalt.internal.TaskManager +import com.beust.kobalt.internal.build.BuildSources +import com.beust.kobalt.internal.build.SingleFileBuildSources +import com.beust.kobalt.misc.CheckVersions +import com.beust.kobalt.misc.kobaltLog +import com.beust.kobalt.wrapper.Main +import com.google.common.collect.HashMultimap +import com.google.inject.Inject +import java.io.File + +/** + * Some options require a build file, others shouldn't have one and some don't care. This + * class captures these requirements. + */ +open class Option(open val enabled: () -> Boolean, open val action: () -> Unit, + open val requireBuildFile: Boolean = true) +class OptionalBuildOption(override val enabled: () -> Boolean, override val action: () -> Unit) + : Option(enabled, action, false) + +class Options @Inject constructor( + val plugins: Plugins, + val checkVersions: CheckVersions, + val projectGenerator: ProjectGenerator, + val pluginInfo: PluginInfo, + val serverFactory: KobaltServer.IFactory, + val updateKobalt: UpdateKobalt, + val projectFinder: ProjectFinder, + val taskManager: TaskManager, + val resolveDependency: ResolveDependency + ) { + + fun run(jc: JCommander, args: Args, argv: Array): Int { + val p = if (args.buildFile != null) File(args.buildFile) else File(".") +// val buildFile = BuildFile(Paths.get(p.absolutePath), p.name) + val buildSources = if (p.isDirectory) BuildSources(p.absoluteFile) else SingleFileBuildSources(p) + val pluginClassLoader = javaClass.classLoader + + // + // Attempt to parse the build file in order to correctly set up repos, plug-ins, etc... + // If the build file can't be parsed, don't give up just yet since some options don't need + // a correct build file to work. + // + var buildError: Throwable? = null + val allProjects = + try { + projectFinder.initForBuildFile(buildSources, args).projects + } catch(ex: Exception) { + buildError = ex + listOf() + } + + fun runIfSuccessfulBuild(buildError: Throwable?, action: () -> Unit) { + buildError?.let { throw it } + action() + } + + // Modify `args` with options found in buildScript { kobaltOptions(...) }, if any + addOptionsFromBuild(args, Kobalt.optionsFromBuild) + + val options = listOf