build.gradle

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
import java.util.stream.Collectors
import java.util.zip.ZipFile

String buildAccess = project.getProperties().getOrDefault('buildAccess', 'opensource')
String buildTag = project.getProperties().get('buildTag')
if (buildTag != null && !buildTag.isEmpty() && buildTag != version) {
    throw new GradleException('Version mismatch.')
}
if (buildTag == null || buildTag.isEmpty() || project.getProperties().getOrDefault('artifactoryRepository', '').toLowerCase().contains('snapshot')) {
    version += '-SNAPSHOT'
}
String buildNumber = project.hasProperty('buildNumber') ? project.getProperty('buildNumber') : System.currentTimeSeconds()
String timestamp = DateTimeFormatter.ofPattern("yyyy-MM-dd-HH:mm").format(LocalDateTime.now())
// classpathLibraries as defined in bin/[magicdraw|csm].properties#CLASSPATH
String[] classpathLibraries = ['lib/classpath.jar']
buildscript {
    repositories {
        mavenCentral()
        maven {
            url 'https://plugins.gradle.org/m2/'
        }
    }
    dependencies {
        classpath group: 'org.jfrog.buildinfo', name: 'build-info-extractor-gradle', version: '4.9.0'
    }
}

apply plugin: 'idea'
apply plugin: 'eclipse'
apply plugin: 'java'
apply plugin: 'distribution'

// In this section you declare where to find the dependencies of your project
repositories {
    flatDir { dirs "libz" }
    mavenCentral()
    maven {
        url 'https://repo.gradle.org/gradle/libs-releases-local/'
    }
}

configurations {
    preCompile
    testPublish
}

// In this section you declare the dependencies for your production and test code
dependencies {
    implementation group: 'net.sf.opencsv', name: 'opencsv', version: '2.3'

    // Test Dependencies
    //testCompile 'junit:junit:4.11'
    testImplementation group: 'org.gradle', name: 'gradle-core', version: '6.1.1'
    testImplementation group: 'org.gradle', name: 'gradle-base-services', version: '6.1.1'
    testImplementation group: 'org.gradle', name: 'gradle-messaging', version: '6.1.1'
    testImplementation group: 'org.gradle', name: 'gradle-logging', version: '6.1.1'
    testImplementation group: 'org.gradle', name: 'gradle-process-services', version: '6.1.1'
    testImplementation group: 'org.gradle', name: 'gradle-worker-processes', version: '6.1.1'
    testImplementation group: 'org.gradle', name: 'gradle-tooling-api', version: '6.1.1'

    testPublish group: 'org.openmbee.testrail', name: 'testrail-cli', version: '1.0.1'

    // Other dependencies we're unable to resolve via standard repositories
    
    preCompile group: 'com.nomagic', name: 'democsm', version: '2022xRefresh2', classifier: 'Cameo_Systems_Modeler_2022x_Refresh2_HF1_no_install', ext: 'zip'
    preCompile group: 'org.openmbee.mdk.magic', name: 'mdk', version: '6.1.0', classifier: 'plugin', ext: 'zip'

    // This ensures classpath load order to match the MagicDraw provided order and then includes extras needed for non-OpenAPI stuff.
    // This was necessary because of the Application class stubbing that was done in the chromium libraries.
    implementation files(classpathLibraries.collect { 'build/dependency-cache/extracted/' + it })
    implementation fileTree(dir: 'build/dependency-cache/extracted', include: ['lib/**/*.jar', 'plugins/**/*.jar'], exclude: ([classpathLibraries, ['plugins/com.nomagic.collaborator.publisher/**/*.jar', 'plugins/com.nomagic.magicdraw.emfuml2xmi*/**/*.jar', 'plugins/com.nomagic.magicdraw.automaton/lib/engines/**/*.jar', 'plugins/tomsawyer/**/*.jar'] ]).flatten())
    implementation fileTree(dir: 'lib', include: ['**/*.jar'])
}

task extractDependencies {
    configurations.preCompile.resolvedConfiguration.resolvedArtifacts.each { artifact ->
        inputs.file artifact.file
        def zipFile = new ZipFile(artifact.file)
        zipFile.entries().each { entry ->
            if (!entry.isDirectory()) {
                outputs.file 'build/dependency-cache/extracted/' + entry.getName()
            }
        }
    }
    doLast {
        inputs.files.each { archive ->
            copy {
                from zipTree(archive)
                into 'build/dependency-cache/extracted'
            }
        }
        fileTree(dir: 'build/dependency-cache/extracted', include: '*.zip').each { archive ->
            copy {
                from zipTree(archive)
                into 'build/dependency-cache/extracted'
            }
        }
        /*fileTree(dir: 'build/dependency-cache/extracted').each { file ->
            outputs.file file
        }*/
    }
}
compileJava.dependsOn extractDependencies

javadoc {
    options.addStringOption("sourcepath", "")
}

if (JavaVersion.current().isJava8Compatible()) {
    tasks.withType(Javadoc) {
        // disable the crazy super-strict doclint tool in Java 8
        //noinspection SpellCheckingInspection
        options.addStringOption('Xdoclint:none', '-quiet')
    }
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

task testsJar(type: Jar, dependsOn: testClasses) {
    classifier = 'tests'
    from sourceSets.test.output

    exclude 'gov/nasa/jpl/mbee/mdk/test/framework/**'
    exclude 'org/**'
    exclude 'worker/**'
    //include 'gov/nasa/jpl/mbee/mdk/test/tests/**'
}

task testsHackJar(type: Jar, dependsOn: testClasses) {
    classifier = 'tests-hack'
    from sourceSets.test.output

    include 'gov/nasa/jpl/mbee/mdk/test/framework/**'
    include 'org/**'
    include 'worker/**'
    //exclude 'gov/nasa/jpl/mbee/mdk/test/tests/**'

    manifest {
        attributes(
                'Main-Class': 'org.openmbee.mdk.test.framework.GradleMagicDrawLauncher'
        )
    }
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    classifier = 'javadoc'
    from javadoc.destinationDir
}

task javadocZip(type: Zip, dependsOn: javadoc) {
    classifier = 'javadoc'
    from javadoc.destinationDir
}

class PreDist extends DefaultTask {
    String humanVersion
    String internalVersion
    String groupName
    String buildTimestamp
    String descriptor

    @TaskAction
    void executeTask() {
        project.copy {
            from 'src/main/dist'
            exclude 'template'
            from 'src/main/dist/template'
            into 'build/generated-dist'
        }
        project.copy {
            from project.configurations.compile.resolvedConfiguration.resolvedArtifacts.file
            from 'lib'
            from project.jar
            into "build/generated-dist/plugins/${groupName}"
        }
        project.copy {
            from project.getTasks().getByName('javadocZip')
            into "build/generated-dist/plugins/${groupName}/javadoc"
        }
        project.fileTree(dir: 'build/generated-dist', include: '**/*${group}*/**').each { file ->
            file.renameTo(project.file(file.getAbsolutePath().replace('${group}', "${groupName}")))
        }

        String pluginLibraries = ''
        project.fileTree(dir: "build/generated-dist/plugins/${groupName}", include: '**/*.jar').each { file ->
            pluginLibraries += '\t\t<library name=\"' + file.absolutePath.replaceAll(~/.*build\/generated-dist\/plugins\/${groupName}\//, '') + '\"/>' + System.lineSeparator()
        }
        project.copy {
            from 'src/main/dist/template/plugins/${group}/plugin.xml'
            filter { String line -> line.replace('<!-- START AUTO-GENERATED -->', '<!-- START AUTO-GENERATED -->' + System.lineSeparator() + System.lineSeparator() + pluginLibraries) }
            filter { String line -> line.replace('${human.version}', humanVersion) }
            filter { String line -> line.replace('${internal.version}', internalVersion) }
            into "build/generated-dist/plugins/${groupName}"
        }

        String descriptorFiles = ''
        project.fileTree(dir: 'build/generated-dist').each { file ->
            String relativePath = file.absolutePath.replaceAll(/.*build\/generated-dist\//, '')
            descriptorFiles += '\t\t<file from=\"' + relativePath + '\" to=\"' + relativePath + '\"/>' + System.lineSeparator()
        }
        project.copy {
            from "src/main/dist/template/data/resourcemanager/${descriptor}"
            filter { String line -> line.replace('<!-- START AUTO-GENERATED -->', '<!-- START AUTO-GENERATED -->' + System.lineSeparator() + System.lineSeparator() + descriptorFiles) }
            filter { String line -> line.replace('${human.version}', humanVersion) }
            filter { String line -> line.replace('${internal.version}', internalVersion) }
            filter { String line -> line.replace('${build.timestamp}', buildTimestamp) }
            into 'build/generated-dist/data/resourcemanager'
        }
    }
}

task preDist(type: PreDist) {
    humanVersion = version.endsWith('-SNAPSHOT') && buildTag != null && !buildTag.isEmpty() ? version.replace('-SNAPSHOT', '') : version
    internalVersion = buildNumber
    groupName = project.group
    buildTimestamp = timestamp
    descriptor = descriptorFile
}
preDist.dependsOn jar
preDist.dependsOn javadocZip

distributions {
    main {
        contents {
            exclude 'template'
            from 'build/generated-dist'
        }
    }
}

tasks.withType(Tar) {
    enabled = false
}

distZip {
    includeEmptyDirs false
    duplicatesStrategy DuplicatesStrategy.EXCLUDE
    eachFile { file ->
        file.setPath(path.substring(path.indexOf("/") + 1, path.length()))
    }
}

distZip.dependsOn preDist

apply plugin: 'maven-publish'
apply plugin: 'com.jfrog.artifactory'

publishing {
    // Reference to Gradle publications defined in the build script.
    // This is how we tell the Artifactory Plugin which artifacts should be
    // published to Artifactory.
    publications {
        mavenJava(MavenPublication) {
            from components.java
            artifact sourcesJar {
                classifier "sources"
            }
            artifact testsJar {
                classifier "tests"
            }
            artifact javadocJar {
                classifier "javadoc"
            }
            artifact distZip {
                classifier "plugin"
            }
        }
    }
}

artifactory {
    contextUrl = project.getProperties().get('artifactoryUrl')
    publish {
        repository {
            repoKey = project.getProperties().get('artifactoryRepository')
            username = project.getProperties().get('artifactoryUsername')
            password = project.getProperties().get('artifactoryPassword')
            maven = true
        }
        defaults {
            publications('mavenJava')
            publishArtifacts = true
            // Properties to be attached to the published artifacts.
            //properties = ['qa.level': 'basic', 'dev.team' : 'core']
            // Publish generated POM files to Artifactory (true by default)
            publishPom = true
        }
    }
    if (buildNumber != null && !buildNumber.isEmpty()) {
        clientConfig.info.setBuildNumber(buildNumber)
    }
}

artifactoryPublish.dependsOn distZip


installDist {
    destinationDir = file('build/plugin')
    doLast {
        copy {
            fileMode 0755
            from 'build/dependency-cache/extracted'
            from 'build/plugin'
            into 'build/install'
        }
    }
}

installDist.dependsOn distZip

task runJava(type: JavaExec) {
    doFirst {
        classpath files(classpathLibraries.collect { 'build/install/' + it })
    }
    workingDir 'build/install'
    ignoreExitValue true

    standardOutput = System.out
    errorOutput = System.err

    main = 'com.nomagic.magicdraw.Main'
    jvmArgs = ['-Xmx8192M', '-Xss512M', '-DLOCALCONFIG=true', '-DWINCONFIG=true', '-Djsse.enableSNIExtension=false', '-Djava.net.preferIPv4Stack=true', '-Dcom.sun.media.imageio.disableCodecLib=true', '-noverify', '-Dlocal.config.dir.ext=-dev', '-splash:data/splash.png', '-Dmd.class.path=$java.class.path', '-Desi.system.config=data/application.conf', '-Dlogback.configurationFile=data/logback.xml', '-Dsun.locale.formatasdefault=true', '-Djdk.attach.allowAttachSelf=true']
    // arguments to pass to the application
    args 'DEVELOPER'
}

runJava.dependsOn installDist

task runScript(type: Exec) {
    workingDir "build/install"
    ignoreExitValue = true

    if (System.getProperty('os.name').toLowerCase().contains('windows')) {
        commandLine 'bin\\magicdraw.exe'
    } else {
        commandLine 'sh', 'bin/magicdraw'
    }
}

runScript.dependsOn installDist

test {
    ignoreFailures = true
    testLogging.showStandardStreams = true
    forkEvery 1

    workingDir 'build/install'

    /**
     * The short version of the rationale is that with 18.4, MagicDraw introduced the OSGi framework as part of its
     * implementation.
     * Gradle and JUnit work very well together out of the box (generated reports in XML and HTML, tight IDE/Jenkins
     * integration, etc.), and Gradle and OSGi was made to work with the runJava task.
     * However, Gradle had to implement a number of hacks to overcome OS limitations and achieve features that can be
     * applied to a broad range of software.
     * Those hacks work well with most applications but not OSGi (commentary: OSGi doesn't play well with anyone), so
     * we implemented a number of hacks ourselves.
     * They involve classloading order, classpath redirection using the jar argument, reflection, and dynamic
     * classloading.
     * Ultimately, this enabled the use of the well-supported and feature-rich Gradle test task, but at the cost of
     * an implementation that could break in the unlikely, albeit possible, case of either Gradle or MagicDraw
     * significantly changing their implementations of the test and OSGi frameworks, respectively.
     *
     * Clears the default classpath since all the necessary libraries are being passed as arguments to
     * GradleMagicDrawLauncher to be added to the OSGi classpath.
     * Then it utilizes the -jar JVM argument to override the default Gradle command and pass the original command
     * as arguments to the main class of the jar, GradleMagicDrawLauncher,
     * including the classpath arguments (one of our own and one of Gradle's). It additionally parses and sets the
     * system properties that are passed.
     *
     * Example command: .../java -Dcom.nomagic.osgi.config.dir=configuration -Desi.system.config=data/application.conf -Djava.security.manager=worker.org.gradle.process.internal.worker.child.BootstrapSecurityManager -Dlogback.configurationFile=data/logback.xml -Dmd.class.path=$java.class.path -jar /Users/igomes/mdk/build/libs/mdk-*-tests-hack.jar -cp ... -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant -ea -cp .../.gradle/caches/.../workerMain/gradle-worker.jar worker.org.gradle.process.internal.worker.GradleWorkerMain 'Gradle Test Executor 1'
     *
     * @author igomes
     */
    classpath = files()
    doFirst {
        def arguments = ['-jar', testsHackJar.outputs.files.singleFile, '-cp',
                         fileTree(dir: 'build/generated-dist', include: '**/*.jar').getFiles().stream().map { i -> i.getAbsolutePath() }.collect(Collectors.joining(File.pathSeparator)) + File.pathSeparator +
                                 /*fileTree(dir: 'build/install', include: ['plugins/** /*.jar']).asPath + */
                                 files(classpathLibraries.collect { 'build/install/' + it }).getFiles().stream().map { i -> i.getAbsolutePath() }.collect(Collectors.joining(File.pathSeparator)) + File.pathSeparator +
                                 configurations.testCompile.resolvedConfiguration.resolvedArtifacts.stream().map { i -> i.getFile().getAbsolutePath() }.collect(Collectors.joining(File.pathSeparator)) + File.pathSeparator +
                                 testsJar.outputs.files.singleFile, '-DLOCALCONFIG=true', '-DWINCONFIG=true', '-Djsse.enableSNIExtension=false', '-Djava.net.preferIPv4Stack=true', '-Dcom.sun.media.imageio.disableCodecLib=true', '-noverify', '-Dlocal.config.dir.ext=-test', '-splash:data/splash.png', '-Dmd.class.path=$java.class.path', '-Dcom.nomagic.osgi.config.dir=configuration', '-Desi.system.config=data/application.conf', '-Dlogback.configurationFile=data/logback.xml', '-Dsun.locale.formatasdefault=true', '-Dorg.osgi.framework.bundle.parent=ext']
        String magicDrawLicense = project.getProperties().get('magicDrawLicense')
        if (magicDrawLicense != null && !magicDrawLicense.isEmpty()) {
            new File('build/install/mdlicense.tmp').write(new String(magicDrawLicense.decodeBase64()))
        }
        String additionalTestArguments = project.getProperties().get('additionalTestArguments')
        if (additionalTestArguments != null && !additionalTestArguments.isEmpty()) {
            arguments.addAll(additionalTestArguments.split(','))
        }
        jvmArgs = arguments
    }
}

test.dependsOn testsJar
test.dependsOn testsHackJar
test.dependsOn installDist

task testrailPublish(type: JavaExec) {
    classpath configurations.testPublish
    main = 'org.openmbee.testrail.cli.JUnitPublisher'
    def arguments = [ '--directory', 'build/test-results/test', '--milestone', version.replace('-SNAPSHOT', '') ]
    def s
    if ((s = project.getProperties().get('testrailHost')) != null) {
        arguments.addAll('--host', s)
    }
    if ((s = project.getProperties().get('testrailUser')) != null || (s = project.getProperties().get('testrailUsername')) != null) {
        arguments.addAll('--user', s)
    }
    if ((s = project.getProperties().get('testrailPassword')) != null) {
        arguments.addAll('--password', s)
    }
    if ((s = project.getProperties().get('testrailSuiteId')) != null) {
        arguments.addAll('--suite-id', s)
    }
    if ((s = project.getProperties().get('testrailPlanId')) != null) {
        arguments.addAll('--plan-id', s)
    }
    if ((s = project.getProperties().get('testrailRunName')) != null) {
        arguments.addAll('--run-name', s)
    }
    if (project.getProperties().hasProperty('testrailSkipCloseRun')) {
        arguments.add('--skip-close-run')
    }
    args arguments

    standardOutput = System.out
    errorOutput = System.err
}

configure(testrailPublish) {
    group = 'Publishing'
    description = 'Publish test results to TestRail'
}
testrailPublish.dependsOn test