def _get_plugin_map()

in src/python/pants/backend/jvm/tasks/jvm_compile/jvm_compile.py [0:0]

• 18 lines of code
• 16 McCabe index (conditional complexity)

  def _get_plugin_map(self, compiler, options_src, target):
    """Returns a map of plugin to args, for the given compiler.

    Only plugins that must actually be activated will be present as keys in the map.
    Plugins with no arguments will have an empty list as a value.

    Active plugins and their args will be gathered from (in order of precedence):
    - The <compiler>_plugins and <compiler>_plugin_args fields of the target, if it has them.
    - The <compiler>_plugins and <compiler>_plugin_args options of this task, if it has them.
    - The <compiler>_plugins and <compiler>_plugin_args fields of this task, if it has them.

    Note that in-repo plugins will not be returned, even if requested, when building
    themselves.  Use published versions of those plugins for that.

    See:
    - examples/src/java/org/pantsbuild/example/javac/plugin/README.md.
    - examples/src/scala/org/pantsbuild/example/scalac/plugin/README.md

    :param compiler: one of 'javac', 'scalac'.
    :param options_src: A JvmToolMixin instance providing plugin options.
    :param target: The target whose plugins we compute.
    """
    # Note that we get() options and getattr() target fields and task methods,
    # so we're robust when those don't exist (or are None).
    plugins_key = '{}_plugins'.format(compiler)
    requested_plugins = (
      tuple(getattr(self, plugins_key, []) or []) +
      tuple(options_src.get_options().get(plugins_key, []) or []) +
      tuple((getattr(target, plugins_key, []) or []))
    )
    # Allow multiple flags and also comma-separated values in a single flag.
    requested_plugins = {p for val in requested_plugins for p in val.split(',')}

    plugin_args_key = '{}_plugin_args'.format(compiler)
    available_plugin_args = {}
    available_plugin_args.update(getattr(self, plugin_args_key, {}) or {})
    available_plugin_args.update(options_src.get_options().get(plugin_args_key, {}) or {})
    available_plugin_args.update(getattr(target, plugin_args_key, {}) or {})

    # From all available args, pluck just the ones for the selected plugins.
    plugin_map = {}
    for plugin in requested_plugins:
      # Don't attempt to use a plugin while building that plugin.
      # This avoids a bootstrapping problem.  Note that you can still
      # use published plugins on themselves, just not in-repo plugins.
      if target not in self._plugin_targets(compiler).get(plugin, {}):
        plugin_map[plugin] = available_plugin_args.get(plugin, [])
    return plugin_map