build.gradle

/*
   Jason Gradle build file

*/

plugins {
  id "ca.coglinc.javacc" version "2.3.1"
  // see https://github.com/johnmartel/javaccPlugin
}

defaultTasks 'jar'

apply plugin: 'java'
//apply plugin: 'eclipse'
apply plugin: 'maven'
apply plugin: 'maven-publish'
apply plugin: 'signing'

version '3.0'
group   'org.jason'

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(15)
    }
}

/*compileJava {
    options.compilerArgs += ['--enable-preview']
}
tasks.withType(Test).all {
    jvmArgs += '--enable-preview'
}
tasks.withType(JavaCompile).all {
    options.compilerArgs += ['--enable-preview']
}
tasks.withType(JavaExec) {
    jvmArgs += '--enable-preview'
}
javadoc.options {
    addBooleanOption('-enable-preview', true)
    addStringOption('-release', '15')
}
*/

/*compileJava {
    sourceCompatibility = JavaVersion.VERSION_1_15
    targetCompatibility = JavaVersion.VERSION_1_15
}*/


repositories {
    mavenCentral()

    maven { url "https://raw.github.com/jacamo-lang/mvn-repo/master" }
    //maven { url "http://jacamo.sourceforge.net/maven2"  }
    //maven { url "http://jade.tilab.com/maven"  //}
    flatDir {
       dirs 'jedit', 'demos/persistent-belief-base/lib'
    }
}

/*configurations {
    umljavadoc  // see http://www.umlgraph.org/doc/indexw.html
}*/


dependencies {
    compile group: 'net.sf.ingenias', name: 'jade', version: '4.3'
    //compile group: 'com.tilab.jade', name: 'jade', version: '4.4.0'

    //compile group: 'org.jacamo',     name: 'cartago', version: '2.5'
    //compile group: 'org.jacamo',     name: 'jaca',    version: '2.5'

    // from jEdit
    compile fileTree(dir: 'jedit', include: '*.jar') // using fileTree, jedit jars are not included as a dependency in the pom file

    runtime group: 'org.apache.ant',  name: 'ant',  version: '1.10.5'

    compile group: 'javax.json', name: 'javax.json-api', version: '1.1.4'
    compile group: 'org.glassfish', name: 'javax.json', version: '1.1.4'

    testImplementation group: 'junit', name: 'junit', version: '4.12'
    testImplementation name: 'hsqldb'

    //umljavadoc 'org.umlgraph:umlgraph:5.6'
}

// copy dep jars and scritps into build directory
task copyJarsToBuild {
    inputs.files configurations.runtime.files
    inputs.dir   'scripts'
    outputs.dir  'build/libs'
    outputs.dir  'build/scripts'
    doLast {
        copy {
            from configurations.runtime
            into 'build/libs'
        }
        copy {
            from 'scripts'
            into 'build/scripts'
            include '**'
            filter {
                String line -> line.replaceAll("JasonREL=[0-9]+\\.[0-9]+", "JasonREL="+project.version)
            }
            filter {
                String line -> line.replaceAll("JadeJar", file(project.configurations.compile.find { it.name.startsWith("jade-") }).name)
            }
        }
    }
}

jar {
    baseName 'jason'
    manifest {
        attributes 'Main-Class': 'jason.util.ConfigGUI',
                   'Specification-Title': 'Jason Language',
                   'Specification-Version': project.version,
                   'Implementation-Version': new Date().toString()
    }
    from('src') {
        include '/test/jason/inc/**/*.asl'
        include '/test/jason/**/*.mas2j'
    }
    /*doFirst {
        Properties props = new Properties()
        props.put('version', '')
        props.put('release', project.version)
        props.store(new File(project.buildDir.absolutePath +'/classes/main/dist.properties').newWriter(), null)
    }*/
}
jar.dependsOn(copyJarsToBuild)

task jarCore(type: Jar, dependsOn: 'classes') {
    baseName 'jason-core'
    from 'build/classes/main'
    from 'build/resources/main'

    exclude '**/MindInspectorAgArch*'
    exclude '**/MindInspectorWebImpl*'
    exclude 'jason/environment/grid/**/*'
    exclude 'jason/jeditplugin/**/*'
    exclude 'jason/runtime/MASConsole*'
    exclude 'jason/runtime/OutputStreamAdapter*'
    exclude 'jason/util/ConfigGUI*'
    exclude 'jason/util/CheckVersion*'
    exclude 'jason/control/ExecutionControlGUI*'
    exclude 'jason/infra/local/*GUI*'
    exclude 'jason/infra/jade/Run*'
    exclude 'jason/infra/repl/**/*'
}

clean {
    delete 'bin'
    delete 'doc/api'
    delete 'doc/faq.html'
    delete 'doc/index.html'
    delete 'doc/readme.html'
    delete 'readme.html'
    delete 'release-notes.html'

    delete fileTree('doc/tutorials')  { include '**/*.html'  }
    delete fileTree('doc/tutorials')  { include '**/bin/**/*'  }

    delete fileTree('.')  { include '**/*~'  }
    delete fileTree('.')  { include '**/.stop___MAS'  }
    delete fileTree('.')  { include '**/APDescription.txt'  }
    delete fileTree('.')  { include '**/MTPs-Main-Container.txt'  }

    delete fileTree('examples')  { include '**/bin/**'  }
    delete fileTree('examples')  { include '**/*.log'  }
    delete fileTree('demos')  { include '**/bin/**'  }
    delete fileTree('demos')  { include '**/*.log'  }
    delete 'demos/persistent-belief-base/a.bb'

    def emptyDirs = []

    fileTree (dir: 'examples').visit {
        def File f = it.file
        if (f.isDirectory() ) {
            def children = project.fileTree(f).filter { it.isFile() }.files
            if (children.size() == 0) {
                emptyDirs << f
            }
        }
    }
    fileTree (dir: 'demos').visit {
        def File f = it.file
        if (f.isDirectory() ) {
            def children = project.fileTree(f).filter { it.isFile() }.files
            if (children.size() == 0) {
                emptyDirs << f
            }
        }
    }
    emptyDirs.reverseEach { it.delete() }
}

task config (type: JavaExec, dependsOn: ['jar', 'plugin']) {
    main = 'jason.util.Config'
    classpath project.buildDir.absolutePath + '/libs/jason-' +project.version+'.jar'
    workingDir project.buildDir.absolutePath + '/libs'

    doFirst {
        delete System.getProperty("user.home")+'/.jason'
    }

    doLast {
        println '------'
        println ''
        println 'you can set the Jason home directory with the following command:'
        println '     export JASON_HOME='+project.buildDir.absolutePath
        println ''
        println 'and also change your PATH with:'
        println '     export PATH=$JASON_HOME/scripts:$PATH'
        println ''
        println '-----'
    }
}

/*
eclipse {
    classpath {
        downloadJavadoc = true
        file.whenMerged { cp ->
            cp.entries.add( new org.gradle.plugins.ide.eclipse.model.SourceFolder('build/generated/javacc', null) )
        }
        file.whenMerged { cp ->
            logger.lifecycle "Removing duplicate classpath entries from eclipse for project '${project.name}'"

            Map entryByPath = cp.entries.groupBy { entry -> entry.path }
            entryByPath.each { key, values ->
              if (values.size() > 1) {
                def entry = values.first()
                if (entry.kind == 'src') {
                  entry.includes = []
                  entry.excludes = []
                }
                int index = cp.entries.indexOf entry
                logger.lifecycle "Removing ${values.collect { it.path }}"
                cp.entries.removeAll values
                logger.lifecycle "Adding ${entry.path}"
                cp.entries.add index, entry
              }
            }
       }
    }
}
*/

javadoc {
    options.showAll()
    options.encoding('UTF-8')
    options.setUse(true)
    options.author(true)
    options.version(true)
    options.windowTitle('Jason API')
    options.docTitle('Jason API')
    options.footer('<a href=http://jason.sf.net>Jason Site</a>')
    destinationDir = file("${buildDir}/../doc/api")
    doFirst {
        javadoc.title = 'Jason API'
        javadoc.options.docTitle = javadoc.title
    }
}

// the following lines is used to avoid errors while generating javadoc
if (JavaVersion.current().isJava8Compatible()) {
    allprojects {
      tasks.withType(Javadoc) {
        options.addStringOption('Xdoclint:none', '-quiet')
      }
    }
}


/*
task javadoc(overwrite: true, dependsOn: compileJava) {
    setDescription('Generates Javadoc API documentation with UMLGraph diagrams')
    setGroup(JavaBasePlugin.DOCUMENTATION_GROUP)

    doLast {
        ant.javadoc(classpath: (configurations.runtime + configurations.compile).asPath,
                    sourcepath: file('src/main/java'),
                    packagenames: '*',
                    destdir: "${docsDir}/../../doc/api",
                    private: 'true' ,
                    docletpath: configurations.umljavadoc.asPath) {
            doclet(name: 'org.umlgraph.doclet.UmlGraphDoc') {
                //param(name: '-inferrel')
                //param(name: '-inferdep')
                param(name: '-qualify')
                //param(name: '-T', value: 'svg')
                param(name: '-postfixpackage')
                param(name: '-hide', value: 'java.*')
                //param(name: '-collpackages', value: 'java.util.*')
                //param(name: '-nodefontsize', value: '9')
                //param(name: '-nodefontpackagesize', value: '7')
                //param(name: '-link', value: 'http://java.sun.com/j2se/1.5.0/docs/guide/javadoc/doclet/spec')
                //param(name: '-link', value: 'http://java.sun.com/j2se/1.5/docs/api')
            }
        }
    }
}
*/

task javadocJar (type: Jar, dependsOn: javadoc) {
    baseName 'jason'
    classifier = 'javadoc'
    from '${docsDir}/../../doc/api'
}

task sourceJar (type : Jar) {
    baseName 'jason'
    classifier = 'sources'
    from sourceSets.main.allSource
}

artifacts {
    archives sourceJar, javadocJar
}


publishing {
    publications {
        maven(MavenPublication) {
            from components.java
			      artifact sourceJar
			      artifact javadocJar
            artifactId 'jason'
        }
    }
}

// from http://central.sonatype.org/pages/gradle.html

// see http://central.sonatype.org/pages/releasing-the-deployment.html
// comment cartago and jaca dependencies
// check gradle.properties for
//    signing.keyId=
//    signing.password=
//    signing.secretKeyRingFile=
//    ossrhUsername=
//    ossrhPassword=
//
// run gradle uploadArchives
// login https://oss.sonatype.org/
// select Staging Repositories
// search jason, close, refresh, release

// uncomment to produce maven jar

/*
signing {
    sign configurations.archives
}

uploadArchives {
    group = 'net.sf.jason'
    repositories {
        mavenDeployer {

            beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

            repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                authentication(userName: ossrhUsername, password: ossrhPassword)
            }

            snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                authentication(userName: ossrhUsername, password: ossrhPassword)
            }

            pom*.whenConfigured { pom -> pom.dependencies.clear() }

            pom.project {
                name 'Jason'
                packaging 'jar'
                groupId 'net.sf.jason'

                // optionally artifactId can be defined here
                description 'Jason is a fully-fledged interpreter for an extended version of AgentSpeak, a BDI agent-oriented logic programming language.'
                url 'http://jason.sf.net'

                scm {
                    connection 'scm:git:https://github.com/jason-lang/jason.git'
                    developerConnection 'scm:git:https://github.com/jason-lang/jason.git'
                    url 'https://github.com/jason-lang/jason.git'
                }

                licenses {
                    license {
                        name 'GNU Library or Lesser General Public License version 2.0 (LGPLv2)'
                        url 'http://www.gnu.org/licenses/gpl-2.0.html'
                    }
                }
                developers {
                    developer {
                        id 'jomi'
                        name 'Jomi F.  Hubner'
                        email 'jomifred@gmail.com'
                    }
                    developer {
                        id 'rafael'
                        name 'Rafael H. Bordini'
                        email 'rafael.h.bordini@gmail.com'
                    }
                }
            }
        }
    }
}
*/

compileJavacc {
    inputDirectory = file('src/main/javacc')
    outputDirectory = file(project.buildDir.absolutePath + '/generated/javacc')
}


jjdoc {
    outputDirectory = file(project.projectDir.absolutePath + '/doc/tech')
    //arguments = [text: 'true']
}

// Builds jEdit plugin
task plugin(type: Jar, dependsOn: 'jar') {
    archiveName 'jason-jedit-plugin.jar'
    destinationDir file('build/jedit/jars')
    from 'build/classes/java/main'
    from 'build/resources/main'
    from 'build/resources/main/jeditPlugin'
    manifest {
        attributes 'Main-Class': 'jason.util.ConfigGUI',
                   'Specification-Title': 'Jason Language',
                   'Specification-Version': project.version,
                   'Implementation-Version': new Date().toString()
    }

    from ( configurations.compile.collect { zipTree(it) } ) {
        include 'jade/**/*.class'
    }


    doFirst {
        ant.untar(compression: 'gzip', dest: 'build', src: 'jedit/jedit.tgz')
    }

    doLast {
        copy {
            from 'src/main/resources/jeditPlugin'
            into 'build/jedit/modes'
            include 'agentSpeak.xml', 'jasonProject.xml', 'catalog'
        }
        copy {
            from 'src/main/resources/jeditPlugin'
            into 'build/jedit/properties'
            include 'jedit-initial.props'
        }
    }
}


// transfer local maven artifact to our maven2 repository at sourceforge
/*task publishMavenSF(dependsOn: [ 'build', 'publishToMavenLocal']) {
  doLast {
    def wdir = System.getProperty("user.home")+'/.m2/repository/org/jason/jason'
    def tdir = System.getenv('USERSF')+',jacamo@web.sf.net:/home/project-web/jacamo/htdocs/maven2/org/jason/jason'
    exec {
        commandLine 'scp', '-r', project.version, tdir
        workingDir wdir
    }
    exec {
        commandLine 'cp', 'maven-metadata-local.xml', 'maven-metadata.xml'
        workingDir wdir
    }
    exec {
        commandLine 'scp', 'maven-metadata.xml', tdir
        workingDir wdir
    }
  }
}*/

task publishMavenGitHub(dependsOn: [ 'build', 'publishToMavenLocal']) {
  doLast {
    def wdir = System.getProperty("user.home")+'/.m2/repository/org/jason/jason'
    def rdir = '../jacamo-mvn-repo'
    exec {
        commandLine 'git', 'pull'
        workingDir rdir
    }
    copy {
        from wdir
        into rdir + '/org/jason/jason'
    }
    exec {
        commandLine 'git', 'add', '*'
        workingDir rdir
    }
    exec {
        commandLine 'git', 'commit', '-a', '-m', 'new version of jason '+project.version
        workingDir rdir
    }
    exec {
        commandLine 'git', 'push'
        workingDir rdir
    }
  }
}


// Builds the distribution, documentation and a new release
task doc(dependsOn: [ 'jjdoc', 'javadoc', 'renderAsciiDocs']) {
}

task renderAsciiDocs(type: Exec) {
    commandLine 'find', '.', '-name', '*.adoc', '-exec', 'scripts/asciidoc-docker', '{}', ';'
    //commandLine 'find', '.', '-name', '*.adoc', '-exec', 'asciidoctor', '{}', ';'
}

task fixTab {
    ant.fixcrlf(eol: 'lf',  includes: '**/*.txt,**/*.bat, **/*.adoc', srcdir: '.')
    ant.fixcrlf(tab: 'remove', tablength: '4', javafiles: 'true', includes: '**/*.java,**/*.xml,**/*.asl,**/*.mas2j,**/*.txt', srcdir: 'src')
    ant.fixcrlf(tab: 'remove', tablength: '4', javafiles: 'true', includes: '**/*.java,**/*.xml,**/*.asl,**/*.mas2j,**/*.txt', srcdir: 'examples')
    ant.fixcrlf(tab: 'remove', tablength: '4', javafiles: 'true', includes: '**/*.java,**/*.xml,**/*.asl,**/*.mas2j,**/*.txt', srcdir: 'demos')
    ant.fixcrlf(tab: 'remove', tablength: '4', javafiles: 'true', includes: '**/*.java,**/*.xml,**/*.asl,**/*.mas2j,**/*.txt', srcdir: 'doc')
    ant.fixcrlf(tab: 'remove', tablength: '4', javafiles: 'true', includes: '*.gradle', srcdir: '.')
}

// Builds the distribution, documentation and a new release
task release(dependsOn: [ 'build', 'doc', 'fixTab', 'plugin', 'zipRel' ]) {
}

// copy files used to build a release
task copyRel (dependsOn: ['plugin', 'jar']) {
  doLast {
    copy {
        from '.'
        into 'build/jason-'+project.version
        include '*.html'
        include 'LICENSE'
        include 'doc/**'
    }
    delete fileTree('build/jason-'+project.version+'/doc')  { include '**/*.adoc', '**/Makefile'  }

    copy {
        from 'build/scripts'
        into 'build/jason-'+project.version+'/scripts'
    }
    copy {
        from libsDir
        from configurations.runtime
        into 'build/jason-'+project.version+'/'+libsDirName
        include '**/*.jar'
    }
    copy {
        from 'build/jedit'
        into 'build/jason-'+project.version+'/jedit'
    }
    copy {
        from 'examples'
        into 'build/jason-'+project.version+'/examples'
    }
    copy {
        from 'demos'
        into 'build/jason-'+project.version+'/demos'
    }
    copy {
        from 'src'
        into 'build/jason-'+project.version+'/src'
    }
  }
}

// creates a zip file for a release
task zipRel(type: Zip, dependsOn: copyRel) {
    from 'build/jason-'+project.version
    baseName 'jason'
}

/**
 * Gradle task to execute unit tests for Jason agents
 * To run this script in a virtual machine to simulate a CI environment type:
 * $ docker volume create --name gradle-cache
 * $ docker run -ti --rm -u gradle -v gradle-cache:/home/gradle/.gradle -v "$PWD":/home/gradle/project -w /home/gradle/project -p 8000:8000 gradle:6.3.0-jdk11 bash -c "./gradlew config test -i"
 */
task testJason(dependsOn: 'config') {
    description 'runs Jason unit tests: tests.mas2j'
    def errorOnTests = false
    outputs.upToDateWhen { false } // disable cache

    doFirst {
        try {
            javaexec {
                jvmArgs += '--enable-preview'
                main = 'jason.infra.local.RunLocalMAS'
                if (gradle.startParameter.logLevel.toString().equals("DEBUG")) {
                    args = ['src/test/jason/unit_tests.mas2j', '--log-conf', 'src/main/resources/templates/console-debug-logging.properties']
                } else if (gradle.startParameter.logLevel.toString().equals("INFO")) {
                    args = ['src/test/jason/unit_tests.mas2j', '--log-conf', 'src/main/resources/templates/console-info-logging.properties']
                } else {
                    args = ['src/test/jason/unit_tests.mas2j', '--log-conf', 'src/main/resources/templates/console-lifecycle-logging.properties']
                }
                classpath sourceSets.main.runtimeClasspath
                sourceSets.test.java.srcDirs += ['src/test/jason/jia']

                errorOutput = new ByteArrayOutputStream()
                standardOutput = new ByteArrayOutputStream()

                ext.stdout = {
                    return standardOutput.toString()
                }
                ext.errout = {
                    return errorOutput.toString()
                }
            }
        } catch (Exception e) {
            errorOnTests = true
        }
    }

    doLast {
        def styler = 'black red green yellow blue magenta cyan white'
            .split().toList().withIndex(30)
            .collectEntries { key, val -> [(key) : { "\033[${val}m${it}\033[0m" }] }

        def std = stdout()
        std.splitEachLine('\n') { String line ->
            line = line.replace("TESTING","${styler['yellow']('TESTING')}")
            line = line.replace("PASSED","${styler['green']('PASSED')}")
            line = line.replace("FAILED","${styler['red']('FAILED')}")
            line = line.replace("TODO","${styler['magenta']('TODO')}")
            line = line.replace("LAUNCHING","${styler['blue']('LAUNCHING')}")
            println line
        }

        def err = errout()
        err.splitEachLine('\n') { String line ->
            line = line.replace("TESTING","${styler['yellow']('TESTING')}")
            line = line.replace("PASSED","${styler['green']('PASSED')}")
            line = line.replace("FAILED","${styler['red']('FAILED')}")
            line = line.replace("TODO","${styler['magenta']('TODO')}")
            line = line.replace("LAUNCHING","${styler['blue']('LAUNCHING')}")
            println line
        }

        if (errorOnTests) {
            throw new GradleException('Jason unit tests: ERROR!')
        }
    }
}
tasks.build.finalizedBy testJason