def create[F[_]]()

in modules/core/src/main/scala/org/scalasteward/core/coursier/CoursierAlg.scala [40:109]

• 63 lines of code
• 8 McCabe index (conditional complexity)

  def create[F[_]](implicit
      logger: Logger[F],
      parallel: Parallel[F],
      F: Async[F]
  ): CoursierAlg[F] = {
    val fetch: Fetch[F] =
      Fetch[F](FileCache[F]())

    val cacheNoTtl: FileCache[F] =
      FileCache[F]().withTtl(None).withCachePolicies(List(CachePolicy.Update))

    new CoursierAlg[F] {
      override def getMetadata(
          dependency: Dependency,
          resolvers: List[Resolver]
      ): F[DependencyMetadata] =
        resolvers.traverseFilter(convertResolver(_).attempt.map(_.toOption)).flatMap {
          repositories =>
            val csrDependency = toCoursierDependency(dependency)
            getMetadataImpl(csrDependency, repositories, DependencyMetadata.empty)
        }

      private def getMetadataImpl(
          dependency: coursier.Dependency,
          repositories: List[coursier.Repository],
          acc: DependencyMetadata
      ): F[DependencyMetadata] = {
        val fetchArtifacts = fetch
          .withArtifactTypes(Set(coursier.Type.pom, coursier.Type.ivy))
          .withDependencies(List(dependency))
          .withRepositories(repositories)

        fetchArtifacts.ioResult.attempt.flatMap {
          case Left(throwable) =>
            logger.debug(throwable)(s"Failed to fetch artifacts of $dependency").as(acc)
          case Right(result) =>
            val maybeProject = result.resolution.projectCache
              .get(dependency.moduleVersion)
              .map { case (_, project) => project }

            maybeProject.fold(F.pure(acc)) { project =>
              val metadata = acc.enrichWith(metadataFrom(project))
              val recurse = Option.when(metadata.repoUrl.isEmpty)(())
              (recurse >> parentOf(project)).fold(F.pure(metadata)) { parent =>
                getMetadataImpl(parent, repositories, metadata)
              }
            }
        }
      }

      override def getVersions(dependency: Dependency, resolver: Resolver): F[List[Version]] =
        convertResolver(resolver).flatMap { repository =>
          val module = toCoursierModule(dependency)
          repository.versions(module, cacheNoTtl.fetch).run.flatMap {
            case Left(message) =>
              logger.debug(message) >> F.raiseError[List[Version]](new Throwable(message))
            case Right((versions, _)) =>
              F.pure(versions.available.map(Version.apply).sorted)
          }
        }

      private def convertResolver(resolver: Resolver): F[coursier.Repository] =
        toCoursierRepository(resolver) match {
          case Right(repository) => F.pure(repository)
          case Left(message) =>
            logger.error(s"Failed to convert $resolver: $message") >>
              F.raiseError[coursier.Repository](new Throwable(message))
        }
    }
  }