• Home
• se.bjurr.gradle
• gradle-scripts
• 2.28.2
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

le.gradle-scripts.2.28.2.source-code.main.gradle Maven / Gradle / Ivy

def configureChangelog() {
  def configuredGitHubToken = System.getenv(effectiveConfig.changelog.githubTokenEnvVariableName)
  task gitChangelogTask(type: se.bjurr.gitchangelog.plugin.gradle.GitChangelogTask) {
    if (configuredGitHubToken != null) {
      gitHubApi = "https://api.github.com/repos/" + effectiveConfig.changelog.githubOrganization + "/" + project.name;
      gitHubToken = configuredGitHubToken;
      logger.lifecycle("Using Github API ${gitHubApi}")
    } else {
      logger.lifecycle("Did not find Github token ${effectiveConfig.changelog.githubTokenEnvVariableName} env variable.")
    }
    jiraIssuePattern = effectiveConfig.changelog.jiraIssuePattern;
    ignoreCommitsIfMessageMatches = effectiveConfig.changelog.ignoreCommitsIfMessageMatches;
  }
}

def findResource(String name, classLoader = project.buildscript.classLoader) {
  URL resource = classLoader.getResource(name)
  if (resource == null) {
    logger.lifecycle("Cannot find resource \"${name}\"")
    return null;
  }
  return resource
}

def copyResourceToFile(URL resource, String copyTo, classLoader = project.buildscript.classLoader) {
  logger.lifecycle("Copying ${resource} to ${copyTo}")
  def content = resource.text
  def parentFile = new File(copyTo).getParentFile()
  if (parentFile != null) {
    parentFile.mkdirs()
  }
  FileWriter fw = new FileWriter(copyTo)
  BufferedWriter bw = new BufferedWriter(fw)
  bw.write(content)
  bw.close()
}

def copyIfFound(String name, String target=null, classLoader = project.buildscript.classLoader) {
  URL resource = findResource(name, classLoader)
  if (resource != null) {
    logger.lifecycle("Found resource ${name} as ${resource}")
    def newFilename = target == null ? "$buildDir/$name" : target
    copyResourceToFile(resource, newFilename)
    return new File(newFilename)
  }
}

def File getFile(String name) {
  def f = new File(name)
  if (!f.exists()) {
    logger.lifecycle("Cannot find file \"${name}\"")
  } else {
    logger.lifecycle("Found file \"${name}\"")
  }
  return f
}

def File getResourceAsFile(String name, classLoader = project.buildscript.classLoader) {
  def f = getFile(name)
  if (f.exists()) {
    return f
  }

  f = getFile("src/main/resources/"+name)
  if (f.exists()) {
    return f
  }

  throw new RuntimeException("Cannot find resource ${name}")
}

def configureStaticCodeAnalysis() {
  apply plugin: com.github.spotbugs.snom.SpotBugsPlugin
  apply plugin: se.bjurr.violations.gradle.plugin.ViolationsGradlePlugin
  apply plugin: 'pmd'

  assemble.doLast {
    copyIfFound("spotbugs-exclude.xml")
    copyIfFound("pmd.xml")
  }

  dependencies {
    spotbugs 'com.github.spotbugs:spotbugs:4.8.3'
    compileOnly "com.github.spotbugs:spotbugs-annotations:${spotbugs.toolVersion.get()}"
  }

  tasks.withType(com.github.spotbugs.snom.SpotBugsTask) {
    enabled = false
  }

  spotbugsMain {
    enabled = true
    ignoreFailures = true
    effort = com.github.spotbugs.snom.Effort.MAX
    showProgress = true
    showStackTraces = false
    excludeFilter = new File("$buildDir/spotbugs-exclude.xml")
    reportsDir = new File("$buildDir/reports/spotbugs/")
    reports {
      xml {
        enabled true
      }
    }
  }

  dependencies {
    spotbugsPlugins 'com.h3xstream.findsecbugs:findsecbugs-plugin:1.12.0'
  }

  pmd {
    sourceSets = [sourceSets.main]
    toolVersion = '6.55.0'
    ruleSets = [] // Gradle has some defaults that needs to be cleared
    ruleSetFiles = files("$buildDir/pmd.xml")
  }
  pmdMain {
    source = "src/main/java"
    ignoreFailures = true
    reports {
      xml.required = true
      html.required = true
    }
  }


  task violations(type: se.bjurr.violations.gradle.plugin.ViolationsTask) {
    minSeverity = 'INFO'
    detailLevel = 'VERBOSE' // PER_FILE_COMPACT, COMPACT or VERBOSE
    maxViolations = effectiveConfig.staticCodeAnalysis.maxViolations
    printViolations = true

    // Many more formats available, see: https://github.com/tomasbjerre/violations-lib
    violations = [
      ["FINDBUGS", ".", ".*/build/reports/findbugs/.*\\.xml\$","Findbugs"],
      ["FINDBUGS", ".", ".*/build/reports/spotbugs/.*\\.xml\$","Spotbugs"],
      ["PMD", ".", ".*/build/reports/pmd/.*\\.xml\$","Pmd"],
      ["GOOGLEERRORPRONE", ".", ".*/build/googleErrorProne.*\\.log\$","Error Prone"]
    ]
  }

  check.finalizedBy violations
}

def configureFormatting() {
  apply plugin: com.diffplug.gradle.spotless.SpotlessPlugin

  check.dependsOn spotlessApply

  spotless {
    java {
      target '**/*.java'
      googleJavaFormat()
      targetExclude effectiveConfig.formattingExcludedPatterns
    }
  }
}

def addSourceFolderIfExists(String folder) {
  if (new File(folder).exists()) {
    logger.lifecycle("Detected ${folder}, adding it as source folder")
    sourceSets.main.java.srcDirs += [ folder ]
  }
}

def addTestSourceFolderIfExists(String folder) {
  if (new File(folder).exists()) {
    logger.lifecycle("Detected ${folder}, adding it as test source folder")
    sourceSets.test.java.srcDirs += [ folder ]
  }
}

def configureJava() {
  apply plugin: 'java-library'
  apply plugin: 'eclipse'

  sourceCompatibility = effectiveConfig.sourceCompatibility
  targetCompatibility = effectiveConfig.targetCompatibility

  repositories {
    mavenLocal()
    mavenCentral()
  }

  effectiveConfig.generatedSourceFolders.each {
    addSourceFolderIfExists(it)
  }

  effectiveConfig.extraTestSourceFolders.each {
    addTestSourceFolderIfExists(it)
  }

  test {
    if (System.getProperty('DEBUG', 'false') == 'true') {
      jvmArgs '-Xdebug',
        '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=9009',
        '-parameters'
    }
  }

  if (JavaVersion.current().isJava8Compatible()) {
    allprojects {
      tasks.withType(Javadoc) {
        options.addStringOption('Xdoclint:none', '-quiet')
      }
    }
  }

  eclipse {
    classpath {
      downloadSources = true
      downloadJavadoc = true
    }
  }

  java {
    withSourcesJar()
    withJavadocJar()
  }

  if (effectiveConfig.manifest.mainClass != '') {
    jar {
      manifest {
        attributes 'Main-Class': effectiveConfig.manifest.mainClass
      }
      if (new File(effectiveConfig.jarResourcesFolder).exists()) {
        from effectiveConfig.jarResourcesFolder
      }
    }
  }
}

def getNewVersion(String oldVersionName, String bump) {
  def (major, minor, patch) = oldVersionName
  .replaceAll("[^0-9\\.]","")
  .concat(".0.0")
  .tokenize('.')
  major = major.toInteger()
  minor = minor.toInteger()
  patch = patch.toInteger()
  if (bump == "Major") { major++; minor = 0; patch = 0; }
  if (bump == "Minor") { minor++; patch = 0; }
  if (bump == "Patch") { patch++ }
  def newVersionName = "$major.$minor.$patch"
  logger.lifecycle("$oldVersionName → $newVersionName")
  return newVersionName
}

def bumpVersionTo(version) {
  def propertyFile = new File("$projectDir/gradle.properties")
  def gradleProps = new Properties()
  propertyFile.withReader { gradleProps.load(it) }
  gradleProps.setProperty('version', version)
  propertyFile.withWriter { gradleProps.store(it, null) }
  gradle.buildFinished { result ->
    if (result.failure) {
      [
        "gradle.properties"
      ].each {
        logger.lifecycle("Restoring ${it} because of failure")
        runCommand(["git", "checkout", it])
      }
    }
  }
}

def bumpVersion(type) {
  logger.lifecycle("Bumping ${type.toLowerCase()} version…")
  String oldVersionName = project.version
  version = getNewVersion(oldVersionName, type)
  bumpVersionTo(version)
}

def runCommand(args, int attempts = 5) {
  logger.lifecycle("Executing ${args.join(' ')}")
  def stdout = new ByteArrayOutputStream()
  try {
    exec {
      commandLine args
      standardOutput = stdout
    }
    return stdout.toString().trim()
  } catch (e) {
    def err = stdout.toString().trim() + "\n" + "Command: ${args.join(' ')}" + "\n" + "Trying ${attempts} more times"
    logger.lifecycle(err)
    if (attempts == 0) {
      throw new RuntimeException(err, e)
    }
    sleep(5 * 1000)
    return runCommand(args, attempts - 1)
  }
}

def doPost(String url, String authString, String payload, Integer attempts = 20) {
  logger.lifecycle("> POST ${url} ${payload}")
  def responseCode = 0
  def content = ""
  def responseMessage = ""
  try {
    def conn = url.toURL().openConnection()
    conn.setRequestMethod("POST")
    conn.setRequestProperty("Authorization", "Basic ${authString}")
    conn.setRequestProperty("Accept", "application/json")
    conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8")
    conn.setDoOutput( true )

    Writer wr = new OutputStreamWriter(conn.outputStream)
    wr.write(payload);
    wr.flush()
    wr.close()
    conn.connect()
    responseCode = conn.responseCode
    content = conn.content
    responseMessage = conn.responseMessage
  } catch (e) {
    // Ignore
  }

  if(responseCode == 201){
    logger.lifecycle("OK")
  } else {
    logger.error("Content: "+content)
    def msg = "There was an error with repositories: ${responseCode} ${responseMessage}"
    if (attempts == 0) {
      throw new Exception(msg)
    } else {
      logger.lifecycle(msg+". ${attempts} left.")
      sleep(5000)
      doPost(url, authString, payload, attempts - 1)
    }
  }
}

List