diff --git a/.gitignore b/.gitignore index 6d6a56f8..a680191b 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ libs out .DS_Store lib/kotlin-* +build +.history diff --git a/README.md b/README.md index 81d87855..d5d7cbe0 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Kobalt -[](https://teamcity.jetbrains.com/project.html?projectId=OpenSourceProjects_Kobalt&tab=projectOverview) +[](https://teamcity.jetbrains.com/project.html?projectId=OpenSourceProjects_Kobalt&tab=projectOverview) Kobalt is a universal build system. @@ -8,7 +8,7 @@ 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.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 4f39dc35..333738df 100755 --- a/dist/kobaltw +++ b/dist/kobaltw @@ -1,7 +1,11 @@ #!/usr/bin/env sh -DIRNAME=`dirname $(readlink -f "$0")` -if [[ "$(uname)" == "CYGWIN"* ]]; then - DIRNAME=`cygpath -d "$DIRNAME"` +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/src/Build.kt b/kobalt/src/Build.kt index 65d29bc0..0d09844a 100644 --- a/kobalt/src/Build.kt +++ b/kobalt/src/Build.kt @@ -1,3 +1,4 @@ + import com.beust.kobalt.* import com.beust.kobalt.api.Project import com.beust.kobalt.api.annotation.Task @@ -16,22 +17,31 @@ 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("http://dl.bintray.com/cbeust/maven") + 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 maven = "3.3.9" - val mavenResolver = "1.0.3" + 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 kotlin = "1.1.1" val aether = "1.0.2.v20150114" - val testng = "6.11" + 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) @@ -54,6 +64,7 @@ val wrapper = project { } assemble { + jar { } jar { name = projectName + ".jar" manifest { @@ -65,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 { @@ -74,50 +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", - "org.eclipse.jgit:org.eclipse.jgit:4.5.0.201609210915-r", + "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.0", - "org.testng:testng:${Versions.testng}" + "org.testng.testng-remote:testng-remote:1.3.2", + "org.testng:testng:${Versions.testng}", + "org.junit.platform:junit-platform-surefire-provider:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-runner:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-engine:${Versions.junitPlatform}", + "org.junit.platform:junit-platform-console:${Versions.junitPlatform}", + "org.junit.jupiter:junit-jupiter-engine:${Versions.junitJupiter}", + "org.junit.vintage:junit-vintage-engine:${Versions.junitJupiter}", + "org.apache.commons:commons-compress:1.15", + "commons-io:commons-io:2.6", + + // Java 9 + "javax.xml.bind:jaxb-api:2.3.0" ) exclude(*aether("impl", "spi", "util", "api")) - compile("org.jetbrains.kotlin:kotlin-stdlib:1.1.1") } @@ -130,12 +142,8 @@ val kobaltPluginApi = project { } } -// install { -// libDir = "lib-test" -// } - kotlinCompiler { - args("-nowarn") + args("nowarn") } bintray { @@ -154,24 +162,32 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { 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.65", + "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}", - "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", - "org.codehaus.groovy:groovy:2.4.8" + "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}", @@ -181,16 +197,15 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { // "org.glassfish.jersey.media:jersey-media-moxy:${Versions.jersey}", // "org.wasabi:wasabi:0.1.182" ) - compile("org.jetbrains.kotlin:kotlin-stdlib:1.1.1") } dependenciesTest { - compile("org.testng:testng:${Versions.testng}", - "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") ) - compile("org.jetbrains.kotlin:kotlin-test:1.1.1") } assemble { @@ -202,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 { @@ -232,6 +257,28 @@ val kobaltApp = project(kobaltPluginApi, wrapper) { } } +fun zipFolders(zipFilePath: String, vararg foldersPath: String) { + val zip = Paths.get(zipFilePath) + Files.deleteIfExists(zip) + Files.createDirectories(zip.parent) + val zipPath = Files.createFile(zip) + ZipOutputStream(Files.newOutputStream(zipPath)).use { + foldersPath.map {Paths.get(it)}.forEach { folderPath -> + Files.walk(folderPath) + .filter { path -> !Files.isDirectory(path) } + .forEach { path -> + val zipEntry = ZipEntry(folderPath.relativize(path).toString()) + try { + it.putNextEntry(zipEntry) + Files.copy(path, it) + it.closeEntry() + } catch (e: Exception) { + } + } + } + } +} + fun readVersion() : String { val localFile = listOf("src/main/resources/kobalt.properties", @@ -258,3 +305,22 @@ fun taskCopyVersionForWrapper(project: Project) : TaskResult { } 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.properties b/kobalt/wrapper/kobalt-wrapper.properties index d12a84ef..0ca8045f 100644 --- a/kobalt/wrapper/kobalt-wrapper.properties +++ b/kobalt/wrapper/kobalt-wrapper.properties @@ -1 +1 @@ -kobalt.version=1.0.46 \ No newline at end of file +kobalt.version=1.0.122 \ No newline at end of file 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/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/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 index dc3fda2d..8158c642 100644 --- 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 @@ -3,7 +3,6 @@ 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.IncludedFile import com.beust.kobalt.misc.KFiles import java.io.File 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 b8cdc2fe..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 @@ -61,6 +61,9 @@ class Args { @Parameter(names = arrayOf("--noIncremental"), description = "Turn off incremental builds") var noIncremental: Boolean = false + @Parameter(names = arrayOf("--offline"), description = "Don't try to download dependencies even if there is no cached version") + var offline: Boolean = false + @Parameter(names = arrayOf("--plugins"), description = "Comma-separated list of plug-in Maven id's") var pluginIds: String? = null @@ -101,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/BuildScript.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/BuildScript.kt index 48ecc0e3..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 @@ -74,8 +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 name: String = url, 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()) } @@ -106,6 +116,7 @@ fun buildFileClasspath(vararg deps: String) { } fun newBuildFileClasspath(vararg deps: String) { + //FIXME newBuildFileClasspath called twice deps.forEach { Kobalt.addBuildFileClasspath(it) } } @@ -115,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 979c2ffe..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 @@ -9,13 +9,13 @@ object Constants { 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.1.1" + val KOTLIN_COMPILER_VERSION = "1.2.70" internal val DEFAULT_REPOS = listOf( // "https://maven-central.storage.googleapis.com/", - HostConfig("http://repo1.maven.org/maven2/", "Maven"), + HostConfig("https://repo1.maven.org/maven2/", "Maven"), HostConfig("https://jcenter.bintray.com/", "JCenter") -// "http://repository.jetbrains.com/all/", // <-- contains snapshots +// "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/FileSpec.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/FileSpec.kt index 715c4221..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 @@ -28,15 +28,15 @@ sealed class IFileSpec { private fun isIncluded(includeMatchers: Glob, excludes: List, rel: Path) : Boolean { excludes.forEach { if (it.matches(rel)) { - kobaltLog(3, "Excluding ${rel.toFile()}") + kobaltLog(3, " Excluding ${rel.toFile()}") return false } } if (includeMatchers.matches(rel)) { - kobaltLog(3, "Including ${rel.toFile().path}") + kobaltLog(3, " Including ${rel.toFile().path}") return true } - kobaltLog(2, "Excluding ${rel.toFile()} (not matching any include pattern") + kobaltLog(2, " Excluding ${rel.toFile()} (not matching any include pattern") return false } 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 ddddaebd..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,16 +3,16 @@ package com.beust.kobalt import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project import com.beust.kobalt.archive.Archives +import com.beust.kobalt.archive.MetaArchive import com.beust.kobalt.archive.Zip import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.aether.Scope -import com.beust.kobalt.misc.* +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) : ArchiveGenerator { @@ -142,7 +142,7 @@ 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 } @@ -151,14 +151,12 @@ class JarGenerator @Inject constructor(val dependencyManager: DependencyManager) 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, zip.name, ".jar", includedFiles, - true /* expandJarFiles */, jarFactory) + true /* expandJarFiles */, manifest) } } \ No newline at end of file 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 598ca401..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 @@ -67,7 +67,7 @@ open class Jvm constructor( return toolsJar } if (javaHome!!.name.equals("jre", true)) { - javaHome = javaHome!!.parentFile + _javaHome = javaHome!!.parentFile toolsJar = File(javaHome, "lib/tools.jar") if (toolsJar.exists()) { return toolsJar @@ -78,7 +78,7 @@ open class Jvm constructor( val version = SystemProperties.Companion.javaVersion if (javaHome!!.name.toRegex().matches("jre\\d+") || javaHome!!.name == "jre$version") { - javaHome = File(javaHome!!.parentFile, "jdk$version") + _javaHome = File(javaHome!!.parentFile, "jdk$version") toolsJar = File(javaHome, "lib/tools.jar") if (toolsJar.exists()) { return toolsJar 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 914ddbaa..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 @@ -28,7 +28,6 @@ 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 { -// val result = listOf( -// findBuildTypeBuildConfig(project, variant), -// findProductFlavorBuildConfig(project, variant), -// project.buildConfig) -// .filterNotNull() -// -// return result -// } + private fun findBuildConfigs(project: Project, variant: Variant?) : List { + val result = listOf( + findBuildTypeBuildConfig(project, variant), + findProductFlavorBuildConfig(project, variant), + project.buildConfig) + .filterNotNull() + + return result + } /** * Generate BuildConfig.java if requested. Also look up if any BuildConfig is defined on the current build type, * product flavor or main project, and use them to generateAndSave any additional field (in that order to * respect the priorities). Return the generated file if it was generated, null otherwise. */ -// fun maybeGenerateBuildConfig(project: Project, context: KobaltContext) : File? { -// val buildConfigs = findBuildConfigs(project, this) -// -// if (buildConfigs.size > 0) { -// val pkg = project.packageName ?: project.group -// ?: throw KobaltException( -// "packageName needs to be defined on the project in order to generateAndSave BuildConfig") -// -// val contributor = ActorUtils.selectAffinityActor(context.pluginInfo.buildConfigContributors, project) -// if (contributor != null) { -// val code = contributor.generateBuildConfig(project, context, pkg, this, buildConfigs) -// val result = KFiles.makeDir(KFiles.generatedSourceDir(project, this, "buildConfig")) -// // Make sure the generatedSourceDirectory doesn't contain the project.directory since -// // that directory will be added when trying to find recursively all the sources in it -// generatedSourceDirectory = result.relativeTo(File(project.directory)) -// val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar)) -// val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig." + contributor.buildConfigSuffix) -// KFiles.saveFile(outputDir, code) -// context.logger.log(project.name, 2, "Generated ${outputDir.path}") -// return result -// } else { -// throw KobaltException("Couldn't find a contributor to generateAndSave BuildConfig") -// } -// } else { -// return null -// } -// } + fun maybeGenerateBuildConfig(project: Project, context: KobaltContext) : File? { + val buildConfigs = findBuildConfigs(project, this) + + if (buildConfigs.size > 0) { + val pkg = project.packageName ?: project.group + ?: throw KobaltException( + "packageName needs to be defined on the project in order to generateAndSave BuildConfig") + + 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")) + // Make sure the generatedSourceDirectory doesn't contain the project.directory since + // that directory will be added when trying to find recursively all the sources in it + generatedSourceDirectory = result.relativeTo(File(project.directory)) + val outputGeneratedSourceDirectory = File(result, pkg.replace('.', File.separatorChar)) + val outputDir = File(outputGeneratedSourceDirectory, "BuildConfig." + contributor.buildConfigSuffix) + KFiles.saveFile(outputDir, code) + context.logger.log(project.name, 2, "Generated ${outputDir.path}") + return result + } else { + throw KobaltException("Couldn't find a contributor to generateAndSave BuildConfig") + } + } else { + return null + } + } override fun toString() = toTask("") 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 d2521255..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 @@ -12,4 +12,5 @@ data class CompilerActionInfo(val directory: String?, val outputDir: File, val compilerArgs: List, val friendPaths: List, - val forceRecompile: Boolean) + 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 a561cd9f..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 @@ -13,6 +13,7 @@ interface IDependencyHolder { val compileDependencies : ArrayList val optionalDependencies : ArrayList val compileProvidedDependencies : ArrayList + val compileOnlyDependencies : ArrayList val compileRuntimeDependencies : ArrayList val excludedDependencies : ArrayList val nativeDependencies : ArrayList @@ -29,6 +30,7 @@ open class DependencyHolder : IDependencyHolder { 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() @@ -37,7 +39,7 @@ open class DependencyHolder : IDependencyHolder { override fun dependencies(init: Dependencies.() -> Unit) : Dependencies { dependencies = Dependencies(project, compileDependencies, optionalDependencies, compileProvidedDependencies, - compileRuntimeDependencies, excludedDependencies, nativeDependencies) + 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/IDependencyManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/IDependencyManager.kt index e272e3d5..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 @@ -61,7 +61,7 @@ interface IDependencyManager { return excluded?.map { it.id }?.contains(dep.id) ?: false } - val accept = dependencies.any { + val accept = dependencies.isEmpty() || dependencies.any { // Is this dependency excluded? val isExcluded = isNodeExcluded(p0, it) || isDepExcluded(p0, project?.excludedDependencies) 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/Kobalt.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/api/Kobalt.kt index 527d35b2..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 @@ -55,6 +56,9 @@ class Kobalt { // Repos from the build file result.addAll(reposFromBuildFiles) + result.forEach { + KobaltMavenResolver.initAuthentication(it) + } return result.toHashSet() } @@ -131,6 +135,7 @@ class Kobalt { fun cleanUp() { buildSourceDirs.clear() + buildFileClasspath.clear() } } } 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 306a61b6..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 @@ -91,7 +91,8 @@ open class Project( @Directive fun dependenciesTest(init: Dependencies.() -> Unit) : Dependencies { dependencies = Dependencies(this, testDependencies, arrayListOf(), - testProvidedDependencies, compileRuntimeDependencies, excludedDependencies, nativeDependencies) + testProvidedDependencies, compileOnlyDependencies, compileRuntimeDependencies, + excludedDependencies, nativeDependencies) dependencies!!.init() return dependencies!! } @@ -128,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]" } @@ -142,6 +155,7 @@ 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) { @@ -232,6 +246,9 @@ class Dependencies(val project: Project, 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) @@ -241,7 +258,6 @@ class Dependencies(val project: Project, @Directive fun provided(vararg dep: String) { addToDependencies(project, providedDependencies, dep) - addToDependencies(project, dependencies, dep) } @Directive 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 7d2e291f..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,16 +1,14 @@ 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.* +import com.beust.kobalt.misc.JarUtils +import com.beust.kobalt.misc.KFiles +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 { @@ -19,9 +17,8 @@ class Archives { @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, @@ -29,15 +26,15 @@ 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) 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) + 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") } 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 296eb784..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,23 +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 var fatJar: Boolean = false): AttributeHolder { + 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,34 +18,10 @@ open class Zip(open val project: Project, open var name: String = Archives.defau specs.forEach { excludes.add(it) } } - @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))) - } - - /** - * 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 open 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/internal/BaseProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/BaseProjectRunner.kt index 2dc77ca0..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,5 +1,7 @@ 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.api.ProjectBuildStatus @@ -25,9 +27,14 @@ abstract class BaseProjectRunner { } fun runBuildListenersForTask(project: Project, context: KobaltContext, taskName: String, start: Boolean, - success: Boolean = false) { + success: Boolean = false, testResult: TestResult? = null) { context.pluginInfo.buildListeners.forEach { - if (start) it.taskStart(project, context, taskName) else it.taskEnd(project, context, taskName, success) + if (start) { + it.taskStart(project, context, taskName) + } else { + val info = IBuildListener.TaskEndInfo(success, testResult?.shortMessage, testResult?.longMessage) + it.taskEnd(project, context, taskName, info) + } } } 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 1a8781a5..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 @@ -11,7 +11,8 @@ import java.util.concurrent.ConcurrentHashMap */ class BuildListeners : IBuildListener, IBuildReportContributor { class ProfilerInfo(val taskName: String, val durationMillis: Long) - class ProjectInfo(val projectName: String, var durationMillis: Long = 0) + 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() @@ -29,18 +30,21 @@ class BuildListeners : IBuildListener, IBuildReportContributor { } // IBuildListener - override fun taskEnd(project: Project, context: KobaltContext, taskName: String, success: Boolean) { + override fun taskEnd(project: Project, context: KobaltContext, taskName: String, info: IBuildListener.TaskEndInfo) { + val success = info.success if (! success) hasFailures = true startTimes[taskName]?.let { val taskTime = System.currentTimeMillis() - it timings.add(ProfilerInfo(taskName, taskTime)) projectInfos[project.name]?.let { - it.durationMillis += taskTime.toLong() + 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>() + private val projectStatuses = arrayListOf>() // IBuildListener override fun projectStart(project: Project, context: KobaltContext) { @@ -49,7 +53,9 @@ class BuildListeners : IBuildListener, IBuildReportContributor { // IBuildListener override fun projectEnd(project: Project, context: KobaltContext, status: ProjectBuildStatus) { - projectStatuses.add(Pair(project, status)) + val shortMessage = projectInfos[project.name]?.shortMessage + val statusText = status.toString() + (if (shortMessage != null) " ($shortMessage)" else "") + projectStatuses.add(Pair(project, statusText)) } // IBuildReportContributor @@ -70,10 +76,15 @@ class BuildListeners : IBuildListener, IBuildReportContributor { } + // 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\$-13s", s) + fun col2(s: String) = String.format(" %1\$-${width}s", s) fun col3(s: String) = String.format(" %1\$-8s", s) + + // 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) { @@ -83,7 +94,7 @@ class BuildListeners : IBuildListener, IBuildReportContributor { 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.toString()), + 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") 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 cbc18dcf..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 @@ -70,7 +70,12 @@ class CompilerUtils @Inject constructor(val files: KFiles, val dependencyManager copyResources(project, context, SourceSet.of(isTest)) val fullClasspath = dependencyManager.calculateDependencies(project, context, - scopes = if (isTest) listOf(Scope.COMPILE, Scope.TEST) else listOf(Scope.COMPILE)) + scopes = if (isTest) { + listOf(Scope.COMPILE, Scope.COMPILEONLY, Scope.TEST) + } else { + listOf(Scope.COMPILE, Scope.COMPILEONLY) + }) + File(project.directory, buildDirectory.path).mkdirs() @@ -196,7 +201,7 @@ class CompilerUtils @Inject constructor(val files: KFiles, val dependencyManager .filter(File::exists) .forEach { context.logger.log(project.name, 2, "Copying from $it to $absOutputDir") - KFiles.copyRecursively(it, absOutputDir, deleteFirst = false) + KFiles.copyRecursively(it, absOutputDir, replaceExisting = true) } } else { context.logger.log(project.name, 2, "No resources to copy for $sourceSet") 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 1ea14a1a..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 @@ -7,7 +7,8 @@ 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) } @@ -393,7 +394,7 @@ fun main(argv: Array) { object: IWorker { override fun call(): TaskResult2? { kobaltLog(1, " Running worker $it") - return TaskResult2(true, null, it) + return TaskResult2(true, value = it) } override val priority: Int get() = 0 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 866eb8d4..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 @@ -4,6 +4,7 @@ import com.beust.kobalt.* import com.beust.kobalt.api.* import com.beust.kobalt.misc.KFiles import com.google.common.annotations.VisibleForTesting +import com.google.inject.Inject import java.io.File import java.util.* @@ -15,14 +16,27 @@ 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 filterTestClasses(classes: List) : List = classes + 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 result = @@ -55,7 +69,7 @@ abstract class GenericTestRunner: ITestRunnerContributor { // } context.logger.log(project.name, 2, "Found ${result.size} test classes") - return filterTestClasses(result.map { it.second }) + return filterTestClasses(project, context, result.map { it.second }) } /** @@ -95,18 +109,19 @@ abstract class GenericTestRunner: ITestRunnerContributor { * @return true if all the tests passed */ open fun runTests(project: Project, context: KobaltContext, classpath: List, - configName: String) : Boolean { + configName: String) : TestResult { var result = false - context.logger.log(project.name, 1, "Running default TestNG runner") + 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 { @@ -122,12 +137,7 @@ abstract class GenericTestRunner: ITestRunnerContributor { 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) { - context.logger.log(project.name, 1, "All tests passed") - } else { - context.logger.log(project.name, 1, "Test failures") - } + errorCode = process.waitFor() result = result || errorCode == 0 } else { context.logger.log(project.name, 1, " No tests to run") @@ -136,7 +146,16 @@ abstract class GenericTestRunner: ITestRunnerContributor { } 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,13 +163,14 @@ abstract class GenericTestRunner: ITestRunnerContributor { */ @VisibleForTesting fun calculateAllJvmArgs(project: Project, context: KobaltContext, - testConfig: TestConfig, classpath: List, pluginInfo: IPluginInfo) : List { + 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 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 58f65776..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 @@ -28,7 +28,6 @@ class JvmCompiler @Inject constructor(val dependencyManager: DependencyManager) .distinct() // Plugins that add flags to the compiler - val currentFlags = arrayListOf().apply { addAll(info.compilerArgs) } val contributorFlags : List = if (project != null) flags else emptyList() val addedFlags = contributorFlags + ArrayList(info.compilerArgs) 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 7732774d..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,7 +9,6 @@ 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.LocalRepo import com.beust.kobalt.maven.Md5 import com.beust.kobalt.maven.aether.Scope import com.beust.kobalt.misc.KFiles @@ -27,7 +26,6 @@ import javax.inject.Singleton */ @Singleton open class JvmCompilerPlugin @Inject constructor( - open val localRepo: LocalRepo, open val files: KFiles, open val dependencyManager: DependencyManager, open val executors: KobaltExecutors, @@ -91,7 +89,7 @@ open class JvmCompilerPlugin @Inject constructor( dependencyFilter = dependencyManager.createDependencyFilter(project, project.testDependencies), scopes = listOf(Scope.TEST)) val compileDependencies = dependencyManager.calculateDependencies(project, context, - scopes = listOf(Scope.COMPILE)) + scopes = listOf(Scope.COMPILE, Scope.COMPILEONLY)) val allDependencies = (testDependencies + compileDependencies).distinct() return testContributor.run(project, context, configName, allDependencies.toList()) } else { @@ -159,6 +157,10 @@ open class JvmCompilerPlugin @Inject constructor( 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() /** @@ -172,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 } @@ -182,8 +187,8 @@ open class JvmCompilerPlugin @Inject constructor( var done = false // The directory where the classes get compiled val buildDirectory = - if (isTest) File(project.buildDirectory, KFiles.TEST_CLASSES_DIR) - else File(project.classesDir(context)) + 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, @@ -221,7 +226,7 @@ open class JvmCompilerPlugin @Inject constructor( } @Task(name = "doc", description = "Generate the documentation for the project", group = GROUP_DOCUMENTATION, - runBefore = arrayOf("assemble")) + runBefore = arrayOf("assemble"), runAfter = arrayOf("clean")) fun taskJavadoc(project: Project): TaskResult { val docGenerator = ActorUtils.selectAffinityActor(project, context, context.pluginInfo.docContributors) if (docGenerator != null) { 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 59b3b894..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 @@ -78,7 +78,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, val compilerInterceptors = arrayListOf() val sourceDirectoriesInterceptors = arrayListOf() val buildDirectoryInterceptors = arrayListOf() - val runnerContributors = arrayListOf() +// val runnerContributors = arrayListOf() val testRunnerContributors = arrayListOf() val classpathInterceptors = arrayListOf() val compilerContributors = arrayListOf() @@ -197,7 +197,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, 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) @@ -225,7 +225,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, listOf(projectContributors, classpathContributors, templateContributors, repoContributors, compilerFlagContributors, compilerInterceptors, sourceDirectoriesInterceptors, buildDirectoryInterceptors, - runnerContributors, testRunnerContributors, classpathInterceptors, + /* runnerContributors, */ testRunnerContributors, classpathInterceptors, compilerContributors, docContributors, sourceDirContributors, testSourceDirContributors, buildConfigFieldContributors, taskContributors, incrementalTaskContributors, assemblyContributors, @@ -252,7 +252,7 @@ class PluginInfo(val xml: KobaltPluginXml, val pluginClassLoader: ClassLoader?, 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) 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 5f82b3dc..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 @@ -25,7 +25,7 @@ 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 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 index 90c5d354..24e643d5 100644 --- 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 @@ -1,16 +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(classes: List) = classes.filter { ! it.contains("$") } + 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/ParallelProjectRunner.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/ParallelProjectRunner.kt index 6a703a20..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 @@ -54,12 +54,12 @@ class ParallelProjectRunner(val tasksByNames: (Project) -> ListMultimap ListMultimap() private val reverseDependsOn = TreeMultimap.create() private val runBefore = TreeMultimap.create() @@ -80,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 { @@ -87,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) @@ -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) } @@ -315,9 +320,11 @@ class TaskWorker(val tasks: List, val dryRun: Boolean, val pluginInfo: Pl val tr = if (dryRun) TaskResult() else it.call() 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 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 c0d2b122..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 @@ -2,23 +2,38 @@ package com.beust.kobalt.internal import com.beust.kobalt.AsciiArt import com.beust.kobalt.TestConfig -import com.beust.kobalt.api.* +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.maven.aether.AetherDependency import com.beust.kobalt.misc.* import org.testng.remote.RemoteArgs -import org.testng.remote.strprotocol.* +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 { @@ -30,7 +45,9 @@ class TestNgRunner : GenericTestRunner() { if (testConfig.testArgs.none { it == "-d" }) { add("-d") - add(defaultOutput(project)) + // 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) { @@ -56,11 +73,50 @@ class TestNgRunner : GenericTestRunner() { } } + /** + * 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): Boolean { + configName: String): TestResult { val testConfig = project.testConfigs.firstOrNull { it.name == configName } @@ -81,7 +137,7 @@ class TestNgRunner : GenericTestRunner() { } return result } else { - return true + return TestResult(true) } } @@ -98,7 +154,8 @@ class TestNgRunner : GenericTestRunner() { } private fun displayPrettyColors(project: Project, context: KobaltContext, - classpath: List, testConfig: TestConfig, versions: Pair): Boolean { + classpath: List, testConfig: TestConfig, versions: Pair) + : TestResult { val port = 2345 // launchRemoteServer(project, context, classpath, testConfig, versions, port) @@ -147,7 +204,7 @@ class TestNgRunner : GenericTestRunner() { val top = it.stackTrace.substring(0, it.stackTrace.indexOf("\n")) kobaltLog(1, " " + it.cls + "." + it.method + "\n " + top) } - return failed.isEmpty() && skipped.isEmpty() + return TestResult(failed.isEmpty() && skipped.isEmpty()) } fun launchRemoteServer(project: Project, context: KobaltContext, classpath: List, 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 081f9846..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 @@ -106,6 +106,10 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, 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) @@ -175,13 +179,13 @@ class DependencyManager @Inject constructor(val executors: KobaltExecutors, * TODO: This should be private, everyone should be calling calculateDependencies(). */ fun transitiveClosure(dependencies : List, - dependencyFilter: DependencyFilter? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, requiredBy: String? = null): List { val result = arrayListOf() dependencies.forEach { dependency -> result.add(dependency) if (dependency.isMaven) { - val resolved = resolver.resolveToIds(dependency.id, null, dependencyFilter).map { create(it) } + val resolved = resolver.resolveToIds(dependency.id, null, filter).map { create(it) } result.addAll(resolved) } } 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 27eeee83..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.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 -class Gpg { +class Gpg @Inject constructor(val localProperties: LocalProperties) { val COMMANDS = listOf("gpg", "gpg2") fun findGpgCommand() : String? { @@ -42,6 +44,21 @@ 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) 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/aether/AetherDependency.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/maven/aether/AetherDependency.kt index cc9631da..825a8ae8 100644 --- 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 @@ -26,33 +26,24 @@ class AetherDependency(val artifact: Artifact, override val optional: Boolean = private fun toId(a: Artifact) = a.toString() override val jarFile: Future - get() = - if (artifact.file != null) { - resolveSourcesIfNeeded() - CompletedFuture(artifact.file) - } else { - resolveSourcesIfNeeded() - val td = aether.resolve(artifact) - CompletedFuture(td.root.artifact.file) - } + 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) { - artifact.toSourcesArtifact().let { sourcesArtifact -> - if (sourcesArtifact.file == null) { + listOf(artifact.toSourcesArtifact(), artifact.toJavaDocArtifact()).forEach { artifact -> + if (artifact.file == null) { try { - aether.resolve(sourcesArtifact) + aether.resolve(artifact) } catch(e: DependencyResolutionException) { - //do nothing - } - } - } - artifact.toJavaDocArtifact().let { javadocArtifact -> - if (javadocArtifact.file == null) { - try { - aether.resolve(javadocArtifact) - } catch(e: DependencyResolutionException) { - //do nothing + // Ignore } } } 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 e3b52dcd..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 @@ -32,8 +33,9 @@ object Booter { // } 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 eb1fe8c7..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 @@ -16,12 +16,6 @@ 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?) { kobaltLog(LOG_LEVEL, "Deployed " + event!!.artifact + " to " + event.repository) } 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 index 6af9cb27..0a661c2c 100644 --- 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 @@ -1,6 +1,8 @@ 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 { @@ -9,7 +11,15 @@ object Filters { } val TEST_FILTER = DependencyFilter { p0, p1 -> p0.dependency.scope == JavaScopes.TEST } - val EXCLUDE_OPTIONAL_FILTER = DependencyFilter { p0, p1 -> - p0.dependency != null && ! p0.dependency.optional + 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 index 46c43272..7c8b705f 100644 --- 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 @@ -2,11 +2,14 @@ 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 @@ -21,6 +24,7 @@ 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, @@ -32,29 +36,76 @@ class KobaltMavenResolver @Inject constructor(val settings: KobaltSettings, 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? = null) : Artifact + fun resolveToArtifact(id: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER) : Artifact = resolve(id, scope, filter).root.artifact - fun resolve(id: String, scope: Scope? = null, filter: DependencyFilter? = null, + fun resolve(passedId: String, scope: Scope? = null, + filter: DependencyFilter = Filters.EXCLUDE_OPTIONAL_FILTER, repos: List = emptyList()): DependencyResult { - val dependencyRequest = DependencyRequest(createCollectRequest(id, scope, repos), filter) + 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()) }) + // 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? = null) + 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? = null, + 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 == null || filter.accept(DefaultDependencyNode(it.dependency), emptyList()) + filter.accept(DefaultDependencyNode(it.dependency), emptyList()) }.filter { it.dependency.scope != Scope.SYSTEM.scope } @@ -90,10 +141,19 @@ class KobaltMavenResolver @Inject constructor(val settings: KobaltSettings, 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, eventBus) + private val session = Booter.newRepositorySystemSession(system, localRepo.localRepo, settings, args, eventBus) - private fun createRepo(hostConfig: HostConfig) = - RemoteRepository.Builder(hostConfig.name, "default", hostConfig.url).build() + 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 { @@ -105,6 +165,9 @@ class KobaltMavenResolver @Inject constructor(val settings: KobaltSettings, } } + 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)) @@ -112,6 +175,6 @@ class KobaltMavenResolver @Inject constructor(val settings: KobaltSettings, dependencies = allIds.map { Dependency(DefaultArtifact(it), scope?.scope) } root = Dependency(DefaultArtifact(MavenId.toMavenId(id)), scope?.scope) - repositories = kobaltRepositories + repos.map { createRepo(HostConfig(it)) } + repositories = createRepos(repos) } } 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 index 6c18f555..7822159e 100644 --- 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 @@ -12,6 +12,7 @@ sealed class Scope(val scope: String, val dependencyLambda: (Project) -> List emptyList() }) object RUNTIME : Scope(JavaScopes.RUNTIME, Project::compileRuntimeDependencies) object TEST : Scope(JavaScopes.TEST, Project::testDependencies) 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 index f4c4161f..cf6b5885 100644 --- 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 @@ -6,12 +6,13 @@ import com.google.inject.Inject import java.io.File class Git @Inject constructor() { - fun maybeTagRelease(project: Project, uploadResult: TaskResult, enabled: Boolean, annotated: Boolean, tag: String, message: String) : TaskResult { + 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, tag, message) + val tagSuccess = tagRelease(project, annotated, push, tag, message) if (! tagSuccess) { - TaskResult(false, "Couldn't tag the project") + TaskResult(false, errorMessage = "Couldn't tag the project") } else { TaskResult() } @@ -21,7 +22,7 @@ class Git @Inject constructor() { return result } - private fun tagRelease(project: Project, annotated: Boolean, tag: String, message: String) : Boolean { + 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\"") @@ -37,7 +38,9 @@ class Git @Inject constructor() { } else { git.tag().setName(version).setMessage(message).call() } - git.push().setPushTags().call() + if (push) { + git.push().setPushTags().call() + } true } catch(ex: Exception) { warn("Couldn't create tag ${version}: ${ex.message}", ex) 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 9f89a01d..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 @@ -86,12 +86,12 @@ 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 -> kobaltLog(1, "\n${zipFile.name} successfully uploaded") @@ -120,8 +120,8 @@ class GithubApi2 @Inject constructor( Duration.between(VersionCheckTimestampFile.timestamp, Instant.now())) { kobaltLog(2, "Skipping GitHub latest release check, too soon.") } else { - val username = localProperties.getNoThrows(PROPERTY_USERNAME, DOC_URL) - val accessToken = localProperties.getNoThrows(PROPERTY_ACCESS_TOKEN, DOC_URL) + val username = localProperties.getNoThrows(PROPERTY_USERNAME) + val accessToken = localProperties.getNoThrows(PROPERTY_ACCESS_TOKEN) try { val req = if (username != null && accessToken != null) { @@ -138,8 +138,8 @@ class GithubApi2 @Inject constructor( val releases = ex.body() if (releases != null) { releases.firstOrNull()?.let { - try { - result = listOf(it.name, it.tagName).filterNotNull().first { !it.isBlank() } + result = try { + listOf(it.name, it.tagName).filterNotNull().first { !it.isBlank() } } catch(ex: NoSuchElementException) { throw KobaltException("Couldn't find the latest release") } 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 ff282ae0..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,16 +1,16 @@ 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 class JarUtils { companion object { @@ -21,18 +21,15 @@ 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 -> @@ -51,50 +48,24 @@ class JarUtils { // 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")) { - kobaltLog(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 = KFiles.fixSlashes(file.to(foundFile.path)) - 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()) { @@ -134,39 +105,3 @@ 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 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 b668b97a..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 @@ -4,20 +4,38 @@ import com.beust.kobalt.* import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.maven.Md5 +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") @@ -29,19 +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 leftSuffix = Kobalt.version.substring(0, Kobalt.version.lastIndexOf(".") + 1) - val previousVersion = leftSuffix + - (Kobalt.version.split(".").let { it[it.size - 1] }.toInt() - 1).toString() + val previousVersion = latestInstalledVersion().version val previousJar = joinDir(distributionsDir, "kobalt-" + previousVersion, "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() } @@ -91,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): String = 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,7 +137,7 @@ 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) = fixSlashes(File(s)) + fun fixSlashes(s: String) = s.replace('\\', '/') fun makeDir(dir: String, s: String? = null) = (if (s != null) File(dir, s) else File(dir)).apply { mkdirs() } @@ -194,69 +216,6 @@ class KFiles { } } - fun copyRecursively(from: File, to: File, replaceExisting: Boolean = true, deleteFirst: Boolean = false, - onError: (File, IOException) -> OnErrorAction = { _, 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. - */ - private fun hackCopyRecursively(from: File, dst: File, - replaceExisting: Boolean, - onError: (File, IOException) -> OnErrorAction = - { _, 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)) { - kobaltLog(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 - } - } - } - } - } - return true - } catch (e: TerminateException) { - return false - } - } - /** * The build location for build scripts is .kobalt/build */ @@ -286,22 +245,18 @@ class KFiles { 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()) { - kobaltLog(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())) { - kobaltLog(3, "Copy from $from to $to") - Files.copy(from, to, option) - } else { - kobaltLog(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 - kobaltLog(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}") } } @@ -386,6 +341,35 @@ class KFiles { } 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/KobaltLogger.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/KobaltLogger.kt index 1d235a44..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,6 +1,9 @@ package com.beust.kobalt.misc -import com.beust.kobalt.* +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 @@ -48,7 +51,7 @@ 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() = @@ -57,6 +60,14 @@ object KobaltLogger { } 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 + } + } } class Logger(val dev: Boolean) { @@ -75,7 +86,8 @@ class Logger(val dev: Boolean) { 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 { e?.toString() } val shortMessage = "***** E $text " + if (docUrl != null) " Documentation: $docUrl" else "" @@ -88,7 +100,10 @@ class Logger(val dev: Boolean) { } fun warn(tag: String, message: CharSequence, e: Throwable? = null) { - val fullMessage = "***** WARNING " + (e?.message ?: message) + 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 != null) { Exceptions.printStackTrace(e) 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 06d01e7b..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 @@ -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 67b666a6..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 @@ -78,19 +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 = if (info.containsErrors != null) ! info.containsErrors!!(error) - else isSuccess(returnCode, input, 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) } @@ -103,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/RunCommand.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/misc/RunCommand.kt deleted file mode 100644 index bad2995c..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 -> kobaltLog(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) - kobaltLog(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 index fc620554..b421e558 100644 --- 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 @@ -29,8 +29,12 @@ class StringVersion(val version: String) : Comparable { if (v1 < v2) return -1 else if (v1 > v2) return 1 } catch(ex: NumberFormatException) { - warn("Couldn't parse version $version or $other") - return -1 + if (version == other.toString()) { + return 0 + } else { + log(2, "Couldn't parse version $version or $other") + return -1 + } } } return 0 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/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/Main.java b/modules/wrapper/src/main/java/com/beust/kobalt/wrapper/Main.java index f91bf3c1..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 @@ -47,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; @@ -78,6 +77,7 @@ public class Main { } int result = 0; if (! exit) { + initWrapperFile(version); Path kobaltJarFile = installDistribution(); if (!noLaunch) { result = launchMain(kobaltJarFile, kobaltArgv); @@ -118,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 { @@ -133,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) { @@ -345,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); } 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 6c6e988e..19b85404 100644 --- a/src/main/kotlin/com/beust/kobalt/Main.kt +++ b/src/main/kotlin/com/beust/kobalt/Main.kt @@ -17,37 +17,13 @@ import java.net.URLClassLoader 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 < Constants.LOG_QUIET_LEVEL) { - 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 http: Http, val files: KFiles, @@ -59,6 +35,43 @@ private class Main @Inject constructor( val pluginInfo: PluginInfo, 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) private fun installCommandLinePlugins(args: Args): ClassLoader { diff --git a/src/main/kotlin/com/beust/kobalt/Options.kt b/src/main/kotlin/com/beust/kobalt/Options.kt index 16166e11..ef4cbfd4 100644 --- a/src/main/kotlin/com/beust/kobalt/Options.kt +++ b/src/main/kotlin/com/beust/kobalt/Options.kt @@ -1,8 +1,10 @@ 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.PluginTask +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 @@ -44,10 +46,26 @@ class Options @Inject constructor( 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) - var pluginClassLoader = javaClass.classLoader + val pluginClassLoader = javaClass.classLoader - val allProjectResult = projectFinder.initForBuildFile(buildSources, args) - val allProjects = allProjectResult.projects + // + // 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) @@ -77,9 +95,11 @@ class Options @Inject constructor( }), Option( { -> args.projectInfo }, { // --projectInfo - allProjects.forEach { - it.compileDependencies.filter { it.isMaven }.forEach { - resolveDependency.run(it.id) + runIfSuccessfulBuild(buildError) { + allProjects.forEach { + it.compileDependencies.filter { it.isMaven }.forEach { + resolveDependency.run(it.id) + } } } }), @@ -89,11 +109,15 @@ class Options @Inject constructor( }), Option( { args.tasks }, { // --tasks - displayTasks() + runIfSuccessfulBuild(buildError) { + displayTasks(allProjects, Kobalt.context!!) + } }), Option( { args.checkVersions }, { // --checkVersions - checkVersions.run(allProjects) + runIfSuccessfulBuild(buildError) { + checkVersions.run(allProjects) + } }), Option( { args.download }, { // --download @@ -121,17 +145,19 @@ class Options @Inject constructor( if (! buildSources.exists()) { throw KobaltException("Could not find build file: " + buildSources) } - val runTargetResult = taskManager.runTargets(args.targets, allProjects) - if (result == 0) { - result = if (runTargetResult.taskResult.success) 0 else 1 - } + runIfSuccessfulBuild(buildError) { + val runTargetResult = taskManager.runTargets(args.targets, allProjects) + if (result == 0) { + result = if (runTargetResult.taskResult.success) 0 else 1 + } - // Shutdown all plug-ins - plugins.shutdownPlugins() + // Shutdown all plug-ins + plugins.shutdownPlugins() - // Run the build report contributors - pluginInfo.buildReportContributors.forEach { - it.generateReport(Kobalt.context!!) + // Run the build report contributors + pluginInfo.buildReportContributors.forEach { + it.generateReport(Kobalt.context!!) + } } } return result @@ -152,19 +178,29 @@ class Options @Inject constructor( } } - private fun displayTasks() { + private fun displayTasks(projects: List, context: KobaltContext) { // // List of tasks, --tasks // - val tasksByPlugins = HashMultimap.create() - taskManager.annotationTasks.forEach { - tasksByPlugins.put(it.plugin.name, it) + val tasksByPlugins = HashMultimap.create() + projects.forEach { project -> + pluginInfo.taskContributors.forEach { + val tasks = it.tasksFor(project, context) + tasks.forEach { + tasksByPlugins.put(it.plugin.name, it) + } + } + } + listOf(taskManager.annotationTasks, taskManager.dynamicTasks).forEach { tasks -> + tasks.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(PluginTask::name).sortedBy(PluginTask::name).forEach { task -> + tasksByPlugins[name].distinctBy(ITask::name).sortedBy(ITask::name).forEach { task -> sb.append(" ${task.name}\t\t${task.doc}\n") } } diff --git a/src/main/kotlin/com/beust/kobalt/app/BuildFiles.kt b/src/main/kotlin/com/beust/kobalt/app/BuildFiles.kt index 98d8815a..b630f253 100644 --- a/src/main/kotlin/com/beust/kobalt/app/BuildFiles.kt +++ b/src/main/kotlin/com/beust/kobalt/app/BuildFiles.kt @@ -119,7 +119,7 @@ class BuildFiles @Inject constructor(val factory: BuildFileCompiler.IFactory, parentFile.mkdirs() val imp = arrayListOf().apply { addAll(imports) - }.distinct() + }.toMutableSet().toMutableList() Collections.sort(imp) writeText(imp.joinToString("\n")) appendText(code.joinToString("\n")) diff --git a/src/main/kotlin/com/beust/kobalt/app/LanguageTemplateGenerator.kt b/src/main/kotlin/com/beust/kobalt/app/LanguageTemplateGenerator.kt index 441939a2..e17a7cd8 100644 --- a/src/main/kotlin/com/beust/kobalt/app/LanguageTemplateGenerator.kt +++ b/src/main/kotlin/com/beust/kobalt/app/LanguageTemplateGenerator.kt @@ -20,6 +20,8 @@ abstract class LanguageTemplateGenerator : ITemplate { abstract val defaultSourceDirectories : HashSet abstract val defaultTestDirectories : HashSet + abstract val mainDependencies : ArrayList + abstract val testDependencies : ArrayList abstract val directive : String abstract val fileMatch : (String) -> Boolean abstract val fileMap: List @@ -131,20 +133,19 @@ abstract class LanguageTemplateGenerator : ITemplate { put("directory", currentDir.absolutePath) put("sourceDirectories", defaultSourceDirectories) put("sourceDirectoriesTest", defaultTestDirectories) + put("mainDependencies", mainDependencies) + put("testDependencies", testDependencies) put("imports", "import com.beust.kobalt.plugin.$templateName.*") put("directive", "project") } - var mainDeps = arrayListOf() - var testDeps = arrayListOf() - map.put("mainDependencies", mainDeps) - map.put("testDependencies", testDeps) File("pom.xml").let { if (it.absoluteFile.exists()) { - importPom(it, mainDeps, testDeps, map) + importPom(it, mainDependencies, testDependencies, map) } } + val fileInputStream = javaClass.classLoader .getResource(ITemplateContributor.DIRECTORY_NAME + "/build.mustache").openStream() val sw = StringWriter() diff --git a/src/main/kotlin/com/beust/kobalt/app/MainModule.kt b/src/main/kotlin/com/beust/kobalt/app/MainModule.kt index 8181a3b9..1f9e07b2 100644 --- a/src/main/kotlin/com/beust/kobalt/app/MainModule.kt +++ b/src/main/kotlin/com/beust/kobalt/app/MainModule.kt @@ -1,6 +1,8 @@ package com.beust.kobalt.app import com.beust.kobalt.Args +import com.beust.kobalt.JavaInfo +import com.beust.kobalt.Jvm import com.beust.kobalt.app.remote.KobaltServer import com.beust.kobalt.internal.IncrementalManager import com.beust.kobalt.internal.KobaltSettings @@ -17,6 +19,7 @@ import com.google.inject.Provider import com.google.inject.Singleton import com.google.inject.TypeLiteral import com.google.inject.assistedinject.FactoryModuleBuilder +import java.io.File import java.util.concurrent.ExecutorService open class MainModule(val args: Args, val settings: KobaltSettings) : AbstractModule() { @@ -49,15 +52,14 @@ open class MainModule(val args: Args, val settings: KobaltSettings) : AbstractMo bind(Args::class.java).toProvider(Provider { args }) - EventBus().let { eventBus -> - bind(EventBus::class.java).toInstance(eventBus) - } + bind(EventBus::class.java).toInstance(EventBus()) bind(PluginInfo::class.java).toProvider(Provider { PluginInfo.readKobaltPluginXml() }).`in`(Singleton::class.java) bind(KobaltSettings::class.java).toProvider(Provider { settings }).`in`(Singleton::class.java) + bind(Jvm::class.java).toInstance(JavaInfo.create(File(com.beust.kobalt.SystemProperties.javaBase))) // bindListener(Matchers.any(), object: TypeListener { // override fun hear(typeLiteral: TypeLiteral?, typeEncounter: TypeEncounter?) { diff --git a/src/main/kotlin/com/beust/kobalt/app/Profiles.kt b/src/main/kotlin/com/beust/kobalt/app/Profiles.kt index bb5ea346..b2cf1a5a 100644 --- a/src/main/kotlin/com/beust/kobalt/app/Profiles.kt +++ b/src/main/kotlin/com/beust/kobalt/app/Profiles.kt @@ -56,7 +56,7 @@ class Profiles(val context: KobaltContext) { val variable = if (match.first) match.second else oldMatch.second if (oldMatch.first) { - warn("Old profile syntax detected for \"$line\"," + + warn("Old profile syntax detected for \"${line.trim()}\"," + " please update to \"val $variable by profile()\"") } diff --git a/src/main/kotlin/com/beust/kobalt/app/java/JavaTemplateGenerator.kt b/src/main/kotlin/com/beust/kobalt/app/java/JavaTemplateGenerator.kt index c34b80d3..ef938f00 100644 --- a/src/main/kotlin/com/beust/kobalt/app/java/JavaTemplateGenerator.kt +++ b/src/main/kotlin/com/beust/kobalt/app/java/JavaTemplateGenerator.kt @@ -1,11 +1,14 @@ package com.beust.kobalt.app.java import com.beust.kobalt.app.LanguageTemplateGenerator +import com.beust.kobalt.maven.Pom /** * Template for the "java" generator. */ class JavaTemplateGenerator : LanguageTemplateGenerator() { + override val mainDependencies = arrayListOf() + override val testDependencies = arrayListOf() override val defaultSourceDirectories = hashSetOf("src/main/java") override val defaultTestDirectories = hashSetOf("src/test/java") override val directive = "project" diff --git a/src/main/kotlin/com/beust/kobalt/app/kotlin/KotlinTemplateGenerator.kt b/src/main/kotlin/com/beust/kobalt/app/kotlin/KotlinTemplateGenerator.kt index 51b11a14..f10698c4 100644 --- a/src/main/kotlin/com/beust/kobalt/app/kotlin/KotlinTemplateGenerator.kt +++ b/src/main/kotlin/com/beust/kobalt/app/kotlin/KotlinTemplateGenerator.kt @@ -1,10 +1,16 @@ package com.beust.kobalt.app.kotlin +import com.beust.kobalt.Constants import com.beust.kobalt.app.LanguageTemplateGenerator +import com.beust.kobalt.maven.Pom class KotlinTemplateGenerator : LanguageTemplateGenerator() { override val defaultSourceDirectories = hashSetOf("src/main/kotlin") override val defaultTestDirectories = hashSetOf("src/test/kotlin") + override val mainDependencies = arrayListOf( + Pom.Dependency("org.jetbrains.kotlin", "kotlin-stdlib", null, Constants.KOTLIN_COMPILER_VERSION) + ) + override val testDependencies = arrayListOf() override val directive = "project" override val templateName = "kotlin" override val templateDescription = "Generate a simple Kotlin project" diff --git a/src/main/kotlin/com/beust/kobalt/app/remote/GetDependencyGraphHandler.kt b/src/main/kotlin/com/beust/kobalt/app/remote/GetDependencyGraphHandler.kt index 3ac7c256..38eb6b0a 100644 --- a/src/main/kotlin/com/beust/kobalt/app/remote/GetDependencyGraphHandler.kt +++ b/src/main/kotlin/com/beust/kobalt/app/remote/GetDependencyGraphHandler.kt @@ -22,12 +22,6 @@ class GetDependencyGraphHandler : WebSocketListener { // so I have to do dependency injections manually :-( val projectFinder = Kobalt.INJECTOR.getInstance(ProjectFinder::class.java) - // URL parameters sent by the client - val PARAMETER_PROJECT_ROOT = "projectRoot" - val PARAMETER_BUILD_FILE = "buildFile" // Deprecated - val PARAMETER_PROFILES = "profiles" - val PARAMETER_DOWNLOAD_SOURCES = "downloadSources" - var session: Session? = null override fun onWebSocketClose(code: Int, reason: String?) { @@ -41,34 +35,45 @@ class GetDependencyGraphHandler : WebSocketListener { fun sendWebsocketCommand(endpoint: RemoteEndpoint, commandName: String, payload: T, errorMessage: String? = null) { + SparkServer.watchDog.rearm() val json = Gson().toJson(WebSocketCommand(commandName, payload = Gson().toJson(payload), errorMessage = errorMessage)) endpoint.sendString(json) } - private fun findProfiles(map: Map>) = map[PARAMETER_PROFILES]?.getOrNull(0) - private fun findDownloadSources(map: Map>) = map[PARAMETER_DOWNLOAD_SOURCES]?.getOrNull(0)?.toBoolean() ?: false + /** + * Convenience class to extract the parameters from the WebSocket connection. + */ + class ParameterExtractor(val map: Map>) { + // URL parameters sent by the client + private val PARAMETER_PROJECT_ROOT = "projectRoot" + private val PARAMETER_BUILD_FILE = "buildFile" // Deprecated + private val PARAMETER_PROFILES = "profiles" + private val PARAMETER_DOWNLOAD_SOURCES = "downloadSources" - private fun findBuildFile(map: Map>) : BuildSources? { + val profiles = map[PARAMETER_PROFILES]?.getOrNull(0) + val downloadSources = map[PARAMETER_DOWNLOAD_SOURCES]?.getOrNull(0)?.toBoolean() ?: false val projectRoot = map[PARAMETER_PROJECT_ROOT] - val buildFile = map[PARAMETER_BUILD_FILE] - val result = - if (projectRoot != null) { - BuildSources(File(projectRoot[0])) - } else if (buildFile != null) { - BuildSources(File(buildFile[0])) - } else { - null + val buildFile: BuildSources? + get() { + val bf = map[PARAMETER_BUILD_FILE] + return if (projectRoot != null) { + BuildSources(File(projectRoot[0])) + } else if (bf != null) { + BuildSources(File(bf[0])) + } else { + null + } } - return result } override fun onWebSocketConnect(s: Session) { session = s val parameterMap = s.upgradeRequest.parameterMap - val buildSources = findBuildFile(parameterMap) - val profiles = findProfiles(parameterMap) - val downloadSources = findDownloadSources(s.upgradeRequest.parameterMap) + val parameters = ParameterExtractor(parameterMap) + val buildSources = parameters.buildFile + val profiles = parameters.profiles + val downloadSources = parameters.downloadSources fun getInstance(cls: Class) : T = Kobalt.INJECTOR.getInstance(cls) @@ -118,7 +123,6 @@ class GetDependencyGraphHandler : WebSocketListener { // Respond to the request sendWebsocketCommand(s.remote, RemoteDependencyData.GetDependenciesData.NAME, result, errorMessage = result.errorMessage) - s.close() } override fun onWebSocketText(message: String?) { diff --git a/src/main/kotlin/com/beust/kobalt/app/remote/KobaltClient.kt b/src/main/kotlin/com/beust/kobalt/app/remote/KobaltClient.kt index a7c0a312..41d9fdd4 100644 --- a/src/main/kotlin/com/beust/kobalt/app/remote/KobaltClient.kt +++ b/src/main/kotlin/com/beust/kobalt/app/remote/KobaltClient.kt @@ -12,15 +12,7 @@ import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.warn import com.google.gson.Gson import com.google.inject.Guice -import okhttp3.OkHttpClient -import okhttp3.Request -import okhttp3.Response -import okhttp3.ResponseBody -import okhttp3.ws.WebSocket -import okhttp3.ws.WebSocketCall -import okhttp3.ws.WebSocketListener -import okio.Buffer -import java.io.IOException +import okhttp3.* fun main(argv: Array) { Kobalt.INJECTOR = Guice.createInjector(MainModule(Args(), KobaltSettings.readSettingsXml())) @@ -39,26 +31,22 @@ class KobaltClient : Runnable { .url("$url?projectRoot=$projectRoot&buildFile=$buildFile") .build() var webSocket: WebSocket? = null - val ws = WebSocketCall.create(client, request).enqueue(object: WebSocketListener { - override fun onOpen(ws: WebSocket, response: Response) { - webSocket = ws - } - - override fun onPong(p0: Buffer?) { - println("WebSocket pong") - } - - override fun onClose(p0: Int, p1: String?) { - println("WebSocket closed") - } - - override fun onFailure(ex: IOException, response: Response?) { + val socketListener = object: WebSocketListener() { + override fun onFailure(webSocket: WebSocket, ex: Throwable, response: Response?) { Exceptions.printStackTrace(ex) error("WebSocket failure: ${ex.message} response: $response") } - override fun onMessage(body: ResponseBody) { - val json = body.string() + override fun onOpen(ws: WebSocket, response: Response) { + webSocket = ws + } + + override fun onClosing(webSocket: WebSocket, code: Int, reason: String) { + println("Closing socket") + } + + override fun onMessage(webSocket: WebSocket, text: String) { + val json = text val wsCommand = Gson().fromJson(json, WebSocketCommand::class.java) if (wsCommand.errorMessage != null) { warn("Received error message from server: " + wsCommand.errorMessage) @@ -87,7 +75,10 @@ class KobaltClient : Runnable { } } } - }) + } + + val ws = client.newWebSocket(request, socketListener) + ws.close(1000, "All good") } } diff --git a/src/main/kotlin/com/beust/kobalt/app/remote/KobaltServer.kt b/src/main/kotlin/com/beust/kobalt/app/remote/KobaltServer.kt index 2e068829..3c4339d3 100644 --- a/src/main/kotlin/com/beust/kobalt/app/remote/KobaltServer.kt +++ b/src/main/kotlin/com/beust/kobalt/app/remote/KobaltServer.kt @@ -1,6 +1,5 @@ package com.beust.kobalt.app.remote -import com.beust.kobalt.api.Project import com.beust.kobalt.homeDir import com.beust.kobalt.internal.PluginInfo import com.beust.kobalt.maven.aether.Exceptions @@ -74,15 +73,12 @@ class KobaltServer @Inject constructor(@Assisted val force: Boolean, @Assisted @ try { if (createServerFile(port, force)) { kobaltLog(1, "KobaltServer listening on port $port") -// OldServer(initCallback, cleanUpCallback).run(port) -// JerseyServer(initCallback, cleanUpCallback).run(port) SparkServer(cleanUpCallback, pluginInfo).run(port) -// WasabiServer(initCallback, cleanUpCallback).run(port) } } catch(ex: Exception) { Exceptions.printStackTrace(ex) } finally { -// deleteServerFile() + deleteServerFile() } return port } diff --git a/src/main/kotlin/com/beust/kobalt/app/remote/RemoteDependencyData.kt b/src/main/kotlin/com/beust/kobalt/app/remote/RemoteDependencyData.kt index bd1914ac..fcd0a80c 100644 --- a/src/main/kotlin/com/beust/kobalt/app/remote/RemoteDependencyData.kt +++ b/src/main/kotlin/com/beust/kobalt/app/remote/RemoteDependencyData.kt @@ -2,6 +2,7 @@ package com.beust.kobalt.app.remote import com.beust.kobalt.Args import com.beust.kobalt.api.IClasspathDependency +import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.app.BuildFileCompiler import com.beust.kobalt.internal.DynamicGraph @@ -29,7 +30,7 @@ class RemoteDependencyData @Inject constructor(val executors: KobaltExecutors, v val taskManager: TaskManager) { fun dependenciesDataFor(buildSources: BuildSources, args: Args, - findProjectResult: BuildFileCompiler.FindProjectResult, + projectResult: BuildFileCompiler.FindProjectResult, progressListener: IProgressListener? = null, useGraph : Boolean = false): GetDependenciesData { val projectDatas = arrayListOf() @@ -42,9 +43,7 @@ class RemoteDependencyData @Inject constructor(val executors: KobaltExecutors, v fun allDeps(l: List, name: String) = dependencyManager.transitiveClosure(l, requiredBy = name) -// val buildFile = BuildFile(Paths.get(buildFilePath), "GetDependenciesCommand") - val buildFileCompiler = buildFileCompilerFactory.create(buildSources, pluginInfo) - val projectResult = buildFileCompiler.compileBuildFiles(args) + val buildFileDependencies = Kobalt.buildFileClasspath.map {toDependencyData(it, "compile")} val pluginDependencies = projectResult.pluginUrls.map { File(it.toURI()) }.map { DependencyData(it.name, "compile", it.absolutePath) @@ -176,8 +175,8 @@ class RemoteDependencyData @Inject constructor(val executors: KobaltExecutors, v }) } - return GetDependenciesData(projectDatas, allTasks, pluginDependencies, findProjectResult.buildContentRoots, - projectResult.taskResult.errorMessage) + return GetDependenciesData(projectDatas, allTasks, pluginDependencies, buildFileDependencies, + projectResult.buildContentRoots, projectResult.taskResult.errorMessage) } ///// @@ -202,6 +201,7 @@ class RemoteDependencyData @Inject constructor(val executors: KobaltExecutors, v class GetDependenciesData(val projects: List = emptyList(), val allTasks: Collection = emptySet(), val pluginDependencies: List = emptyList(), + val buildFileDependencies: List = emptyList(), val buildContentRoots: List = emptyList(), val errorMessage: String?) { companion object { diff --git a/src/main/kotlin/com/beust/kobalt/app/remote/SparkServer.kt b/src/main/kotlin/com/beust/kobalt/app/remote/SparkServer.kt index 49f3e4a1..f78c8f37 100644 --- a/src/main/kotlin/com/beust/kobalt/app/remote/SparkServer.kt +++ b/src/main/kotlin/com/beust/kobalt/app/remote/SparkServer.kt @@ -5,6 +5,7 @@ import com.beust.kobalt.app.Templates import com.beust.kobalt.internal.PluginInfo import com.google.common.collect.ListMultimap import com.google.gson.Gson +import org.slf4j.Logger import spark.ResponseTransformer import spark.Route import spark.Spark @@ -14,6 +15,8 @@ class SparkServer(val cleanUpCallback: () -> Unit, val pluginInfo : PluginInfo) companion object { lateinit var cleanUpCallback: () -> Unit + val URL_QUIT = "/quit" + lateinit var watchDog: WatchDog } init { @@ -28,19 +31,25 @@ class SparkServer(val cleanUpCallback: () -> Unit, val pluginInfo : PluginInfo) private fun jsonRoute(path: String, route: Route) = Spark.get(path, "application/json", route, JsonTransformer()) - val log = org.slf4j.LoggerFactory.getLogger("SparkServer") + val log: Logger = org.slf4j.LoggerFactory.getLogger("SparkServer") override fun run(port: Int) { + val threadPool = Executors.newFixedThreadPool(2) + watchDog = WatchDog(port, 60 * 10 /* 10 minutes */, log) + threadPool.submit { + watchDog.run() + } log.debug("Server running") Spark.port(port) Spark.webSocket("/v1/getDependencyGraph", GetDependencyGraphHandler::class.java) Spark.get("/ping") { req, res -> + watchDog.rearm() log.debug(" Received ping") """ { "result" : "ok" } """ } - Spark.get("/quit", { req, res -> + Spark.get(URL_QUIT, { req, res -> log.debug(" Received quit") - Executors.newFixedThreadPool(1).let { executor -> + threadPool.let { executor -> executor.submit { Thread.sleep(1000) Spark.stop() diff --git a/src/main/kotlin/com/beust/kobalt/app/remote/WatchDog.kt b/src/main/kotlin/com/beust/kobalt/app/remote/WatchDog.kt new file mode 100644 index 00000000..c006abd4 --- /dev/null +++ b/src/main/kotlin/com/beust/kobalt/app/remote/WatchDog.kt @@ -0,0 +1,71 @@ +package com.beust.kobalt.app.remote + +import com.beust.kobalt.misc.warn +import org.slf4j.Logger +import java.net.HttpURLConnection +import java.net.URL +import java.time.Duration +import java.time.LocalDateTime +import java.time.OffsetDateTime +import java.time.format.DateTimeFormatter + +/** + * Wakes up every `WAKE_UP_INTERVAL` and check if a certain period of time (`checkPeriod`) has elapsed + * without being rearmed. If that time has elapsed, send a QUIT command to the Kobalt server. If the WatchDog + * gets rearmed, the expiration period is reset. + */ +class WatchDog(val port: Int, val checkPeriodSeconds: Long, val log: Logger) { + private val WAKE_UP_INTERVAL: Duration = Duration.ofSeconds(60) + private val FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern("MM/d/y HH:mm:ss") + + private var nextWakeUpMillis: Long = arm() + private var stop: Boolean = false + + /** + * Rearm for another `checkPeriod`. + */ + fun rearm() { + nextWakeUpMillis = arm() + log.info("Watchdog rearmed for " + format(nextWakeUpMillis)) + } + + /** + * Start the watch dog. + */ + fun run() { + val wakeUpSeconds = WAKE_UP_INTERVAL.toMillis() + log.info("Server dying at " + format(nextWakeUpMillis) + ", next wake up in " + + (wakeUpSeconds / 1000) + " seconds") + while (! stop) { + Thread.sleep(wakeUpSeconds) + val diffSeconds = (nextWakeUpMillis - System.currentTimeMillis()) / 1000 + if (diffSeconds <= 0) { + log.info("Time to die") + stop = true + } else { + log.info("Dying in $diffSeconds seconds") + } + } + + try { + val connection = (URL("http://localhost:$port" + SparkServer.URL_QUIT) + .openConnection() as HttpURLConnection).apply { + requestMethod = "GET" + } + val code = connection.responseCode + if (code == 200) { + log.info("Successfully stopped the server") + } else { + warn("Couldn't stop the server, response: " + code) + } + } catch(ex: Exception) { + warn("Couldn't stop the server: " + ex.message, ex) + } + } + + private fun arm() = System.currentTimeMillis() + (checkPeriodSeconds * 1000) + + private fun toLocalDate(millis: Long) = LocalDateTime.ofEpochSecond(millis / 1000, 0, OffsetDateTime.now().offset) + + private fun format(millis: Long) = FORMAT.format(toLocalDate(millis)) +} \ No newline at end of file diff --git a/src/main/kotlin/com/beust/kobalt/plugin/KobaltPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/KobaltPlugin.kt index d8248b75..eb3f7314 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/KobaltPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/KobaltPlugin.kt @@ -27,11 +27,4 @@ class KobaltPlugin @Inject constructor(val checkVersions: CheckVersions, val upd checkVersions.run(project) return TaskResult() } - - @Task(name = "update", description = "Update Kobalt to the latest version") - fun taskUpdate(project: Project) : TaskResult { - updateKobalt.updateKobalt() - return TaskResult() - } - } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/application/ApplicationPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/application/ApplicationPlugin.kt index 44a2989b..926a00bf 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/application/ApplicationPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/application/ApplicationPlugin.kt @@ -1,17 +1,18 @@ package com.beust.kobalt.plugin.application -import com.beust.kobalt.* +import com.beust.kobalt.Jvm +import com.beust.kobalt.KobaltException +import com.beust.kobalt.Plugins +import com.beust.kobalt.TaskResult import com.beust.kobalt.api.* import com.beust.kobalt.api.annotation.Directive -import com.beust.kobalt.api.annotation.Task import com.beust.kobalt.archive.Archives -import com.beust.kobalt.internal.ActorUtils import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.aether.Scope import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors -import com.beust.kobalt.misc.RunCommand import com.beust.kobalt.misc.kobaltLog +import com.beust.kobalt.misc.runCommand import com.beust.kobalt.plugin.packaging.PackageConfig import com.beust.kobalt.plugin.packaging.PackagingPlugin import com.google.inject.Inject @@ -19,6 +20,9 @@ import com.google.inject.Singleton import java.io.File class ApplicationConfig { + @Directive + var taskName: String = "run" + @Directive var mainClass: String? = null @@ -29,6 +33,15 @@ class ApplicationConfig { @Directive fun args(vararg argv: String) = argv.forEach { args.add(it) } val args = arrayListOf() + + @Directive + var ignoreErrorStream: Boolean = false + + @Directive + var ignoreInputStream: Boolean = true + + @Directive + var ignoreExitValue: Boolean = false } @Directive @@ -40,10 +53,10 @@ fun Project.application(init: ApplicationConfig.() -> Unit): ApplicationConfig { } @Singleton -class ApplicationPlugin @Inject constructor(val configActor: ConfigActor, +class ApplicationPlugin @Inject constructor(val configActor: ConfigsActor, val executors: KobaltExecutors, val nativeManager: NativeManager, - val dependencyManager: DependencyManager, val taskContributor : TaskContributor) - : BasePlugin(), IRunnerContributor, ITaskContributor, IConfigActor by configActor { + val dependencyManager: DependencyManager, val taskContributor : TaskContributor, val jvm: Jvm) + : BasePlugin(), ITaskContributor, IConfigsActor by configActor { companion object { const val PLUGIN_NAME = "Application" @@ -53,49 +66,50 @@ class ApplicationPlugin @Inject constructor(val configActor: ConfigActor 0) { - return runContributor.run(project, context, - dependencyManager.dependencies(project, context, listOf(Scope.RUNTIME))) - } else { - context.logger.log(project.name, 1, - "Couldn't find a runner for project ${project.name}. Please make sure" + - " your build file contains " + - "an application{} directive with a mainClass=... in it") - return TaskResult() + configurationFor(project)?.let { configs -> + configs.forEach { config -> + taskContributor.addTask(this, project, config.taskName, + description = "Run the class " + config.mainClass, + group = "run", + dependsOn = listOf("assemble"), + runTask = { run(project, context, config) }) + } } } +// fun taskRun(project: Project, config: ApplicationConfig): TaskResult { +// val runContributor = ActorUtils.selectAffinityActor(project, context, +// context.pluginInfo.runnerContributors) +// if (runContributor != null && runContributor.affinity(project, context) > 0) { +// return runContributor.run(project, context, +// dependencyManager.dependencies(project, context, listOf(Scope.RUNTIME))) +// } else { +// context.logger.log(project.name, 1, +// "Couldn't find a runner for project ${project.name}. Please make sure" + +// " your build file contains " + +// "an application{} directive with a mainClass=... in it") +// return TaskResult() +// } +// } + private fun isFatJar(packages: List, jarName: String): Boolean { val foundJar = packages.flatMap { it.jars }.filter { jarName.endsWith(it.name) } return foundJar.size == 1 && foundJar[0].fatJar } - // IRunContributor - - override fun affinity(project: Project, context: KobaltContext): Int { - return if (configurationFor(project) != null) IAffinity.DEFAULT_POSITIVE_AFFINITY else 0 - } - - override fun run(project: Project, context: KobaltContext, classpath: List): TaskResult { - var result = TaskResult() + private fun run(project: Project, context: KobaltContext, config: ApplicationConfig): TaskResult { if (project.nativeDependencies.any()) { nativeManager.installLibraries(project) } - configurationFor(project)?.let { config -> + + val result = if (config.mainClass != null) { - result = runJarFile(project, context, config) + runJarFile(project, context, config) } else { throw KobaltException("No \"mainClass\" specified in the application{} part of project ${project.name}") } - } + return result } @@ -106,14 +120,12 @@ class ApplicationPlugin @Inject constructor(val configActor: ConfigActor val allDeps = arrayListOf(jarName) - val java = JavaInfo.create(File(SystemProperties.javaBase)).javaExecutable!! + val java = jvm.javaExecutable!! if (! isFatJar(packages, jarName)) { @Suppress("UNCHECKED_CAST") // If the jar file is not fat, we need to add the transitive closure of all dependencies @@ -131,20 +143,38 @@ class ApplicationPlugin @Inject constructor(val configActor: ConfigActor -> - kobaltLog(1, output.joinToString("\n")) - }, - errorCallback = { output: List -> - kobaltLog(1, "ERROR") - kobaltLog(1, output.joinToString("\n")) - } - ) + val allArgs = contributorFlags + initialArgs + config.args + val exitCode = runCommand { + command = "java" + args = allArgs + useErrorStreamAsErrorIndicator = false + directory = File(project.directory) + successCallback = { output: List -> + kobaltLog(1, output.joinToString("\n")) + } + errorCallback = { output: List -> + kobaltLog(1, "ERROR") + kobaltLog(1, output.joinToString("\n")) + } + useErrorStreamAsErrorIndicator = !config.ignoreErrorStream + useInputStreamAsErrorIndicator = !config.ignoreInputStream + ignoreExitValue = config.ignoreExitValue + } return TaskResult(exitCode == 0) } //ITaskContributor - override fun tasksFor(project: Project, context: KobaltContext): List = taskContributor.dynamicTasks + override fun tasksFor(project: Project, context: KobaltContext): List { + val result = arrayListOf() + configurationFor(project)?.let { configs -> + configs.forEach { config -> + result.add(DynamicTask(this, config.taskName, "Run the class " + config.mainClass, "run", project, + dependsOn = listOf("assemble"), + closure = { run(project, context, config) })) + } + } + + return result + } } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/apt/AptPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/apt/AptPlugin.kt index b90c9f5a..f2d7410b 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/apt/AptPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/apt/AptPlugin.kt @@ -1,10 +1,20 @@ package com.beust.kobalt.plugin.apt +import com.beust.kobalt.Constants +import com.beust.kobalt.Jvm +import com.beust.kobalt.TaskResult import com.beust.kobalt.api.* +import com.beust.kobalt.api.annotation.AnnotationDefault import com.beust.kobalt.api.annotation.Directive +import com.beust.kobalt.internal.CompilerUtils import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.maven.aether.Filters +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.KobaltLogger import com.beust.kobalt.misc.warn +import com.beust.kobalt.plugin.kotlin.KotlinPlugin import com.google.common.collect.ArrayListMultimap import com.google.inject.Inject import java.io.File @@ -12,33 +22,16 @@ import java.util.* import javax.inject.Singleton /** - * The AptPlugin has two components: + * The AptPlugin manages both apt and kapt. Each of them has two components: * 1) A new apt directive inside a dependency{} block (similar to compile()) that declares where * the annotation processor is found * 2) An apt{} configuration on Project that lets the user configure how the annotation is performed * (outputDir, etc...). */ @Singleton -class AptPlugin @Inject constructor(val dependencyManager: DependencyManager) - : BasePlugin(), ICompilerFlagContributor, ISourceDirectoryContributor { - - // ISourceDirectoryContributor - - private fun generatedDir(project: Project, outputDir: String) : File - = File(KFiles.joinDir(project.directory, KFiles.KOBALT_BUILD_DIR, outputDir)) - - override fun sourceDirectoriesFor(project: Project, context: KobaltContext): List { - val result = arrayListOf() - aptConfigs[project.name]?.let { config -> - result.add(generatedDir(project, config.outputDir)) - } - - kaptConfigs[project.name]?.let { config -> - result.add(generatedDir(project, config.outputDir)) - } - - return result - } +class AptPlugin @Inject constructor(val dependencyManager: DependencyManager, val kotlinPlugin: KotlinPlugin, + val compilerUtils: CompilerUtils, val jvm: Jvm) + : BasePlugin(), ICompilerFlagContributor, ISourceDirectoryContributor, IClasspathContributor, ITaskContributor { companion object { const val PLUGIN_NAME = "Apt" @@ -49,10 +42,14 @@ class AptPlugin @Inject constructor(val dependencyManager: DependencyManager) override val name = PLUGIN_NAME override fun apply(project: Project, context: KobaltContext) { - listOf(aptConfigs[project.name]?.outputDir, aptConfigs[project.name]?.outputDir) + super.apply(project, context) + val kaptConfig = kaptConfigs[project.name] + + // Delete the output directories + listOf(aptConfigs[project.name]?.outputDir, kaptConfig?.outputDir) .filterNotNull() .distinct() - .map { generatedDir(project, it) } + .map { aptGeneratedDir(project, it) } .forEach { it.normalize().absolutePath.let { path -> context.logger.log(project.name, 1, " Deleting " + path) @@ -62,21 +59,195 @@ class AptPlugin @Inject constructor(val dependencyManager: DependencyManager) } } - private fun generated(project: Project, context: KobaltContext, outputDir: String) = - KFiles.joinAndMakeDir(project.directory, project.buildDirectory, outputDir, - context.variant.toIntermediateDir()) + // IClasspathContributor + override fun classpathEntriesFor(project: Project?, context: KobaltContext): Collection { + val result = arrayListOf() + val kaptConfig = kaptConfigs[project?.name] + if (project != null && kaptConfig != null) { + kaptConfig.let { config -> + val c = kaptClassesDir(project, config.outputDir) + File(c).mkdirs() + result.add(FileDependency(c)) + } + } + return result + } + + private fun aptGeneratedDir(project: Project, outputDir: String) : File + = File(KFiles.joinDir(project.directory, KFiles.KOBALT_BUILD_DIR, outputDir)) + + // ISourceDirectoryContributor + override fun sourceDirectoriesFor(project: Project, context: KobaltContext): List { + val result = arrayListOf() + aptConfigs[project.name]?.let { config -> + result.add(aptGeneratedDir(project, config.outputDir)) + } + + kaptConfigs[project.name]?.let { config -> + result.add(File(kaptSourcesDir(project, config.outputDir))) + } + + return result + } + + private fun kaptGenerated(project: Project, outputDir: String) = + KFiles.joinAndMakeDir(project.directory, project.buildDirectory, outputDir) + + private fun kaptSourcesDir(project: Project, outputDir: String) = + KFiles.joinDir(kaptGenerated(project, outputDir), "sources") + private fun kaptStubsDir(project: Project, outputDir: String) = + KFiles.joinDir(kaptGenerated(project, outputDir), "stubs") + private fun kaptClassesDir(project: Project, outputDir: String) = + KFiles.joinDir(kaptGenerated(project, outputDir), "classes") + + // ITaskContributor + override fun tasksFor(project: Project, context: KobaltContext): List { + val kaptConfig = kaptConfigs[project.name] + val result = + if (kaptConfig != null) { + listOf( + DynamicTask(this, "runKapt", "Run kapt", AnnotationDefault.GROUP, project, + reverseDependsOn = listOf("compile"), runAfter = listOf("clean"), + closure = {p: Project -> taskRunKapt(p)}), + DynamicTask(this, "compileKapt", "Compile the sources generated by kapt", + AnnotationDefault.GROUP, project, + dependsOn = listOf("runKapt"), reverseDependsOn = listOf("compile"), + closure = {p: Project -> taskCompileKapt(p)}) + ) + } else { + emptyList() + } + return result + } + + fun taskCompileKapt(project: Project) : TaskResult { + var success = true + kaptConfigs[project.name]?.let { config -> + val sourceDirs = listOf( + kaptStubsDir(project, config.outputDir), + kaptSourcesDir(project, config.outputDir)) + val sourceFiles = KFiles.findSourceFiles(project.directory, sourceDirs, listOf("kt")).toList() + val buildDirectory = File(KFiles.joinDir(project.directory, + kaptClassesDir(project, config.outputDir))) + val flags = listOf() + val cai = CompilerActionInfo(project.directory, allDependencies(project), sourceFiles, listOf(".kt"), + buildDirectory, flags, emptyList(), forceRecompile = true, compilerSeparateProcess = true) + + val cr = compilerUtils.invokeCompiler(project, context, kotlinPlugin.compiler, cai) + success = cr.failedResult == null + } + + return TaskResult(success) + } + + val annotationDependencyId = "org.jetbrains.kotlin:kotlin-annotation-processing:" + + Constants.KOTLIN_COMPILER_VERSION + + fun annotationProcessorDependency() = dependencyManager.create(annotationDependencyId) + + fun aptJarDependencies(project: Project) = aptDependencies[project.name].map { dependencyManager.create(it) } + + fun allDependencies(project: Project): List { + val allDeps = arrayListOf() + allDeps.add(annotationProcessorDependency()) + allDeps.addAll(aptJarDependencies(project)) + + return allDeps + } + + fun taskRunKapt(project: Project) : TaskResult { + var success = true + val flags = arrayListOf() + val kaptConfig = kaptConfigs[project.name] + kaptConfig?.let { config -> + val generated = kaptGenerated(project, config.outputDir) + val generatedSources = kaptSourcesDir(project, config.outputDir).replace("//", "/") + File(generatedSources).mkdirs() + + // + // Tell the Kotlin compiler to use the annotation plug-in + // + flags.add("-Xplugin") + flags.add(annotationProcessorDependency().jarFile.get().absolutePath) + + // Also need tools.jar on the plug-in classpath + val toolsJar = jvm.toolsJar + if (toolsJar != null) { + flags.add("-Xplugin") + flags.add(toolsJar.absolutePath) + } else { + warn("Couldn't find tools.jar from the JDK") + } + + aptJarDependencies(project).forEach { + flags.add("-Xplugin") + flags.add(it.jarFile.get().absolutePath) + } + + // + // Pass options to the annotation plugin + // + flags.add("-P") + fun kaptPluginFlag(flagValue: String) = "plugin:org.jetbrains.kotlin.kapt3:$flagValue" + val kaptPluginFlags = arrayListOf() + val verbose = KobaltLogger.LOG_LEVEL >= 2 + listOf("sources=" + generatedSources, + "classes=" + kaptClassesDir(project, config.outputDir), + "stubs=" + kaptStubsDir(project, config.outputDir), + "verbose=$verbose", + "aptOnly=true").forEach { + kaptPluginFlags.add(kaptPluginFlag(it)) + } + + // + // Dependencies for the annotation plug-in and the generation + // + val allDeps = allDependencies(project) + val dependencies = dependencyManager.calculateDependencies(project, context, + Filters.EXCLUDE_OPTIONAL_FILTER, + listOf(Scope.COMPILE), + allDeps) + dependencies.forEach { + val jarFile = it.jarFile.get().absolutePath + kaptPluginFlags.add(kaptPluginFlag("apclasspath=$jarFile")) + } + + flags.add(kaptPluginFlags.joinToString(",")) + listOf("-language-version", "1.1", "-api-version", "1.1").forEach { + flags.add(it) + } + + val sourceFiles = + KFiles.findSourceFiles(project.directory, project.sourceDirectories, listOf("kt")) + .toList() + generatedSources + val buildDirectory = File(KFiles.joinDir(project.directory, generated)) + val cai = CompilerActionInfo(project.directory, allDeps, sourceFiles, listOf(".kt"), + buildDirectory, flags, emptyList(), forceRecompile = true, compilerSeparateProcess = true) + + context.logger.log(project.name, 2, "kapt3 flags:") + context.logger.log(project.name, 2, " " + kaptPluginFlags.joinToString("\n ")) + val cr = compilerUtils.invokeCompiler(project, context, kotlinPlugin.compiler, cai) + success = cr.failedResult == null + } + + return TaskResult(success) + } // ICompilerFlagContributor override fun compilerFlagsFor(project: Project, context: KobaltContext, currentFlags: List, suffixesBeingCompiled: List): List { - if (!suffixesBeingCompiled.contains("java")) return emptyList() - val result = arrayListOf() + // Only run for Java files + if (!suffixesBeingCompiled.contains("java")) return emptyList() + fun addFlags(outputDir: String) { aptDependencies[project.name]?.let { result.add("-s") - result.add(generated(project, context, outputDir)) + aptGeneratedDir(project, outputDir).let { generatedSource -> + generatedSource.mkdirs() + result.add(generatedSource.path) + } } } @@ -84,10 +255,6 @@ class AptPlugin @Inject constructor(val dependencyManager: DependencyManager) addFlags(config.outputDir) } - kaptConfigs[project.name]?.let { config -> - addFlags(config.outputDir) - } - context.logger.log(project.name, 2, "New flags from apt: " + result.joinToString(" ")) return result } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/java/JavaCompiler.kt b/src/main/kotlin/com/beust/kobalt/plugin/java/JavaCompiler.kt index 01b7c90d..a88c2957 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/java/JavaCompiler.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/java/JavaCompiler.kt @@ -1,7 +1,6 @@ package com.beust.kobalt.plugin.java -import com.beust.kobalt.JavaInfo -import com.beust.kobalt.SystemProperties +import com.beust.kobalt.Jvm import com.beust.kobalt.TaskResult import com.beust.kobalt.api.* import com.beust.kobalt.internal.CompilerUtils @@ -22,7 +21,7 @@ import javax.tools.ToolProvider @Singleton class JavaCompiler @Inject constructor(val jvmCompiler: JvmCompiler, val kobaltLog: ParallelLogger, - val compilerUtils: CompilerUtils) : ICompiler { + val compilerUtils: CompilerUtils, val jvm: Jvm) : ICompiler { fun compilerAction(executable: File) = object : ICompilerAction { override fun compile(project: Project?, info: CompilerActionInfo): TaskResult { val projectName = project?.name @@ -84,7 +83,7 @@ class JavaCompiler @Inject constructor(val jvmCompiler: JvmCompiler, val kobaltL val pb = ProcessBuilder(executable.absolutePath, "@" + KFiles.fixSlashes(atFile)) pb.inheritIO() logk(1, " Java compiling " + Strings.pluralizeAll(info.sourceFiles.size, "file")) - logk(2, " Java compiling file: " + KFiles.fixSlashes(atFile)) + logk(2, " Java compiling using file: " + KFiles.fixSlashes(atFile)) command = allArgs.joinToString(" ") + " " + info.sourceFiles.joinToString(" ") val process = pb.start() @@ -94,11 +93,11 @@ class JavaCompiler @Inject constructor(val jvmCompiler: JvmCompiler, val kobaltL } return if (result) { - TaskResult(true, "Compilation succeeded") + TaskResult(true, errorMessage = "Compilation succeeded") } else { val message = "Compilation errors, command:\n$command\n" + errorMessage logk(1, message) - TaskResult(false, message) + TaskResult(false, errorMessage = message) } } @@ -119,7 +118,7 @@ class JavaCompiler @Inject constructor(val jvmCompiler: JvmCompiler, val kobaltL -> it.compilerFlagsFor(project, context, currentFlags, suffixesBeingCompiled) } FlagContributor(it.flagPriority, closure) } - return run(project, context, info, JavaInfo.create(File(SystemProperties.javaBase)).javacExecutable!!, + return run(project, context, info, jvm.javacExecutable!!, compilerUtils.compilerFlags(project, context, info, adapters)) } @@ -130,7 +129,7 @@ class JavaCompiler @Inject constructor(val jvmCompiler: JvmCompiler, val kobaltL -> it.docFlagsFor(project, context, currentFlags, suffixesBeingCompiled) } FlagContributor(it.flagPriority, closure) } - return run(project, context, info, JavaInfo.create(File(SystemProperties.javaBase)).javadocExecutable!!, + return run(project, context, info, jvm.javadocExecutable!!, compilerUtils.compilerFlags(project, context, info, adapters)) } } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/java/JavaPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/java/JavaPlugin.kt index 9f6108d2..0b4d2e4b 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/java/JavaPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/java/JavaPlugin.kt @@ -44,9 +44,18 @@ class JavaPlugin @Inject constructor(val javaCompiler: JavaCompiler, override va // IDocFlagContributor override fun docFlagsFor(project: Project, context: KobaltContext, currentFlags: List, suffixesBeingCompiled: List): List { - return listOf("-d", "javadoc", "-Xdoclint:none", "-Xmaxerrs", "1", "-quiet") + val config = javadocConfigurations[project.name] + return if (config == null || config.args.isEmpty()) DEFAULT_JAVADOC_ARGS + else config.args } + val DEFAULT_JAVADOC_ARGS = listOf("-d", "javadoc", "-Xdoclint:none", "-Xmaxerrs", "1", "-quiet") + + val javadocConfigurations = hashMapOf() + + fun addJavadocConfiguration(project: Project, configuration: JavadocConfig) + = javadocConfigurations.put(project.name, configuration) + // ICompilerContributor val compiler = CompilerDescription(PLUGIN_NAME, "java", SOURCE_SUFFIXES, javaCompiler) @@ -77,4 +86,12 @@ fun Project.javaCompiler(init: JavaConfig.() -> Unit) = JavaConfig(this).also { config -> config.init() (Kobalt.findPlugin(JavaPlugin.PLUGIN_NAME) as JavaPlugin).addConfiguration(this, config) - } \ No newline at end of file + } + +@Directive +fun Project.javadoc(init: JavadocConfig.() -> Unit) = + JavadocConfig(this).also { config -> + config.init() + (Kobalt.findPlugin(JavaPlugin.PLUGIN_NAME) as JavaPlugin).addJavadocConfiguration(this, config) + } + diff --git a/src/main/kotlin/com/beust/kobalt/plugin/java/JavadocConfig.kt b/src/main/kotlin/com/beust/kobalt/plugin/java/JavadocConfig.kt new file mode 100644 index 00000000..7129dcaa --- /dev/null +++ b/src/main/kotlin/com/beust/kobalt/plugin/java/JavadocConfig.kt @@ -0,0 +1,603 @@ +package com.beust.kobalt.plugin.java + +import com.beust.kobalt.api.Project +import com.google.inject.Singleton +import java.io.BufferedReader +import java.io.File +import java.io.InputStream +import java.io.InputStreamReader +import java.util.concurrent.TimeUnit + +@Singleton +class JavadocConfig(val project: Project) { + val args = arrayListOf("-Xdoclint:none", "-Xmaxerrs", "1", "-quiet") + + private fun removeArg(match: String, startsWith: Boolean = false, pair: Boolean = false) { + val it = args.iterator() + while (it.hasNext()) { + val next = it.next() + var removed = false + if (startsWith) { + if (next.startsWith(match)) { + it.remove() + removed = true + } + } else if (next == match) { + it.remove() + removed = true + } + // If it's a pair, delete the next arg too. + if (pair && removed && it.hasNext()) { + it.next() + it.remove() + } + } + } + + private fun addInt(option: String, value: Int): Int { + args.add("-$option") + args.add(value.toString()) + return value + } + + private fun addBoolean(option: String, value: Boolean): Boolean { + args.remove("-$option") + if (value) { + args.add("-$option") + } + return value + } + + private fun addString(option: String, value: String): String { + if (value.isNotEmpty()) { + args.add("-$option") + args.add("\"$value\"") + } + return value + } + + private fun addStrings(option: String, vararg value: String) { + value.forEach { + addString(option, it) + } + } + + private fun addPair(option: String, first: String, second: String) { + if (first.isNotEmpty() && second.isNotEmpty()) { + args.add("-$option") + args.add("\"$first\"") + args.add("\"$second\"") + } + } + + private fun addFile(option: String, value: String): String { + val f = File(value) + if (f.exists()) { + args.add("-$option") + args.add("\"${f.absolutePath}\"") + } + return value + } + + /** + * Set arguments manually. + */ + fun args(vararg options: String) = args.addAll(options) + + // + // Jvm Options + // + + /** + * @see -Xdoclint + */ + var docLint: String = "none" + set(value) { + removeArg("-Xdoclint:", startsWith = true) + addString("Xdoclint:", value) + } + + /** + * @see -Xmaxerrs + */ + var maxErrs: Int = 1 + set(value) { + removeArg("-Xmaxerrs", startsWith = true, pair = true) + addInt("Xmaxerrs", value) + } + + /** + * @see -Xmaxwarns + */ + var maxWarns: Int = 1 + set(value) { + removeArg("-Xmaxwarns", startsWith = true, pair = true) + addInt("Xmaxwarns", value) + } + + // + // Javadoc Options + // + + /** + * @see -overview + */ + var overview: String = "" + set(value) { + addFile("overview", value) + } + + /** + * @see -public + */ + var public: Boolean = false + set(value) { + addBoolean("public", value) + } + + /** + * @see -protected + */ + var protected: Boolean = false + set(value) { + addBoolean("protected", value) + } + + /** + * @see -pakage + */ + var pkg: Boolean = false + set(value) { + addBoolean("package", pkg) + } + + /** + * @see -private + */ + var private: Boolean = false + set(value) { + addBoolean("private", private) + } + + /** + * @see -doclet + */ + var doclet: String = "" + set(value) { + addString("doclet", value) + } + + /** + * @see -docletpath + */ + var docletPath: String = "" + set(value) { + addString("docletpath", value) + } + + /** + * @see -source + */ + var source: String = "" + set(value) { + addString("source", source) + } + + /** + * @see -sourcepath + */ + var sourcePath: String = "" + set(value) { + addString("sourcepath", value) + } + + /** + * @see -classpath + */ + var classPath: String = "" + set(value) { + addString("classpath", value) + } + + /** + * @see -subpackages + */ + var subPackages: String = "" + set(value) { + addString("subpackages", value) + } + + /** + * @see -exclude + */ + var exclude: String = "" + set(value) { + addString("exclude", value) + } + + /** + * @see -bootClassPath + */ + var bootClassPath: String = "" + set(value) { + addString("bootclasspath", value) + } + + /** + * @see -extdirs + */ + var extDirs: String = "" + set(value) { + addString("extdirs", value) + } + + /** + * @see -verbose + */ + var verbose: Boolean = false + set(value) { + addBoolean("verbose", value) + } + + /** + * @see -quiet + */ + var quiet: Boolean = true + set(value) { + addBoolean("quiet", value) + } + + /** + * @see -breakiterator + */ + var breakIterator: Boolean = false + set(value) { + addBoolean("breakiterator", value) + } + + /** + * @see -locale + */ + var locale: String = "" + set(value) { + addString("locale", value) + } + + /** + * @see -encoding + */ + var encoding: String = "" + set(value) { + addString("encoding", value) + } + + /** + * @see -Jflag + */ + var jFlag: String = "" + set(value) { + addString("J-", value) + } + + // + // Standard Doclet + // + + /** + * @see -use + */ + var use: Boolean = false + set(value) { + addBoolean("use", value) + } + + /** + * @see -version + */ + var version: Boolean = false + set(value) { + addBoolean("version", value) + } + + /** + * @see -author + */ + var author: Boolean = false + set(value) { + addBoolean("author", value) + } + + /** + * @see -splitindex + */ + var splitIndex: Boolean = false + set(value) { + addBoolean("splitindex", value) + } + + /** + * Set both the [windowTitle] and [docTitle] + */ + var title: String = "" + set(value) { + windowTitle = value + docTitle = value + } + + /** + * @see -windowtitle + */ + var windowTitle: String = "" + set(value) { + addString("windowtitle", value) + } + + /** + * @see -doctitle + */ + var docTitle: String = "" + set(value) { + addString("doctitle", value) + } + + /** + * @see -header + */ + var header: String = "" + set(value) { + addString("header", value) + } + + /** + * @see -footer + */ + var footer: String = "" + set(value) { + addString("footer", value) + } + + /** + * @see -top + */ + var top: String = "" + set(value) { + addString("top", value) + } + + /** + * @see -bottom + */ + var bottom: String = "" + set(value) { + addString("bottom", value) + } + + /** + * @see -linksource + */ + var linkSource: Boolean = false + set(value) { + addBoolean("linksource", value) + } + + /** + * @see -nodeprecated + */ + var noDeprecated: Boolean = false + set(value) { + addBoolean("nodeprecated", value) + } + + /** + * @see -nodeprecatedlist + */ + var noDeprecatedList: Boolean = false + set(value) { + addBoolean("nodeprecatedlist", value) + } + + /** + * @see -nosince + */ + var noSince: Boolean = false + set(value) { + addBoolean("nosince", value) + } + + /** + * @see -notree + */ + var noTree: Boolean = false + set(value) { + addBoolean("notree", value) + } + + /** + * @see -noindex + */ + var noIndex: Boolean = false + set(value) { + addBoolean("noindex", value) + } + + /** + * @see -nohelp + */ + var noHelp: Boolean = false + set(value) { + addBoolean("nohelp", value) + } + + /** + * @see -nonavbar + */ + var noNavBar: Boolean = false + set(value) { + addBoolean("nonavbar", value) + } + + /** + * @see -helpfile + */ + var helpFile: String = "" + set(value) { + addFile("helpfile", value) + } + + /** + * @see -stylesheet + */ + var stylesheet: String = "" + set(value) { + addFile("stylesheet", value) + } + + /** + * @see -serialwarn + */ + var serialWarn: Boolean = false + set(value) { + addBoolean("serialwarn", value) + } + + /** + * @see -charset + */ + var charSet: String = "" + set(value) { + addString("charset", value) + } + + /** + * @see -docencoding + */ + var docEncoding: String = "" + set(value) { + addString("docencoding", value) + } + + /** + * @see -keywords + */ + var keywords: Boolean = false + set(value) { + addBoolean("keywords", value) + } + + /** + * @see -tagletpath + */ + var tagletPath: String = "" + set(value) { + addString("tagletpath", value) + } + + /** + * @see -docfilessubdirs + */ + var docFilesSubDirs: Boolean = false + set(value) { + addBoolean("docfilessubdirs", value) + } + + /** + * @see -excludedocfilessubdir + */ + var excludeDocFilesSubDir: String = "" + set(value) { + addString("excludedocfilessubdir", value) + } + + /** + * @see -noqualifiers + */ + var noQualifiers: String = "" + set(value) { + addString("noqualifier", value) + } + + /** + * @see -notimestamp + */ + var noTimestamp: Boolean = false + set(value) { + addBoolean("notimestamp", value) + } + + /** + * @see -nocomment + */ + var noComment: Boolean = false + set(value) { + addBoolean("nocomment", value) + } + + /** + * @see -sourcetab + */ + var sourceTab: String = "" + set(value) { + addString("sourcetab", value) + } + + /** + * @see -group + */ + fun group(groupHeading: String, packagePattern: String) = addPair("group", groupHeading, packagePattern) + + /** + * @see -linkoffline + */ + fun linkOffline(extdocURL: String, packagelistLoc: String) = addPair("linkoffline", extdocURL, packagelistLoc) + + /** + * @see -link + */ + fun links(vararg links: String) = addStrings("link", *links) + + /** + * @see -tag + */ + fun tags(vararg tags: String) = addStrings("tag", *tags) + + /** + * @see -taglets + */ + fun taglets(vararg taglets: String) = addStrings("taglet", *taglets) +} + +fun main(args: Array) { + fun fromStream(ins: InputStream): List { + val result = arrayListOf() + val br = BufferedReader(InputStreamReader(ins)) + var line = br.readLine() + + while (line != null) { + result.add(line) + println(line) + line = br.readLine() + } + + return result + } + + val config = JavadocConfig(Project()) + config.title = "This is a test." + config.verbose = true + config.quiet = false + config.links("http://docs.oracle.com/javase/8/docs/api/") + config.args.add(0, ".\\kobaltBuild\\docs\\javadoc") + config.args.add(0, "-d") + config.args.add(0, "javadoc") + config.args.add(".\\modules\\wrapper\\src\\main\\java\\com\\beust\\kobalt\\wrapper\\Config.java") + config.args.add(".\\modules\\wrapper\\src\\main\\java\\com\\beust\\kobalt\\wrapper\\Main.java") + + println(config.args.joinToString(" ")) + + val pb = ProcessBuilder().command(config.args.toList()) + pb.directory(File(".")) + val proc = pb.start() + val err = proc.waitFor(30, TimeUnit.SECONDS) + val stdout = if (proc.inputStream.available() > 0) fromStream(proc.inputStream) else emptyList() + val stderr = if (proc.errorStream.available() > 0) fromStream(proc.errorStream) else emptyList() +} \ No newline at end of file diff --git a/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinCompiler.kt b/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinCompiler.kt index 4d8a0f85..c1429910 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinCompiler.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinCompiler.kt @@ -8,10 +8,12 @@ import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.misc.* import org.jetbrains.kotlin.cli.common.ExitCode import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments +import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler +import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.ICReporter import org.jetbrains.kotlin.incremental.makeIncrementally @@ -35,23 +37,26 @@ class KotlinCompiler @Inject constructor( val settings: KobaltSettings, val jvmCompiler: JvmCompiler, val compilerUtils: CompilerUtils, - val kobaltLog: ParallelLogger) { + val kobaltLog: ParallelLogger, + val jvm: Jvm) { val compilerAction = object: ICompilerAction { override fun compile(project: Project?, info: CompilerActionInfo): TaskResult { val projectName = project?.name - val version = settings.kobaltCompilerVersion + val version = kotlinVersion(project) var filesToCompile = 0 if (! info.outputDir.path.endsWith("ript.jar")) { // Don't display the message if compiling Build.kt - filesToCompile = - info.sourceFiles.map(::File).map { - if (it.isDirectory) KFiles.findRecursively(it).size else 1 - }.reduce { a, b -> - a + b - } - kobaltLog.log(projectName ?: "", 1, - " Kotlin $version compiling " + Strings.pluralizeAll(filesToCompile, "file")) + if (info.sourceFiles.isNotEmpty()) { + filesToCompile = + info.sourceFiles.map(::File).map { + if (it.isDirectory) KFiles.findRecursively(it).size else 1 + }.reduce { a, b -> + a + b + } + kobaltLog.log(projectName ?: "", 1, + " Kotlin $version compiling " + Strings.pluralizeAll(filesToCompile, "file")) + } } val cp = compilerFirst(info.dependencies.map { it.jarFile.get() }) val infoDir = info.directory @@ -69,77 +74,88 @@ class KotlinCompiler @Inject constructor( File(outputDir).parentFile.mkdirs() } val classpath = cp.joinToString(File.pathSeparator) - val allArgs = arrayListOf( - "-d", outputDir, - "-classpath", classpath, - *(info.compilerArgs.toTypedArray()), - *(info.sourceFiles.toTypedArray()) - ) - - // Get rid of annoying and useless warning - if (! info.compilerArgs.contains("-no-stdlib")) { - allArgs.add("-no-stdlib") - } // If the Kotlin compiler version in settings.xml is different from the default, we // need to spawn a Kotlin compiler in a separate process. Otherwise, we can just invoke // the K2JVMCompiler class directly - val actualVersion = kotlinConfig(project)?.version ?: settings.kobaltCompilerVersion - if (settings.kobaltCompilerSeparateProcess || actualVersion != Constants.KOTLIN_COMPILER_VERSION) { - return invokeCompilerInSeparateProcess(classpath, info, project) + val actualVersion = kotlinVersion(project) + + return if (settings.kobaltCompilerSeparateProcess || actualVersion != Constants.KOTLIN_COMPILER_VERSION + || info.compilerSeparateProcess) { + invokeCompilerInSeparateProcess(classpath, info, actualVersion, project) } else { - return invokeCompilerDirectly(projectName ?: "kobalt-" + Random().nextInt(), outputDir, + invokeCompilerDirectly(project, projectName ?: "kobalt-" + Random().nextInt(), outputDir, info, classpath, filesToCompile) } } - fun kotlinConfig(project: Project?) - = (Kobalt.findPlugin(KotlinPlugin.PLUGIN_NAME) as KotlinPlugin).configurationFor(project) - private fun invokeCompilerInSeparateProcess(classpath: String, info: CompilerActionInfo, - project: Project?): TaskResult { - val java = JavaInfo.create(File(SystemProperties.javaBase)).javaExecutable + compilerVersion: String, project: Project?): TaskResult { + val java = jvm.javaExecutable - val compilerClasspath = compilerDep.jarFile.get().path + File.pathSeparator + - compilerEmbeddableDependencies(null).map { it.jarFile.get().path } + val compilerClasspath = compilerDep(compilerVersion).jarFile.get().path + File.pathSeparator + + compilerEmbeddableDependencies(null, compilerVersion).map { it.jarFile.get().path } .joinToString(File.pathSeparator) val xFlagsString = listOf(kotlinConfig(project)?.args?.joinToString(" "), settings.kobaltCompilerFlags) .filterNotNull() .joinToString(" ") - val xFlagsArray = xFlagsString.split(" ").toTypedArray() ?: emptyArray() + val infoDir = info.directory + + val outputDir = + if (infoDir != null) { + KFiles.joinDir(infoDir, info.outputDir.path) + } else { + info.outputDir.path + } + + val xFlagsArray = xFlagsString.split(" ").toTypedArray() val newArgs = listOf( "-classpath", compilerClasspath, K2JVMCompiler::class.java.name, + *info.compilerArgs.toTypedArray(), "-classpath", classpath, - "-d", info.outputDir.absolutePath, + "-d", outputDir, *xFlagsArray, *info.sourceFiles.toTypedArray()) .filter { ! it.isEmpty() } - log(2, " Invoking separate kotlinc:\n " + java!!.absolutePath + " " + newArgs.joinToString()) + log(2, " Invoking separate kotlinc:\n " + java!!.absolutePath + " " + newArgs.joinToString(" ")) val result = NewRunCommand(RunCommandInfo().apply { command = java.absolutePath args = newArgs directory = File(".") - // The Kotlin compiler issues warnings on stderr :-( - containsErrors = { errors: List -> errors.any { it.contains("rror")} } +// // The Kotlin compiler issues warnings on stderr :-( + useErrorStreamAsErrorIndicator = false +// containsErrors = { +// errors: List -> errors.any { it.contains("rror")} +// } }).invoke() - return TaskResult(result == 0, "Error while compiling") + return TaskResult(result == 0, errorMessage = "Error while compiling") } - private fun invokeCompilerDirectly(projectName: String, outputDir: String?, info: CompilerActionInfo, - classpathString: String, filesToCompile: Int): TaskResult { + private fun invokeCompilerDirectly(project: Project?, projectName: String, outputDir: String?, + info: CompilerActionInfo, classpathString: String, filesToCompile: Int): TaskResult { val sourceFiles = info.sourceFiles val friends = info.friendPaths.toTypedArray() - val args = K2JVMCompilerArguments().apply { + + // Collect the compiler args from kotlinCompiler{} and from settings.xml and parse them + val args2 = + info.compilerArgs + + (settings.kobaltCompilerFlags?.split(" ") ?: listOf()) + val args = K2JVMCompilerArguments() + val compiler = K2JVMCompiler() + parseCommandLineArguments(args2, args) + + // Override important arguments with our values + args.apply { moduleName = projectName destination = outputDir classpath = classpathString - freeArgs = sourceFiles + freeArgs = sourceFiles.toMutableList() friendPaths = friends } @@ -163,12 +179,12 @@ class KotlinCompiler @Inject constructor( "single-module" -> args.singleModule = true "load-builtins-from-dependencies" -> args.loadBuiltInsFromDependencies = true - "coroutines=enable" -> args.coroutinesEnable = true - "coroutines=warn" -> args.coroutinesWarn = true - "coroutines=error" -> args.coroutinesError = true + "coroutines=enable" -> args.coroutinesState = LanguageFeature.State.ENABLED.name + "coroutines=warn" -> args.coroutinesState = LanguageFeature.State.ENABLED_WITH_WARNING.name + "coroutines=error" -> args.coroutinesState = LanguageFeature.State.ENABLED_WITH_ERROR.name "no-inline" -> args.noInline = true "multi-platform" -> args.multiPlatform = true - "no-check-impl" -> args.noCheckImpl = true +// "no-check-impl" -> args.noCheckImpl = true else -> warn("Unknown Kotlin compiler flag found in config.xml: $it") } } @@ -178,13 +194,27 @@ class KotlinCompiler @Inject constructor( fun logk(level: Int, message: CharSequence) = kobaltLog.log(projectName, level, message) - logk(2, " Invoking K2JVMCompiler with arguments:" + fun pluginClasspaths(args: K2JVMCompilerArguments) : String { + var result = "" + args.pluginClasspaths?.forEach { + result += " -Xplugin " + it + } + args.pluginOptions?.let { + result += " -P " + result += it.joinToString(",") + } + return result + } + + logk(2, " Invoking K2JVMCompiler with arguments: kotlinc " + if (args.skipMetadataVersionCheck) " -Xskip-metadata-version-check" else "" - + " -moduleName " + args.moduleName + " -d " + args.destination - + " -friendPaths " + args.friendPaths.joinToString(";") + " -classpath " + args.classpath + + pluginClasspaths(args) + " " + sourceFiles.joinToString(" ")) + logk(2, " Additional kotlinc arguments: " + + " -moduleName " + args.moduleName + + " -friendPaths " + args.friendPaths?.joinToString(";")) val collector = object : MessageCollector { override fun clear() { throw UnsupportedOperationException("not implemented") @@ -195,7 +225,7 @@ class KotlinCompiler @Inject constructor( } fun dump(location: CompilerMessageLocation?, s: String) = - if (location != null && location.lineContent != null) { + if (location?.lineContent != null) { with(location) { "$lineContent\n$path:$line:$column $s" } @@ -203,12 +233,13 @@ class KotlinCompiler @Inject constructor( s } - override fun report(severity: CompilerMessageSeverity, - message: String, location: CompilerMessageLocation) { + override fun report(severity: CompilerMessageSeverity, message: String, + location: CompilerMessageLocation?) { if (severity.isError) { "Couldn't compile file: ${dump(location, message)}".let { fullMessage -> - System.err.println(fullMessage) - throw KobaltException(fullMessage) + error(fullMessage) + val ex = KobaltException(fullMessage) + throw ex } } else if (severity == CompilerMessageSeverity.WARNING && KobaltLogger.LOG_LEVEL >= 2) { warn(dump(location, message)) @@ -217,29 +248,27 @@ class KotlinCompiler @Inject constructor( } } } +// +// System.setProperty("kotlin.incremental.compilation", "true") +// // TODO: experimental should be removed as soon as it becomes standard +// System.setProperty("kotlin.incremental.compilation.experimental", "true") - System.setProperty("kotlin.incremental.compilation", "true") - // TODO: experimental should be removed as soon as it becomes standard - System.setProperty("kotlin.incremental.compilation.experimental", "true") - - val result = - if (cliArgs.noIncrementalKotlin || Kobalt.context?.internalContext?.noIncrementalKotlin ?: false) { - log(2, " Kotlin incremental compilation is disabled") - val duration = benchmarkMillis { - K2JVMCompiler().exec(collector, Services.Builder().build(), args) - } - log(1, " Regular compilation time: ${duration.first} ms") - TaskResult(duration.second == ExitCode.OK) - } else { - log(1, " Kotlin incremental compilation is enabled") - val start = System.currentTimeMillis() - val duration = benchmarkMillis { - compileIncrementally(filesToCompile, sourceFiles, outputDir, info, args, collector) - } - log(1, " Incremental compilation time: ${duration.first} ms") - TaskResult() + return if (cliArgs.noIncrementalKotlin || Kobalt.context?.internalContext?.noIncrementalKotlin ?: false) { + log(2, " Kotlin incremental compilation is disabled") + val duration = benchmarkMillis { + compiler.exec(collector, Services.Builder().build(), args) } - return result + log(1, " Regular compilation time: ${duration.first} ms") + TaskResult(duration.second == ExitCode.OK) + } else { + log(1, " Kotlin incremental compilation is enabled") + //val start = System.currentTimeMillis() + val duration = benchmarkMillis { + compileIncrementally(filesToCompile, sourceFiles, outputDir, info, args, collector) + } + log(1, " Incremental compilation time: ${duration.first} ms") + TaskResult() + } } private fun compileIncrementally(filesToCompile: Int, sourceFiles: List, outputDir: String?, @@ -343,12 +372,17 @@ class KotlinCompiler @Inject constructor( } } - val compilerVersion = settings.kobaltCompilerVersion - val compilerDep = dependencyManager.create("org.jetbrains.kotlin:kotlin-compiler-embeddable:$compilerVersion") + private fun kotlinConfig(project: Project?) + = (Kobalt.findPlugin(KotlinPlugin.PLUGIN_NAME) as KotlinPlugin).configurationFor(project) - fun compilerEmbeddableDependencies(project: Project?): List { - val deps = dependencyManager.transitiveClosure(listOf(compilerDep), requiredBy = project?.name ?: "") - return deps + private fun kotlinVersion(project: Project?) + = kotlinConfig(project)?.version ?: settings.kobaltCompilerVersion ?: Constants.KOTLIN_COMPILER_VERSION + + private fun compilerDep(version: String) + = dependencyManager.create("org.jetbrains" + ".kotlin:kotlin-compiler-embeddable:$version") + + fun compilerEmbeddableDependencies(project: Project?, version: String): List { + return dependencyManager.transitiveClosure(listOf(compilerDep(version)), requiredBy = project?.name ?: "") } /** @@ -357,12 +391,13 @@ class KotlinCompiler @Inject constructor( * JvmCompilerPlugin#createCompilerActionInfo instead */ fun compile(project: Project?, context: KobaltContext?, compileDependencies: List, - otherClasspath: List, sourceFiles: List, outputDir: File, args: List) : TaskResult { + otherClasspath: List, sourceFiles: List, outputDir: File, args: List, + compilerSeparateProcess: Boolean) : TaskResult { val executor = executors.newExecutor("KotlinCompiler", 10) // Force a download of the compiler dependencies - compilerEmbeddableDependencies(project).forEach { it.jarFile.get() } + compilerEmbeddableDependencies(project, kotlinVersion(project)).forEach { it.jarFile.get() } executor.shutdown() @@ -380,13 +415,15 @@ class KotlinCompiler @Inject constructor( if (project != null) { listOf(KFiles.joinDir(project.directory, project.buildDirectory, KFiles.CLASSES_DIR)) } else { - emptyList() + emptyList() } val info = CompilerActionInfo(project?.directory, dependencies, sourceFiles, listOf("kt"), outputDir, args, - friendPaths, context?.internalContext?.forceRecompile ?: false) + friendPaths, context?.internalContext?.forceRecompile ?: false, compilerSeparateProcess) - return jvmCompiler.doCompile(project, context, compilerAction, info, - if (context != null) compilerUtils.sourceCompilerFlags(project, context, info) else emptyList()) + val compilerFlags = + if (context != null) compilerUtils.sourceCompilerFlags(project, context, info) + else emptyList() + return jvmCompiler.doCompile(project, context, compilerAction, info, compilerFlags) } } @@ -397,6 +434,7 @@ class KConfiguration @Inject constructor(val compiler: KotlinCompiler){ var output: File by Delegates.notNull() val args = arrayListOf() var noIncrementalKotlin = false + var compilerSeparateProcess = false fun sourceFiles(s: String) = source.add(s) @@ -411,7 +449,8 @@ class KConfiguration @Inject constructor(val compiler: KotlinCompiler){ fun compile(project: Project? = null, context: KobaltContext? = null) : TaskResult { val saved = context?.internalContext?.noIncrementalKotlin ?: false if (context != null) context.internalContext.noIncrementalKotlin = noIncrementalKotlin - val result = compiler.compile(project, context, dependencies, classpath, source, output, args) + val result = compiler.compile(project, context, dependencies, classpath, source, output, args, + compilerSeparateProcess) if (context != null) context.internalContext.noIncrementalKotlin = saved return result } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinPlugin.kt index 220be8a7..886f3537 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/kotlin/KotlinPlugin.kt @@ -83,6 +83,7 @@ class KotlinPlugin @Inject constructor(val executors: KobaltExecutors, val depen sourceFiles(info.sourceFiles) compilerArgs(info.compilerArgs) output = info.outputDir + compilerSeparateProcess = info.compilerSeparateProcess }.compile(project, context) } @@ -98,9 +99,10 @@ class KotlinPlugin @Inject constructor(val executors: KobaltExecutors, val depen // IClasspathContributor override fun classpathEntriesFor(project: Project?, context: KobaltContext): List = - if (project == null || accept(project)) { + if (project == null || + context.pluginInfo.plugins.any { it is KotlinPlugin && it.settings.kobaltCompilerVersion == null }) { // All Kotlin projects automatically get the Kotlin runtime added to their class path - listOf(kotlinJarFiles.stdlib, kotlinJarFiles.runtime) + listOf(kotlinJarFiles.stdlib) .map { FileDependency(it.absolutePath) } } else { emptyList() diff --git a/src/main/kotlin/com/beust/kobalt/plugin/osgi/OsgiPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/osgi/OsgiPlugin.kt new file mode 100644 index 00000000..83ae5228 --- /dev/null +++ b/src/main/kotlin/com/beust/kobalt/plugin/osgi/OsgiPlugin.kt @@ -0,0 +1,118 @@ +package com.beust.kobalt.plugin.osgi + +import aQute.bnd.osgi.Analyzer +import com.beust.kobalt.TaskResult +import com.beust.kobalt.api.* +import com.beust.kobalt.api.annotation.Directive +import com.beust.kobalt.archive.Archives +import com.beust.kobalt.archive.MetaArchive +import com.beust.kobalt.maven.DependencyManager +import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.plugin.packaging.PackagingPlugin +import com.google.common.reflect.ClassPath +import com.google.inject.Inject +import com.google.inject.Singleton +import java.io.ByteArrayOutputStream +import java.io.File +import java.net.URLClassLoader +import java.nio.file.* +import java.time.LocalDate +import java.time.format.DateTimeFormatter +import java.util.jar.JarFile + +/** + * Generate OSGi attributes in the MANIFEST.MF if an osgi{} directive was found in the project. + */ +@Singleton +class OsgiPlugin @Inject constructor(val configActor: ConfigActor, val taskContributor: TaskContributor, + val dependencyManager: DependencyManager) + : BasePlugin(), ITaskContributor by taskContributor, IConfigActor by configActor { + companion object { + const val PLUGIN_NAME = "Osgi" + } + override val name: String = PLUGIN_NAME + + override fun apply(project: Project, context: KobaltContext) { + super.apply(project, context) + + configurationFor(project)?.let { config -> + taskContributor.addTask(this, project, "generateOsgiManifest", + description = "Generate the OSGi information in the manifest", + group = "build", + alwaysRunAfter = listOf(PackagingPlugin.TASK_ASSEMBLE), + runTask = { generateManifest(project, context) }) + } + } + + private fun generateManifest(project: Project, context: KobaltContext): TaskResult { + val jarName = project.projectProperties.get(Archives.JAR_NAME) as String + val jarFile = File(KFiles.libsDir(project), jarName) + val cp = ClassPath.from(URLClassLoader(arrayOf(jarFile.toURI().toURL()), null)) + + val packages = cp.allClasses.map { it.packageName }.distinct() + val exportPackageLine = packages.map { + it + ";version=\"" + project.version + "\"" + }.joinToString(",") + + val toFile = Files.createTempFile(null, ".jar") + val analyzer = Analyzer().apply { + jar = aQute.bnd.osgi.Jar(jarName) + val dependencies = project.compileDependencies + project.compileRuntimeDependencies + dependencyManager.calculateDependencies(project, context, passedDependencies = dependencies).forEach { + addClasspath(it.jarFile.get()) + } + setProperty("Build-Date", LocalDate.now().format(DateTimeFormatter.ofPattern("y-MM-dd"))) + setProperty(Analyzer.BUNDLE_VERSION, project.version) + setProperty(Analyzer.BUNDLE_NAME, project.group + "." + project.artifactId) + setProperty(Analyzer.BUNDLE_DESCRIPTION, project.description) + setProperty(Analyzer.IMPORT_PACKAGE, "*") + setProperty(Analyzer.EXPORT_PACKAGE, exportPackageLine) + project.pom?.let { pom -> + if (pom.licenses.any()) { + setProperty(Analyzer.BUNDLE_LICENSE, pom.licenses[0].url) + } + } + } + + analyzer.calcManifest().let { manifest -> + val lines2 = ByteArrayOutputStream().use { baos -> + manifest.write(baos) + String(baos.toByteArray()) + } + + context.logger.log(project.name, 2, " Generated manifest:\n$lines2") + + // + // Update or create META-INF/MANIFEST.MF + // + KFiles.copy(Paths.get(jarFile.toURI()), Paths.get(toFile.toUri())) + + val fileSystem = FileSystems.newFileSystem(toFile, null) + fileSystem.use { fs -> + JarFile(jarFile).use { jf -> + val mf = jf.getEntry(MetaArchive.MANIFEST_MF) + if (mf == null) { + Files.createDirectories(fs.getPath("META-INF/")) + } + val jarManifest = fs.getPath(MetaArchive.MANIFEST_MF) + Files.write(jarManifest, listOf(lines2), + if (mf != null) StandardOpenOption.APPEND else StandardOpenOption.CREATE) + } + } + Files.copy(Paths.get(toFile.toUri()), Paths.get(jarFile.toURI()), StandardCopyOption.REPLACE_EXISTING) + return TaskResult() + } + } +} + +class OsgiConfig + +@Directive +fun Project.osgi(init: OsgiConfig.() -> Unit) { + OsgiConfig().let { + it.init() + (Kobalt.findPlugin(OsgiPlugin.PLUGIN_NAME) as OsgiPlugin).addConfiguration(this, it) + } +} + + diff --git a/src/main/kotlin/com/beust/kobalt/plugin/packaging/PackagingPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/packaging/PackagingPlugin.kt index 74266e62..b7871c90 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/packaging/PackagingPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/packaging/PackagingPlugin.kt @@ -12,11 +12,11 @@ import com.beust.kobalt.internal.ParallelLogger import com.beust.kobalt.maven.DependencyManager import com.beust.kobalt.maven.Md5 import com.beust.kobalt.maven.PomGenerator -import com.beust.kobalt.misc.IncludedFile import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.KobaltExecutors import com.beust.kobalt.misc.benchmarkMillis import java.io.File +import java.nio.file.Paths import javax.inject.Inject import javax.inject.Singleton @@ -26,9 +26,9 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana val executors: KobaltExecutors, val jarGenerator: JarGenerator, val warGenerator: WarGenerator, val zipGenerator: ZipGenerator, val taskContributor: TaskContributor, val kobaltLog: ParallelLogger, - val pomFactory: PomGenerator.IFactory, val configActor: ConfigActor) - : BasePlugin(), ITaskContributor, IIncrementalAssemblyContributor, - IConfigActor by configActor { + val pomFactory: PomGenerator.IFactory, val configActor: ConfigsActor) + : BasePlugin(), ITaskContributor by taskContributor, IIncrementalAssemblyContributor, + IConfigsActor by configActor { companion object { const val PLUGIN_NAME = "Packaging" @@ -41,7 +41,6 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana const val PACKAGES = "packages" const val TASK_ASSEMBLE: String = "assemble" - const val TASK_INSTALL: String = "install" } override val name = PLUGIN_NAME @@ -56,9 +55,20 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana taskContributor.addVariantTasks(this, project, context, "assemble", group = "build", dependsOn = listOf("compile"), runTask = { doTaskAssemble(project) }) - taskContributor.addVariantTasks(this, project, context, "install", - dependsOn = listOf("assemble"), - runTask = { taskInstall(project) }) + + configurationFor(project)?.let { configs -> + configs.forEach { config -> + taskContributor.addTask(this, project, config.taskName, + description = "Install to \"" + config.target + "\"", + group = "build", + dependsOn = listOf(PackagingPlugin.TASK_ASSEMBLE), + runTask = { taskInstall(project, context, config) }) + taskContributor.addVariantTasks(this, project, context, config.taskName, + dependsOn = listOf("assemble"), + runTask = { taskInstall(project, context, config) }) + } + } + } override fun assemble(project: Project, context: KobaltContext) : IncrementalTaskInfo { @@ -95,7 +105,7 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana val outputFile = jarGenerator.fullArchiveName(project, context, it.name) outputFiles.add(outputFile) allIncludedFiles.addAll(files) - zipToFiles[it.name] = files + zipToFiles[outputFile.name] = files } } } @@ -107,14 +117,7 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana context.variant.archiveName(project, null, ".jar")) // Turn the IncludedFiles into actual Files - val inputFiles = allIncludedFiles.fold(arrayListOf()) { files, includedFile: IncludedFile -> - val foundFiles = includedFile.allFromFiles(project.directory) - val absFiles = foundFiles.map { - File(KFiles.joinDir(project.directory, includedFile.from, it.path)) - } - files.addAll(absFiles) - files - } + val inputFiles = KFiles.materializeIncludedFiles(project, allIncludedFiles) val inMd5 = Md5.toMd5Directories(inputFiles) val outMd5 = Md5.toMd5Directories(outputFiles) @@ -145,9 +148,7 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana Pair(packageConfig.zips, zipGenerator) ) - pairs.forEach { pair -> - val zips = pair.first - val generator = pair.second + pairs.forEach { (zips, generator) -> zips.forEach { generator.generateArchive(packageConfig.project, context, it, findFiles(generator, it)) @@ -193,45 +194,37 @@ class PackagingPlugin @Inject constructor(val dependencyManager : DependencyMana packages.add(p) } -// @Task(name = "generateOsgiManifest", alwaysRunAfter = arrayOf(TASK_ASSEMBLE)) -// fun generateManifest(project: Project): TaskResult { -// val analyzer = Analyzer().apply { -// jar = aQute.bnd.osgi.Jar(project.projectProperties.get(Archives.JAR_NAME) as String) -// val dependencies = project.compileDependencies + project.compileRuntimeDependencies -// dependencyManager.calculateDependencies(project, context, passedDependencies = dependencies).forEach { -// addClasspath(it.jarFile.get()) -// } -// setProperty(Analyzer.BUNDLE_VERSION, project.version) -// setProperty(Analyzer.BUNDLE_NAME, project.group) -// setProperty(Analyzer.BUNDLE_DESCRIPTION, project.description) -// setProperty(Analyzer.IMPORT_PACKAGE, "*") -// setProperty(Analyzer.EXPORT_PACKAGE, "*;-noimport:=false;version=" + project.version) -// } -// -// val manifest = analyzer.calcManifest() -// manifest.write(System.out) -// return TaskResult() -// } - - - @Task(name = PackagingPlugin.TASK_INSTALL, description = "Install the artifacts", - dependsOn = arrayOf(PackagingPlugin.TASK_ASSEMBLE)) - fun taskInstall(project: Project) : TaskResult { - val config = configurationFor(project) ?: InstallConfig() + private fun taskInstall(project: Project, context: KobaltContext, config: InstallConfig) : TaskResult { val buildDir = project.projectProperties.getString(LIBS_DIR) val buildDirFile = File(buildDir) if (buildDirFile.exists()) { - context.logger.log(project.name, 1, "Installing from $buildDir to ${config.libDir}") - val toDir = KFiles.makeDir(config.libDir) - KFiles.copyRecursively(buildDirFile, toDir, deleteFirst = true) + if (config.includedFiles.isEmpty()) { + context.logger.log(project.name, 1, " Installing from $buildDir to ${config.target}") + val toDir = KFiles.makeDir(config.target) + File(buildDir).copyRecursively(toDir, overwrite = true) + } else { + // Delete all target directories + config.includedFiles.map { File(it.to) }.distinct().forEach { targetFile -> + val isFile = targetFile.isFile + context.logger.log(project.name, 2, " Deleting target dir $targetFile") + targetFile.deleteRecursively() + if (! isFile) targetFile.mkdirs() + } + // Perform the installations + config.includedFiles.forEach { inf -> + val targetFile = File(inf.to) + val files = KFiles.materializeIncludedFiles(project, listOf(inf)) + files.forEach { + context.logger.log(project.name, 1, " Installing $it to $targetFile") + KFiles.copyRecursively(it, targetFile, true) + } + } + } } return TaskResult() } - - //ITaskContributor - override fun tasksFor(project: Project, context: KobaltContext): List = taskContributor.dynamicTasks } @Directive @@ -242,7 +235,7 @@ fun Project.install(init: InstallConfig.() -> Unit) { } } -class InstallConfig(var libDir : String = "libs") +class InstallConfig(var target : String = "libs", var taskName : String = "install") : IncludeFromTo() @Directive fun Project.assemble(init: PackageConfig.(p: Project) -> Unit): PackageConfig = let { @@ -292,14 +285,14 @@ class PackageConfig(val project: Project) : AttributeHolder { name = "${project.name}-${project.version}-sources.jar" project.sourceDirectories.forEach { if (File(project.directory, it).exists()) { - include(from(it), to(""), glob("**")) + include(From(it), To(""), glob("**")) } } } jar { name = "${project.name}-${project.version}-javadoc.jar" val fromDir = KFiles.joinDir(project.buildDirectory, JvmCompilerPlugin.DOCS_DIRECTORY) - include(from(fromDir), to(""), glob("**")) + include(From(fromDir), To(""), glob("**")) } mainJarAttributes.forEach { @@ -331,3 +324,19 @@ class Pom { } +fun main(args: Array) { + val realSource = File("/tmp/a") + val sourceDir = File(realSource, "b").apply { mkdirs() } + val from = File(sourceDir, "foo").apply { writeText("I'm a file") } + val to = File("/tmp/to").apply { + deleteRecursively() + mkdirs() + } + val sourcePath = Paths.get(realSource.toURI()) + val targetPath = Paths.get(to.toURI()) +// Files.walkFileTree(sourcePath, KFiles.Companion.CopyFileVisitor(targetPath)) + + if (! to.isDirectory) { + throw AssertionError("Should be a directory") + } +} diff --git a/src/main/kotlin/com/beust/kobalt/plugin/packaging/WarGenerator.kt b/src/main/kotlin/com/beust/kobalt/plugin/packaging/WarGenerator.kt index 295224c7..f5e21b8d 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/packaging/WarGenerator.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/packaging/WarGenerator.kt @@ -1,8 +1,6 @@ package com.beust.kobalt.plugin.packaging -import com.beust.kobalt.ArchiveGenerator -import com.beust.kobalt.IFileSpec -import com.beust.kobalt.JarGenerator +import com.beust.kobalt.* import com.beust.kobalt.api.IClasspathDependency import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project @@ -10,15 +8,10 @@ import com.beust.kobalt.archive.Archives import com.beust.kobalt.archive.Zip import com.beust.kobalt.internal.ParallelLogger import com.beust.kobalt.maven.DependencyManager -import com.beust.kobalt.misc.From -import com.beust.kobalt.misc.IncludedFile import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.To import com.google.inject.Inject import java.io.File -import java.io.OutputStream import java.nio.file.Paths -import java.util.jar.JarOutputStream class WarGenerator @Inject constructor(val dependencyManager: DependencyManager, val kobaltLog: ParallelLogger) : ArchiveGenerator { @@ -91,9 +84,8 @@ class WarGenerator @Inject constructor(val dependencyManager: DependencyManager, manifest.mainAttributes.putValue(attribute.first, attribute.second) } - val jarFactory = { os: OutputStream -> JarOutputStream(os, manifest) } return Archives.generateArchive(project, context, war.name, ".war", files, - false /* don't expand jar files */, jarFactory) + false /* don't expand jar files */, manifest) } } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/packaging/ZipGenerator.kt b/src/main/kotlin/com/beust/kobalt/plugin/packaging/ZipGenerator.kt index e15c61ae..f70ad9a4 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/packaging/ZipGenerator.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/packaging/ZipGenerator.kt @@ -1,6 +1,7 @@ package com.beust.kobalt.plugin.packaging import com.beust.kobalt.ArchiveGenerator +import com.beust.kobalt.IncludedFile import com.beust.kobalt.JarGenerator import com.beust.kobalt.api.KobaltContext import com.beust.kobalt.api.Project @@ -8,7 +9,6 @@ import com.beust.kobalt.archive.Archives import com.beust.kobalt.archive.Zip import com.beust.kobalt.internal.ParallelLogger import com.beust.kobalt.maven.DependencyManager -import com.beust.kobalt.misc.IncludedFile import com.google.inject.Inject class ZipGenerator @Inject constructor(val dependencyManager: DependencyManager, val kobaltLog: ParallelLogger) diff --git a/src/main/kotlin/com/beust/kobalt/plugin/publish/BintrayApi.kt b/src/main/kotlin/com/beust/kobalt/plugin/publish/BintrayApi.kt index 7793a77d..1a80ff0e 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/publish/BintrayApi.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/publish/BintrayApi.kt @@ -15,6 +15,7 @@ import com.google.gson.Gson import com.google.gson.JsonArray import com.google.gson.JsonObject import com.google.gson.TypeAdapter +import com.google.gson.annotations.SerializedName import com.google.gson.reflect.TypeToken import com.google.inject.assistedinject.Assisted import okhttp3.* @@ -62,7 +63,7 @@ class BintrayApi @Inject constructor(val http: Http, @Path("publish") publish: Int, @Body file: File): Call - class UpdateVersion(val desc: String?, val vcsTag: String?) + class UpdateVersion(val desc: String?, @SerializedName("vcs_tag") val vcsTag: String?) @PATCH("/packages/{owner}/maven/{repo}/versions/{version}") fun updateVersion(@Path("owner") owner: String, @@ -79,12 +80,12 @@ class BintrayApi @Inject constructor(val http: Http, // level = HttpLoggingInterceptor.Level.BASIC // }) builder.interceptors().add(Interceptor { chain -> - val original = chain.request(); + val original = chain.request() chain.proceed(original.newBuilder() .header("Authorization", Credentials.basic(username, password)) .method(original.method(), original.body()) - .build()); + .build()) }) val okHttpClient = builder.build() @@ -96,25 +97,29 @@ class BintrayApi @Inject constructor(val http: Http, .create(Api::class.java) } - fun validatePackage(project: Project) { - val execute = service.getPackage(org ?: username!!, project.name).execute() + fun validatePackage(project: Project, config: BintrayConfig) { + val pkgName = config.name ?: project.name + val execute = service.getPackage(org ?: username!!, pkgName).execute() - if (execute.errorBody()?.string()?.contains("'${project.name}' was not found") ?: false) { + if (execute.errorBody()?.string()?.contains("'$pkgName' was not found") == true) { warn("Package does not exist on bintray. Creating now.") - val result = service.createPackage(org ?: username!!, buildPackageInfo(project)) + val result = service.createPackage(org ?: username!!, buildPackageInfo(project, config)) .execute() if (result.errorBody() != null) { - throw KobaltException("Error while creating package:\n" + result.errorBody().string()) + throw KobaltException("Error while creating package:\n" + result.errorBody()!!.string()) } } } - private fun buildPackageInfo(project: Project): JsonObject { - val jsonObject = JsonObject() - jsonObject.addNonNull("name", project.name) - jsonObject.addNonNull("desc", project.description) - jsonObject.addNonNull("vcs_url", project.pom?.scm?.url) - jsonObject.addNonNull("website_url", project.url) + private fun buildPackageInfo(project: Project, config: BintrayConfig): JsonObject { + val jsonObject = JsonObject().apply { + addNonNull("name", config.name ?: project.name) + addNonNull("desc", + if (project.description.isNotBlank()) project.description else project.pom?.description) + addNonNull("vcs_url", project.pom?.scm?.url) + addNonNull("website_url", project.url ?: project.pom?.url) + addNonNull("issue_tracker_url", config.issueTrackerUrl) + } val licenses = JsonArray() project.pom?.licenses?.forEach { licenses.add(it.name) @@ -124,7 +129,7 @@ class BintrayApi @Inject constructor(val http: Http, } fun uploadMaven(project: Project, files: List, config: BintrayConfig): TaskResult { - validatePackage(project) + validatePackage(project, config) return upload(project, files, config, generateMd5 = true) } @@ -158,13 +163,13 @@ class BintrayApi @Inject constructor(val http: Http, fun dots(total: Int, list: List, file: File? = null): String { val spaces: String = Array(total - list.size, { " " }).joinToString("") - return "|" + list.map { if (it) "." else "X" }.joinToString("") + spaces + + return "|" + list.joinToString("") { if (it) "." else "X" } + spaces + (if (file != null) "| [ $file ]" else "|") } val results = arrayListOf() val owner = org ?: username!! - val repo = project.name + val repo = config.name ?: project.name val group = project.group!!.replace('.', '/') val artifact = project.artifactId!! val version = project.version!! @@ -203,8 +208,8 @@ class BintrayApi @Inject constructor(val http: Http, return TaskResult() } else { - error(" Errors while uploading:\n" + errorMessages.map { " $it" }.joinToString("\n")) - return TaskResult(false, errorMessages.joinToString("\n")) + error(" Errors while uploading:\n" + errorMessages.joinToString("\n") { " $it" }) + return TaskResult(false, errorMessage = errorMessages.joinToString("\n")) } } else { warn("Found no artifacts to upload") @@ -216,7 +221,7 @@ class BintrayApi @Inject constructor(val http: Http, fun JsonObject.addNonNull(name: String, value: String?) { if (value != null) { - addProperty(name, value); + addProperty(name, value) } } @@ -231,20 +236,16 @@ class ConverterFactory : Converter.Factory() { override fun requestBodyConverter(type: Type, parameterAnnotations: Array, methodAnnotations: Array, retrofit: Retrofit?): Converter<*, RequestBody>? { - val result = - if (type.typeName == File::class.java.name) FileBodyConverter() - else GsonBodyConverter() - return result + return if (type.typeName == File::class.java.name) FileBodyConverter() + else GsonBodyConverter() } } class GsonResponseBodyConverter(private val gson: Gson, private val adapter: TypeAdapter) : Converter { override fun convert(value: ResponseBody): Any { val jsonReader = gson.newJsonReader(value.charStream()) - try { + value.use { return adapter.read(jsonReader) - } finally { - value.close() } } } diff --git a/src/main/kotlin/com/beust/kobalt/plugin/publish/PublishPlugin.kt b/src/main/kotlin/com/beust/kobalt/plugin/publish/PublishPlugin.kt index 23519c43..c5878368 100644 --- a/src/main/kotlin/com/beust/kobalt/plugin/publish/PublishPlugin.kt +++ b/src/main/kotlin/com/beust/kobalt/plugin/publish/PublishPlugin.kt @@ -47,7 +47,7 @@ class PublishPlugin @Inject constructor(val files: KFiles, val factory: PomGener private fun autoGitTag(project: Project, uploadResult: TaskResult, config: AutoGitTagConfig?) : TaskResult { if (config != null) { with(config) { - return git.maybeTagRelease(project, uploadResult, enabled, annotated, tag, message) + return git.maybeTagRelease(project, uploadResult, enabled, annotated, push, tag, message) } } else { return TaskResult() @@ -117,7 +117,7 @@ class PublishPlugin @Inject constructor(val files: KFiles, val factory: PomGener val docUrl = DocUrl.PUBLISH_PLUGIN_URL val user = localProperties.get(PROPERTY_BINTRAY_USER, docUrl) val password = localProperties.get(PROPERTY_BINTRAY_PASSWORD, docUrl) - val org = localProperties.getNoThrows(PROPERTY_BINTRAY_ORG, docUrl) + val org = localProperties.getNoThrows(PROPERTY_BINTRAY_ORG) val jcenter = bintrayFactory.create(user, password, org) var success = false @@ -153,7 +153,7 @@ class PublishPlugin @Inject constructor(val files: KFiles, val factory: PomGener TaskResult() } - val result = TaskResult(tmpResult.success, messages.joinToString("\n ")) + val result = TaskResult(tmpResult.success, errorMessage = messages.joinToString("\n ")) return result } @@ -222,6 +222,9 @@ data class AutoGitTagConfig(val project: Project) { @Directive var annotated: Boolean = false + @Directive + var push: Boolean = true + @Directive var tag : String = project.version!! @@ -268,9 +271,18 @@ data class BintrayConfig(val project: Project) { files.add(Pair(filePath, url)) } + /** + * The package name on Bintray which is not always the project name. + */ + @Directive + var name: String? = null + @Directive var description: String? = null + @Directive + var issueTrackerUrl: String? = null + @Directive var vcsTag: String? = null } diff --git a/src/main/resources/META-INF/kobalt-core-plugin.xml b/src/main/resources/META-INF/kobalt-core-plugin.xml index 4a2b359b..57354ff2 100644 --- a/src/main/resources/META-INF/kobalt-core-plugin.xml +++ b/src/main/resources/META-INF/kobalt-core-plugin.xml @@ -15,6 +15,7 @@ com.beust.kobalt.plugin.groovy.GroovyPlugin com.beust.kobalt.internal.JvmCompilerPlugin com.beust.kobalt.internal.BuildListeners + com.beust.kobalt.plugin.osgi.OsgiPlugin com.beust.kobalt.app.Templates @@ -24,6 +25,7 @@ com.beust.kobalt.internal.TestNgRunner com.beust.kobalt.internal.SpekRunner com.beust.kobalt.internal.KotlinTestRunner + com.beust.kobalt.internal.JUnit5Runner com.beust.kobalt.app.KobaltPluginTemplate diff --git a/src/main/resources/kobalt.properties b/src/main/resources/kobalt.properties index 81cb9702..0d568d3c 100644 --- a/src/main/resources/kobalt.properties +++ b/src/main/resources/kobalt.properties @@ -1 +1 @@ -kobalt.version=1.0.46 +kobalt.version=1.0.122 diff --git a/src/main/resources/templates/build.mustache b/src/main/resources/templates/build.mustache index 07a7dc96..808dc24a 100644 --- a/src/main/resources/templates/build.mustache +++ b/src/main/resources/templates/build.mustache @@ -2,36 +2,37 @@ import com.beust.kobalt.* import com.beust.kobalt.plugin.packaging.* import com.beust.kobalt.plugin.application.* {{imports}} - +{{#repositories.length}} val bs = buildScript { repos({{{repositories}}}) } - +{{/repositories.length}} {{#properties}} val {{first}} = "{{second}}" {{/properties}} val p = {{directive}} { - name = "{{name}}" group = "{{group}}" artifactId = name version = "{{version}}" - +{{#sourceDirectories.length}} sourceDirectories { {{#sourceDirectories}} path("{{toString}}") {{/sourceDirectories}} } - +{{/sourceDirectories.length}} +{{#sourceDirectoriesTest.length}} sourceDirectoriesTest { {{#sourceDirectoriesTest}} path("{{toString}}") {{/sourceDirectoriesTest}} } +{{/sourceDirectoriesTest.length}} dependencies { -// compile("com.beust:jcommander:1.48") +// compile("com.beust:jcommander:1.68") {{#mainDependencies}} compile("{{groupId}}:{{artifactId}}:{{version}}") {{/mainDependencies}} @@ -42,7 +43,6 @@ val p = {{directive}} { {{#testDependencies}} compile("{{groupId}}:{{artifactId}}:{{version}}") {{/testDependencies}} - } assemble { @@ -53,6 +53,4 @@ val p = {{directive}} { application { mainClass = "com.example.{{mainClass}}" } - - } diff --git a/src/main/resources/templates/idea/KotlinJavaRuntime.xml b/src/main/resources/templates/idea/KotlinJavaRuntime.xml index c630c0b8..3792609b 100644 --- a/src/main/resources/templates/idea/KotlinJavaRuntime.xml +++ b/src/main/resources/templates/idea/KotlinJavaRuntime.xml @@ -1,12 +1,12 @@ - + - + \ No newline at end of file diff --git a/src/test/kotlin/com/beust/kobalt/BaseTest.kt b/src/test/kotlin/com/beust/kobalt/BaseTest.kt index d0aa7c38..3930f318 100644 --- a/src/test/kotlin/com/beust/kobalt/BaseTest.kt +++ b/src/test/kotlin/com/beust/kobalt/BaseTest.kt @@ -1,5 +1,6 @@ package com.beust.kobalt +import com.beust.jcommander.JCommander import com.beust.kobalt.api.Kobalt import com.beust.kobalt.api.Project import com.beust.kobalt.app.BuildFileCompiler @@ -8,13 +9,16 @@ import com.beust.kobalt.internal.KobaltPluginXml import com.beust.kobalt.internal.PluginInfo import com.beust.kobalt.internal.build.SingleFileBuildSources import com.beust.kobalt.misc.KFiles +import com.beust.kobalt.misc.KobaltLogger import com.beust.kobalt.misc.log import org.testng.annotations.BeforeClass +import org.testng.annotations.Guice import java.io.File import java.nio.file.Files import java.nio.file.Paths import java.util.* +@Guice(modules = arrayOf(TestModule::class)) open class BaseTest(val compilerFactory: BuildFileCompiler.IFactory? = null) { @BeforeClass fun bc() { @@ -90,4 +94,66 @@ open class BaseTest(val compilerFactory: BuildFileCompiler.IFactory? = null) { fun createTemporaryProjectDirectory() = KFiles.fixSlashes(Files.createTempDirectory("kobaltTest").toFile()) + class ProjectDescription(val file: File, val name: String, val version: String) + + fun createProject(projectInfo: ProjectInfo) : ProjectDescription { + val root = Files.createTempDirectory("kobalt-test").toFile() + val projectName = "p" + Math.abs(Random().nextInt()) + val version = "1.0" + + fun createFile(root: File, f: String, text: String) = File(root, f).apply { + parentFile.mkdirs() + writeText(text) + } + + createFile(root, "kobalt/src/Build.kt", + projectInfo.buildFile.text(KFiles.fixSlashes(root.absolutePath), projectName, version)) + + projectInfo.files.forEach { + createFile(root, it.path, it.content) + } + return ProjectDescription(root, projectName, version) + } + + class LaunchProjectResult(val projectDescription: ProjectDescription, val result: Int) + + fun launchProject(projectInfo: ProjectInfo, commandLine: Array) : LaunchProjectResult { + val project = createProject(projectInfo) + val main = Kobalt.INJECTOR.getInstance(Main::class.java) + val args = Args() + val jc = JCommander(args).apply { parse(*commandLine) } + + KobaltLogger.setLogLevel(args) + + args.buildFile = KFiles.fixSlashes(project.file.absolutePath) + "/kobalt/src/Build.kt" + val result = Main.launchMain(main, jc, args, arrayOf("assemble")) + return LaunchProjectResult(project, result) + } } + +class BuildFile(val imports: List, val projectText: String) { + fun text(projectDirectory: String, projectName: String, version: String) : String { + val bottom = """ + + val $projectName = project { + name = "$projectName" + version = "$version" + directory = "$projectDirectory" + $projectText + } + + """ +// .trimIndent() + val buildFileText= """ + import com.beust.kobalt.* + import com.beust.kobalt.api.* +""".trimIndent() + + "\n" + + imports.map { "import " + it }.joinToString("\n") + "\n" + + bottom + + return buildFileText + } +} +class ProjectFile(val path: String, val content: String) +class ProjectInfo(val buildFile: BuildFile, val files: List) \ No newline at end of file diff --git a/src/test/kotlin/com/beust/kobalt/ContextTest.kt b/src/test/kotlin/com/beust/kobalt/ContextTest.kt index 783dc1cc..b0cec7ba 100644 --- a/src/test/kotlin/com/beust/kobalt/ContextTest.kt +++ b/src/test/kotlin/com/beust/kobalt/ContextTest.kt @@ -4,11 +4,9 @@ import com.beust.kobalt.api.KobaltContext import com.google.inject.Inject import org.assertj.core.api.Assertions.assertThat import org.testng.annotations.DataProvider -import org.testng.annotations.Guice import org.testng.annotations.Test import java.io.File -@Guice(modules = arrayOf(TestModule::class)) class ContextTest @Inject constructor(val context: KobaltContext) : BaseTest() { val GROUP = "org.testng" diff --git a/src/test/kotlin/com/beust/kobalt/IncludeExcludeTest.kt b/src/test/kotlin/com/beust/kobalt/IncludeExcludeTest.kt index 81969a1c..054aff2d 100644 --- a/src/test/kotlin/com/beust/kobalt/IncludeExcludeTest.kt +++ b/src/test/kotlin/com/beust/kobalt/IncludeExcludeTest.kt @@ -1,8 +1,5 @@ package com.beust.kobalt -import com.beust.kobalt.misc.From -import com.beust.kobalt.misc.IncludedFile -import com.beust.kobalt.misc.To import org.testng.Assert import org.testng.annotations.BeforeClass import org.testng.annotations.DataProvider @@ -24,7 +21,7 @@ class IncludeExcludeTest : KobaltTest() { val A_HTML = "a.html" @BeforeClass - fun bc() { + fun bc2() { topDirectory = Files.createTempDirectory("kobaltTest-").toFile() directory = File(topDirectory, "com/beust") directory.mkdirs() diff --git a/src/test/kotlin/com/beust/kobalt/KobaltTest.kt b/src/test/kotlin/com/beust/kobalt/KobaltTest.kt index 913cc35a..c7667a4a 100644 --- a/src/test/kotlin/com/beust/kobalt/KobaltTest.kt +++ b/src/test/kotlin/com/beust/kobalt/KobaltTest.kt @@ -2,10 +2,8 @@ package com.beust.kobalt import com.beust.kobalt.api.Kobalt import org.testng.annotations.BeforeSuite -import org.testng.annotations.Guice -@Guice(modules = arrayOf(TestModule::class)) -open class KobaltTest { +open class KobaltTest: BaseTest() { companion object { @BeforeSuite fun bs() { diff --git a/src/test/kotlin/com/beust/kobalt/VerifyKobaltZipTest.kt b/src/test/kotlin/com/beust/kobalt/VerifyKobaltZipTest.kt index 3f80c5cb..d0439725 100644 --- a/src/test/kotlin/com/beust/kobalt/VerifyKobaltZipTest.kt +++ b/src/test/kotlin/com/beust/kobalt/VerifyKobaltZipTest.kt @@ -2,11 +2,15 @@ package com.beust.kobalt import com.beust.kobalt.misc.KFiles import com.beust.kobalt.misc.kobaltLog +import com.beust.kobalt.misc.warn +import org.assertj.core.api.Assertions.assertThat import org.testng.annotations.Test import java.io.File import java.io.FileInputStream import java.io.FileReader import java.io.InputStream +import java.nio.file.Files +import java.nio.file.Paths import java.util.* import java.util.jar.JarEntry import java.util.jar.JarFile @@ -27,37 +31,54 @@ class VerifyKobaltZipTest : KobaltTest() { var foundJar = false var foundWrapperJar = false - val mainJarFilePath = "kobalt-$KOBALT_VERSION.jar" - val zipFilePath = KFiles.joinDir("kobaltBuild", "libs", "kobalt-$KOBALT_VERSION.zip") + val root = "kobalt-$KOBALT_VERSION" + val mainJarFilePath = "$root.jar" + val zipFilePath = KFiles.joinDir("kobaltBuild", "libs", "$root.zip") if (File(zipFilePath).exists()) { val zipFile = JarFile(zipFilePath) val stream = JarInputStream(FileInputStream(zipFilePath)) var entry = stream.nextEntry while (entry != null) { + assertThat(entry.name).doesNotContain("\\") + if (! entry.name.startsWith(root)) { + throw AssertionError("Entries in the zip file should be under the directory $root") + } if (entry.name.endsWith("kobaltw")) { + val ins = zipFile.getInputStream(entry) + ins.readBytes().forEach { + // Look for carriage returns + if (it.compareTo(13) == 0) { + throw AssertionError("kobaltw has wrong line endings") + } + } + if (OperatingSystem.current().isWindows()) { + warn("Can't determine if kobaltw is executable under Windows") + } else if (!Files.isExecutable(Paths.get("dist/kobaltw"))) { + throw AssertionError("kobaltw has invalid permissions") + } foundKobaltw = true } else if (entry.name.endsWith(mainJarFilePath)) { val ins = zipFile.getInputStream(entry) if (ins.available() < 20000000) { - throw KobaltException(mainJarFilePath + " is too small: " + mainJarFilePath) + throw AssertionError(mainJarFilePath + " is too small: " + mainJarFilePath) } verifyMainJarFile(ins) foundJar = true } else if (entry.name.endsWith("kobalt-wrapper.jar")) { val ins = zipFile.getInputStream(entry) foundWrapperJar = true - assertExistence(ins, listOf("kobalt.properties")) + assertExistence(ins, listOf("kobalt.properties", "com/beust/kobalt/wrapper/Main.class")) } entry = stream.nextEntry } if (!foundKobaltw) { - throw KobaltException("Couldn't find kobaltw in $zipFilePath") + throw AssertionError("Couldn't find kobaltw in $zipFilePath") } if (!foundJar) { - throw KobaltException("Couldn't find jar in $zipFilePath") + throw AssertionError("Couldn't find jar in $zipFilePath") } if (!foundWrapperJar) { - throw KobaltException("Couldn't find wrapper jar in $zipFilePath") + throw AssertionError("Couldn't find wrapper jar in $zipFilePath") } kobaltLog(1, "$zipFilePath looks correct") } else { diff --git a/src/test/kotlin/com/beust/kobalt/internal/BlockExtractorTest.kt b/src/test/kotlin/com/beust/kobalt/internal/BlockExtractorTest.kt index aeea5f06..9e0e3514 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/BlockExtractorTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/BlockExtractorTest.kt @@ -1,14 +1,12 @@ package com.beust.kobalt.internal -import com.beust.kobalt.TestModule +import com.beust.kobalt.BaseTest import com.beust.kobalt.app.BuildFiles import org.assertj.core.api.Assertions.assertThat -import org.testng.annotations.Guice import org.testng.annotations.Test import java.io.File -@Guice(modules = arrayOf(TestModule::class)) -class BlockExtractorTest { +class BlockExtractorTest : BaseTest() { @Test fun verifyExtraction() { diff --git a/src/test/kotlin/com/beust/kobalt/internal/BuildFilesTest.kt b/src/test/kotlin/com/beust/kobalt/internal/BuildFilesTest.kt new file mode 100644 index 00000000..53ec3a0e --- /dev/null +++ b/src/test/kotlin/com/beust/kobalt/internal/BuildFilesTest.kt @@ -0,0 +1,28 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.BaseTest +import com.beust.kobalt.BuildFile +import com.beust.kobalt.ProjectFile +import com.beust.kobalt.ProjectInfo +import com.beust.kobalt.misc.KFiles +import org.assertj.core.api.Assertions.assertThat +import org.testng.annotations.Test +import java.io.File + +class BuildFilesTest : BaseTest() { + + @Test + fun shouldGenerateArtifact() { + val projectInfo = ProjectInfo( + BuildFile(listOf("com.beust.kobalt.plugin.packaging.*"), "assemble{jar{}}"), + listOf(ProjectFile("src/main/kotlin/A.kt", "val a = \"foo\""))) + + val result = launchProject(projectInfo, arrayOf("assemble")) + + val project = result.projectDescription + val jarFile = File(KFiles.joinDir(project.file.absolutePath, "kobaltBuild/libs", project.name + "-" + + project.version + ".jar")) + + assertThat(jarFile).exists() + } +} \ No newline at end of file diff --git a/src/test/kotlin/com/beust/kobalt/internal/BuildOrderTest.kt b/src/test/kotlin/com/beust/kobalt/internal/BuildOrderTest.kt index cd660049..1ef53824 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/BuildOrderTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/BuildOrderTest.kt @@ -1,23 +1,15 @@ package com.beust.kobalt.internal -import com.beust.kobalt.TestModule +import com.beust.kobalt.BaseTest import com.beust.kobalt.api.Kobalt import com.beust.kobalt.project import org.assertj.core.api.Assertions.assertThat -import org.testng.annotations.BeforeClass import org.testng.annotations.DataProvider -import org.testng.annotations.Guice import org.testng.annotations.Test -@Guice(modules = arrayOf(TestModule::class)) -class BuildOrderTest { +class BuildOrderTest : BaseTest() { val taskManager: TaskManager get() = Kobalt.INJECTOR.getInstance(TaskManager::class.java) - @BeforeClass - fun beforeClass() { - Kobalt.init(TestModule()) - } - private fun toExpectedList(vararg projectNames: Int) = projectNames.map { "p$it:assemble" }.toList() @DataProvider diff --git a/src/test/kotlin/com/beust/kobalt/internal/DependencyTest.kt b/src/test/kotlin/com/beust/kobalt/internal/DependencyTest.kt index 74db351e..521653fd 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/DependencyTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/DependencyTest.kt @@ -1,13 +1,14 @@ package com.beust.kobalt.internal +import com.beust.kobalt.BaseTest import com.beust.kobalt.TestConfig -import com.beust.kobalt.TestModule -import com.beust.kobalt.api.* +import com.beust.kobalt.api.ITestJvmFlagContributor +import com.beust.kobalt.api.ITestJvmFlagInterceptor +import com.beust.kobalt.api.KobaltContext +import com.beust.kobalt.api.Project import com.beust.kobalt.maven.dependency.FileDependency import com.beust.kobalt.project import org.assertj.core.api.Assertions.assertThat -import org.testng.annotations.BeforeClass -import org.testng.annotations.Guice import org.testng.annotations.Test import javax.inject.Inject @@ -15,8 +16,7 @@ import javax.inject.Inject /** * Test ITestJvmFlagContributor and ITestJvmFlagInterceptor. */ -@Guice(modules = arrayOf(TestModule::class)) -class DependencyTest @Inject constructor(val context: KobaltContext) { +class DependencyTest @Inject constructor(val context: KobaltContext) : BaseTest() { private fun isWindows() = System.getProperty("os.name").toLowerCase().contains("ndows") private val A_JAR = if (isWindows()) "c:\\tmp\\a.jar" else "/tmp/a.jar" private val B_JAR = if (isWindows()) "c:\\tmp\\b.jar" else "/tmp/b.jar" @@ -37,11 +37,6 @@ class DependencyTest @Inject constructor(val context: KobaltContext) { } } - @BeforeClass - fun beforeClass() { - Kobalt.init(TestModule()) - } - private fun runTest(pluginInfo: IPluginInfo, expected: List) { val result = TestNgRunner().calculateAllJvmArgs(project, context, TestConfig(project), classpath, pluginInfo) diff --git a/src/test/kotlin/com/beust/kobalt/internal/DynamicGraphTest.kt b/src/test/kotlin/com/beust/kobalt/internal/DynamicGraphTest.kt index 64dbd5bd..ca74505a 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/DynamicGraphTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/DynamicGraphTest.kt @@ -31,7 +31,7 @@ class DynamicGraphTest { override fun call() : TaskResult2 { kobaltLog(2, "Running node $n") runNodes.add(n) - return TaskResult2(errorFunction(n), null, n) + return TaskResult2(errorFunction(n), value = n) } } diff --git a/src/test/kotlin/com/beust/kobalt/internal/ExcludeTest.kt b/src/test/kotlin/com/beust/kobalt/internal/ExcludeTest.kt index 41865745..ccd65835 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/ExcludeTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/ExcludeTest.kt @@ -1,7 +1,6 @@ package com.beust.kobalt.internal import com.beust.kobalt.BaseTest -import com.beust.kobalt.TestModule import com.beust.kobalt.api.Kobalt import com.beust.kobalt.app.BuildFileCompiler import com.beust.kobalt.maven.DependencyManager @@ -9,10 +8,8 @@ import com.beust.kobalt.maven.aether.Scope import com.google.inject.Inject import org.assertj.core.api.Assertions.assertThat import org.testng.annotations.DataProvider -import org.testng.annotations.Guice import org.testng.annotations.Test -@Guice(modules = arrayOf(TestModule::class)) class ExcludeTest @Inject constructor(compilerFactory: BuildFileCompiler.IFactory, val dependencyManager: DependencyManager) : BaseTest(compilerFactory) { diff --git a/src/test/kotlin/com/beust/kobalt/internal/InstallTest.kt b/src/test/kotlin/com/beust/kobalt/internal/InstallTest.kt new file mode 100644 index 00000000..8b36b55a --- /dev/null +++ b/src/test/kotlin/com/beust/kobalt/internal/InstallTest.kt @@ -0,0 +1,50 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.BaseTest +import com.beust.kobalt.BuildFile +import com.beust.kobalt.ProjectFile +import com.beust.kobalt.ProjectInfo +import com.beust.kobalt.app.BuildFileCompiler +import com.google.inject.Inject +import org.assertj.core.api.Assertions.assertThat +import org.testng.annotations.Test +import java.io.File + +class InstallTest @Inject constructor(compilerFactory: BuildFileCompiler.IFactory) : BaseTest(compilerFactory) { + + @Test(description = "Test that copy() and include() work properly") + fun shouldInstall() { + val from = from("testFile") + val to = to("installed") + val inc = include("a", "deployed2", "glob(\"**/*\")") + val install = """ + install { + copy($from, $to) + $inc + } + """.trimIndent() + val bf = BuildFile(listOf("com.beust.kobalt.plugin.packaging.*"), install) + val testFileContent = "This should be in the file\n" + val cContent = "Nested file\n" + val files = listOf(ProjectFile("testFile", testFileContent), + ProjectFile("a/b/c", cContent)) + val result = launchProject(ProjectInfo(bf, files), arrayOf("install")) + + assertFile(result, "installed/testFile", testFileContent) + assertFile(result, "deployed2/b/c", cContent) + } + + + private fun toPath(s: String) = "\"\${project.directory}/$s\"" + private fun from(path: String) = "from(" + toPath(path) + ")" + private fun to(path: String) = "to(" + toPath(path) + ")" + private fun include(s1: String, s2: String, s3: String) = "include(from(" + toPath(s1) + "), " + + "to(" + toPath(s2) + "), " + s3 + ")" + + private fun assertFile(lpr: LaunchProjectResult, path: String, content: String) { + File(lpr.projectDescription.file.absolutePath, path).let { file -> + assertThat(file).exists() + assertThat(file.readText()).isEqualTo(content) + } + } +} diff --git a/src/test/kotlin/com/beust/kobalt/internal/KotlinCompilerVersionTest.kt b/src/test/kotlin/com/beust/kobalt/internal/KotlinCompilerVersionTest.kt new file mode 100644 index 00000000..21eb6edc --- /dev/null +++ b/src/test/kotlin/com/beust/kobalt/internal/KotlinCompilerVersionTest.kt @@ -0,0 +1,58 @@ +package com.beust.kobalt.internal + +import com.beust.kobalt.BaseTest +import com.beust.kobalt.BuildFile +import com.beust.kobalt.ProjectFile +import com.beust.kobalt.ProjectInfo +import com.beust.kobalt.misc.KFiles +import org.assertj.core.api.Assertions.assertThat +import org.testng.annotations.Test +import java.io.File + +class KotlinCompilerVersionTest : BaseTest() { + + @Test + fun shouldCompileWithExternalKotlin() { + val projectInfo = ProjectInfo( + BuildFile( + listOf("com.beust.kobalt.plugin.packaging.*", "com.beust.kobalt.plugin.kotlin.kotlinCompiler"), + """ + kotlinCompiler { + version = "1.2.60" + } + assemble{ jar{} } + """ + ), + listOf( + ProjectFile("src/main/kotlin/A.kt", "val a = Bob()"), + ProjectFile("src/main/kotlin/Bob.java", "class Bob { }") + ) + ) + + val result = launchProject(projectInfo, arrayOf("assemble", "--log", "2")) + + val project = result.projectDescription + val jarFile = File(KFiles.joinDir(project.file.absolutePath, "kobaltBuild/libs", project.name + "-" + + project.version + ".jar")) + + assertThat(jarFile).exists() + } + + @Test + fun shouldFailWhenKotlinVersionDoesNotExist() { + val projectInfo = ProjectInfo( + BuildFile( + listOf("com.beust.kobalt.plugin.packaging.*", "com.beust.kobalt.plugin.kotlin.kotlinCompiler"), + """ + kotlinCompiler { version = "1.1.20" } + assemble{ jar{} } + """ + ), + listOf(ProjectFile("src/main/kotlin/A.kt", "val a = \"foo\"")) + ) + + val result = launchProject(projectInfo, arrayOf("assemble", "--log", "2")) + + assertThat(result.result).isEqualTo(1) + } +} diff --git a/src/test/kotlin/com/beust/kobalt/internal/ProfileTest.kt b/src/test/kotlin/com/beust/kobalt/internal/ProfileTest.kt index b36fd612..e0f62382 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/ProfileTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/ProfileTest.kt @@ -9,11 +9,9 @@ import com.beust.kobalt.app.BuildFileCompiler import com.google.inject.Inject import org.assertj.core.api.Assertions.assertThat import org.testng.annotations.DataProvider -import org.testng.annotations.Guice import org.testng.annotations.Test import java.util.* -@Guice(modules = arrayOf(TestModule::class)) class ProfileTest @Inject constructor(compilerFactory: BuildFileCompiler.IFactory) : BaseTest(compilerFactory) { private fun runTestWithProfile(enabled: Boolean, oldSyntax: Boolean) : Project { diff --git a/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt b/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt index bb28018a..c60bb00f 100644 --- a/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt +++ b/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt @@ -1,15 +1,12 @@ package com.beust.kobalt.internal import com.beust.kobalt.BaseTest -import com.beust.kobalt.TestModule import com.google.common.collect.ArrayListMultimap import com.google.common.collect.Multimap import com.google.common.collect.TreeMultimap import org.assertj.core.api.Assertions.assertThat -import org.testng.annotations.Guice import org.testng.annotations.Test -@Guice(modules = arrayOf(TestModule::class)) class TaskManagerTest : BaseTest() { class DryRunGraphExecutor(val graph: DynamicGraph) { diff --git a/src/test/kotlin/com/beust/kobalt/maven/DependencyManagerTest.kt b/src/test/kotlin/com/beust/kobalt/maven/DependencyManagerTest.kt index a6f0e9f3..762493a5 100644 --- a/src/test/kotlin/com/beust/kobalt/maven/DependencyManagerTest.kt +++ b/src/test/kotlin/com/beust/kobalt/maven/DependencyManagerTest.kt @@ -14,7 +14,6 @@ import org.eclipse.aether.util.filter.AndDependencyFilter import org.testng.annotations.Guice import org.testng.annotations.Test -@Guice(modules = arrayOf(TestModule::class)) class DependencyManagerTest @Inject constructor(val dependencyManager: DependencyManager, compilerFactory: BuildFileCompiler.IFactory) : BaseTest(compilerFactory) { @@ -55,10 +54,12 @@ class DependencyManagerTest @Inject constructor(val dependencyManager: Dependenc // Should resolve to TestNG and its dependencies dependencyManager.transitiveClosure(testDeps).let { dependencies -> assertContains(dependencies, ":jcommander:") - assertContains(dependencies, ":bsh:") - assertContains(dependencies, ":ant:") - assertContains(dependencies, ":ant-launcher:") assertContains(dependencies, ":testng:") + + // Optional dependencies + assertDoesNotContain(dependencies, ":bsh:") + assertDoesNotContain(dependencies, ":ant:") + assertDoesNotContain(dependencies, ":ant-launcher:") } } diff --git a/src/test/kotlin/com/beust/kobalt/maven/DependencyTest.kt b/src/test/kotlin/com/beust/kobalt/maven/DependencyTest.kt index 9cbf3ce1..cd2bc9a3 100644 --- a/src/test/kotlin/com/beust/kobalt/maven/DependencyTest.kt +++ b/src/test/kotlin/com/beust/kobalt/maven/DependencyTest.kt @@ -1,16 +1,18 @@ package com.beust.kobalt.maven -import com.beust.kobalt.TestModule +import com.beust.kobalt.BaseTest import com.beust.kobalt.misc.KobaltExecutors import com.beust.kobalt.misc.StringVersion import org.testng.Assert -import org.testng.annotations.* +import org.testng.annotations.AfterClass +import org.testng.annotations.BeforeClass +import org.testng.annotations.DataProvider +import org.testng.annotations.Test import java.util.concurrent.ExecutorService import javax.inject.Inject import kotlin.properties.Delegates -@Guice(modules = arrayOf(TestModule::class)) -class DependencyTest @Inject constructor(val executors: KobaltExecutors) { +class DependencyTest @Inject constructor(val executors: KobaltExecutors) : BaseTest() { @DataProvider fun dpVersions(): Array> { @@ -29,7 +31,7 @@ class DependencyTest @Inject constructor(val executors: KobaltExecutors) { private var executor: ExecutorService by Delegates.notNull() @BeforeClass - fun bc() { + fun bc2() { executor = executors.newExecutor("DependencyTest", 5) } diff --git a/src/test/kotlin/com/beust/kobalt/maven/DownloadTest.kt b/src/test/kotlin/com/beust/kobalt/maven/DownloadTest.kt index 820bef21..5d501689 100644 --- a/src/test/kotlin/com/beust/kobalt/maven/DownloadTest.kt +++ b/src/test/kotlin/com/beust/kobalt/maven/DownloadTest.kt @@ -23,7 +23,7 @@ class DownloadTest @Inject constructor( private var executor: ExecutorService by Delegates.notNull() @BeforeClass - fun bc() { + fun bc2() { executor = executors.newExecutor("DependentTest", 5) } @@ -153,7 +153,7 @@ class DownloadTest @Inject constructor( // since snapshots are not allowed to be returned when looking up a versionless id) val id = "com.squareup.moshi:moshi:1.1.0" val artifact = resolver.resolveToArtifact(id) - assertThat(artifact.version).isEqualTo("1.1.0") + assertThat(artifact.version.toString()).isEqualTo("1.1.0") } @Test diff --git a/src/test/kotlin/com/beust/kobalt/maven/FileSpecTest.kt b/src/test/kotlin/com/beust/kobalt/maven/FileSpecTest.kt index f0e8bc52..11e524af 100644 --- a/src/test/kotlin/com/beust/kobalt/maven/FileSpecTest.kt +++ b/src/test/kotlin/com/beust/kobalt/maven/FileSpecTest.kt @@ -1,11 +1,7 @@ package com.beust.kobalt.maven -import com.beust.kobalt.IFileSpec -import com.beust.kobalt.homeDir -import com.beust.kobalt.misc.From -import com.beust.kobalt.misc.IncludedFile +import com.beust.kobalt.* import com.beust.kobalt.misc.KFiles -import com.beust.kobalt.misc.To import org.testng.annotations.Test @Test(enabled = false) diff --git a/src/test/kotlin/com/beust/kobalt/misc/IncludedFileTest.kt b/src/test/kotlin/com/beust/kobalt/misc/IncludedFileTest.kt index 52a9eb69..2f98b54e 100644 --- a/src/test/kotlin/com/beust/kobalt/misc/IncludedFileTest.kt +++ b/src/test/kotlin/com/beust/kobalt/misc/IncludedFileTest.kt @@ -1,9 +1,14 @@ package com.beust.kobalt.misc +import com.beust.kobalt.From import com.beust.kobalt.IFileSpec +import com.beust.kobalt.IncludedFile +import com.beust.kobalt.To +import org.assertj.core.api.Assertions.assertThat import org.testng.Assert import org.testng.annotations.Test import java.io.File +import java.nio.file.Files @Test class IncludedFileTest { @@ -14,4 +19,28 @@ class IncludedFileTest { Assert.assertTrue(it.exists(), "Should exist: $it") } } + + fun shouldRecursivelyCopy() { + val TEXT = "I'm a file" + val ROOT = Files.createTempDirectory("kobalt-test").toFile() + val from = File(ROOT, "from") + File(from, "a/b").apply { mkdirs() } + val file = File("/a/b/foo") + File(from, file.path).apply { writeText(TEXT) } + val to = File(ROOT, "to").apply { + deleteRecursively() + mkdirs() + } + + val targetFile = File(to, file.path) + assertThat(targetFile).doesNotExist() + + KFiles.copyRecursively(from, to) + + assertThat(to).isDirectory() + with(targetFile) { + assertThat(this).exists() + assertThat(this.readText()).isEqualTo(TEXT) + } + } } diff --git a/src/test/kotlin/com/beust/kobalt/misc/JarUtilsTest.kt b/src/test/kotlin/com/beust/kobalt/misc/JarUtilsTest.kt index b4d1dc66..1cd3c4e2 100644 --- a/src/test/kotlin/com/beust/kobalt/misc/JarUtilsTest.kt +++ b/src/test/kotlin/com/beust/kobalt/misc/JarUtilsTest.kt @@ -1,6 +1,9 @@ package com.beust.kobalt.misc +import com.beust.kobalt.From import com.beust.kobalt.IFileSpec +import com.beust.kobalt.IncludedFile +import com.beust.kobalt.To import org.testng.Assert import org.testng.annotations.Test import javax.inject.Inject diff --git a/src/test/kotlin/com/beust/kobalt/misc/MavenResolverTest.kt b/src/test/kotlin/com/beust/kobalt/misc/MavenResolverTest.kt index 2e98cf28..4cee6077 100644 --- a/src/test/kotlin/com/beust/kobalt/misc/MavenResolverTest.kt +++ b/src/test/kotlin/com/beust/kobalt/misc/MavenResolverTest.kt @@ -1,6 +1,7 @@ package com.beust.kobalt.misc -import com.beust.kobalt.TestModule +import com.beust.kobalt.Args +import com.beust.kobalt.BaseTest import com.beust.kobalt.internal.KobaltSettings import com.beust.kobalt.internal.KobaltSettingsXml import com.beust.kobalt.maven.DependencyManager @@ -18,11 +19,9 @@ import org.eclipse.aether.resolution.ArtifactResult import org.eclipse.aether.resolution.DependencyRequest import org.eclipse.aether.resolution.DependencyResolutionException import org.testng.annotations.DataProvider -import org.testng.annotations.Guice import org.testng.annotations.Test -@Guice(modules = arrayOf(TestModule::class)) -class MavenResolverTest { +class MavenResolverTest : BaseTest() { @Inject lateinit var resolver: KobaltMavenResolver @@ -84,10 +83,20 @@ class MavenResolverTest { repos = listOf("https://hub.spigotmc.org/nexus/content/repositories/snapshots")) } + @Test(enabled = false) + fun shouldIgnoreOptionalResolutions() { + resolver.resolve("org.springframework:spring-context-support:2.5.6.SEC03") + } + + @Test(expectedExceptions = arrayOf(DependencyResolutionException::class)) + fun shouldThrowIfResolutionFails() { + resolver.resolve("org.testng:bogus:6.11") + } + private fun resolve(id: String): List { val system = Booter.newRepositorySystem() val session = Booter.newRepositorySystemSession(system, - localRepo.localRepo, KobaltSettings(KobaltSettingsXml()), EventBus()) + localRepo.localRepo, KobaltSettings(KobaltSettingsXml()), Args(), EventBus()) val artifact = DefaultArtifact(id) val collectRequest = CollectRequest().apply {