#140 Only attempt to detect Scala version if it isn't already configured by the scoverageScalaVersion option

Author: eyalroth

Diff for: README.md

@@ -46,8 +46,8 @@ build script. These options are as follows:
 * `scoverageVersion = <String>` (default `"1.4.1"`): The version of the scoverage scalac plugin. This (gradle) plugin
 should be compatible with all 1+ versions.
 
-* `scoverageScalaVersion = <String>` (default `"2.12"`): The scala version of the scoverage scalac plugin. This will
-be overridden by the version of the `scala-library` compile dependency (if the dependency is configured).
+* `scoverageScalaVersion = <String>` (default `"2.12"`): The scala version of the scoverage scalac plugin. This
+overrides the version of the `scala-library` compile dependency (if the dependency is configured).
 
 * `coverageOutputCobertura = <boolean>` (default `true`): Enables/disables cobertura.xml file generation (for both aggregated and non-aggregated reports).
 
@@ -115,6 +115,13 @@ it is possible to only compile the code with the scoverage scalac plugin, thus r
 In order to do so, simply add the arguments `-x compileScala` to the gradle execution.
 For example: `gradle reportScoverage -x compileScala`.
 
+
+### Compatibility with Consistent Versions Plugin
+
+In order for the plugin to work alongside [Palantir's consistent versions plugin](https://github.com/palantir/gradle-consistent-versions),
+the Scala version must be manually configured (via `scoverageScalaVersion`); otherwise, the plugin will attempt to
+resolve the compilation classpath, which is prohibited by the versions plugin.
+
 Migration to 4.x
 ----------------
 

Diff for: src/functionalTest/java/org/scoverage/DetectScalaLibraryTest.java

@@ -16,8 +16,9 @@ public class DetectScalaLibraryTest extends ScoverageFunctionalTest {
     private static final String SCALA_VERSION = "2.12";
     private static final String SCALA_LIBRARY_PARAMETER = "-PdetectedScalaLibraryVersion=";
 
-    private static final String EXPECTED_OUTPUT_A = "Detected scala library in compilation classpath";
-    private static final String EXPECTED_OUTPUT_B = "Using scoverage scalac plugin version '" + SCALA_VERSION;
+    private static final String EXPECTED_OUTPUT_CONFIGURED_VERSION = "Using configured Scala version";
+    private static final String EXPECTED_OUTPUT_DETECTED_VERSION = "Detected scala library in compilation classpath";
+    private static final String EXPECTED_OUTPUT_USING = "Using scoverage scalac plugin version '" + SCALA_VERSION;
 
     @Parameterized.Parameter(0)
     public String projectDir;
@@ -26,16 +27,19 @@ public class DetectScalaLibraryTest extends ScoverageFunctionalTest {
     public String[] subVersions;
 
     @Parameterized.Parameter(2)
+    public boolean detect;
+
+    @Parameterized.Parameter(3)
     public String[] additionalParameters;
 
     @Parameterized.Parameters(name = "{index}: Project {0} ")
     public static Collection<Object[]> data() {
         Object[][] data = new Object[][]{
-                {"/compile", new String[] {".0", ".+"}, new String[0]},
-                {"/compileOnly", new String[] {".0", ".+"}, new String[0]},
-                {"/implementation", new String[] {".0", ".+"}, new String[0]},
-                {"/dependency-management", new String[] {".0", ".+"}, new String[0]},
-                {"/gradle-consistent-versions", new String[] {"ignored"}, new String[] {"--write-locks"}},
+                {"/compile", new String[] {".0", ".+"}, true, new String[0]},
+                {"/compileOnly", new String[] {".0", ".+"}, true, new String[0]},
+                {"/implementation", new String[] {".0", ".+"}, true, new String[0]},
+                {"/dependency-management", new String[] {".0", ".+"}, true, new String[0]},
+                {"/gradle-consistent-versions", new String[] {"ignored"}, false, new String[] {"--write-locks"}},
         };
         return Arrays.asList(data);
     }
@@ -48,20 +52,24 @@ public DetectScalaLibraryTest() {
     public void test() {
         setProjectName("detect-scala-library" + projectDir);
         for (String subVersion : subVersions) {
-            testWithParameter(SCALA_LIBRARY_PARAMETER + SCALA_VERSION + subVersion);
+            testWithParameter(SCALA_LIBRARY_PARAMETER + SCALA_VERSION + subVersion, detect);
         }
     }
 
-    private void testWithParameter(String parameter) {
+    private void testWithParameter(String parameter, Boolean detect) {
 
         String[] basicParameters = {"clean", parameter, "--info"};
         String[] parameters = Stream.concat(Arrays.stream(basicParameters), Arrays.stream(additionalParameters))
                 .toArray(String[]::new);
         AssertableBuildResult result = dryRun(parameters);
 
         String output = result.getResult().getOutput();
-        Assert.assertTrue(output.contains(EXPECTED_OUTPUT_A));
-        Assert.assertTrue(output.contains(EXPECTED_OUTPUT_B));
+        if (detect) {
+            Assert.assertTrue(output.contains(EXPECTED_OUTPUT_DETECTED_VERSION));
+        } else {
+            Assert.assertTrue(output.contains(EXPECTED_OUTPUT_CONFIGURED_VERSION));
+        }
+        Assert.assertTrue(output.contains(EXPECTED_OUTPUT_USING));
     }
 
 }

Diff for: src/functionalTest/resources/projects/detect-scala-library/gradle-consistent-versions/build.gradle

@@ -11,4 +11,9 @@ description = 'defines scala library using the "implementation" configuration an
 
 dependencies {
     implementation group: 'org.scala-lang', name: 'scala-library'
+}
+
+scoverage {
+    // 'detectedScalaLibraryVersion' is set by the test `DetectScalaLibraryTest.java`
+    scoverageScalaVersion = detectedScalaLibraryVersion
 }

Diff for: src/main/groovy/org/scoverage/ScoverageExtension.groovy

@@ -60,7 +60,6 @@ class ScoverageExtension {
         scoverageVersion.set('1.4.1')
 
         scoverageScalaVersion = project.objects.property(String)
-        scoverageScalaVersion.set('2.12')
 
         sources = project.objects.property(File)
         sources.set(project.projectDir)

Diff for: src/main/groovy/org/scoverage/ScoveragePlugin.groovy

@@ -24,6 +24,7 @@ class ScoveragePlugin implements Plugin<PluginAware> {
     static final String CHECK_NAME = 'checkScoverage'
     static final String COMPILE_NAME = 'compileScoverageScala'
     static final String AGGREGATE_NAME = 'aggregateScoverage'
+    static final String DEFAULT_SCALA_VERSION = '2.12'
 
     static final String DEFAULT_REPORT_DIR = 'reports' + File.separatorChar + 'scoverage'
 
@@ -347,19 +348,26 @@ class ScoveragePlugin implements Plugin<PluginAware> {
 
     private String resolveScalaVersion(Project project) {
 
-        def components = project.configurations.compileClasspath.incoming.resolutionResult.getAllComponents()
-
-        def scalaLibrary = components.find {
-            it.moduleVersion.group == "org.scala-lang" && it.moduleVersion.name == "scala-library"
-        }
-
-        if (scalaLibrary == null) {
-            project.logger.info("No scala library detected. Using property 'scoverageScalaVersion'")
-            return project.extensions.scoverage.scoverageScalaVersion.get()
+        def scalaVersionProperty = project.extensions.scoverage.scoverageScalaVersion
+        if (scalaVersionProperty.isPresent()) {
+            def configuredScalaVersion = scalaVersionProperty.get()
+            project.logger.info("Using configured Scala version: $configuredScalaVersion")
+            return configuredScalaVersion
         } else {
-            project.logger.info("Detected scala library in compilation classpath")
-            def fullScalaVersion = scalaLibrary.moduleVersion.version
-            return fullScalaVersion.substring(0, fullScalaVersion.lastIndexOf("."))
+            project.logger.info("No Scala version configured. Detecting scala library...")
+            def components = project.configurations.compileClasspath.incoming.resolutionResult.getAllComponents()
+            def scalaLibrary = components.find {
+                it.moduleVersion.group == "org.scala-lang" && it.moduleVersion.name == "scala-library"
+            }
+            if (scalaLibrary != null) {
+                def fullScalaVersion = scalaLibrary.moduleVersion.version
+                def scalaVersion = fullScalaVersion.substring(0, fullScalaVersion.lastIndexOf("."))
+                project.logger.info("Detected scala library in compilation classpath. Scala version: $scalaVersion")
+                return scalaVersion
+            } else {
+                project.logger.info("No scala library detected. Using default Scala version: $DEFAULT_SCALA_VERSION")
+                return DEFAULT_SCALA_VERSION
+            }
         }
     }