build.gradle

buildscript {
  repositories {
    mavenLocal()
    jcenter()
    mavenCentral()
    maven {
      name = 'forge'
      url = 'https://files.minecraftforge.net/maven'
    }
    maven {
      name = 'gradle'
      url 'https://plugins.gradle.org/m2/'
    }
    maven {
      name = 'sonatype'
      url = 'https://oss.sonatype.org/content/groups/public'
    }
  }
  dependencies {
    classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: project.fg_version
    //classpath group: 'com.jaredsburrows', name: 'gradle-checker-framework-plugin', version: '0.2.2'
  }
}

plugins {
  id 'com.github.spotbugs' version '1.6.9'
  id 'com.matthewprenger.cursegradle' version '1.4.0'
  id 'org.sonarqube' version '2.8'
  id 'se.bjurr.gitchangelog.git-changelog-gradle-plugin' version '1.60'
//id 'org.junit.platform.gradle.plugin' version '1.2.0'
  id 'maven-publish'
  id 'jacoco'
  id 'checkstyle'
}

apply plugin: 'net.minecraftforge.gradle.forge'
//apply plugin: 'com.jaredsburrows.checkerframework'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'maven-publish'

project.afterEvaluate {
  //final def junitPlatformTestTask = project.tasks.getByName('junitPlatformTest')

  // configure jacoco to analyze the junitPlatformTest task
  jacoco {
    // this tool version is compatible with
    toolVersion = '0.8.3'
    // Not needed with new way
    //applyTo junitPlatformTestTask
  }

  // create junit platform jacoco task
  project.task(type: JacocoReport, 'junitPlatformJacocoReport',
  {
    sourceDirectories = files('./src/main')
    classDirectories = files("${project.buildDir}/classes/main")
    // Not needed with new way
    //executionData junitPlatformTestTask
  })
}

// Only works with JUnit Platform Launcher 1.2.0 and earlier
/*
junitPlatform {
  // platformVersion '1.2.0'
  // logManager 'org.apache.logging.log4j.jul.LogManager'
  reportsDir file("${project.buildDir}/test-results/junit-platform")
  // enableStandardTestTask true
  // selectors (optional)
  // filters (optional)
}
*/

spotbugs {
  ignoreFailures = true
  toolVersion = '3.1.6'
  effort = 'max'
  reportLevel = 'low'
  //includeFilter = file("$rootProject.projectDir/config/spotbugs-filter.xml")
}

import com.github.spotbugs.SpotBugsTask
tasks.withType(SpotBugsTask) {
  reports {
    xml.enabled = false
    html.enabled = true
  }
}

checkstyle {
  ignoreFailures = true
  toolVersion = '8.20'
}

tasks.withType(JavaCompile) {
  options.encoding = 'UTF-8'
  options.compilerArgs = [
    '-Xlint:deprecation', // deprecation, rawtypes, cast, unchecked, all
    //'-Xdiags:verbose',
    //'-Werror'
  ]
}

tasks.withType(Test) {
  compileTestJava.options.compilerArgs += '-proc:none'
}

javadoc {
  failOnError = false
}

test {
  useJUnitPlatform()
/*
  useJUnitPlatform {
    includeTags 'fast', 'smoke & feature-a'
    //excludeTags 'slow', 'ci'
    includeEngines 'junit-jupiter'
    //excludeEngines 'junit-vintage'
  }
*/
}

//project.ext.short_version = '1.0.0'
//ext.short_version = getModVersion('VERSION', <path to file containing version string)
project.ext.short_version = getModVersion('VERSION')
version = (project.hasProperty('mc_version') ? project.mc_version : project.forge_mc_version) + '-' + short_version
project.ext.display_version = short_version

if ((System.getenv('BUILD_NUMBER')) || (System.getenv('TRAVIS_BUILD_NUMBER')) || (System.getenv('CIRCLE_BUILD_NUM'))) {
  version += '.' + buildNumber
  display_version += '.' + buildNumber
}

static String getBuildNumber() {
  return System.getenv('BUILD_NUMBER') ?: System.getenv('TRAVIS_BUILD_NUMBER') ?: System.getenv('CIRCLE_BUILD_NUM') ?: '0'
}

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

eclipse.project {
  buildCommand 'org.eclipse.buildship.core.gradleprojectbuilder'
  natures 'org.eclipse.buildship.core.gradleprojectnature'
}

idea.module {
  downloadJavadoc = true
  //inheritOutputDirs = true
}

class Secrets {
  Map m_data = null

  final String getProperty(final String key) {
    return (m_data && (m_data[key] != null)) ? m_data[key] : ''
  }
}

final def secretFile
if (System.getenv('SECRET_FILE')) {
  secretFile = file System.getenv().SECRET_FILE
} else {
  secretFile = file 'secret.json'
}

import groovy.json.JsonSlurper
project.ext.secret = new Secrets()
if (secretFile.exists()) {
  secretFile.withReader {
    project.secret.m_data = new JsonSlurper().parse it
  }
} else {
  project.secret.m_data = new JsonSlurper().parseText(
    '{ "username" : "' + (System.getenv('userMaven') ?: '') + '",'
    + '"password" : "' + (System.getenv('authMaven') ?: '') + '",'
    + '"url" : "' + (System.getenv('urlMaven') ?: '') + '",'
    + '"curseforgeAPIKey" : "' + (System.getenv('curse_auth') ?: '00000000-0000-0000-0000-000000000000') + '",'
    + '"sonarHost" : "' + (System.getenv('SONAR_HOST_URL') ?: 'https://sonarcloud.io') + '",'
    + '"sonarOrganization" : "' + (System.getenv('SONAR_ORGANIZATION') ?: '') + '",'
    + '"sonarToken" : "' + (System.getenv('SONAR_AUTH_TOKEN') ?: 0) + '"}'
  )
}

minecraft {
  version = project.forge_mc_version + '-' + project.forge_version
  mappings = project.mcp_mappings_version

  if (project.hasProperty('runDir')) {
    runDir = project.runDir
  } else if (file('../run').exists()) {
    runDir = '../run'
  } else {
    runDir = 'run'
  }

  replace '@MOD_VERSION@', project.short_version

  if (project.hasProperty('signSHA1') && getBooleanProperty('do_sign_jar')) {
    replace '@FINGERPRINT@', project.findProperty('signSHA1')
  } else {
    replace '@FINGERPRINT@', ''
  }

  if (project.hasProperty('core_plugin')) {
    clientJvmArgs += "-Dfml.coreMods.load=${project.core_plugin}"
    serverJvmArgs += "-Dfml.coreMods.load=${project.core_plugin}"
  }

  if (project.hasProperty('mc_username')) {
    clientRunArgs += ['--username', project.mc_username]
    if (project.hasProperty('mc_password')) {
      clientRunArgs += ['--password', project.mc_password]
    }
  }
  if (project.hasProperty('mc_uuid')) {
    clientRunArgs += ['--uuid', project.mc_uuid]
  }

  if (getBooleanProperty('mc_server_nogui')) {
    serverRunArgs += 'nogui'
  }

  if (getBooleanProperty('forge_do_not_backup')) {
    serverJvmArgs += '-Dfml.doNotBackup=true'
    clientJvmArgs += '-Dfml.doNotBackup=true'
  }

  if (getBooleanProperty('forge_query_result_confirm')) {
    serverJvmArgs += '-Dfml.queryResult=confirm'
  }

  if (getBooleanProperty('log4j_skip_jansi')) {
    serverJvmArgs += '-Dlog4j.skipJansi=true'
    clientJvmArgs += '-Dlog4j.skipJansi=true'
  }

  if (project.hasProperty('mc_resolution')) {
    final def res = [
                     '480p': [640, 480],
                     '576p': [640, 576],
                     '720p': [1280, 720],
                     '1080p': [1920, 1080],
                     'custom': [project.findProperty('mc_custom_resolution_width'), project.findProperty('mc_custom_resolution_height')]]
    final def choice = res?.get(project.mc_resolution)
    if (choice != null) {
      clientRunArgs += ['--width', choice[0]]
      clientRunArgs += ['--height', choice[1]]
    }
  }

  if (project.hasProperty('client_jvm_args')) {
    clientJvmArgs += project.client_jvm_args
  }
  if (project.hasProperty('server_jvm_args')) {
    serverJvmArgs += project.server_jvm_args
  }

  if (project.hasProperty('client_game_args')) {
    clientRunArgs += project.client_game_args
  }
  if (project.hasProperty('server_game_args')) {
    serverRunArgs += project.server_game_args
  }

  makeObfSourceJar = getBooleanProperty('create_source_jar')

  useDepAts = getBooleanProperty('dep_has_ats')
}

repositories {
  mavenLocal()
  jcenter()
  mavenCentral()

  maven {
    name 'MMD'
    url 'https://maven.mcmoddev.com/'
  }
}

dependencies {
  testCompile('org.junit.platform:junit-platform-launcher:1.4.+')
  testCompile('org.junit.jupiter:junit-jupiter-api:5.4.+') // testImplementation
  testRuntime('org.junit.jupiter:junit-jupiter-engine:5.4.+') //testRuntimeOnly
  testCompileOnly 'junit:junit:4.12'
  testRuntime 'org.junit.vintage:junit-vintage-engine:5.4.+' //testRuntimeOnly
  testCompile('org.mockito:mockito-core:2.+')
  testCompile('org.mockito:mockito-junit-jupiter:2.+') {
    exclude group: 'org.junit.jupiter', module: 'junit-jupiter-engine'
  }
  annotationProcessor group: 'org.apache.logging.log4j', name: 'log4j-core', version: '2.11.0'
}

processResources {
  inputs.property 'version', project.short_version
  inputs.property 'mcversion', project.minecraft.version

  from (sourceSets.main.resources.srcDirs) {
    include 'mcmod.info'
    expand 'version': project.short_version, 'mcversion': project.minecraft.version
  }

  from (sourceSets.main.resources.srcDirs) {
    exclude 'mcmod.info'
  }

  rename '(.+_at.cfg)', 'META-INF/$1'
}

jar {
  //from sourceSets.api.output
  //from sourceSets.main.output

  manifest {
    mainAttributes(
      'Maven-Artifact': "${project.group}:${project.archivesBaseName}:${project.version}",
      'Timestamp': System.currentTimeMillis(),
      'Specification-Title': 'examplemod',
      'Specification-Vendor': 'mcmoddev',
      'Specification-Version': '1',
      'Implementation-Title': project.archivesBaseName,
      'Implementation-Version': project.version,
      'Implementation-Vendor' :'mcmoddev',
      'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
      'Built-On-Java': "${System.getProperty('java.vm.version')} (${System.getProperty('java.vm.vendor')})",
      'Built-On': "${project.mc_version}-${project.forge_version}"
    )
    if (project.hasProperty('core_plugin')) {
      attributes 'FMLCorePluginContainsFMLMod': 'true'
      attributes 'FMLCorePlugin': project.core_plugin
    }
    if (project.hasProperty('mod_at_file')) {
      attributes 'FMLAT': project.at_file
    }
  }
}

task apiJar(type: Jar) {
  onlyIf {
    getBooleanProperty('create_api_jar')
  }

  description = 'Creates a JAR containing the API Classes.'
  classifier = 'api'
  from apiClasses
  // from sourceSets.api.output
  manifest {
    mainAttributes(
      'Maven-Artifact': "${project.group}:${project.archivesBaseName}:${project.version}:api",
      'Timestamp': System.currentTimeMillis(),
      'Specification-Title': 'examplemod',
      'Specification-Vendor': 'mcmoddev',
      'Specification-Version': '1',
      'Implementation-Title': project.name + '-api',
      'Implementation-Version': project.version,
      'Implementation-Vendor' :'mcmoddev',
      'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
      'Built-On-Java': "${System.getProperty('java.vm.version')} (${System.getProperty('java.vm.vendor')})",
      'Built-On': "${project.forge_mc_version}-${project.forge_version}"
    )
  }
}

task deobfJar(type: Jar) {
  onlyIf {
    getBooleanProperty('create_deobf_jar')
  }

  description = 'Creates a JAR containing the non-obfuscated compiled code.'
  classifier = 'deobf'
  from sourceSets.main.output
  manifest {
    mainAttributes(
      'Maven-Artifact': "${project.group}:${project.archivesBaseName}:${project.version}:deobf",
      'Timestamp': System.currentTimeMillis(),
      'Specification-Title': 'examplemod',
      'Specification-Vendor': 'mcmoddev',
      'Specification-Version': '1',
      'Implementation-Title': project.name + '-deobf',
      'Implementation-Version': project.version,
      'Implementation-Vendor' :'mcmoddev',
      'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
      'Built-On-Java': "${System.getProperty('java.vm.version')} (${System.getProperty('java.vm.vendor')})",
      'Built-On': "${project.forge_mc_version}-${project.forge_version}"
    )
    if (project.hasProperty('at_file')) {
      attributes 'FMLAT': project.at_file
    }
    if (project.hasProperty('core_plugin')) {
      attributes 'FMLCorePlugin': project.core_plugin
    }
  }
}

task javadocJar(type: Jar, dependsOn: javadoc) {
  onlyIf {
    getBooleanProperty('create_javadoc_jar')
  }

  description = 'Creates a JAR containing the JavaDocs.'
  classifier = 'javadoc'
  from javadoc.getDestinationDir()
  manifest.mainAttributes(
    'Maven-Artifact': "${project.group}:${project.archivesBaseName}:${project.version}:javadoc",
    'Timestamp': System.currentTimeMillis(),
    'Implementation-Title': project.name + '-javadoc',
    'Implementation-Version': project.version,
    'Built-On-Java': "${System.getProperty('java.vm.version')} + (${System.getProperty('java.vm.vendor')})",
    'Built-On': "${project.forge_mc_version}-${project.forge_version}"
  )
}

task signJar(type: SignJar, dependsOn: reobfJar) {
  onlyIf {
    getBooleanProperty('do_sign_jar') &&
    project.hasProperty('keyStore')
  }

  description = 'Sign the Main JAR'
  inputFile = jar.archivePath
  outputFile = jar.archivePath

  keyStore = project.findProperty('keyStore')
  alias = project.findProperty('keyStoreAlias')
  storePass = project.findProperty('keyStorePass')
  keyPass = project.findProperty('keyStoreKeyPass')
}

task signApiJar(type: SignJar) {
  onlyIf {
    getBooleanProperty('create_api_jar') &&
    getBooleanProperty('do_sign_jar') &&
    project.hasProperty('keyStore')
  }

  description = 'Sign the API JAR'
  keyStore = project.findProperty('keyStore')
  alias = project.findProperty('keyStoreAlias')
  storePass = project.findProperty('keyStorePass')
  keyPass = project.findProperty('keyStoreKeyPass')

  inputFile = apiJar.archivePath
  outputFile = apiJar.archivePath
}

task signDeobfJar(type: SignJar) {
  onlyIf {
    getBooleanProperty('create_deobf_jar') &&
    getBooleanProperty('do_sign_jar') &&
    project.hasProperty('keyStore')
  }

  description = 'Sign the deobf JAR'
  keyStore = project.findProperty('keyStore')
  alias = project.findProperty('keyStoreAlias')
  storePass = project.findProperty('keyStorePass')
  keyPass = project.findProperty('keyStoreKeyPass')

  inputFile = deobfJar.archivePath
  outputFile = deobfJar.archivePath
}

task signSourceJar(type: SignJar) {
  onlyIf {
    getBooleanProperty('create_source_jar') &&
    getBooleanProperty('do_sign_jar') &&
    project.hasProperty('keyStore')
  }

  description = 'Sign the Sources JAR'
  keyStore = project.findProperty('keyStore')
  alias = project.findProperty('keyStoreAlias')
  storePass = project.findProperty('keyStorePass')
  keyPass = project.findProperty('keyStoreKeyPass')

  inputFile = sourceJar.archivePath
  outputFile = sourceJar.archivePath
}

task signJavadocJar(type: SignJar) {
  onlyIf {
    getBooleanProperty('create_javadoc_jar') &&
    getBooleanProperty('do_sign_jar') &&
    project.hasProperty('keyStore')
  }

  keyStore = project.findProperty('keyStore')
  alias = project.findProperty('keyStoreAlias')
  storePass = project.findProperty('keyStorePass')
  keyPass = project.findProperty('keyStoreKeyPass')

  inputFile = javadocJar.archivePath
  outputFile = javadocJar.archivePath
}

if (getBooleanProperty('do_sign_jar')) {
  build.dependsOn signJar
  if (getBooleanProperty('create_api_jar')) {
    build.dependsOn signApiJar
  }
  if (getBooleanProperty('create_deobf_jar')) {
    build.dependsOn signDeobfJar
  }
  if (getBooleanProperty('create_source_jar')) {
    build.dependsOn signSourceJar
  }
  if (getBooleanProperty('create_javadoc_jar')) {
    build.dependsOn signJavadocJar
  }
}

tasks.publish.dependsOn build
tasks.curseforge.dependsOn publish

artifacts {
  if (getBooleanProperty('create_api_jar')) {
    archives apiJar
  }
  if (getBooleanProperty('create_deobf_jar')) {
    archives deobfJar
  }
  if (getBooleanProperty('create_source_jar')) {
    archives sourceJar
  }
  if (getBooleanProperty('create_javadoc_jar')) {
    archives javadocJar
  }
}

publishing {
  publications {
    mavenJava(MavenPublication) {
      groupId project.group
      artifactId project.archivesBaseName
      version project.version
      from components.java
      if (getBooleanProperty('create_source_jar')) {
        artifact sourceJar {
          classifier 'sources'
        }
      }
      if (getBooleanProperty('create_api_jar')) {
        artifact apiJar {
          classifier 'api'
        }
      }
      if (getBooleanProperty('create_deobf_jar')) {
        artifact deobfJar {
          classifier 'deobf'
        }
      }
      if (getBooleanProperty('create_javadoc_jar')) {
        artifact javadocJar {
          classifier 'javadoc'
        }
      }
      /*
      pom {
        name = 'Example'
        description = 'An Example'
        url = 'https://github.com/Examples/Example'
        packaging = 'jar'
        //inceptionYear = ''
        licenses {
          license {
            name = 'GNU Lesser General Public License, Version 2.1'
            url = 'https://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt'
          }
        }
        scm {
          connection = 'scm:git:git://github.com/Examples/Example.git'
          developerConnection = 'scm:git:git@github.com:Examples/Example.git'
          url = 'https://github.com/Examples/Example'
        }
        issueManagement {
          system = 'github'
          url = 'https://github.com/Examples/Example.git/issues'
        }
        ciManagement {
          system = 'jenkins'
          url = 'https://ci.mcmoddev.com/'
        }
        organization {
          name = 'Minecraft Mod Development'
          url = 'https://mcmoddev.com/'
        }
      }
      */
    }
  }
  repositories {
    maven {
      if ((secret.username != '') && (secret.password != '')) {
        credentials {
          username secret.username
          password secret.password
        }
      }
      if (secret.url != '') {
        url secret.url
      } else {
        url "file:///${project.buildDir}/repo"
      }
    }
  }
}

curseforge {
  if (project.hasProperty('curseforge_project_id')) {
    apiKey = secret.curseforgeAPIKey
    project {
      id = project.curseforge_project_id
      if (project.hasProperty('curseforge_changelog_filename')) {
        changelog = file(project.curseforge_changelog_filename)
      } else {
        changelog = ''
      }
      if (project.hasProperty('curseforge_changelog_type')) {
        changelogType = project.curseforge_changelog_type
      }
      if ((project.hasProperty('curseforge_release_type')) && ((project.curseforge_release_type == 'alpha') || (project.curseforge_release_type == 'beta') || (project.curseforge_release_type == 'release'))) {
        releaseType = project.curseforge_release_type
      } else {
        releaseType = 'alpha'
      }
      if (project.hasProperty('curseforge_versions')) {
        final def versions = "${project.curseforge_versions}".split(', ')
        versions.each {
          addGameVersion "${it}"
        }
      }
      mainArtifact(jar) {
        if (getBooleanProperty('curseforge_use_custom_display_name')) {
          displayName = "${project.name} ${project.display_version}"
        }
        if (project.hasProperty('curseforge_requirements') || project.hasProperty('curseforge_optionals') || project.hasProperty('curseforge_embeddeds') || project.hasProperty('curseforge_tools') || project.hasProperty('curseforge_incompatibles') || project.hasProperty('curseforge_includes')) {
          relations {
            if (project.hasProperty('curseforge_requirements')) {
              final def requirements = "${project.curseforge_requirements}".split(', ')
              requirements.each {
                requiredDependency "${it}"
              }
            }
            if (project.hasProperty('curseforge_optionals')) {
              final def optionals = "${project.curseforge_optionals}".split(', ')
              optionals.each {
                optionalDependency "${it}"
              }
            }
            if (project.hasProperty('curseforge_embeddeds')) {
              final def embeddeds = "${project.curseforge_embeddeds}".split(', ')
              embeddeds.each {
                embeddedLibrary "${it}"
              }
            }
            if (project.hasProperty('curseforge_tools')) {
              final def tools = "${project.curseforge_tools}".split(', ')
              tools.each {
                tool "${it}"
              }
            }
            if (project.hasProperty('curseforge_incompatibles')) {
              final def incompatibles = "${project.curseforge_incompatibles}".split(', ')
              incompatibles.each {
                incompatible "${it}"
              }
            }
            if (project.hasProperty('curseforge_includes')) {
              final def includes = "${project.curseforge_includes}".split(', ')
              includes.each {
                include "${it}"
              }
            }
          }
        }
      }
      if (getBooleanProperty('create_api_jar')) {
        addArtifact(apiJar) {
          if (getBooleanProperty('curseforge_use_custom_display_name')) {
            displayName = "${project.name} ${project.display_version} API"
          }
        }
      }
      if (getBooleanProperty('create_source_jar')) {
        addArtifact(sourceJar) {
          if (getBooleanProperty('curseforge_use_custom_display_name')) {
            displayName = "${project.name} ${project.display_version} Sources"
          }
        }
      }
      if (getBooleanProperty('create_deobf_jar')) {
        addArtifact(deobfJar) {
          if (getBooleanProperty('curseforge_use_custom_display_name')) {
            displayName = "${project.name} ${project.display_version} Development"
          }
        }
      }
      if (getBooleanProperty('create_javadoc_jar')) {
        addArtifact(javadocJar) {
          if (getBooleanProperty('curseforge_use_custom_display_name')) {
            displayName = "${project.name} ${project.display_version} Javadoc"
          }
        }
      }
    }
  }
}

sonarqube {
  properties {
    if (project.hasProperty('sonar_host_url')) {
      property 'sonar.host.url', project.sonar_host_url
    } else if (secret.sonarHost != '') {
      property 'sonar.host.url', secret.sonarHost
    }
    property 'sonar.login', secret.sonarToken
    if (project.hasProperty('sonar_organisation')) {
      property 'sonar.organization', project.sonar_organisation
    } else if (secret.sonarOrganisation != '') {
      property 'sonar.organization', secret.sonarOrganization
    }
    //property 'sonar.projectName', project.archivesBaseName
    //property 'sonar.projectKey', "${project.group}:${project.archivesBaseName}"
    //property 'sonar.branch.name', 'master-1.12.2'
    //property 'sonar.branch.target', ''
    property 'sonar.junit.reportPaths', "${project.buildDir}/test-results/junit-platform/*.xml"
    property 'sonar.jacoco.reportPaths', "${project.buildDir}/jacoco/junitPlatformTest.exec"
  }
}

String getModFile() {
  String path = ''
  final FileTree tree = fileTree(dir: 'src/main/java')
  tree.include '**/*.java'
  tree.visit { final element ->
    if (element.file.isFile()) {
      element.file.eachLine { final String s ->
        final String sTrim = s.trim()
        if (sTrim.startsWith('@Mod(')) {
          path = "src/main/java/${element.relativePath}"
        }
      }
    }
  }
  return path
}

String getModVersion(final String type) {
  return getModVersion(type, modFile)
}

import java.util.regex.Matcher
String getModVersion(final String type, final String modFile) {
  if ((modFile != null) && (modFile != '')) {
    final File file = file(modFile)
    final def prefix = ~/^(?:\s*)(?:(?<modifier>public|protected|private) )?(?:(?<static>static) )?(?:(?<final>final) )?String $type = "(?:(?<major>\d*)\.)?(?:(?<minor>\d*)\.)?(?:(?<patch>[^."]*)\.?)(?<build>[^"]*)";$/
    for (final String s in file.readLines()) {
      final Matcher matcher = (s.trim() =~ prefix)
      if (matcher.matches()) {
        return "${matcher.group('major') ?: '0'}.${matcher.group('minor') ?: '0'}.${matcher.group('patch')}"
      }
    }
  }
  return '0.0.0'
}

boolean getBooleanProperty(final String property) {
  if (project.hasProperty(property)) {
    return ((String) project.findProperty(property)).toBoolean()
  } else {
    return false
  }
}

import se.bjurr.gitchangelog.plugin.gradle.GitChangelogTask
task gitChangelog(type: GitChangelogTask) {
  file = new File('CHANGELOG.md')
  gitHubIssuePattern = "nonada123"
  templateContent = file('changelog.mustache').getText('UTF-8')
}