Experiments

gradle/commonStaticAnalysis.gradle

@@ -6,7 +6,7 @@ apply plugin: 'io.gitlab.arturbosch.detekt'
 def getCpdTask
 def getPmdTask
 def getCheckstyleTask
-def getLintTasks
+def getLintTask
 def getKotlinDetektTask
 
 def appendError
@@ -73,15 +73,19 @@ ext.getIdeaFormatTask = { isAndroidProject, sources ->
     }
 }
 
-ext.getStaticAnalysisTaskNames = { isAndroidProject, sources ->
+ext.getStaticAnalysisTaskNames = { isAndroidProject, sources, buildVariant, checkstyleEnabled, pmdEnabled ->
     def tasksNames = new ArrayList<String>()
     try {
         tasksNames.add(getCpdTask(isAndroidProject, sources))
         tasksNames.add(getKotlinDetektTask())
         if (isAndroidProject) {
+            if (checkstyleEnabled) {
                 tasksNames.add(getCheckstyleTask(sources))
+            }
+            if (pmdEnabled) {
                 tasksNames.add(getPmdTask(sources))
-            tasksNames.addAll(getLintTasks())
+            }
+            tasksNames.add(getLintTask(buildVariant))
         }
     } catch (Exception exception) {
         println(exception.toString())
@@ -111,13 +115,27 @@ ext.generateReport = { isAndroidProject ->
     }
 
     if (isAndroidProject) {
+        def checkstyleFile = new File("${project.buildDir}/reports/checkstyle.xml")
+        if (checkstyleFile.exists()) {
             previousCount = count
-        count = appendPmdErrors(count, new File("${project.buildDir}/reports/pmd.xml"))
+            count = appendCheckstyleErrors(count, checkstyleFile)
+            if (count - previousCount > 0) {
+                consoleReport.append("\nCheckstyle: FAILED (" + (count - previousCount) + " errors)")
+            } else {
+                consoleReport.append("\nCheckstyle: PASSED")
+            }
+        }
+
+        def pmdFile = new File("${project.buildDir}/reports/pmd.xml")
+        if (pmdFile.exists()) {
+            previousCount = count
+            count = appendPmdErrors(count, pmdFile)
             if (count - previousCount > 0) {
                 consoleReport.append("\nPMD: FAILED (" + (count - previousCount) + " errors)")
             } else {
                 consoleReport.append("\nPMD: PASSED")
             }
+        }
 
         previousCount = count
         count = appendLintErrors(count, new File("${project.buildDir}/reports/lint_report.xml"))
@@ -126,14 +144,6 @@ ext.generateReport = { isAndroidProject ->
         } else {
             consoleReport.append("\nLint: PASSED")
         }
-
-        previousCount = count
-        count = appendCheckstyleErrors(count, new File("${project.buildDir}/reports/checkstyle.xml"))
-        if (count - previousCount > 0) {
-            consoleReport.append("\nCheckstyle: FAILED (" + (count - previousCount) + " errors)")
-        } else {
-            consoleReport.append("\nCheckstyle: PASSED")
-        }
     }
 
     if (count > 0) {
@@ -254,7 +264,9 @@ appendLintErrors = { count, lintFile ->
 
 getCpdTask = { isAndroidProject, sources ->
     def taskName = (isAndroidProject ? "android" : "server") + "cpd_${project.name}"
-    tasks.create(taskName, tasks.findByName('cpdCheck').getClass().getSuperclass()) {
+    def task = tasks.findByName(taskName)
+    if (task == null) {
+        task = tasks.create(taskName, tasks.findByName('cpdCheck').getClass().getSuperclass()) {
             minimumTokenCount = 60
             source = files(sources)
             ignoreFailures = true
@@ -265,12 +277,15 @@ getCpdTask = { isAndroidProject, sources ->
                 }
             }
         }
-    return taskName
+    }
+    return task.name
 }
 
 getPmdTask = { sources ->
     def taskName = "pmd_${project.name}"
-    tasks.create(taskName, Pmd) {
+    def task = tasks.findByName(taskName)
+    if (task == null) {
+        task = tasks.create(taskName, Pmd) {
             pmdClasspath = configurations.pmd.asFileTree
             ruleSetFiles = files "$buildScriptsDir/pmd/rulesets/java/android.xml"
             ruleSets = []
@@ -287,24 +302,18 @@ getPmdTask = { sources ->
                 }
             }
         }
-    return taskName
+    }
+    return task.name
 }
 
-getLintTasks = {
+getLintTask = { buildVariant ->
-    def lintTaskNames = new ArrayList<String>()
+    def lintTaskName
-
+    if (buildVariant != null) {
-    def lintReleaseTask = tasks.matching {
+        lintTaskName = "lint${buildVariant.name.capitalize()}"
-        it.getName().contains("lint") && it.getName().contains("Release")
+    } else {
-    }.first()
+        def lintDebugTask = tasks.matching { it.getName().contains("lint") && it.getName().contains("Debug") }.first()
-    //TODO return on jack lintReleaseTask.dependsOn.clear()
+        lintTaskName = lintDebugTask.getName()
-    lintTaskNames.add(lintReleaseTask.getName())
+    }
-
-    def lintDebugTask = tasks.matching {
-        it.getName().contains("lint") && it.getName().contains("Debug")
-    }.first()
-    //TODO return on jack lintDebugTask.dependsOn.clear()
-    lintTaskNames.add(lintDebugTask.getName())
-
     android.lintOptions.abortOnError = false
     android.lintOptions.checkAllWarnings = true
     android.lintOptions.warningsAsErrors = false
@@ -312,15 +321,17 @@ getLintTasks = {
     android.lintOptions.xmlOutput = file "$project.buildDir/reports/lint_report.xml"
     android.lintOptions.htmlReport = false
     android.lintOptions.lintConfig = file "$buildScriptsDir/lint/lint.xml"
-    return lintTaskNames
+    return lintTaskName
 }
 
 getCheckstyleTask = { sources ->
-    def taskName = "checkstyle_${project.name}"
+    def taskName = "checkstyle_$project.name"
+    def task = tasks.findByName(taskName)
+    if (task == null) {
         def compileReleaseTask = tasks.matching {
             it.getName().contains("compile") && it.getName().contains("Release") && it.getName().contains("Java") && !it.getName().contains("UnitTest")
         }.last()
-    tasks.create(taskName, Checkstyle) {
+        task = tasks.create(taskName, Checkstyle) {
             ignoreFailures = true
             showViolations = false
             source files(sources)
@@ -336,12 +347,11 @@ getCheckstyleTask = { sources ->
                 }
             }
         }
-    return taskName
+    }
+    return task.name
 }
 
-getKotlinDetektTask = {
+getKotlinDetektTask = { "detekt" }
-    return "detekt"
-}
 
 task optimizePng {
     doFirst {

gradle/staticAnalysis.gradle

@@ -18,10 +18,14 @@ gradle.projectsEvaluated {
     }
 
     def excludes = rootProject.extensions.findByName("staticAnalysisExcludes")
+    def checkstyleEnabled = rootProject.extensions.findByName("checkstyleEnabled") ?: false
+    def pmdEnabled = rootProject.extensions.findByName("pmdEnabled") ?: false
 
-    def androidStaticAnalysisTasks = getStaticAnalysisTaskNames(true, getAndroidProjectSources(excludes))
+    def androidSources = getAndroidProjectSources(excludes)
-    def androidIdeaFormatTask = getIdeaFormatTask(true, getAndroidProjectSources(excludes))
+    def androidStaticAnalysisTasks = getStaticAnalysisTaskNames(true, androidSources, null, checkstyleEnabled, pmdEnabled)
-    task staticAnalysis {
+    def androidIdeaFormatTask = getIdeaFormatTask(true, androidSources)
+
+    task staticAnalysisWithFormatting {
         androidStaticAnalysisTasks.each { task ->
             tasks.findByName(task).mustRunAfter(androidIdeaFormatTask)
         }
@@ -32,16 +36,17 @@ gradle.projectsEvaluated {
         }
     }
 
-    task staticAnalysisWithoutFormatting {
+    task staticAnalysis {
         dependsOn androidStaticAnalysisTasks
         doFirst {
             generateReport(true)
         }
     }
 
-    def serverStaticAnalysisTasks = getStaticAnalysisTaskNames(false, getServerProjectSources(excludes))
+    def serverStaticAnalysisTasks = getStaticAnalysisTaskNames(false, getServerProjectSources(excludes), null, checkstyleEnabled, pmdEnabled)
     def serverIdeaFormatTask = getIdeaFormatTask(false, getServerProjectSources(excludes))
-    task serverStaticAnalysis {
+
+    task serverStaticAnalysisWithFormatting {
         serverStaticAnalysisTasks.each { task ->
             tasks.findByName(task).mustRunAfter(serverIdeaFormatTask)
         }
@@ -52,12 +57,19 @@ gradle.projectsEvaluated {
         }
     }
 
-    task serverStaticAnalysisWithoutFormatting {
+    task serverStaticAnalysis {
         dependsOn serverStaticAnalysisTasks
         doFirst {
             generateReport(false)
         }
     }
+
+    android.applicationVariants.all { variant ->
+        task("staticAnalysis${variant.name.capitalize()}") {
+            dependsOn getStaticAnalysisTaskNames(true, androidSources, variant, checkstyleEnabled, pmdEnabled)
+            doFirst { generateReport(true) }
+        }
+    }
 }
 
 getServerProjectSources = { excludes ->

gradle/stringGenerator.gradle

@@ -1,94 +0,0 @@
-import groovy.json.JsonSlurper
-import groovy.xml.MarkupBuilder
-
-task stringGenerator {
-    final Map<String, String> languageMap = android.extensions.findByName("languageMap")
-
-    generate(languageMap)
-    println("Strings generated!")
-}
-
-private def generate(Map<String, String> sources) {
-    if (sources == null || sources.isEmpty()) {
-        throw new IOException("languageMap can't be null or empty")
-    }
-    Map jsonMap = getJsonsMap(sources)
-    def diffs = calcDiffs(jsonMap)
-    if (!diffs.isEmpty()) {
-        printDiffs(diffs)
-        throw new IllegalStateException("Strings source can't be different")
-    }
-    def defaultLang = getDefaultLangKey(sources)
-    jsonMap.forEach { key, json ->
-
-        def sw = new StringWriter()
-        def xml = new MarkupBuilder(sw)
-
-        xml.setDoubleQuotes(true)
-        xml.mkp.xmlDeclaration(version: "1.0", encoding: "utf-8")
-        xml.resources() {
-            json.each {
-                k, v ->
-                    string(name: "${k}", formatted: "false", "${v}".replace('\n', '\\n'))
-            }
-        }
-
-        def stringsFile = getFile(key, key == defaultLang)
-        stringsFile.write(sw.toString(), "UTF-8")
-    }
-}
-
-private printDiffs(Map<?, ?> diffs) {
-    def diffLog = new StringBuilder()
-    diffs.forEach { k, v ->
-        if (v.size() > 0) {
-            diffLog.append("For $k was missed string keys: ${v.size()}\n")
-            v.forEach {
-                diffLog.append("\tString key: $it\n")
-            }
-        }
-    }
-    println(diffLog.toString())
-}
-
-private static def calcDiffs(Map<String, Object> jsonsMap) {
-    if (jsonsMap.size() == 1) {
-        return [:]
-    }
-    def keys = jsonsMap.collectEntries {
-        [(it.key): (it.value).keySet() as List]
-    }
-    def inclusive = keys.get(keys.keySet().first())
-    def diffs = keys.collectEntries {
-        [(it.key): inclusive - it.value.intersect(inclusive)]
-    }.findAll { it.value.size() > 0 }
-    return diffs
-}
-
-private static Map<String, Object> getJsonsMap(Map sources) {
-    return sources.collectEntries {
-        [(it.key): new JsonSlurper().parseText(new File(it.value).text)]
-    }
-}
-
-private static File getFile(String key, boolean defaultLang) {
-    if (defaultLang) {
-        return new File("app/src/main/res/values/strings.xml")
-    } else {
-        def directory = new File("app/src/main/res/values-$key")
-        if (!directory.exists()) {
-            directory.mkdir()
-        }
-        return new File("app/src/main/res/values-$key/strings.xml")
-    }
-}
-
-private static String getDefaultLangKey(Map<String, String> sources) {
-    def defaultLanguage = sources.find { it.value.contains("default") }
-    if (defaultLanguage != null) {
-        return defaultLanguage.key
-    } else {
-        throw new IOException("Can't find default language")
-    }
-
-}

gradle/stringGenerator.gradle.kts

@@ -0,0 +1,97 @@
+import groovy.json.JsonSlurper
+import groovy.xml.MarkupBuilder
+import org.gradle.api.internal.plugins.DefaultExtraPropertiesExtension
+
+task("stringGenerator") {
+//    val languageMap: Map<String, String>? = android.extensions.findByName("languageMap")
+
+    println(extra.properties)
+//    println(android.ext)
+//    generate(languageMap)
+    println("Strings generated!")
+}
+
+//private def generate(Map<String, String> sources) {
+//    if (sources == null || sources.isEmpty()) {
+//        throw new IOException("languageMap can't be null or empty")
+//    }
+//    Map jsonMap = getJsonsMap(sources)
+//    def diffs = calcDiffs(jsonMap)
+//    if (!diffs.isEmpty()) {
+//        printDiffs(diffs)
+//        throw new IllegalStateException("Strings source can't be different")
+//    }
+//    def defaultLang = getDefaultLangKey(sources)
+//    jsonMap.forEach { key, json ->
+//
+//        def sw = new StringWriter()
+//        def xml = new MarkupBuilder(sw)
+//
+//        xml.setDoubleQuotes(true)
+//        xml.mkp.xmlDeclaration(version: "1.0", encoding: "utf-8")
+//        xml.resources() {
+//            json.each {
+//                k, v ->
+//                    string(name: "${k}", formatted: "false", "${v}".replace('\n', '\\n'))
+//            }
+//        }
+//
+//        def stringsFile = getFile(key, key == defaultLang)
+//        stringsFile.write(sw.toString(), "UTF-8")
+//    }
+//}
+//
+//private printDiffs(Map<?, ?> diffs) {
+//    def diffLog = new StringBuilder()
+//    diffs.forEach { k, v ->
+//        if (v.size() > 0) {
+//            diffLog.append("For $k was missed string keys: ${v.size()}\n")
+//            v.forEach {
+//                diffLog.append("\tString key: $it\n")
+//            }
+//        }
+//    }
+//    println(diffLog.toString())
+//}
+//
+//private static def calcDiffs(Map<String, Object> jsonsMap) {
+//    if (jsonsMap.size() == 1) {
+//        return [:]
+//    }
+//    def keys = jsonsMap.collectEntries {
+//        [(it.key): (it.value).keySet() as List]
+//    }
+//    def inclusive = keys.get(keys.keySet().first())
+//    def diffs = keys.collectEntries {
+//        [(it.key): inclusive - it.value.intersect(inclusive)]
+//    }.findAll { it.value.size() > 0 }
+//    return diffs
+//}
+//
+//private static Map<String, Object> getJsonsMap(Map sources) {
+//    return sources.collectEntries {
+//        [(it.key): new JsonSlurper().parseText(new File(it.value).text)]
+//    }
+//}
+//
+//private static File getFile(String key, boolean defaultLang) {
+//    if (defaultLang) {
+//        return new File("app/src/main/res/values/strings.xml")
+//    } else {
+//        def directory = new File("app/src/main/res/values-$key")
+//        if (!directory.exists()) {
+//            directory.mkdir()
+//        }
+//        return new File("app/src/main/res/values-$key/strings.xml")
+//    }
+//}
+//
+//private static String getDefaultLangKey(Map<String, String> sources) {
+//    def defaultLanguage = sources.find { it.value.contains("default") }
+//    if (defaultLanguage != null) {
+//        return defaultLanguage.key
+//    } else {
+//        throw new IOException("Can't find default language")
+//    }
+//
+//}