Add license check

README.md

@@ -18,6 +18,15 @@ If you happen to be using a multi project sbt build, you can instead use `dumpLi
 from `aggregate` on the root project) or `dumpLicenseReportAnyProject` (which collects the results for all projects in the sbt build).
 In either case the results will be merged into a single report file in a format that mirrors `dumpLicenseReport`.
 
+### Check licenses
+
+If you want to check that only certain licenses are used in a project, you can use
+
+     > licenseCheck
+
+This ensures all licenses fall into one of the categories given by `licenseCheckAllow` which defaults
+to a set of commonly allowed [OSS licenses](./src/main/scala/sbtlicensereport/SbtLicenseReport.scala#L173).
+
 ## Configuration
 
 The license report plugin can be configured to dump any number of reports, but the default report

project/build.properties

@@ -1 +1 @@
-sbt.version=1.9.0-M1
+sbt.version=1.9.3

src/main/scala/sbtlicensereport/SbtLicenseReport.scala

@@ -36,6 +36,7 @@ object SbtLicenseReport extends AutoPlugin {
     val dumpLicenseReportAnyProject = taskKey[File](
       "Dumps a report file against all projects of the license report (using the target language) and combines it into a single file."
     )
+    val licenseCheck = taskKey[Unit]("Checks that all licenses are allowed. Fails if other licenses are found.")
     val licenseReportColumns =
       settingKey[Seq[Column]]("Additional columns to be added to the final report")
     val licenseReportDir = settingKey[File]("The location where we'll write the license reports.")
@@ -59,6 +60,7 @@ object SbtLicenseReport extends AutoPlugin {
     )
     val licenseFilter =
       settingKey[LicenseCategory => Boolean]("Configuration for what licenses to include in the report, by default.")
+    val licenseCheckAllow = settingKey[Seq[LicenseCategory]]("Licenses that are allowed to pass in checkLicenses.")
   }
   // Workaround for broken autoImport in sbt 0.13.5
   val autoImport = autoImportImpl
@@ -132,6 +134,12 @@ object SbtLicenseReport extends AutoPlugin {
         for (config <- licenseReportConfigurations.value)
           LicenseReport.dumpLicenseReport(reports.flatMap(_.licenses), config)
         dir
+      },
+      licenseCheck := {
+        val log = streams.value.log
+        val report = updateLicenses.value
+        val allowed = licenseCheckAllow.value
+        LicenseReport.checkLicenses(report.licenses, allowed, log)
       }
     )
 
@@ -145,6 +153,16 @@ object SbtLicenseReport extends AutoPlugin {
     licenseFilter := TypeFunctions.const(true),
     licenseReportStyleRules := None,
     licenseReportTypes := Seq(MarkDown, Html, Csv),
-    licenseReportColumns := Seq(Column.Category, Column.License, Column.Dependency)
+    licenseReportColumns := Seq(Column.Category, Column.License, Column.Dependency),
+    licenseCheckAllow := Seq(
+      LicenseCategory.Apache,
+      LicenseCategory.BouncyCastle,
+      LicenseCategory.BSD,
+      LicenseCategory.CC0,
+      LicenseCategory.EPL,
+      LicenseCategory.MIT,
+      LicenseCategory.Mozilla,
+      LicenseCategory.PublicDomain
+    )
   )
 }

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

@@ -21,6 +21,18 @@ case class DepLicense(
     s"$module ${homepage.map(url => s" from $url")} on $license in ${configs.mkString("(", ",", ")")}"
 }
 
+object DepLicense {
+  implicit val ordering: Ordering[DepLicense] = Ordering.fromLessThan { case (l, r) =>
+    if (l.license.category != r.license.category) l.license.category.name < r.license.category.name
+    else {
+      if (l.license.name != r.license.name) l.license.name < r.license.name
+      else {
+        l.module.toString < r.module.toString
+      }
+    }
+  }
+}
+
 case class LicenseReport(licenses: Seq[DepLicense], orig: ResolveReport) {
   override def toString = s"""|## License Report ##
                               |${licenses.mkString("\t", "\n\t", "\n")}
@@ -45,15 +57,7 @@ object LicenseReport {
       config: LicenseReportConfiguration
   ): Unit = {
     import config._
-    val ordered = reportLicenses.filter(l => licenseFilter(l.license.category)) sortWith { case (l, r) =>
-      if (l.license.category != r.license.category) l.license.category.name < r.license.category.name
-      else {
-        if (l.license.name != r.license.name) l.license.name < r.license.name
-        else {
-          l.module.toString < r.module.toString
-        }
-      }
-    }
+    val ordered = reportLicenses.filter(l => licenseFilter(l.license.category)).sorted
     // TODO - Make one of these for every configuration?
     for (language <- languages) {
       val reportFile = new File(config.reportDir, s"${title}.${language.ext}")
@@ -78,6 +82,24 @@ object LicenseReport {
     }
   }
 
+  def checkLicenses(reportLicenses: Seq[DepLicense], allowed: Seq[LicenseCategory], log: Logger): Unit = {
+    val violators = reportLicenses.collect {
+      case dep if !allowed.contains(dep.license.category) => dep
+    }
+    if (violators.nonEmpty) {
+      log.error(
+        violators.sorted
+          .map(v => (v.license, v.module))
+          .distinct
+          .map { case (license, module) => s"${license.category.name}: ${module.toString}" }
+          .mkString("Found non-allowed licenses among the dependencies:\n", "\n", "")
+      )
+      throw new sbt.MessageOnlyException(s"Found non-allowed licenses!")
+    } else {
+      log.info("Found only allowed licenses among the dependencies!")
+    }
+  }
+
   private def getModuleInfo(dep: IvyNode): DepModuleInfo = {
     // TODO - null handling...
     DepModuleInfo(dep.getModuleId.getOrganisation, dep.getModuleId.getName, dep.getModuleRevision.getId.getRevision)