Update dependencies (#4)

* Update Kotlin to 1.3.11
* Update Gradle to 5.1.1
* Update Android Gradle Plugin to 3.3.0
* Update RootCoveragePlugin for Gradle 5+ changes

Author: pavlospt

gradle/dependencies.gradle

@@ -4,13 +4,13 @@ ext {
             targetSdk   : 28,
             compileSdk  : 28,
             // Kotlin version is used in multiple places hence it is available as version variable
-            kotlin      : "1.2.71"
+            kotlin      : "1.3.11"
     ]
     projectDependency = [
 
             // Gradle Plugins
             kotlinPlugin      : "org.jetbrains.kotlin:kotlin-gradle-plugin:${projectVersion.kotlin}",
-            gradlePlugin      : "com.android.tools.build:gradle:3.2.1",
+            gradlePlugin      : "com.android.tools.build:gradle:3.3.0",
 
             // Dependencies
             kotlinStdlibJdk7  : "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${projectVersion.kotlin}",
@@ -28,4 +28,4 @@ ext {
             "org.jetbrains.kotlin.android": "${projectVersion.kotlin}",
             "org.jetbrains.kotlin.jvm": "${projectVersion.kotlin}"
     ]
-}
+}

gradle/wrapper/gradle-wrapper.jar

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradle/wrapper/gradle-wrapper.properties

@@ -177,41 +177,44 @@ class RootCoveragePlugin : Plugin<Project> {
 
         val name = variant.name.capitalize()
 
-        val task = project.tasks.create("codeCoverageReport$name", RootCoverageModuleTask::class.java)
-        task.group = null // null makes sure the group does not show in the gradle-view in Android Studio/Intellij
-        task.description = "Generate unified Jacoco code codecoverage report"
-
-        if (!rootProjectExtension.skipTestExecution) {
-            if (rootProjectExtension.testTypes.contains(TestVariantBuildOutput.TestType.UNIT)) {
-                task.dependsOn("test${name}UnitTest")
-            }
-            if (rootProjectExtension.testTypes.contains(TestVariantBuildOutput.TestType.ANDROID_TEST)) {
-                task.dependsOn("connected${name}AndroidTest")
+        val codeCoverageReportTask = project.tasks.register("codeCoverageReport$name", RootCoverageModuleTask::class.java)
+        codeCoverageReportTask.configure { task ->
+            task.group = null // null makes sure the group does not show in the gradle-view in Android Studio/Intellij
+            task.description = "Generate unified Jacoco code codecoverage report"
+
+            if (!rootProjectExtension.skipTestExecution) {
+                if (rootProjectExtension.testTypes.contains(TestVariantBuildOutput.TestType.UNIT)) {
+                    task.dependsOn("test${name}UnitTest")
+                }
+                if (rootProjectExtension.testTypes.contains(TestVariantBuildOutput.TestType.ANDROID_TEST)) {
+                    task.dependsOn("connected${name}AndroidTest")
+                }
             }
-        }
 
-        // Collect the class files based on the Java Compiler output
-        val javaClassTrees = variant.javaCompiler.outputs.files.map { file ->
-            project.fileTree(file, excludes = getFileFilterPatterns()).excludeNonClassFiles()
-        }
-        // Hard coded alternative to get class files for Java.
-        //val classesTree = project.fileTree(mapOf("dir" to "${project.buildDir}/intermediates/classes/${variant.dirName}", "excludes" to getFileFilterPatterns()))
+            // Collect the class files based on the Java Compiler output
+            val javaClassOutputs = variant.javaCompileProvider.get().outputs
+            val javaClassTrees = javaClassOutputs.files.map { file ->
+                project.fileTree(file, excludes = getFileFilterPatterns()).excludeNonClassFiles()
+            }
+            // Hard coded alternative to get class files for Java.
+            //val classesTree = project.fileTree(mapOf("dir" to "${project.buildDir}/intermediates/classes/${variant.dirName}", "excludes" to getFileFilterPatterns()))
 
-        // TODO: No idea how to dynamically get the kotlin class files output folder, so for now this is hardcoded.
-        // TODO: For some reason the tmp/kotlin-classes folder does not use the variant.dirName property, for now we instead use the variant.name.
-        val kotlinClassFolder = "${project.buildDir}/tmp/kotlin-classes/${variant.name}"
-        project.logger.info("Kotlin class folder for variant '${variant.name}': $kotlinClassFolder")
+            // TODO: No idea how to dynamically get the kotlin class files output folder, so for now this is hardcoded.
+            // TODO: For some reason the tmp/kotlin-classes folder does not use the variant.dirName property, for now we instead use the variant.name.
+            val kotlinClassFolder = "${project.buildDir}/tmp/kotlin-classes/${variant.name}"
+            project.logger.info("Kotlin class folder for variant '${variant.name}': $kotlinClassFolder")
 
-        val kotlinClassTree = project.fileTree(kotlinClassFolder, excludes = getFileFilterPatterns()).excludeNonClassFiles()
+            val kotlinClassTree = project.fileTree(kotlinClassFolder, excludes = getFileFilterPatterns()).excludeNonClassFiles()
 
-        // getSourceFolders returns ConfigurableFileCollections, but we only need the base directory of each ConfigurableFileCollection.
-        val sourceFiles = variant.getSourceFolders(SourceKind.JAVA).map { file -> file.dir }
+            // getSourceFolders returns ConfigurableFileCollections, but we only need the base directory of each ConfigurableFileCollection.
+            val sourceFiles = variant.getSourceFolders(SourceKind.JAVA).map { file -> file.dir }
 
-        task.sourceDirectories = project.files(sourceFiles)
-        task.classDirectories = project.files(javaClassTrees, kotlinClassTree)
-        task.executionData = project.fileTree(project.buildDir, includes = getExecutionDataFilePatterns())
+            task.sourceDirectories = project.files(sourceFiles)
+            task.classDirectories = project.files(javaClassTrees, kotlinClassTree)
+            task.executionData = project.fileTree(project.buildDir, includes = getExecutionDataFilePatterns())
+        }
 
-        return task
+        return codeCoverageReportTask.get()
     }
 
     private fun addSubTaskDependencyToRootTask(rootTask: JacocoReport, subModuleTask: RootCoverageModuleTask) {
@@ -221,19 +224,19 @@ class RootCoveragePlugin : Plugin<Project> {
 
         // Set or add the sub-task class directories to the root task
         if (rootTask.classDirectories == null) {
-            rootTask.classDirectories = subModuleTask.classDirectories
+            rootTask.classDirectories.setFrom(subModuleTask.classDirectories)
         } else {
-            rootTask.classDirectories += subModuleTask.classDirectories
+            rootTask.additionalClassDirs(subModuleTask.classDirectories)
         }
 
         // Set or add the sub-task source directories to the root task
         if (rootTask.sourceDirectories == null) {
-            rootTask.sourceDirectories = subModuleTask.sourceDirectories
+            rootTask.sourceDirectories.setFrom(subModuleTask.sourceDirectories)
         } else {
-            rootTask.sourceDirectories += subModuleTask.sourceDirectories
+            rootTask.additionalSourceDirs(subModuleTask.sourceDirectories)
         }
 
         // Add the sub-task class directories to the root task
         rootTask.executionData(subModuleTask.executionData)
     }
-}
+}