def create_dep_usage_node()

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

• 36 lines of code
• 15 McCabe index (conditional complexity)

  def create_dep_usage_node(self,
                            target,
                            analyzer,
                            product_deps_by_src,
                            classes_by_source,
                            targets_by_file,
                            transitive_deps):
    declared_deps_with_aliases = set(analyzer.resolve_aliases(target))
    eligible_unused_deps = {d for d, _ in analyzer.resolve_aliases(target, scope=Scopes.DEFAULT)}
    concrete_target = target.concrete_derived_from
    declared_deps = [resolved for resolved, _ in declared_deps_with_aliases]
    products_total = analyzer.count_products(target)
    node = Node(concrete_target)
    node.add_derivation(target, products_total)

    def _construct_edge(dep_tgt, products_used):
      is_declared, is_used = self._dep_type(target,
                                            dep_tgt,
                                            declared_deps,
                                            eligible_unused_deps,
                                            len(products_used) > 0)
      return Edge(is_declared=is_declared, is_used=is_used, products_used=products_used)

    # Record declared Edges, initially all as "unused" or "declared".
    for dep_tgt, aliased_from in declared_deps_with_aliases:
      derived_from = dep_tgt.concrete_derived_from
      if self._select(derived_from):
        node.add_edge(_construct_edge(dep_tgt, products_used=set()), derived_from, aliased_from)

    # Record the used products and undeclared Edges for this target. Note that some of
    # these may be self edges, which are considered later.
    target_product_deps_by_src = product_deps_by_src.get(target, {})
    for product_deps in target_product_deps_by_src.values():
      for product_dep in product_deps:
        for dep_tgt in targets_by_file.get(product_dep, []):
          derived_from = dep_tgt.concrete_derived_from
          if not self._select(derived_from):
            continue
          # Create edge only for those direct or transitive dependencies in order to
          # disqualify irrelevant targets that happen to share some file in sources,
          # not uncommon when globs especially rglobs is used.
          if not derived_from in transitive_deps:
            continue
          node.add_edge(_construct_edge(dep_tgt, products_used={product_dep}), derived_from)

    return node