jmonkeyengine/sdk/build.gradle

//ant.importBuild 'build.xml'
import groovy.xml.MarkupBuilder
import java.util.zip.ZipFile

if (!hasProperty('mainClass')) {
    ext.mainClass = ''
}

configurations {
    corelibs
    optlibs
    testdatalibs
}

dependencies {
    corelibs project(':jme3-blender')
    corelibs project(':jme3-core')
    corelibs project(':jme3-desktop')
    corelibs project(':jme3-effects')
    corelibs project(':jme3-jbullet')
    corelibs project(':jme3-jogg')
    corelibs project(':jme3-lwjgl')
    corelibs project(':jme3-networking')
    corelibs project(':jme3-niftygui')
    corelibs project(':jme3-plugins')
    corelibs project(':jme3-terrain')
    
    testdatalibs project(':jme3-testdata')

    optlibs project(':jme3-bullet')
    optlibs project(':jme3-jogl')
    
}

//task copyToLib << {
//    configurations.opt.resolvedConfiguration.resolvedArtifacts.each { artifact ->
//        copy {
//            from artifact.file
//            into '../dist/opt'
//            if(artifact.classifier != null){
//                rename { "${artifact.name}-${artifact.classifier}.${artifact.extension}" }
//            } else{
//                rename { "${artifact.name}.${artifact.extension}" }
//            }
//        }  
//    }
//}

//build.dependsOn copyToLib

artifacts {
    //    jar null
}

//    <taskdef resource="net/sf/antcontrib/antcontrib.properties" classpathref="ant-import.classpath"/>
//    <taskdef resource="com/jme/ant/ant-jme.properties" classpathref="ant-import.classpath"/>
//    <taskdef name="deb" classname="com.googlecode.ant_deb_task.Deb" classpathref="ant-import.classpath"/>
//    <taskdef name="gcupload" classname="net.bluecow.googlecode.ant.GoogleCodeUploadTask" classpathref="ant-import.classpath"/>
//    <taskdef name="desktopentry" classname="com.googlecode.ant_deb_task.DesktopEntry" classpathref="ant-import.classpath"/>

//configurations {
//    antlibs
//}

//dependencies {
//    antlibs filetree(dir: 'ant-lib', include: '*.jar')
//}
//
//ant.taskdef(resource: 'net/sf/antcontrib/antcontrib.properties', classpath: configurations.antlibs.asPath)
//ant.taskdef(name: 'deb', classname: 'com.googlecode.ant_deb_task.Deb', classpath: configurations.antlibs.asPath)
//ant.taskdef(name: 'gcupload', classname: 'net.bluecow.googlecode.ant.GoogleCodeUploadTask', classpath: configurations.antlibs.asPath)
//ant.taskdef(name: 'desktopentry', classname: 'com.googlecode.ant_deb_task.DesktopEntry', classpath: configurations.antlibs.asPath)
//ant.importBuild 'build.xml'

ant.properties['plugins.version'] = jmeVersion
ant.properties['app.version']= jmeMainVersion + jmeVersionSuffix
//ant.properties.buildDir = buildDir
//ant.properties['buildDir'] = buildDir
//ant.property(name: 'buildDir', location: buildDir)

//ant.taskdef(resource: 'checkstyletask.properties') {
//    classpath {
//        fileset(dir: 'ant-lib', includes: '*.jar')
//    }
//}
//ant.checkstyle(config: 'checkstyle.xml') {
//    fileset(dir: 'src')
//}

//task copyFiles(type: Copy) {
//    from 'src/files'
//    into "$buildDir/files"
//    rename '(.*)-(.*).html', '$2/$1.html'
//    rename ~/(.*).template.(.*)/, '$1.$2'
//    rename { filename ->
//        filename.replace 'java', 'groovy'
//    }
//}
//task copyTaskWithPatterns(type: Copy) {
//    from 'src/main/webapp'
//    into 'build/explodedWar'
//    include '**/*.html'
//    include '**/*.jsp'
//    exclude { details -> details.file.name.endsWith('.html') && details.file.text.contains('staging') }
//}
task copyBaseLibs{
    description "Copies the library files needed to run the SDK to "+
                "jme3-core-baselibs and jme3-core-libraries"
    dependsOn configurations.corelibs
    dependsOn configurations.optlibs
    
    // for each dependency in corelibs..
    project.configurations.corelibs.dependencies.each {dep ->
        // copy built jme3 jar files to jme3-core-baselibs
        dep.dependencyProject.configurations.archives.allArtifacts.each{ artifact->
            if(artifact.classifier == "sources"){
            } else if(artifact.classifier == "javadoc"){
            } else{
                copy {
                    from artifact.file
                    into "jme3-core-baselibs/release/modules/ext/"
                }
            }
        }
        // copy external jar files to jme3-core-libraries
        copy {
            from dep.dependencyProject.configurations.compile.copyRecursive({ !(it instanceof ProjectDependency); }).resolve()
            into "jme3-core-libraries/release/modules/ext/"
        }
    }
}

task createBaseXml{
    description "Creates the project.xml files for "+
                "jme3-core-baselibs and jme3-core-libraries"
    def depJars = [] // jme3 jar files
    def depExtJars = [] // external jar files
    
    // collect jar files
    project.configurations.corelibs.dependencies.each {dep ->
        // collect external jar files
        dep.dependencyProject.configurations.compile.copyRecursive({ !(it instanceof ProjectDependency); }).resolve().each{ file->
            depExtJars.add(file)
        }
        // collect internal jar files (classes, sources and javadoc)
        dep.dependencyProject.configurations.archives.allArtifacts.each{ artifact->
            if(artifact.classifier == "sources"){
            } else if(artifact.classifier == "javadoc"){
            } else{
                if(!depJars.contains(artifact.file)){
                    depJars.add(artifact.file)
                }
            }
        }
    }

    // collect base packages
    def packages = []
    depJars.each{jarFile ->
        ZipFile file = new ZipFile(jarFile)
        file.entries().each { entry ->  
            if(entry.name.endsWith('.class')){
                // TODO: "/" works on windows?
                def pathPart = entry.name.substring(0,entry.name.lastIndexOf('/'))
                def classPath = pathPart.replace('/','.');
                if(!packages.contains(classPath)){
                    packages.add(classPath)
                }
            }
        } 
    }
    
    // collect library packages
    def extPackages = []
    depExtJars.each{jarFile ->
        ZipFile file = new ZipFile(jarFile)
        file.entries().each { entry ->  
            if(entry.name.endsWith('.class')){
                // TODO: "/" works on windows?
                def pathPart = entry.name.substring(0,entry.name.lastIndexOf('/'))
                def classPath = pathPart.replace('/','.');
                if(!extPackages.contains(classPath)){
                    extPackages.add(classPath)
                }
            }
        } 
    }
    
    def writer = new StringWriter()
    def xml = new MarkupBuilder(writer)
    xml.mkp.xmlDeclaration(version:'1.0')
    xml.project(xmlns:"http://www.netbeans.org/ns/project/1"){
        type "org.netbeans.modules.apisupport.project"
        configuration {
            data(xmlns:"http://www.netbeans.org/ns/nb-module-project/3") {
                "code-name-base" "com.jme3.gde.core.baselibs"
                "suite-component"{}
                "module-dependencies"{
                    dependency{
                        "code-name-base" "com.jme3.gde.core.libraries"
                        "build-prerequisite"{}
                        "compile-dependency"{}
                        "run-dependency"{
                            "release-version" "1"
                            "specification-version" "3.0.0"
                        }
                    }
                }
                "public-packages"{
                    packages.each{
                        "package" it
                    }
                }
                depJars.each{jarFile ->
                    "class-path-extension"{
                        "runtime-relative-path" "ext/${jarFile.name}"
                        "binary-origin" "release/modules/ext/${jarFile.name}"
                    }
                }
            }
        }
    }
    // write XML file
    File baselibsProjectFile = file("jme3-core-baselibs/nbproject/project.xml");
    baselibsProjectFile.write(writer.toString())

    def extWriter = new StringWriter()
    def extXml = new MarkupBuilder(extWriter)
//    extXml.mkp.xmlDeclaration(version:'1.0')
    extXml.project(xmlns:"http://www.netbeans.org/ns/project/1"){
        type "org.netbeans.modules.apisupport.project"
        configuration {
            data(xmlns:"http://www.netbeans.org/ns/nb-module-project/3") {
                "code-name-base" "com.jme3.gde.core.libraries"
                "suite-component"{}
                "module-dependencies"{}
                "public-packages"{
                    extPackages.each{
                        "package" it
                    }
                }
                depExtJars.each{jarFile ->
                    "class-path-extension"{
                        "runtime-relative-path" "ext/${jarFile.name}"
                        "binary-origin" "release/modules/ext/${jarFile.name}"
                    }
                }
            }
        }
    }
    // write XML file
    File librariesProjectFile = file("jme3-core-libraries/nbproject/project.xml");
    librariesProjectFile.write(extWriter.toString())
}

// workaround method to add a tag with the name "name" and "file" to an XML MarkupBuilder
def makeName(builder, nameR) { builder.name nameR }
def makeFile(builder, nameR) { builder.file(name:nameR, url:nameR) }

task createProjectXml{
    description "Creates needed J2SE library and layer XML files in jme3-project-baselibs"
    
    def eol = System.properties.'line.separator' 
    def j2seLibraries = [] // created J2SE library descriptors
    
    // for each dependency in corelibs..
    project.configurations.corelibs.dependencies.each {dep ->
        def depJars = [] // jme3 jar files
        def depSources = [] // jme3 sources
        def depJavadocs = [] // jme3 javadoc
        def depExtJars = [] // external jar files
        j2seLibraries.add(dep.dependencyProject.name+".xml")
        // collect external jar files
        dep.dependencyProject.configurations.compile.copyRecursive({ !(it instanceof ProjectDependency); }).resolve().each{ file->
            depExtJars.add(file.name)
        }
        // collect internal jar files (classes, sources and javadoc)
        dep.dependencyProject.configurations.archives.allArtifacts.each{ artifact->
            if(artifact.classifier == "sources"){
                depSources.add(artifact.file.name)
            } else if(artifact.classifier == "javadoc"){
                depJavadocs.add(artifact.file.name)
            } else{
                if(!depJars.contains(artifact.file.name)){
                    depJars.add(artifact.file.name)
                }
            }
        }
        // create J2SE library descriptor xml file
        def libraryWriter = new StringWriter()
        def libraryXml = new MarkupBuilder(libraryWriter)
//        xml.mkp.xmlDeclaration(version:'1.0')
        libraryWriter << '<?xml version="1.0" encoding="UTF-8"?>' << eol 
        libraryWriter << '<!DOCTYPE library PUBLIC "-//NetBeans//DTD Library Declaration 1.0//EN" "http://www.netbeans.org/dtds/library-declaration-1_0.dtd">' << eol
        libraryXml.library(version:"1.0", encoding: "UTF-8"){
            makeName(libraryXml, "${dep.dependencyProject.name}.xml")
            type "j2se"
            "localizing-bundle" "com.jme3.gde.project.baselibs.Bundle"
            volume{
                type "classpath"
                depJars.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/${jar}!/"
                }
                depExtJars.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.libraries/libs/${jar}!/"
                }
            }
            volume{
                type "src"
                depSources.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/${jar}!/"
                }
            }
            volume{
                type "javadoc"
                depJavadocs.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/${jar}!/"
                }
            }
        }
        // write XML file
        File libraryXmlFile = file("jme3-project-baselibs/src/com/jme3/gde/project/baselibs/${dep.dependencyProject.name}.xml");
        libraryXmlFile.write(libraryWriter.toString())
    }

    // create layer.xml file with entries of library xml files
    def layerWriter = new StringWriter()
    def layerXml = new MarkupBuilder(layerWriter)
//    layerXml.mkp.xmlDeclaration(version:'1.0')
    layerWriter << '<?xml version="1.0" encoding="UTF-8"?>' << eol 
    layerWriter << '<!DOCTYPE filesystem PUBLIC "-//NetBeans//DTD Filesystem 1.1//EN" "http://www.netbeans.org/dtds/filesystem-1_1.dtd">' << eol
    layerXml.filesystem{
        folder(name:"org-netbeans-api-project-libraries"){
            folder(name:"Libraries"){
                j2seLibraries.each{lib ->
                    makeFile(layerXml, lib)
                }
            }
        }
    }
    File layerXmlFile = file("jme3-project-baselibs/src/com/jme3/gde/project/baselibs/layer.xml");
    layerXmlFile.write(layerWriter.toString())
}

task copyProjectLibs{
    description "Copies the jar files needed to supply the J2SE Libraries in the "+
                "SDK to jme3-project-baselibs and jme3-project-libraries"
    dependsOn configurations.corelibs
    dependsOn configurations.optlibs

    // for each dependency in corelibs..
    project.configurations.corelibs.dependencies.each {dep ->
        // copy jme3 jar files, sources and javadocs to jme3-project-baselibs
        dep.dependencyProject.configurations.archives.allArtifacts.each{ artifact->
            if(artifact.classifier == "sources"){
                copy {
                    from artifact.file
                    into "jme3-project-baselibs/release/libs/"
                }
            } else if(artifact.classifier == "javadoc"){
                copy {
                    from artifact.file
                    into "jme3-project-baselibs/release/libs/"
                }
            } else{
                copy {
                    from artifact.file
                    into "jme3-project-baselibs/release/libs/"
                }
            }
        }
        // copy external jar files to jme3-project-libraries
        copy {
            from dep.dependencyProject.configurations.compile.copyRecursive({ !(it instanceof ProjectDependency); }).resolve()
            into "jme3-project-libraries/release/libs/"
        }
    }

}

task buildSdk(){
    //    ant.ant(dir: ".", antfile: "build.xml", target: "hudson-stable")
}

task cleanSdk(){
    //    ant.ant(dir: ".", antfile: "build.xml", target: "clean")
}

jar.dependsOn([copyBaseLibs, copyProjectLibs, createProjectXml, createBaseXml, buildSdk])
clean.dependsOn(cleanSdk);

//    <target name="-do-update-sdk">
//        <fileset id="jme3-jars" dir="build">
//            <include name="**/jME3**.jar"/>
//            <exclude name="**/jME3-testdata.jar"/>
//            <exclude name="**/jME3-bullet-natives.jar"/>
//            <exclude name="**/jME3-bullet-natives-android.jar"/>
//            <exclude name="**/jME3-openal-soft-natives-android.jar"/>
//        </fileset>
//        <fileset id="jme3-sdk-jars" dir="build">
//            <include name="**/jME3**.jar"/>
//            <exclude name="**/jME3-android.jar"/>
//            <exclude name="**/jME3-testdata.jar"/>
//            <exclude name="**/jME3-bullet.jar"/>
//            <exclude name="**/jME3-bullet-natives.jar"/>
//            <exclude name="**/jME3-bullet-natives-android.jar"/>
//            <exclude name="**/jME3-openal-soft-natives-android.jar"/>
//        </fileset>
//        <fileset id="jme3-bullet-native-jars" dir="${dist.dir}/opt/native-bullet">
//            <include name="**/jME3-bullet-native**.jar"/>
//        </fileset>
//        <fileset id="jme3-openal-soft-natives-jars" dir="${dist.dir}/opt/native-openal-soft">
//            <include name="**/jME3-openal-soft-natives-android.jar"/>
//        </fileset>
//        <fileset id="jme3-testdata-jars" dir="build">
//            <include name="**/jME3-testdata.jar"/>
//        </fileset>
//        <fileset id="jme3-lwjgl-native-jars" dir="${dist.dir}/lib">
//            <include name="**/jME3-lwjgl-natives.jar"/>
//        </fileset>
//        <fileset id="jme3-external-libraries" dir="${dist.dir}/lib/">
//            <exclude name="jME3-**"/>
//            <exclude name="**/nifty-examples.jar"/>
//        </fileset>
//        <echo>Clearing old files</echo>
//        <delete dir="${jmp_dir}/JME3TestsTemplate/src/"/>
//        <delete dir="${jmp_dir}/jme3-core-baselibs/release/modules/ext/"/>
//        <delete dir="${jmp_dir}/jme3-core-libraries/release/modules/ext/"/>
//        <delete dir="${jmp_dir}/jme3-project-libraries/release/libs/"/>
//        <delete dir="${jmp_dir}/jme3-project-baselibs/release/libs/"/>
//        <delete dir="${jmp_dir}/jme3-project-testdata/release/libs/"/>
//
//        <echo>Copying jMonkeyPlatform jME3 libs</echo>
//        <copy toDir="${jmp_dir}/jme3-core-baselibs/release/modules/ext/" overwrite="true" failonerror="true" verbose="false" flatten="true">
//            <fileset refid="jme3-sdk-jars"/>
//            <!--natives need to be in jme3 package for jme to work in jMP-->
//            <fileset refid="jme3-lwjgl-native-jars"/>
//        </copy>
//
//        <echo>Copying jMonkeyPlatform external libraries</echo>
//        <copy todir="${jmp_dir}/jme3-core-libraries/release/modules/ext/" overwrite="true" failonerror="true" verbose="false" flatten="true">
//            <fileset refid="jme3-external-libraries"/>
//        </copy>
//
//        <echo>Copying Project jME3 libs</echo>
//        <copy toDir="${jmp_dir}/jme3-project-baselibs/release/libs/" overwrite="true" failonerror="true" verbose="false" flatten="true">
//            <fileset refid="jme3-jars"/>
//            <fileset refid="jme3-openal-soft-natives-jars"/>
//        </copy>
//
//        <echo>Copying Project external libraries</echo>
//        <copy todir="${jmp_dir}/jme3-project-libraries/release/libs/" overwrite="true" failonerror="true" verbose="false" flatten="true">
//            <fileset refid="jme3-external-libraries"/>
//            <fileset refid="jme3-lwjgl-native-jars"/>
//            <fileset refid="jme3-bullet-native-jars"/>
//        </copy>
//
//        <echo>Copying Test Project Data</echo>
//        <copy toDir="${jmp_dir}/jme3-project-testdata/release/libs/" overwrite="true" failonerror="true" verbose="false">
//            <fileset refid="jme3-testdata-jars"/>
//        </copy>
//
//        <echo>Copying Javadoc</echo>
//        <zip destfile="${dist.dir}/jMonkeyEngine3-javadoc.zip">
//            <zipfileset dir="${dist.dir}/javadoc/"/>
//        </zip>
//        <copy file="${dist.dir}/jMonkeyEngine3-javadoc.zip" toDir="${jmp_dir}/jme3-project-baselibs/release/libs/" overwrite="true" failonerror="true" verbose="false"/>
//
//        <zip destfile="${dist.dir}/jMonkeyEngine3-sources.zip">
//            <zipfileset dir="${src.core.dir}"/>
//            <zipfileset dir="${src.core-data.dir}"/>
//            <zipfileset dir="${src.core-effects.dir}"/>
//            <zipfileset dir="${src.core-plugins.dir}"/>
//            <zipfileset dir="${src.desktop.dir}"/>
//            <zipfileset dir="${src.jbullet.dir}"/>
//            <zipfileset dir="${src.niftygui.dir}"/>
//            <zipfileset dir="${src.jogg.dir}"/>
//            <zipfileset dir="${src.lwjgl.dir}"/>
//            <zipfileset dir="${src.ogre.dir}"/>
//            <zipfileset dir="${src.test.dir}"/>
//            <zipfileset dir="${src.tools.dir}"/>
//            <zipfileset dir="${src.xml.dir}"/>
//            <zipfileset dir="${src.terrain.dir}"/>
//            <zipfileset dir="${src.networking.dir}"/>
//        </zip>
//        <copy file="${dist.dir}/jMonkeyEngine3-sources.zip" toDir="${jmp_dir}/jme3-project-baselibs/release/libs/" overwrite="true" failonerror="true" verbose="false"/>
//
//        <copy todir="${jmp_dir}/jme3-project-libraries/release/libs/" overwrite="true" failonerror="true" verbose="false" flatten="true">
//            <fileset refid="jme3-external-libraries"/>
//            <fileset refid="jme3-lwjgl-native-jars"/>
//            <fileset refid="jme3-bullet-native-jars"/>
//            <fileset refid="jme3-openal-soft-natives-jars"/>
//            <fileset dir="lib/niftygui/">
//                <include name="nifty-javadoc.jar"/>
//                <include name="nifty-default-controls-javadoc.jar"/>
//            </fileset>
//        </copy>
//
//        <echo>Copying Test Examples</echo>
//        <copy todir="${jmp_dir}/JME3TestsTemplate/src/" overwrite="true" failonerror="true" verbose="false">
//            <fileset dir="src/test/">
//                <exclude name=".svn"/>
//            </fileset>
//        </copy>
//        <copy todir="${jmp_dir}/JME3TestsTemplateAndroid/src/" overwrite="true" failonerror="true" verbose="false">
//            <fileset dir="src/test/">
//                <exclude name=".svn"/>
//            </fileset>
//        </copy>
//    </target>