Use 'update' instead of ivy resolution

README.md

@@ -1,6 +1,6 @@
 # sbt-license-report
 
-This plugin will allow you to report the licenses used in your projects. It requires 1.0.0+.
+This plugin will allow you to report the licenses used in your projects. It requires 1.10.5+.
 
 ## Installation
 

src/main/scala/sbtlicensereport/SbtLicenseReport.scala

@@ -1,7 +1,6 @@
 package sbtlicensereport
 
 import sbt._
-import sbt.librarymanagement.ivy.IvyDependencyResolution
 import Keys._
 import license._
 
@@ -82,13 +81,13 @@ object SbtLicenseReport extends AutoPlugin {
     Seq(
       licenseReportTitle := s"${normalizedName.value}-licenses",
       updateLicenses := {
-        val ignore = update.value
+        if (VersionNumber(sbtVersion.value).matchesSemVer(SemanticSelector("<1.10.5")))
+          throw new sbt.MessageOnlyException("sbt-license-report requires sbt 1.10.5 or greater.")
         val overrides = licenseOverrides.value.lift
         val depExclusions = licenseDepExclusions.value.lift
         val originatingModule = DepModuleInfo(organization.value, name.value, version.value)
         license.LicenseReport.makeReport(
-          ivyModule.value,
-          IvyDependencyResolution(ivyConfiguration.value),
+          update.value,
           licenseConfigurations.value,
           licenseSelection.value,
           overrides,

src/main/scala/sbtlicensereport/license/LicenseReport.scala

@@ -3,13 +3,6 @@ package license
 
 import sbt._
 import sbt.io.Using
-import sbt.internal.librarymanagement.IvySbt
-import sbt.librarymanagement.{
-  DependencyResolution,
-  UnresolvedWarning,
-  UnresolvedWarningConfiguration,
-  UpdateConfiguration
-}
 
 case class DepModuleInfo(organization: String, name: String, version: String) {
   override def toString = s"${organization} # ${name} # ${version}"
@@ -117,23 +110,14 @@ object LicenseReport {
   }
 
   def makeReport(
-      module: IvySbt#Module,
-      depRes: DependencyResolution,
+      updateReport: UpdateReport,
       configs: Set[String],
       licenseSelection: Seq[LicenseCategory],
       overrides: DepModuleInfo => Option[LicenseInfo],
       exclusions: DepModuleInfo => Option[Boolean],
       originatingModule: DepModuleInfo,
       log: Logger
   ): LicenseReport = {
-    // Ideally we should be using just standard sbt update task however due to
-    // https://github.com/coursier/coursier/issues/1790 coursier cannot correctly
-    // resolve license information from Ivy modules, so instead we just use
-    // IvyDependencyResolution directly
-    val updateReport = resolve(depRes, module, log) match {
-      case Left(exception)     => throw exception.resolveException
-      case Right(updateReport) => updateReport
-    }
     makeReportImpl(updateReport, configs, licenseSelection, overrides, exclusions, originatingModule, log)
   }
 
@@ -193,30 +177,14 @@ object LicenseReport {
     }
   }
 
-  // TODO: Use https://github.com/sbt/librarymanagement/pull/428 instead when merged and released
-  private def moduleKey(m: ModuleID) = (m.organization, m.name, m.revision)
-
-  private def allModuleReports(configurations: Vector[ConfigurationReport]): Vector[ModuleReport] =
-    configurations.flatMap(_.modules).groupBy(mR => moduleKey(mR.module)).toVector map { case (_, v) =>
-      v reduceLeft { (agg, x) =>
-        agg.withConfigurations(
-          (agg.configurations, x.configurations) match {
-            case (v, _) if v.isEmpty  => x.configurations
-            case (ac, v) if v.isEmpty => ac
-            case (ac, xc)             => ac ++ xc
-          }
-        )
-      }
-    }
-
   private def getLicenses(
       report: UpdateReport,
-      configs: Set[String] = Set.empty,
-      categories: Seq[LicenseCategory] = LicenseCategory.all,
+      configs: Set[String],
+      categories: Seq[LicenseCategory],
       originatingModule: DepModuleInfo
   ): Seq[DepLicense] = {
     for {
-      dep <- allModuleReports(report.configurations)
+      dep <- report.allModuleReports
       report <- pickLicenseForDep(dep, configs, categories, originatingModule)
     } yield report
   }
@@ -241,15 +209,4 @@ object LicenseReport {
     // TODO - Filter for a real report...
     LicenseReport(licenses, report)
   }
-
-  private def resolve(
-      depRes: DependencyResolution,
-      module: IvySbt#Module,
-      log: Logger
-  ): Either[UnresolvedWarning, UpdateReport] = {
-    val uc = UpdateConfiguration().withLogging(UpdateLogging.Quiet)
-    val uwc = UnresolvedWarningConfiguration()
-
-    depRes.update(module, uc, uwc, log)
-  }
 }