groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cchamp...@apache.org
Subject [06/19] groovy git commit: Remove `groovy-all` jar
Date Tue, 12 Dec 2017 20:56:27 GMT
Remove `groovy-all` jar

This commit removes the generation of a Groovy all jar. This is done because of the JDK 9+
era, that prevents
the use of different "modules" containing the same packages, which is exactly what the all
jar is. This also
adds an automatic module name to all generated jars and fixes several caching/up-to-date checking
issues.

A "pom packaging" groovy-all artifact is going to be added in a subsequent commit.


Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/17ff9823
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/17ff9823
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/17ff9823

Branch: refs/heads/GROOVY_2_6_X
Commit: 17ff98234571a34cff8ecdc0d127e7eb54b024ff
Parents: 8b5cebf
Author: Cedric Champeau <cchampeau@apache.org>
Authored: Sun Dec 10 21:04:47 2017 +0100
Committer: Cedric Champeau <cchampeau@apache.org>
Committed: Tue Dec 12 21:55:47 2017 +0100

----------------------------------------------------------------------
 build.gradle                                    |  44 ++---
 gradle/assemble.gradle                          | 187 +------------------
 gradle/backports.gradle                         |   6 +-
 gradle/binarycompatibility.gradle               |  31 ---
 gradle/quality.gradle                           |   5 +-
 gradle/upload.gradle                            |  47 +----
 .../org/codehaus/groovy/tools/DgmConverter.java |   5 +-
 subprojects/performance/build.gradle            |   4 +-
 8 files changed, 40 insertions(+), 289 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/build.gradle
----------------------------------------------------------------------
diff --git a/build.gradle b/build.gradle
index 36cbc98..6bb4ab7 100644
--- a/build.gradle
+++ b/build.gradle
@@ -50,7 +50,7 @@ buildscript {
 }
 
 plugins {
-    id 'com.gradle.build-scan' version '1.6'
+    id 'com.gradle.build-scan' version '1.10.2'
     id 'me.champeau.buildscan-recipes' version '0.1.7'
 }
 
@@ -122,12 +122,12 @@ task(copyResources, type: Copy) {
         include('**/*.png', '**/*.gif', '**/*.ico', '**/*.css')
     }
 }
-compileJava.dependsOn(copyResources)
+jar.dependsOn(copyResources)
 task(copyTestResources, type: Copy)
         .from('src/test')
         .into("$buildDir/classes/test")
         .include('**/*.txt', '**/*.xml', '**/*.properties', '**/*.png', '**/*.html', '**/*.gif',
'**/*.ico', '**/*.css')
-compileTestJava.dependsOn(copyTestResources)
+test.dependsOn(copyTestResources)
 
 task sourceJar(type: Jar) {
     classifier = 'sources'
@@ -344,8 +344,8 @@ processResources.doLast {
     }
 }
 
-tasks.withType(Jar) {
-    doFirst {
+compileJava {
+    doLast {
         ant.java(classname:'org.jboss.bridger.Bridger', classpath: rootProject.configurations.tools.asPath,
outputproperty: 'stdout') {
             arg(value: "${sourceSets.main.output.classesDir.canonicalPath}/org/codehaus/groovy/runtime/DefaultGroovyMethods.class")
         }
@@ -387,24 +387,26 @@ apply from: 'gradle/utils.gradle'
 apply from: 'wrapper.gradle'
 
 task dgmConverter(dependsOn:compileJava) {
+    outputs.cacheIf { true }
+
     description = 'Generates DGM info file required for faster startup.'
-    def classesDir = sourceSets.main.output.classesDir
-    def classpath = files(classesDir, configurations.compile)
+    def classpath = files(sourceSets.main.output.classesDirs, configurations.compile)
+    ext.outputDir = file("$buildDir/dgm")
 
     //main = 'org.codehaus.groovy.tools.DgmConverter'
     //args = ['--info', classesDir.absolutePath]
     doFirst {
-        file("$classesDir/META-INF").mkdirs()
+        file("$outputDir/META-INF").mkdirs()
         // we use ant.java because Gradle is a bit "too smart" with JavaExec
         // as it will invalidate the task if classpath changes, which will
         // happen once Groovy files are compiled
         ant.java(classname:'org.codehaus.groovy.tools.DgmConverter', classpath: classpath.asPath)
{
             arg(value: '--info')
-            arg(value: classesDir.absolutePath)
+            arg(value: "$outputDir.absolutePath")
         }
     }
     inputs.files fileTree('src').include('**/*GroovyMethods.java')
-    outputs.file file("${classesDir}/META-INF/dgminfo")
+    outputs.dir outputDir
 }
 
 compileJava {
@@ -415,26 +417,16 @@ compileJava {
     // Gradle classloading magic with Groovy will only work if it finds a *jar*
     // on classpath. This "bootstrap jar" contains the minimal compiler, without .groovy
compiled files
 
-task bootstrapJar {
+task bootstrapJar(type:Jar ) {
     dependsOn compileJava, dgmConverter
 
-    def destinationDir = file("$buildDir/bootstrap")
-    def archiveName = "groovy-${version}-bootstrap.jar"
-    ext.archivePath = file("$destinationDir/$archiveName")
+    from compileJava.destinationDir
+    from dgmConverter.outputDir
 
-    doLast {
-        // we use ant.jar because Gradle is a bit "too smart" with JavaExec
-        // as it will invalidate the task if classpath changes, which will
-        // happen once Groovy files are compiled
-        destinationDir.mkdirs()
-        ant.jar(
-                destfile: archivePath,
-                basedir: file(sourceSets.main.output.classesDir)
-        )
-    }
     inputs.property('indy', useIndy())
-    inputs.files sourceSets.main.allJava
-    outputs.file archivePath
+
+    destinationDir = file("$buildDir/bootstrap")
+    classifier = 'bootstrap'
 }
 
 compileGroovy.dependsOn bootstrapJar

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/gradle/assemble.gradle
----------------------------------------------------------------------
diff --git a/gradle/assemble.gradle b/gradle/assemble.gradle
index 1b3a3f4..762b043 100644
--- a/gradle/assemble.gradle
+++ b/gradle/assemble.gradle
@@ -134,6 +134,7 @@ ext.subprojectOsgiManifest = {
 
 jar {
     dependsOn('dgmConverter')
+    from files(dgmConverter.outputDir)
     metaInf {
         from("$projectDir/licenses/LICENSE-JARJAR")
         from("$projectDir/licenses") {
@@ -209,6 +210,8 @@ allprojects {
                 symbolicName = gradleProject.name
                 instruction 'Import-Package', '*;resolution:=optional'
                 classesDir = targetTmp
+                def moduleName = "org.codehaus.${it.name.replace('-', '.')}"
+                attributes('Automatic-Module-Name': moduleName)
             }
             manifest(manifestSpec)
 
@@ -289,67 +292,6 @@ subprojects { sp ->
     }
 }
 
-def moduleJars() {
-    modules()*.jar.archivePath
-}
-
-def mergeModuleDescriptors() {
-    new File("$buildDir/tmp/").mkdirs()
-
-    def extensionClasses = []
-    def staticExtensionClasses = []
-
-    modules().collect {
-        new File("${it.buildDir}/classes/main/META-INF/services/org.codehaus.groovy.runtime.ExtensionModule")
-    }.findAll { it.exists() }.each {
-        def props = new Properties()
-        props.load(it.newInputStream())
-        extensionClasses += props.get('extensionClasses').split(',').findAll { it }
-        staticExtensionClasses += props.get('staticExtensionClasses').split(',').findAll
{ it }
-    }
-
-    def descriptor = new File("$buildDir/tmp/org.codehaus.groovy.runtime.ExtensionModule")
-    descriptor.withWriter('UTF-8') {
-        it << '# This is a generated file, do not edit\n'
-        it << 'moduleName=groovy-all\n'
-        it << "moduleVersion=${project.version}\n"
-        it << "extensionClasses=${extensionClasses.join(',')}\n"
-        it << "staticExtensionClasses=${staticExtensionClasses.join(',')}\n"
-    }
-
-    descriptor
-}
-
-def mergeGlobalTransforms() {
-    new File("$buildDir/tmp/").mkdirs()
-
-    def descriptor = new File("$buildDir/tmp/org.codehaus.groovy.transform.ASTTransformation")
-    descriptor.withWriter('UTF-8') {
-        it << '# This is a generated file, do not edit\n'
-    }
-
-    def files = []
-    files << new File("${rootProject.buildDir}/resources/main/META-INF/services/org.codehaus.groovy.transform.ASTTransformation")
-    modules().collect {
-        new File("${it.buildDir}/resources/main/META-INF/services/org.codehaus.groovy.transform.ASTTransformation")
-    }.findAll { it.exists() }.each {
-        files << it
-    }
-    files.each {
-        def skipping = true
-        it.readLines().each { line ->
-            if (skipping) {
-                skipping = line.startsWith('#')
-            }
-            if (!skipping) {
-                descriptor << line + '\n'
-            }
-        }
-    }
-
-    descriptor
-}
-
 task replaceJarWithJarJar(dependsOn: allprojects.jarjar ) {
     description = "Overwrites normal JAR files with their JARJAR version"
     doLast {
@@ -370,80 +312,6 @@ allprojects {
     rootProject.replaceJarWithJarJar.mustRunAfter(test)
 }
 
-task jarAll(type: Jar, dependsOn: replaceJarWithJarJar) {
-
-    inputs.files(allprojects.jar.archivePath)
-
-    ext.metaInfDir = "$buildDir/tmp/groovy-all-metainf"
-    baseName = 'groovy-all'
-    includeEmptyDirs = false
-    if (rootProject.useIndy()) {
-        classifier = 'indy'
-    }
-    doLast {
-        def manifestPath = "$ext.metaInfDir/MANIFEST.MF"
-        manifest.writeTo(manifestPath)
-        copy {
-            from "$projectDir/notices/NOTICE-ALLJARJAR"
-            into owner.ext.metaInfDir
-            rename('NOTICE-ALLJARJAR', 'NOTICE')
-        }
-        copy {
-            from "$projectDir/licenses"
-            into "$owner.ext.metaInfDir/licenses"
-            include 'normalize-stylesheet-license.txt'
-            include 'jsr223-license.txt'
-            include 'jline2-license.txt'
-        }
-        copy {
-            from "$projectDir/licenses/LICENSE-ALLJARJAR"
-            into owner.ext.metaInfDir
-            rename('LICENSE-ALLJARJAR', 'LICENSE')
-        }
-        copy {
-            from(mergeModuleDescriptors())
-            into "$owner.ext.metaInfDir/services"
-        }
-        copy {
-            from(mergeGlobalTransforms())
-            into "$owner.ext.metaInfDir/services"
-        }
-        copy {
-            into "$owner.ext.metaInfDir"
-        }
-        logger.info 'Packaging with jarjar'
-
-        def archivePathTmp = new File("${archivePath}.1.tmp")
-        ant {
-            taskdef name: 'jarjar', classname: jarjarTaskClassName, classpath: configurations.tools.asPath
-            jarjar(jarfile: archivePathTmp, manifest: "$owner.ext.metaInfDir/MANIFEST.MF")
{
-                zipfileset(dir: "$owner.ext.metaInfDir", prefix: 'META-INF')
-                zipfileset(src: jar.archivePath, excludes:'META-INF/NOTICE,META-INF/LICENSE')
-                moduleJars().each {
-                    zipfileset(src: it, excludes:'META-INF/NOTICE,META-INF/LICENSE')
-                }
-            }
-        }
-
-        manifest = osgiManifest {
-            symbolicName = 'groovy-all'
-            instruction 'Import-Package', '*;resolution:=optional'
-            classesDir = archivePathTmp
-        }
-        manifest groovyOsgiManifest
-        manifestPath = "${temporaryDir}/META-INF/MANIFEST.MF"
-        manifest.writeTo(manifestPath)
-
-        ant {
-            copy(file: archivePathTmp, tofile: archivePath)
-            jar(destfile: archivePath, update: true, index: true, manifest: manifestPath)
{
-                zipfileset(src: jar.archivePath, excludes:'META-INF')
-            }
-            delete(file: archivePathTmp, quiet: true, deleteonexit: true)
-        }
-    }
-}
-
 allprojects {
     task jarWithIndy(type: GradleBuild) {
         onlyIf rootProject.indyCapable
@@ -455,32 +323,6 @@ allprojects {
     }
 }
 
-task jarAllWithIndy(type: GradleBuild) {
-    onlyIf rootProject.indyCapable
-    description = 'Triggers an external build generating the indy jarAll'
-    buildFile = 'build.gradle'
-    startParameter.projectProperties['indy'] = true
-    startParameter.projectCacheDir = file("$buildDir/indyAllCacheDir")
-    tasks = ['jarAll']
-}
-
-task jarAllAll(dependsOn: [jarAll, jarAllWithIndy]) {
-    description = 'Generates groovy-all and groovy-all-indy jars'
-    doFirst {
-        if (useIndy()) {
-            logger.lifecycle('InvokeDynamic support was activated but needs to be off for
this pass. Disabling.')
-            ext.useIndy = false
-        }
-    }
-}
-
-allprojects {
-    tasks.withType(Test) { task ->
-        jarAll.mustRunAfter(task)
-        jarAllWithIndy.mustRunAfter(task)
-    }
-}
-
 task sourceAllJar(type: Jar, dependsOn: { modules()*.sourceJar + rootProject.sourceJar })
{
     with sourceJar.rootSpec
     modules()*.sourceJar.each {
@@ -570,12 +412,14 @@ ext.distSpec = copySpec {
         include 'xstream-license.txt'
     }
     into('embeddable') {
-        from jarAll.archivePath
-        from { new File(jarAll.destinationDir, "${jarAll.baseName}-${jarAll.version}-indy.jar")
}
+        subprojects.each {
+            from jar.archivePath
+            from { new File(jar.destinationDir, "${jar.baseName}-${jar.version}-indy.jar")
}
+        }
     }
 }
 
-task distBin(type: Zip, dependsOn: [jar, jarAllAll, replaceJarWithJarJar]) {
+task distBin(type: Zip, dependsOn: [jar, replaceJarWithJarJar]) {
     baseName = 'apache-groovy'
     appendix = 'binary'
     into("groovy-$version") {
@@ -676,23 +520,18 @@ task updateLicenses {
     ext.licenseDocGeneratorFile = "${projectDir}/subprojects/groovy-docgenerator/LICENSE"
     ext.licenseGroovyDocFile = "${projectDir}/subprojects/groovy-groovydoc/LICENSE"
     ext.licenseJsr223File = "${projectDir}/subprojects/groovy-jsr223/LICENSE"
-    ext.licenseAllJarJarFile = "${licensesDir}/LICENSE-ALLJARJAR"
     ext.licenseBinZipFile = "${licensesDir}/LICENSE-BINZIP"
     ext.licenseDocFile = "${licensesDir}/LICENSE-DOC"
     ext.licenseJarJarFile = "${licensesDir}/LICENSE-JARJAR"
     ext.licenseSdkFile = "${licensesDir}/LICENSE-SDK"
     inputs.files(licenseBaseFile, fileTree(licensesDir).include('*.txt'))
-    outputs.files(licenseAllJarJarFile, licenseBinZipFile, licenseDocFile, licenseJarJarFile,
licenseSrcFile,
+    outputs.files(licenseBinZipFile, licenseDocFile, licenseJarJarFile, licenseSrcFile,
             licenseDocGeneratorFile, licenseGroovyDocFile, licenseJsr223File, licenseSdkFile)
 
     doLast {
         def srcFiles = fileTree(licensesDir).include('*-SRC*.txt').sort { it.name }
         def docFiles = fileTree(licensesDir).include('*-DOC*.txt').sort { it.name }
         def jarjarFiles = fileTree(licensesDir).include('*-JARJAR*.txt').sort { it.name }
-        def allJarjarFiles = fileTree(licensesDir) {
-            include '*-JARJAR*.txt'
-            include '*-ALLJARJAR*.txt'
-        }.sort { it.name }
         def binzipFiles = fileTree(licensesDir) {
             include '*-JARJAR*.txt'
             include '*-ALLJARJAR*.txt'
@@ -703,7 +542,6 @@ task updateLicenses {
         def jsr223Files = fileTree(licensesDir).include('jsr223-ALLJARJAR-SRC.txt')
         def licenseHdr = '\n\n------------------------------------------------------------------------\n\n'
         [
-                (licenseAllJarJarFile)  : allJarjarFiles,
                 (licenseBinZipFile)     : binzipFiles,
                 (licenseDocFile)        : docFiles,
                 (licenseJarJarFile)     : jarjarFiles,
@@ -751,19 +589,14 @@ task updateNotices {
             include '*-JARJAR*.txt'
             include '*-GROOID*.txt'
         }.sort { it.name }
-        def allJarjarFiles = fileTree(noticesDir) {
-            include '*-JARJAR*.txt'
-            include '*-ALLJARJAR*.txt'
-        }.sort { it.name }
         def binzipFiles = fileTree(noticesDir) {
             include '*-JARJAR*.txt'
             include '*-ALLJARJAR*.txt'
             include '*-GROOID*.txt'
             include '*-BINZIP*.txt'
         }.sort { it.name }
-        def groovyconsoleFiles = fileTree(noticesDir).include('silkicons-ALLJARJAR-SRC.txt')
+        def groovyconsoleFiles = fileTree(noticesDir)
         [
-                (noticeAllJarJarFile): allJarjarFiles,
                 (noticeBinZipFile): binzipFiles,
                 (noticeGrooidFile): grooidFiles,
                 (noticeGrooidJarJarFile): grooidJarjarFiles,

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/gradle/backports.gradle
----------------------------------------------------------------------
diff --git a/gradle/backports.gradle b/gradle/backports.gradle
index 0d8e5ed..8d4c779 100644
--- a/gradle/backports.gradle
+++ b/gradle/backports.gradle
@@ -38,7 +38,7 @@ uploadArchives.dependsOn backportJars
 backports.each { pkg, classList ->
     def backportJar = task "backport${pkg}Jar"(type:Jar) {
         group = 'Backports'
-        dependsOn jarAll
+        dependsOn jar
 
         from zipTree(jar.archivePath)
         include classList
@@ -50,14 +50,14 @@ backports.each { pkg, classList ->
     // it's stupid in our case, because we don't have such, but we have no choice
     def javadocJar = task "backport${pkg}JavadocJar"(type:Jar) {
         group = 'Backports'
-        dependsOn jarAll
+        dependsOn jar
 
         baseName = "groovy-backports-$pkg"
         classifier = 'javadoc'
     }
     def sourcesJar = task "backport${pkg}SourcesJar"(type:Jar) {
         group = 'Backports'
-        dependsOn jarAll
+        dependsOn jar
 
         baseName = "groovy-backports-$pkg"
         classifier = 'sources'

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/gradle/binarycompatibility.gradle
----------------------------------------------------------------------
diff --git a/gradle/binarycompatibility.gradle b/gradle/binarycompatibility.gradle
index 96b1059..b822d11 100644
--- a/gradle/binarycompatibility.gradle
+++ b/gradle/binarycompatibility.gradle
@@ -140,37 +140,6 @@ templateConfiguration.with {
 }
 def engine = new MarkupTemplateEngine(this.class.classLoader, configDir, templateConfiguration)
 
-task japicmpAll(type: me.champeau.gradle.ArtifactJapicmpTask) {
-    dependsOn jarAll
-    baseline = "org.codehaus.groovy:groovy-all:${referenceMinorVersion}@jar"
-    to = jarAll.archivePath
-    accessModifier = 'protected'
-    onlyModified = true
-    failOnModification = false
-    txtOutputFile = file("$buildDir/reports/japi.txt")
-
-    doFirst {
-        classpath = allprojects.configurations.japicmp.files.flatten()
-    }
-
-    def htmlReportFile = file("${buildDir}/reports/binary-compat-${project.name}-all.html")
-    inputs.file file("$configDir/$templateFile")
-    inputs.file templateFile
-    outputs.file htmlReportFile
-
-    def model = [title   : "Binary compatibility report for ${project.name}",
-                 project : project,
-                 baseline: baseline,
-                 archive : to.name]
-    outputProcessor(reportGenerator.curry(model))
-
-    doLast {
-        htmlReportFile.withWriter('utf-8') { wrt ->
-            engine.createTemplateByPath(templateFile).make(model).writeTo(wrt)
-        }
-    }
-}
-
 allprojects {
     if (!(project.name in excludeModules)) {
         dependencies {

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/gradle/quality.gradle
----------------------------------------------------------------------
diff --git a/gradle/quality.gradle b/gradle/quality.gradle
index 01fd6e6..b59f1d7 100644
--- a/gradle/quality.gradle
+++ b/gradle/quality.gradle
@@ -54,12 +54,9 @@ allprojects {
 
     // don't fail build on CodeNarc tasks
     tasks.withType(CodeNarc) {
-        dependsOn jarAll
+        dependsOn jar
         ignoreFailures = true
         configFile = file("$rootProject.projectDir/config/codenarc/codenarc.groovy")
-        codenarcClasspath = files(rootProject.jarAll.archivePath) +
-                configurations.compile +
-                files { configurations.codenarc.findAll { !(it.name =~ /groovy|junit/)} }
     }
 
     tasks.withType(Checkstyle) {

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/gradle/upload.gradle
----------------------------------------------------------------------
diff --git a/gradle/upload.gradle b/gradle/upload.gradle
index be65fba..88f5ab6 100644
--- a/gradle/upload.gradle
+++ b/gradle/upload.gradle
@@ -101,9 +101,7 @@ allprojects {
         }
 
         [uploadArchives, install]*.with {
-            // dependency on jarAllAll should in theory be replaced with jar, jarWithIndy
but
-            // in practice, it is faster
-            dependsOn([jarAllAll, sourceJar, javadocJar, groovydocJar])
+            dependsOn([jar, jarWithIndy, sourceJar, javadocJar, groovydocJar])
             doFirst {
                 if (rootProject.useIndy()) {
                     new GradleException('You cannot use uploadArchives or install task with
the flag [indy] turned'
@@ -145,24 +143,11 @@ allprojects {
 // we don't want them in the root project so add them as artifacts with a modified name
 // we'll exclude the original artifacts during publication with an exclude pattern
 [uploadArchives, install]*.with {
-    dependsOn([sourceAllJar, javadocAllJar, groovydocAllJar, distBin, distDoc, dist, distBin])
+    dependsOn([sourceJar, javadocJar, groovydocJar, distBin, distDoc, dist, distBin])
     doFirst {
-        project.artifacts.add('archives', jarAll) {
-            name = 'groovy-all'
-        }
-        project.artifacts.add('archives', sourceAllJar) {
-            name = 'groovy-all'
-        }
-        project.artifacts.add('archives', javadocAllJar) {
-            name = 'groovy-all'
-        }
-        project.artifacts.add('archives', groovydocAllJar) {
-            name = 'groovy-all'
-        }
         project.artifacts.add('archives', distBin) {
             name = 'groovy-binary'
         }
-        signArchiveTask(jarAll)
         signArchiveTask(sourceAllJar)
         signArchiveTask(javadocAllJar)
         signArchiveTask(groovydocAllJar)
@@ -202,17 +187,6 @@ allprojects {
                 }
             }
         }
-
-        def indyJar = deriveFile(jarAll.archivePath, 'indy')
-        if (indyJar.exists()) {
-            project.artifacts.add('archives', indyJar)
-            signWithClassifier('indy', indyJar)
-        }
-        def grooidJar = deriveFile(jarAll.archivePath, 'grooid')
-        if (grooidJar.exists()) {
-            project.artifacts.add('archives', grooidJar)
-            signWithClassifier('grooid', grooidJar)
-        }
     }
 }
 
@@ -237,10 +211,6 @@ ext.pomAll = {
     // regular pom
     def groovypom = pom('groovy', pomConfigureClosure)
 
-    // pom for 'all'
-    def allpom = pom('all', pomConfigureClosure)
-    allpom.artifactId = 'groovy-all'
-
     // pom for binary zip
     def binarypom = pom('binary', pomConfigureClosureWithoutTweaks)
     binarypom.artifactId = 'groovy-binary'
@@ -255,20 +225,7 @@ ext.pomAll = {
         }
     }
 
-    modules().each { sp ->
-        sp.install.repositories.mavenInstaller.pom.whenConfigured { subpom ->
-            // add dependencies of other modules
-            allpom.dependencies.addAll(subpom.dependencies)
-        }
-        sp.uploadArchives.repositories.mavenDeployer.pom.whenConfigured { subpom ->
-            // add dependencies of other modules
-            allpom.dependencies.addAll(subpom.dependencies)
-        }
-    }
-
-
     groovypom.whenConfigured(removeJarjaredDependencies)
-    allpom.whenConfigured(removeJarjaredDependencies)
 
     binarypom.whenConfigured { p ->
         p.dependencies.clear()

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/src/main/org/codehaus/groovy/tools/DgmConverter.java
----------------------------------------------------------------------
diff --git a/src/main/org/codehaus/groovy/tools/DgmConverter.java b/src/main/org/codehaus/groovy/tools/DgmConverter.java
index 0965c92..ba714bb 100644
--- a/src/main/org/codehaus/groovy/tools/DgmConverter.java
+++ b/src/main/org/codehaus/groovy/tools/DgmConverter.java
@@ -29,6 +29,7 @@ import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
+import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -92,7 +93,9 @@ public class DgmConverter implements Opcodes {
             cw.visitEnd();
 
             final byte[] bytes = cw.toByteArray();
-            final FileOutputStream fileOutputStream = new FileOutputStream(targetDirectory
+ className + ".class");
+            File targetFile = new File(targetDirectory + className + ".class").getCanonicalFile();
+            targetFile.getParentFile().mkdirs();
+            final FileOutputStream fileOutputStream = new FileOutputStream(targetFile);
             fileOutputStream.write(bytes);
             fileOutputStream.flush();
             fileOutputStream.close();

http://git-wip-us.apache.org/repos/asf/groovy/blob/17ff9823/subprojects/performance/build.gradle
----------------------------------------------------------------------
diff --git a/subprojects/performance/build.gradle b/subprojects/performance/build.gradle
index 118ddb0..b0b7e1f 100644
--- a/subprojects/performance/build.gradle
+++ b/subprojects/performance/build.gradle
@@ -36,7 +36,7 @@ task performanceTests {
     ext.outputDir = file("$buildDir/compilation")
     ext.dataFile = file("$buildDir/compilation-stats.csv")
 
-    dependsOn rootProject.jarAll
+    dependsOn rootProject.jar
     doLast {
         ext.outputDir.deleteDir()
         def versions = []
@@ -65,7 +65,7 @@ task performanceTests {
         dependsOn compileTestJava
         def groovyConf = configurations.detachedConfiguration(
                 dependencies.create(
-                        'current' == version ? files(rootProject.jarAll.archivePath) : "org.codehaus.groovy:groovy-all:$version")
+                        'current' == version ? files(rootProject.jar.archivePath) : "org.codehaus.groovy:groovy:$version")
         )
         groovyConf.transitive = false
         main = 'org.apache.groovy.perf.CompilerPerformanceTest'


Mime
View raw message