Scoverage work - add scoverage to OSS pants

BUILD.tools

@@ -27,6 +27,7 @@ jar_library(name = 'scrooge-linter',
               jar(org='com.twitter', name='scrooge-linter_2.11', rev=SCROOGE_REV)
             ])
 
+
 # Google doesn't publish Kythe jars (yet?).  So we publish them to a custom repo
 # (https://github.com/toolchainlabs/binhost) for now.  See build-support/ivy/ivysettings.xml
 # for more info.

src/python/pants/backend/jvm/register.py

@@ -8,6 +8,7 @@
 from pants.backend.jvm.scala_artifact import ScalaArtifact
 from pants.backend.jvm.subsystems.jar_dependency_management import JarDependencyManagementSetup
 from pants.backend.jvm.subsystems.scala_platform import ScalaPlatform
+from pants.backend.jvm.subsystems.scoverage_platform import ScoveragePlatform
 from pants.backend.jvm.subsystems.shader import Shading
 from pants.backend.jvm.targets.annotation_processor import AnnotationProcessor
 from pants.backend.jvm.targets.benchmark import Benchmark
@@ -138,7 +139,7 @@ def build_file_aliases():
 
 
 def global_subsystems():
-  return (ScalaPlatform,)
+  return (ScalaPlatform, ScoveragePlatform, )
 
 
 # TODO https://github.com/pantsbuild/pants/issues/604 register_goals

src/python/pants/backend/jvm/subsystems/BUILD

@@ -111,6 +111,17 @@ python_library(
   ],
 )
 
+python_library(
+  name = 'scoverage_platform',
+  sources = ['scoverage_platform.py'],
+  dependencies = [
+    'src/python/pants/option',
+    'src/python/pants/subsystem',
+     'src/python/pants/java/jar',
+    'src/python/pants/backend/jvm/targets:jvm',
+  ],
+)
+
 python_library(
   name = 'shader',
   sources = ['shader.py'],

src/python/pants/backend/jvm/subsystems/scoverage_platform.py

@@ -0,0 +1,125 @@
+# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+import os
+from pants.build_graph.injectables_mixin import InjectablesMixin
+from pants.subsystem.subsystem import Subsystem
+from pants.java.jar.jar_dependency import JarDependency
+from pants.backend.jvm.targets.jar_library import JarLibrary
+from pants.build_graph.address import Address
+from typing import Any, Dict, List, Optional, Union
+
+
+SCOVERAGE = "scoverage"
+blacklist_file = 'new_blacklist_scoverage'
+
+
+class ScoveragePlatform(InjectablesMixin, Subsystem):
+  """The scala coverage platform."""
+
+  options_scope = 'scoverage'
+
+  @classmethod
+  def register_options(cls, register):
+    super().register_options(register)
+    register('--enable-scoverage',
+      default=False,
+      type=bool,
+      help='Specifies whether to generate scoverage reports for scala test targets.'
+           'Default value is False')
+
+    register('--blacklist-file',
+      default=blacklist_file,
+      type=str,
+      help='Path to files containing targets not to be instrumented.')
+
+    register('--scoverage-target-path',
+      default='//:scoverage',
+      type=str,
+      help='Path to the scoverage dependency.')
+
+  def scoverage_jar(self):
+    return [JarDependency(org='com.twitter.scoverage', name='scalac-scoverage-plugin_2.12',
+      rev='1.0.1-twitter'),
+      JarDependency(org='com.twitter.scoverage', name='scalac-scoverage-runtime_2.12',
+        rev='1.0.1-twitter')]
+
+  def injectables(self, build_graph):
+    specs_to_create = [
+      ('scoverage', self.scoverage_jar),
+    ]
+
+    for spec_key, create_jardep_func in specs_to_create:
+      spec = self.injectables_spec_for_key(spec_key)
+      target_address = Address.parse(spec)
+      if not build_graph.contains_address(target_address):
+        target_jars = create_jardep_func()
+        jars = target_jars if isinstance(target_jars, list) else [target_jars]
+        build_graph.inject_synthetic_target(target_address,
+          JarLibrary,
+          jars=jars,
+          scope='forced')
+      elif not build_graph.get_target(target_address).is_synthetic:
+        raise build_graph.ManualSyntheticTargetError(target_address)
+
+  @property
+  def injectables_spec_mapping(self):
+    return {
+      'scoverage': [f"{self.get_options().scoverage_target_path}"],
+    }
+
+  def get_scalac_plugins(self, target) -> List[str]:
+    """
+    Adds 'scoverage' to scalac_plugins in case scoverage is enabled for that [target].
+    :return: modified scalac_plugins
+    """
+
+    # Prevent instrumenting generated targets and targets in blacklist.
+    if target.identifier.startswith(".pants.d.gen") or self.is_blacklisted(target):
+      return target.payload.scalac_plugins
+
+    scalac_plugins = target.payload.scalac_plugins
+    if scalac_plugins:
+      scalac_plugins.append(SCOVERAGE)
+    else:
+      scalac_plugins = [SCOVERAGE]
+    return scalac_plugins
+
+  def get_scalac_plugin_args(self, target) -> Dict[str, List[str]]:
+    """
+    Adds 'scoverage' to scalac_plugins_args in case scoverage is enabled for that [target].
+    :return: modified scalac_plugins_args
+    """
+    scalac_plugin_args = target.payload.scalac_plugin_args
+    if scalac_plugin_args:
+      scalac_plugin_args.update(
+        {"scoverage": ["writeToClasspath:true", f"dataDir:{target.identifier}"]})
+    else:
+      scalac_plugin_args = {
+        "scoverage": ["writeToClasspath:true", f"dataDir:{target.identifier}"]
+      }
+    return scalac_plugin_args
+
+  def get_compiler_option_sets(self, target):
+    """
+   Adds 'scoverage' to compiler_options_sets in case scoverage is enabled for that [target].
+   :return: modified compiler_option_sets
+   """
+    compiler_option_sets = target.payload.compiler_option_sets
+    if compiler_option_sets:
+      list(compiler_option_sets).append(SCOVERAGE)
+    else:
+      compiler_option_sets = [SCOVERAGE]
+    return tuple(compiler_option_sets)
+
+  def is_blacklisted(self, target) -> bool:
+    """
+    Checks if the [target] is blacklisted or not.
+    """
+    if not os.path.exists(self.get_options().blacklist_file):
+      return False
+
+    if target.address.spec in open(self.get_options().blacklist_file).read():
+      return True
+    else:
+      return False

src/python/pants/backend/jvm/targets/BUILD

@@ -79,6 +79,7 @@ python_library(
     '3rdparty/python/twitter/commons:twitter.common.collections',
     'src/python/pants/java/jar',
     'src/python/pants/backend/jvm/subsystems:scala_platform',
+    'src/python/pants/backend/jvm/subsystems:scoverage_platform',
     'src/python/pants/base:exceptions',
     'src/python/pants/base:validation',
     'src/python/pants/build_graph',

src/python/pants/backend/jvm/targets/scala_library.py

@@ -2,6 +2,7 @@
 # Licensed under the Apache License, Version 2.0 (see LICENSE).
 
 from pants.backend.jvm.subsystems.scala_platform import ScalaPlatform
+from pants.backend.jvm.subsystems.scoverage_platform import ScoveragePlatform
 from pants.backend.jvm.targets.exportable_jvm_library import ExportableJvmLibrary
 from pants.backend.jvm.targets.junit_tests import JUnitTests
 from pants.base.exceptions import TargetDefinitionException
@@ -27,7 +28,7 @@ class ScalaLibrary(ExportableJvmLibrary):
 
   @classmethod
   def subsystems(cls):
-    return super().subsystems() + (ScalaPlatform, )
+    return super().subsystems() + (ScalaPlatform, ScoveragePlatform,)
 
   def __init__(self, java_sources=None, payload=None, **kwargs):
     """
@@ -47,6 +48,8 @@ def __init__(self, java_sources=None, payload=None, **kwargs):
     })
     super().__init__(payload=payload, **kwargs)
 
+    self._scoverage = ScoveragePlatform.global_instance().get_options().enable_scoverage
+
   @classmethod
   def compute_injectable_specs(cls, kwargs=None, payload=None):
     for spec in super().compute_injectable_specs(kwargs, payload):
@@ -65,6 +68,10 @@ def compute_dependency_specs(cls, kwargs=None, payload=None):
     for spec in ScalaPlatform.global_instance().injectables_specs_for_key('scala-library'):
       yield spec
 
+    if ScoveragePlatform.global_instance().get_options().enable_scoverage:
+      for spec in ScoveragePlatform.global_instance().injectables_specs_for_key('scoverage'):
+        yield spec
+
   def get_jar_dependencies(self):
     for jar in super().get_jar_dependencies():
       yield jar
@@ -82,3 +89,37 @@ def java_sources(self):
         raise TargetDefinitionException(self, 'No such java target: {}'.format(spec))
       targets.append(target)
     return targets
+
+  @property
+  def scalac_plugins(self):
+    """The names of compiler plugins to use when compiling this target with scalac.
+    :return: See constructor.
+    :rtype: list of strings.
+    """
+    if self._scoverage:
+      return ScoveragePlatform.global_instance().get_scalac_plugins(self)
+
+    return self.payload.scalac_plugins
+
+  @property
+  def scalac_plugin_args(self):
+    """Map from scalac plugin name to list of args for that plugin.
+    :return: See constructor.
+    :rtype: map from string to list of strings.
+    """
+    if self._scoverage:
+      return ScoveragePlatform.global_instance().get_scalac_plugin_args(self)
+
+    return self.payload.scalac_plugin_args
+
+  @property
+  def compiler_option_sets(self):
+    """For every element in this list, enable the corresponding flags on compilation
+    of targets.
+    :return: See constructor.
+    :rtype: list
+    """
+    if self._scoverage:
+      return ScoveragePlatform.global_instance().get_compiler_option_sets(self)
+
+    return self.payload.compiler_option_sets

src/python/pants/backend/jvm/tasks/coverage/manager.py

@@ -4,7 +4,9 @@
 import os
 import shutil
 
+from pants.backend.jvm.subsystems.scoverage_platform import ScoveragePlatform
 from pants.backend.jvm.tasks.coverage.cobertura import Cobertura
+from pants.backend.jvm.tasks.coverage.scoverage import Scoverage
 from pants.backend.jvm.tasks.coverage.engine import NoCoverage
 from pants.backend.jvm.tasks.coverage.jacoco import Jacoco
 from pants.subsystem.subsystem import Subsystem
@@ -57,14 +59,14 @@ class CodeCoverage(Subsystem):
 
   @classmethod
   def subsystem_dependencies(cls):
-    return super().subsystem_dependencies() + (Cobertura.Factory, Jacoco.Factory)
+    return super().subsystem_dependencies() + (Cobertura.Factory, Jacoco.Factory, Scoverage.Factory)
 
   # TODO(jtrobec): move these to subsystem scope after deprecating
   @staticmethod
   def register_junit_options(register, register_jvm_tool):
     register('--coverage', type=bool, fingerprint=True, help='Collect code coverage data.')
     register('--coverage-processor', advanced=True, fingerprint=True,
-             choices=['cobertura', 'jacoco'], default=None,
+             choices=['cobertura', 'jacoco', 'scoverage'], default=None,
              help="Which coverage processor to use if --coverage is enabled. If this option is "
                   "unset but coverage is enabled implicitly or explicitly, defaults to 'cobertura'."
                   "If this option is explicitly set, implies --coverage.")
@@ -83,18 +85,25 @@ def register_junit_options(register, register_jvm_tool):
     # register options for coverage engines
     # TODO(jtrobec): get rid of these calls when engines are dependent subsystems
     Cobertura.register_junit_options(register, register_jvm_tool)
+    Scoverage.register_junit_options(register, register_jvm_tool)
 
   class InvalidCoverageEngine(Exception):
     """Indicates an invalid coverage engine type was selected."""
 
   def get_coverage_engine(self, task, output_dir, all_targets, execute_java):
     options = task.get_options()
-    if options.coverage or options.coverage_processor or options.is_flagged('coverage_open'):
+    processor = options.coverage_processor
+    if ScoveragePlatform.global_instance().get_options().enable_scoverage:
+      processor = 'scoverage'
+
+    if options.coverage or processor or options.is_flagged('coverage_open'):
       settings = CodeCoverageSettings.from_task(task, workdir=output_dir)
-      if options.coverage_processor in ('cobertura', None):
+      if processor in ('cobertura', None):
         return Cobertura.Factory.global_instance().create(settings, all_targets, execute_java)
-      elif options.coverage_processor == 'jacoco':
+      elif processor == 'jacoco':
         return Jacoco.Factory.global_instance().create(settings, all_targets, execute_java)
+      elif processor == 'scoverage':
+        return Scoverage.Factory.global_instance().create(settings, all_targets, execute_java)
       else:
         # NB: We should never get here since the `--coverage-processor` is restricted by `choices`,
         # but for clarity.