build.gradle

import groovy.text.SimpleTemplateEngine
import org.apache.tools.ant.filters.ReplaceTokens
import org.gradle.plugins.signing.Sign
import org.kohsuke.github.*

buildscript {
    repositories {
        jcenter()
        gradlePluginPortal()
    }
    dependencies {
        classpath 'org.kohsuke:github-api:1.111'
        classpath "gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:4.0.5"
    }
}

plugins {
    id 'java'
    id 'groovy'

    id 'eclipse'
    id 'idea'

    id 'maven-publish'
    id "com.github.ethankhall.semantic-versioning" version "1.1.0"
    id "com.github.ben-manes.versions" version "0.28.0"
    id "com.jfrog.bintray" version "1.8.5"
    id "org.asciidoctor.convert" version "2.4.0"
    id "org.ajoberstar.git-publish" version "2.1.3"
    id "com.github.hierynomus.license" version "0.15.0"
    id "net.saliman.properties" version "1.5.1"
    id 'com.github.jk1.dependency-license-report' version '1.13'
}

project.version.with {
    major = textIoVersionMajor as int
    minor= textIoVersionMinor as int
    patch = textIoVersionPatch as int
    if (project.hasProperty('textIoVersionLabel')) {
        preRelease = textIoVersionLabel
    }
    releaseBuild = Boolean.valueOf(textIoReleaseBuild)
}
ext.textIoVersion = project.version as String
ext.textIoTag = Boolean.valueOf(textIoReleaseBuild) ? "v$ext.textIoVersion" : 'master'

repositories {
  jcenter()
  mavenCentral()
}

def pomConfig = {
    url "https://github.com/beryx/text-io"
    developers {
        developer {
            id "siordache"
            name "Serban Iordache"
        }
    }
    scm {
        connection "https://github.com/beryx/text-io.git"
        developerConnection "https://github.com/beryx/text-io.git"
        url "https://github.com/beryx/text-io"
    }
}

ext.groovyVersion = '3.0.3'

allprojects {
    group = 'org.beryx'
    version = textIoVersion

    tasks.withType(Javadoc) {
        options.addStringOption('Xdoclint:all,-syntax,-missing', '-quiet')
    }
}

dependencies.compile subprojects

subprojects {
    apply plugin: 'java'
    apply plugin: 'groovy'

    apply plugin: "com.github.spotbugs"
    apply plugin: 'signing'
    apply plugin: 'com.github.hierynomus.license'

    repositories {
        jcenter()
        mavenCentral()
    }

    sourceCompatibility = 1.8

    def defaultEncoding = 'UTF-8'
    [compileJava, compileTestJava]*.options*.encoding = defaultEncoding

    configurations {
      provided
      compile {transitive = true}
    }

    license {
        header rootProject.file("license-header.txt")
        skipExistingHeaders true
        ignoreFailures false
        excludes (["**/*.properties", "**/*.html", "**/*.css", "**/*.json"])
    }


    signing {
        sign configurations.archives
    }

    signArchives {
      onlyIf { gradle.taskGraph.allTasks.findAll {task -> isPublishTask(task)} }
    }

    dependencies {
      implementation 'org.slf4j:slf4j-api:1.8.0-beta4'

      testImplementation "org.codehaus.groovy:groovy-all:$groovyVersion"
      testImplementation('org.spockframework:spock-core:2.0-M2-groovy-3.0') {
          exclude module: 'groovy-all'
      }
      testImplementation 'cglib:cglib-nodep:3.3.0'
      testImplementation 'org.objenesis:objenesis:3.1'
      testImplementation('com.athaydes:spock-reports:1.7.1') { transitive = false}

      testImplementation('ch.qos.logback:logback-classic:1.3.0-alpha4')
    }

    sourceSets.main.compileClasspath += configurations.provided
    spotbugs {
        toolVersion = '4.0.2'
        // sourceSets = [project.sourceSets.main]// check only main classes
        excludeFilter = file("$rootDir/findbugsExclude.xml")
        effort = "max"
        ignoreFailures = false
    }

    spotbugsMain {
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    spotbugsTest.enabled = false



    jar {
        manifest {
            attributes 'Implementation-Title': "${project.archivesBaseName}",
                    'Implementation-Version': textIoVersion
        }

        from ("${projectDir}/src/main/java") {
            include('**/*.fxml')
            include('**/*.css')
            include('**/*.png')
        }
    }

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

    task javadocJar(type: Jar, dependsOn: classes) {
        classifier "javadoc"
        from javadoc
    }
    artifacts {
        (System.getenv("TRAVIS") == "true") ? archives(sourcesJar) : archives(sourcesJar, javadocJar)
    }

    publishing {
        publications {
            "$project.name"(MavenPublication) {
                from components.java
                artifact sourcesJar { classifier "sources" }
                artifact javadocJar { classifier "javadoc" }
                groupId 'org.beryx'
                artifactId project.name
                version textIoVersion
                pom.withXml {
                    def root = asNode()
                    root.appendNode('name', "Module $project.name")
                    root.appendNode('description', "The $project.name artifact")
                    root.children().last() + pomConfig

                    // We cannot configure the licenses in pomConfig due to a name conflict with the 'license' extension defined by the com.github.hierynomus.license plugin
                    def licenseNode = root.appendNode('licenses').appendNode('license')
                    licenseNode.appendNode('name', 'The Apache Software License, Version 2.0')
                    licenseNode.appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.txt')
                    licenseNode.appendNode('distribution', 'repo')
                }
            }
        }
    }

    task "create-dirs" {
        doLast {
            sourceSets*.java.srcDirs*.each { it.mkdirs() }

            sourceSets*.resources.srcDirs*.each { it.mkdirs() }
        }
    }

    eclipse {
        classpath {
            file {
                whenMerged {
                    def jre = entries.find { it.path.contains 'org.eclipse.jdt.launching.JRE_CONTAINER' }
                }
            }
            plusConfigurations << configurations.provided
        }
        project {
            file.beforeMerged { project ->
                project.natures.clear()
            }
        }
    }

    idea {
        module {
            scopes.PROVIDED.plus += [configurations.provided]
        }
    }
}

def gitIgnore = file(".gitignore").readLines()
def gitIgnoreDirs = gitIgnore*.trim().findAll { !it.startsWith("#") && it.endsWith("/") }
asciidoctor {
  sourceDir = file("doc")
  sources {include 'index.adoc'}
  logDocuments = true
  attributes 'source-highlighter': 'coderay',
             'coderay-linenums-mode': 'table',
             'project-name': 'text-io',
             'project-version': version,
             icons: 'font',
             imagesdir: 'img',
             'data-uri': '',
             linkattrs: true,
             linkcss: true,
             'git-tag': textIoTag,
             'blob-root': "https://github.com/beryx/text-io/blob/$textIoTag"
}

gitPublish {
    System.properties['org.ajoberstar.grgit.auth.username'] = System.getenv('GH_PAGES_ACCESS_TOKEN') ?: ''
    System.properties['org.ajoberstar.grgit.auth.password'] = ''

    repoUri = 'https://github.com/beryx/text-io.git'
    branch = 'gh-pages'

    contents {
        def pgType = project.hasProperty('ghPageType') ? ghPageType : 'latest'
        if(pgType == 'init') {
            from file("ghpages")
        } else if(pgType == 'list') {
            from file("build/release-list")
        } else {
            from file("${asciidoctor.outputDir.path}/html5")
            from file("build/docs")
        }
        def docDir = Boolean.valueOf(textIoReleaseBuild) ? 'releases' : 'snapshots'
        if(pgType == 'init') {
            into "."
        } else if(pgType == 'list') {
            into "."
            preserve {
                include '**'
                exclude "releases.md"
            }
        } else if(pgType == 'version') {
            gitPublishPush.enabled = (docDir != 'snapshots')
            into "$docDir/$textIoVersion"

            preserve {
                include '**'
                exclude "$docDir/$textIoVersion"
            }
        } else {
            into "$docDir/latest"

            preserve {
                include '**'
                exclude "$docDir/latest"
            }
        }
    }
}


project('text-io') {
    dependencies {
      implementation 'jline:jline:2.14.6'
        implementation 'org.beryx:awt-color-factory:1.0.1'
    }
    jar {
        manifest {
            attributes 'Automatic-Module-Name': 'org.beryx.textio'
        }
    }
}

project('text-io-web') {
    dependencies {
        implementation project(':text-io')
        implementation 'com.google.code.gson:gson:2.8.6'
        implementation 'org.apache.commons:commons-lang3:3.10'
        compileOnly 'com.sparkjava:spark-core:2.9.1'
        compileOnly 'io.ratpack:ratpack-core:1.7.6'
        compileOnly 'io.ratpack:ratpack-session:1.7.6'
        testImplementation 'io.ratpack:ratpack-test:1.7.6'
    }
    jar {
        manifest {
            attributes 'Automatic-Module-Name': 'org.beryx.textio.web'
        }
    }
}

project('text-io-demo') {
    apply plugin: 'application'
    dependencies {
        implementation project(':text-io')
        implementation project(':text-io-web')
        implementation 'com.sparkjava:spark-core:2.9.1'
        implementation 'io.ratpack:ratpack-core:1.7.6'
        implementation 'io.ratpack:ratpack-session:1.7.6'
        implementation 'com.google.code.gson:gson:2.8.6'
        runtime ('ch.qos.logback:logback-classic:1.3.0-alpha4')
    }
    artifacts {
        (System.getenv("TRAVIS") == "true") ? archives(sourcesJar) : archives(sourcesJar, javadocJar)
    }
    jar {
        manifest {
            attributes 'Main-Class': 'org.beryx.textio.demo.TextIoDemo',
                    'Automatic-Module-Name': 'org.beryx.textio.demo'
        }
    }
    mainClassName = 'org.beryx.textio.demo.TextIoDemo'

    applicationName = "textio-demo"

    startScripts {
        defaultJvmOpts = ['-Dlogback.configurationFile=logback.xml']
    }

    applicationDistribution.from("${rootProject.projectDir}/dist") {
        exclude 'xbin'
        filter(ReplaceTokens, tokens:[textIoVersion : textIoVersion])
    }

    applicationDistribution.from("${rootProject.projectDir}/dist/xbin") {
        into 'bin'
    }

    applicationDistribution.from("${rootProject.projectDir}/..") {
        include('LICENSE', 'NOTICE')
    }
}


configureJavadoc(javadoc)

def configureJavadoc(task) {
  configure(task) {
      title "text-io Documentation ($textIoVersion)"
      destinationDir file("build/docs/javadoc")
      source subprojects.javadoc.source
      classpath = files(subprojects.javadoc.classpath)
      if(project.configurations.hasProperty('provided')) {
          classpath += project.configurations.provided
      }
      configure(options) {
          links "http://docs.oracle.com/javase/8/docs/api/"
      }
  }
}

task "update-release-list" {
    doLast {
        def docBaseUrl = 'http://text-io.beryx.org'
        updateReleaseList(docBaseUrl)
    }
}

def updateReleaseList(String docBaseUrl) {
    List<String> releases = getReleases()
    def markdown = getReleasesMarkdown(releases, docBaseUrl)
    def releaseListDir = new File('build/release-list')
    releaseListDir.mkdirs()
    new File(releaseListDir, 'releases.md').write(markdown)
}

def getReleases() {
    GitHub gitHubApi = GitHub.connectUsingPassword(System.getenv('GH_PAGES_ACCESS_TOKEN') ?: '', '')
    def releases = gitHubApi.getOrganization("beryx")
            .getRepository("text-io")
            .getDirectoryContent("releases", "gh-pages")*.name
    releases.removeAll { !it || it == 'latest' }
    releases.reverse()
}

def getReleasesMarkdown(List<String> releases, String docBaseUrl) {
    def releasesTemplate = '''
            ## List of all releases ##

            **Latest snapshot**
            - [documentation]($docBaseUrl/snapshots/latest)
            - [javadoc]($docBaseUrl/snapshots/latest/javadoc)

            <% releases.each { %>**Release $it**
              - [documentation]($docBaseUrl/releases/$it)
              - [javadoc]($docBaseUrl/releases/$it/javadoc)

            <% } %>
        '''.stripIndent()

    def engine = new SimpleTemplateEngine()
    def template = engine.createTemplate(releasesTemplate)
    def binding = [
            docBaseUrl: docBaseUrl,
            releases  : releases
    ]

    template.make(binding).toString()
}



def readFromConsole(prompt) {
    readFromConsole('', prompt)
}
def readFromConsole(header, prompt) {
    readFromConsole(header, prompt, false)
}
def readPasswordFromConsole(prompt) {
    readPasswordFromConsole(prompt, true)
}
def readPasswordFromConsole(header, prompt) {
    readFromConsole(header, prompt, true)
}
def readFromConsole(header, prompt, isPassword) {
    def console = System.console()
    if (console) {
        if(header) {
            console.printf "\n\n# $header\n"
        }
        String value = null;
        while(!value?.trim()) {
            def val = console."read${isPassword ? 'Password' : 'Line'}"("> $prompt: ")
            if(val) {
                value = new String(val)
            }
        }
        return value
    } else {
      throw new GradleException("Cannot get console. Try running gradle with the '--no-daemon' option")
    }
}

def isPublishTask(task) {
  task.name.startsWith('publish')
}

gradle.taskGraph.whenReady { taskGraph ->
    if (gradle.taskGraph.allTasks.findAll {task -> isPublishTask(task)}) {
        def password = readPasswordFromConsole('Please enter your signing credentials', 'PGP Private Key Password')
        allprojects { ext."signing.keyId" = signingKeyId }
        allprojects { ext."signing.secretKeyRingFile" = signingSecretKeyRingFile }
        allprojects { ext."signing.password" = password }
    }
}

bintray {
    user = project.hasProperty('bintrayUser') ? project.getProperty('bintrayUser') : "unknownUser"
    key =  project.hasProperty('bintrayKey') ? project.getProperty('bintrayKey') : "unknownKey"
    publications = ['text-io', 'text-io-web']
    pkg {
        repo = 'maven'
        name = 'text-io'
        userOrg = 'beryx'
        licenses = ['Apache-2.0']
        vcsUrl = 'https://github.com/beryx/text-io.git'

        version {
                name = textIoVersion
                desc = "text-io $textIoVersion"
                released  = new Date().format("yyyy-MM-dd'T'HH:mm:ss.SSSZZ")
                vcsTag = textIoVersion
                gpg {
                    sign = true
                }
        }
    }
}

task prepareNpm(type: Copy) {
    from "text-io-web/src/main/resources/public-html/textterm"
    into "build/npm"
    filter(ReplaceTokens, tokens:[textIoVersion : textIoVersion])
    filteringCharset = 'UTF-8'
}

build.dependsOn prepareNpm