Scoverage work - add scoverage to OSS pants

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,95 @@
+# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+import logging
+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
+
+logger = logging.getLogger(__name__)
+
+SCOVERAGE = "scoverage"
+
+class ScoveragePlatform(InjectablesMixin, Subsystem):
+  """The scoverage 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. If True,'
+           'implies --test-junit-coverage-processor=scoverage.')
+
+    register('--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 __init__(self, *args, **kwargs):
+    super(ScoveragePlatform, self).__init__(*args, **kwargs)
+
+    # Setting up the scoverage blacklist files which contains targets
+    # not to be instrumented. Since the file is not expected to be really big,
+    # would it be ok to store it in memory?
+    if (self.get_options().blacklist_file and
+      os.path.exists(self.get_options().blacklist_file)):
+      self._blacklist_file_contents = open(self.get_options().blacklist_file).read()
+    else:
+      self._blacklist_file_contents = None
+
+  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 is_blacklisted(self, target) -> bool:
+    """
+    Checks if the [target] is blacklisted or not.
+    """
+    # File not specified
+    if not self._blacklist_file_contents:
+      return False
+
+    if target.address.spec in self._blacklist_file_contents:
+      logger.warning(f"{target.address.spec} found in blacklist, not instrumented.")
+      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,13 +2,15 @@
 # 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
 from pants.base.payload import Payload
 from pants.base.payload_field import PrimitiveField
 from pants.build_graph.address import Address
 
+SCOVERAGE = "scoverage"
 
 class ScalaLibrary(ExportableJvmLibrary):
   """A Scala library.
@@ -25,9 +27,11 @@ class ScalaLibrary(ExportableJvmLibrary):
   default_sources_globs = '*.scala'
   default_sources_exclude_globs = JUnitTests.scala_test_globs
 
+
+
   @classmethod
   def subsystems(cls):
-    return super().subsystems() + (ScalaPlatform, )
+    return super().subsystems() + (ScalaPlatform, ScoveragePlatform,)
 
   def __init__(self, java_sources=None, payload=None, **kwargs):
     """
@@ -47,6 +51,8 @@ def __init__(self, java_sources=None, payload=None, **kwargs):
     })
     super().__init__(payload=payload, **kwargs)
 
+    self._scoverage_instance = ScoveragePlatform.global_instance()
+
   @classmethod
   def compute_injectable_specs(cls, kwargs=None, payload=None):
     for spec in super().compute_injectable_specs(kwargs, payload):
@@ -65,6 +71,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 +92,59 @@ 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_instance.get_options().enable_scoverage:
+      # Prevent instrumenting generated targets and targets in blacklist.
+      if self.identifier.startswith(".pants.d.gen") or self._scoverage_instance.is_blacklisted(self):
+        return self.payload.scalac_plugins
+
+      scalac_plugins = self.payload.scalac_plugins
+      if scalac_plugins:
+        scalac_plugins.append(SCOVERAGE)
+      else:
+        scalac_plugins = [SCOVERAGE]
+      return scalac_plugins
+
+    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_instance.get_options().enable_scoverage:
+      scalac_plugin_args = self.payload.scalac_plugin_args
+      if scalac_plugin_args:
+        scalac_plugin_args.update(
+          {"scoverage": ["writeToClasspath:true", f"dataDir:{self.identifier}"]})
+      else:
+        scalac_plugin_args = {
+          "scoverage": ["writeToClasspath:true", f"dataDir:{self.identifier}"]
+        }
+      return scalac_plugin_args
+
+    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_instance.get_options().enable_scoverage:
+      compiler_option_sets = self.payload.compiler_option_sets
+      if compiler_option_sets:
+        list(compiler_option_sets).append(SCOVERAGE)
+      else:
+        compiler_option_sets = [SCOVERAGE]
+      return tuple(compiler_option_sets)
+
+    return self.payload.compiler_option_sets

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

@@ -1,16 +1,20 @@
 # Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
 # Licensed under the Apache License, Version 2.0 (see LICENSE).
 
+import logging
 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
 from pants.util.dirutil import safe_mkdir
 from pants.util.strutil import safe_shlex_split
 
+logger = logging.getLogger(__name__)
 
 class CodeCoverageSettings:
   """A class containing settings for code coverage tasks."""
@@ -57,21 +61,24 @@ 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.")
+                  "unset but coverage is enabled implicitly or explicitly, defaults to 'cobertura'. "
+                  "If this option is explicitly set, implies --coverage. If this option is set to "
+                  "scoverage, then first scoverage MUST be enabled by passing option "
+                  "--scoverage-enable-scoverage.")
     # We need to fingerprint this even though it nominally UI-only affecting option since the
     # presence of this option alone can implicitly flag on `--coverage`.
     register('--coverage-open', type=bool, fingerprint=True,
-             help='Open the generated HTML coverage report in a browser. Implies --coverage.')
+             help='Open the generated HTML coverage report in a browser. Implies --coverage '
+                  'with cobertura as the engine.')
 
     register('--coverage-jvm-options', advanced=True, type=list, fingerprint=True,
              help='JVM flags to be added when running the coverage processor. For example: '
@@ -89,12 +96,29 @@ class InvalidCoverageEngine(Exception):
 
   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'):
+    enable_scoverage = ScoveragePlatform.global_instance().get_options().enable_scoverage
+    processor = options.coverage_processor
+
+    if (processor == 'scoverage' and not enable_scoverage):
+      raise self.InvalidCoverageEngine("Cannot set processor to scoverage without first enabling "
+                                       "scoverage (by passing --scoverage-enable-scoverage option)")
+
+    if enable_scoverage:
+      if processor is None:
+        logger.info("Scoverage is enabled. Setting coverage engine to scoverage.")
+      elif processor != 'scoverage':
+        logger.warning(f"Scoverage is enabled. Cannot use {processor} as the engine. Setting "
+                       f"coverage engine to 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.