def relaxedForAllModules: Seq[()

in multiversion/src/main/scala/multiversion/configs/ThirdpartyConfig.scala [91:130]

• 32 lines of code
• 4 McCabe index (conditional complexity)

  def relaxedForAllModules: Seq[(ModuleMatchers, Reconciliation)] =
    Vector((ModuleMatchers.all, Reconciliation.Relaxed))

  /** Collect all the root dependencies to resolve together. */
  def rootDependencies(
      root: DependencyConfig,
      previousIndex: Option[ResolutionIndex]
  ): Seq[Dependency] = {
    val seen = mutable.Set.empty[String]
    val roots = mutable.Buffer.empty[Dependency]
    val queue = mutable.Queue(root)
    while (queue.nonEmpty) {
      val current = queue.dequeue()
      roots += current.toCoursierDependency(scala)
      current.dependencies.foreach { dep =>
        if (seen.add(dep)) {
          depsByTargets
            .getOrElse(dep, Nil)
            .foreach(d => queue.enqueue(d))
        }
      }
    }
    // Use a previous index to explicitly resolve selected versions of transitive
    // dependencies. This is necessary to pick up the transitive dependencies of the selected
    // versions of our dependencies.
    // For instance, if A depends on D v1, but D v1 is evicted in favor of D v2 and D v2 has a
    // dependency on E, which D v1 didn't have, then resolving A along with D v2 will ensure
    // that E will end up on the classpath of A.
    previousIndex.foreach { index =>
      index.dependencies
        .getOrElse(root.id, Nil)
        .foreach { d =>
          val reconciledVersion = index.reconciledVersion(d)
          if (reconciledVersion != d.version) {
            roots += d.withVersion(reconciledVersion)
          }
        }
    }
    roots
  }