def generate_doc()

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

• 45 lines of code
• 19 McCabe index (conditional complexity)

  def generate_doc(self, language_predicate, create_jvmdoc_command):
    """
    Generate an execute method given a language predicate and command to create documentation

    language_predicate: a function that accepts a target and returns True if the target is of that
                        language
    create_jvmdoc_command: (classpath, directory, *targets) -> command (string) that will generate
                           documentation documentation for targets
    """
    catalog = self.context.products.isrequired(self.jvmdoc().product_type)
    if catalog and self.combined:
      raise TaskError(
          'Cannot provide {} target mappings for combined output'.format(self.jvmdoc().product_type))

    def docable(target):
      if not language_predicate(target):
        self.context.log.debug('Skipping [{}] because it is does not pass the language predicate'.format(target.address.spec))
        return False
      if not self._include_codegen and target.is_synthetic:
        self.context.log.debug('Skipping [{}] because it is a synthetic target'.format(target.address.spec))
        return False
      for pattern in self._exclude_patterns:
        if pattern.search(target.address.spec):
          self.context.log.debug(
            "Skipping [{}] because it matches exclude pattern '{}'".format(target.address.spec, pattern.pattern))
          return False
      return True

    targets = self.get_targets(predicate=docable)
    if not targets:
      return

    with self.invalidated(targets, invalidate_dependents=self.combined) as invalidation_check:
      def find_invalid_targets():
        invalid_targets = set()
        for vt in invalidation_check.invalid_vts:
          invalid_targets.update(vt.targets)
        return invalid_targets

      invalid_targets = list(find_invalid_targets())
      if invalid_targets:
        if self.combined:
          self._generate_combined(targets, create_jvmdoc_command)
        else:
          self._generate_individual(invalid_targets, create_jvmdoc_command)

    if self.open and self.combined:
      try:
        desktop.ui_open(os.path.join(self.workdir, 'combined', 'index.html'))
      except desktop.OpenError as e:
        raise TaskError(e)

    if catalog:
      for target in targets:
        gendir = self._gendir(target)
        jvmdocs = []
        for root, dirs, files in safe_walk(gendir):
          jvmdocs.extend(os.path.relpath(os.path.join(root, f), gendir) for f in files)
        self.context.products.get(self.jvmdoc().product_type).add(target, gendir, jvmdocs)