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 {

    repositories {
        maven { url 'https://www.jitpack.io' }
        maven { url "https://pms2021u.isecret.im/nexus3/repository/maven-public/"}
        google()
        jcenter()
        mavenCentral()
    }

    dependencies {
        classpath "com.android.tools.build:gradle:${Versions.PLUGIN_GRADLE_VERSION}"
        classpath "com.mutualmobile.gradle.plugins:dexinfo:${Versions.PLUGIN_DEXINFO_VERSION}"
        classpath "com.wire:gradle-android-scala-plugin:${Versions.PLUGIN_SCALA_VERSION}"
        classpath "com.google.gms:google-services:${Versions.PLUGIN_GMS_VERSION}"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${Versions.KOTLIN_VERSION}"
        classpath "org.ajoberstar.grgit:grgit-core:${Versions.PLUGIN_GRGIT_VERSION}"
        classpath 'com.github.os72:protoc-jar:3.0.0-b1'
        classpath 'com.github.ghik:silencer-plugin_2.11:0.6'
        classpath 'com.android.tools.build.jetifier:jetifier-processor:1.0.0-beta02'
    }
}

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

ext {

    // 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)
    }
}

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

allprojects {
    repositories {
        google()
        jcenter()
        mavenLocal()
        maven { url 'https://www.jitpack.io' }
        maven { url "https://pms2021u.isecret.im/nexus3/repository/maven-public/"}
        maven { url "https://jitpack.io" }
        mavenCentral()
    }
}

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

task ci(dependsOn: [
    ':app:assembleDevDebug',
    ':app:lintDevDebug',
    ':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
    String toString() {
        return "${file}:${line}:${column}: ${error}"
    }
}

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

class PmdIssue extends Issue {
    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 {
    CheckstyleIssue(File file, Node node) {
        this.file = file
        line = node.'@line'
        column = node.'@column'
        error = node.'@message'
    }
}