build.gradle

import groovy.json.JsonSlurper
import org.ajoberstar.grgit.Grgit
import org.ajoberstar.grgit.Credentials

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {

    ext.kotlinVersion = '1.3.10'

    repositories {
        maven {
            url "https://dl.bintray.com/wire-android/third-party"
        }
        google()
        jcenter()
        mavenCentral()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:3.2.1'
        classpath 'com.jakewharton.hugo:hugo-plugin:1.2.1'
        classpath 'com.mutualmobile.gradle.plugins:dexinfo:0.1.2'
        classpath 'com.wire:gradle-android-scala-plugin:1.5.0'
        classpath 'com.google.gms:google-services:3.1.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
        classpath 'org.ajoberstar.grgit:grgit-core:3.0.0'
    }
}

plugins {
    id "com.github.hierynomus.license" version "0.13.1"
}

license {
    header = file('LICENSE_HEADER')
    ext.year = Calendar.getInstance().get(Calendar.YEAR)
    ext.name = 'Wire Swiss GmbH'
    skipExistingHeaders = true
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

task licenseFormatAndroid(type: nl.javadude.gradle.plugins.license.License) {
    source = fileTree(dir: getRootDir()).include([
            "**/*.java",
            "**/*.scala",
            "**/*.gradle",
            "**/*.xml",
    ]).exclude([
            "**/*build*",
            "**/*target*",
            "**/*gen*",
            "**/*generated*",
    ])
}
licenseFormat.dependsOn licenseFormatAndroid

ext {
    compileSdkVersion = 27
    // When upgrading minimum sdk you might want to search for occurrences of Build.VERSION_CODES.
    // There are some classes with possibility of being simplified.
    minSdkVersion = 17
    targetSdkVersion = 27

    buildToolsVersion = '28.0.3'
    sourceCompatibilityVersion = JavaVersion.VERSION_1_8
    targetCompatibilityVersion = JavaVersion.VERSION_1_8

    // directory where customization files live
    wireConfig = new File("$rootDir/default.json")
    isCleanTask = gradle.startParameter.taskNames.contains("clean")

    customFolder = System.getenv("CUSTOM_FOLDER") ?: ''
    customRepository = System.getenv("CUSTOM_REPOSITORY") ?: ''
    token = System.getenv("API_TOKEN") ?: ''

    repoDir = "$rootDir/custom"
    customDir = repoDir
    if (!customFolder.isEmpty()) {
        customDir = customDir + '/' + customFolder
    }
    customConfig = file("$customDir/custom.json")

    def repo = file(repoDir)
    if (repo.exists()) {
        delete repo
    }

    def slurper = new JsonSlurper()
    config = null

    if (!customRepository.isEmpty() && !token.isEmpty()) {
        credentials = new Credentials(token, '')
        Grgit.clone(dir: repoDir, uri: customRepository, credentials: credentials)
        project.logger.info("Cloned $repoDir to $customRepository")
        config = slurper.parseText(customConfig.text)
    } else {
        config = slurper.parseText(wireConfig.text)
    }
}

allprojects {
    repositories {
        mavenLocal()
        maven { url "https://dl.bintray.com/wire-android/releases" }
        maven { url "https://dl.bintray.com/wire-android/snapshots" }
        maven { url "https://dl.bintray.com/wire-android/third-party" }
        maven { url 'https://maven.google.com' }
        mavenCentral()
    }
}

task ci(dependsOn: [
                    ':app:assembleDevDebug',
                    ':app:lintDevDebug',
                    // By default on whole app
                    //':app:checkstyle',
                    ':app:pmd'
                    ]) {

    doLast {
        def lintReportsPattern = /\/?(.*)\/build\/outputs\/lint-results\-(devDebug|debug)\.xml/
        def pmdReportsPattern = /\/?(.*)\/build\/reports\/pmd\/pmd\.xml/
        def checkstyleReportsPattern = /\/?(.*)\/reports\/checkstyle\/checkstyle\.xml/

        def results = new HashMap<String, Map<String, List<Issue>>>()
        def totalIssues = 0

        def findFilenameClosure = {
            if (it.isDirectory()) {
                return;
            }
            def absolutePath = it.getAbsolutePath()
            def foundIssues = new ArrayList<Issue>()
            def type = ''
            if (absolutePath.matches(lintReportsPattern)) {
                def issues = new XmlParser().parse(it)
                type = 'Lint'
                issues.issue.each {
                    def id = it.'@summary'
                    it.location.each { foundIssues.add(new LintIssue(id, it)) }
                }
            } else if (absolutePath.matches(pmdReportsPattern)) {
                def issues = new XmlParser().parse(it)
                type = 'PMD'
                issues.file.each {
                    def file = new File(it.'@name')
                    it.violation.each { foundIssues.add(new PmdIssue(file, it)) }
                }
            } else if (absolutePath.matches(checkstyleReportsPattern)) {
                def files = new XmlParser().parse(it)
                type = 'Checkstyle'
                files.file.findAll { it.children().size() > 0 }.each {
                    def file = new File(it.'@name')
                    it.error.each { foundIssues.add(new CheckstyleIssue(file, it)) }
                }
            }
            if (foundIssues.size() > 0) {
                if (!results.containsKey(type)) {
                    results.put(type, new HashMap<String, List<Issue>>())
                }
                results.get(type).put(it, foundIssues)
                totalIssues += foundIssues.size()
            }
        }

        rootProject.rootDir.eachFileRecurse(findFilenameClosure)

        if (totalIssues > 0) {
            def message = new StringBuilder()
            message.append("Found ${totalIssues} issue${totalIssues == 1 ? '' : 's'}\n\n")
            for (def entry : results.entrySet()) {
                def issues = new StringBuilder()
                def count = 0;
                for (def file : entry.value.entrySet()) {
                    issues.append("> ${file.value.size()} in ${file.key}\n")
                    file.value.each { issues.append("\t${it}\n")}
                    count += file.value.size()
                }
                message.append("${entry.key}: ${count} issue${count == 1 ? '' : 's'}\n")
                        .append(issues.toString())
                        .append('\n')
            }
            throw new Exception(message.toString())
        } else {
            println 'No issues found'
        }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
    def repo = file(repoDir)
    if (repo.exists()) {
        delete repo
    }
}


class Issue {
    File file
    String line
    String column
    String error

    @Override
    public String toString() {
        return "${file}:${line}:${column}: ${error}";
    }
}

class LintIssue extends Issue {
    def LintIssue(String error, Node location) {
        file = new File(location.'@file')
        line = location.'@line'
        column = location.'@column'
        this.error = error
    }
}

class PmdIssue extends Issue {
    def PmdIssue(File file, Node violation) {
        this.file = file
        def beginline = violation.'@beginline'
        def endline = violation.'@endline'
        line = beginline == endline ? beginline : "${beginline}-${endline}"
        column = violation.'@begincolumn'
        error = violation.text().replaceAll(/\n/, '')
    }
}

class CheckstyleIssue extends Issue {
    def CheckstyleIssue(File file, Node node) {
        this.file = file
        line = node.'@line'
        column = node.'@column'
        error = node.'@message'
    }
}