BDOG-183 improve version range display in Bobby Explorer

Author: colin-lamed

app/uk/gov/hmrc/cataloguefrontend/connector/model/BobbyRule.scala

@@ -20,15 +20,18 @@ import java.time.LocalDate
 
 import play.api.libs.json.{Json, Reads}
 
-case class BobbyRule(organisation: String, name: String, range: String, reason: String, from: LocalDate) {
+case class BobbyRule(organisation: String, name: String, range: BobbyVersionRange, reason: String, from: LocalDate) {
   val groupArtifactName: String = {
     val wildcard = "*"
     if (organisation == wildcard && name == wildcard) "*" else s"$organisation:$name"
   }
 }
 
 object BobbyRule {
-  implicit val reader: Reads[BobbyRule] = Json.reads[BobbyRule]
+  implicit val reader: Reads[BobbyRule] = {
+    implicit val bvr = BobbyVersionRange.reads
+    Json.reads[BobbyRule]
+  }
 
 }
 

app/uk/gov/hmrc/cataloguefrontend/connector/model/Dependencies.scala

@@ -19,7 +19,7 @@ package uk.gov.hmrc.cataloguefrontend.connector.model
 import java.time.LocalDate
 
 import org.joda.time.DateTime
-import play.api.libs.json.{Format, JsError, JsObject, JsString, JsSuccess, JsValue, Json, OFormat, Reads, __}
+import play.api.libs.json.{Format, JsError, JsObject, JsPath, JsString, JsSuccess, JsValue, Json, OFormat, Reads, __}
 import play.api.libs.functional.syntax._
 import uk.gov.hmrc.http.controllers.RestFormats
 
@@ -33,11 +33,6 @@ object VersionState {
   case object BobbyRulePending      extends VersionState
 }
 
-// TODO avoid caching LocalDate, and provide to isActive function
-case class BobbyRuleViolation(reason: String, range: String, from: LocalDate)(implicit now: LocalDate = LocalDate.now()) {
-  def isActive: Boolean = now.isAfter(from)
-}
-
 case class Dependency(
   name          : String,
   currentVersion: Version,
@@ -74,12 +69,89 @@ case class Dependencies(
     toSeq.exists(_.isOutOfDate)
 }
 
+case class BobbyVersion(version: Version, inclusive: Boolean)
+
+object BobbyVersion {
+  val reads: Reads[BobbyVersion] = {
+    implicit val bvf = Version.format
+    ( (__ \ "version"  ).read[Version]
+    ~ (__ \ "inclusive").read[Boolean]
+    )(BobbyVersion.apply _)
+  }
+}
+
+case class BobbyVersionRange(
+    lowerBound: Option[BobbyVersion]
+  , upperBound: Option[BobbyVersion]
+  , qualifier : Option[String]
+  , range     : String
+  ) {
+  def description: String = {
+    def comp(v: BobbyVersion) = if (v.inclusive) " <= " else " < "
+    lowerBound.map(v => s"${v.version} ${comp(v)}").getOrElse("") +
+      "x" +
+      upperBound.map(v => s" ${comp(v)} ${v.version}").getOrElse("")
+  }
+}
+
+object BobbyVersionRange {
+
+  private val fixed      = """^\[(\d+\.\d+.\d+)\]""".r
+  private val fixedUpper = """^\(,?(\d+\.\d+.\d+)[\]\)]""".r
+  private val fixedLower = """^[\[\(](\d+\.\d+.\d+),[\]\)]""".r
+  private val rangeRegex = """^[\[\(](\d+\.\d+.\d+),(\d+\.\d+.\d+)[\]\)]""".r
+  private val qualifier  = """^\[[-\*]+(.*)\]""".r
+
+  def apply(range: String): BobbyVersionRange = {
+    val trimmedRange = range.replaceAll(" ", "")
+
+    trimmedRange match {
+      case fixed(v) =>
+        val fixed = Version.parse(v).map(BobbyVersion(_, inclusive = true))
+        BobbyVersionRange(lowerBound = fixed, upperBound = fixed, qualifier = None, range = trimmedRange)
+      case fixedUpper(v) =>
+        BobbyVersionRange(
+          lowerBound = None,
+          upperBound = Version.parse(v).map(BobbyVersion(_, inclusive = trimmedRange.endsWith("]"))),
+          qualifier  = None,
+          range      = trimmedRange)
+      case fixedLower(v) =>
+        BobbyVersionRange(
+          lowerBound = Version.parse(v).map(BobbyVersion(_, inclusive = trimmedRange.startsWith("["))),
+          upperBound = None,
+          qualifier  = None,
+          range      = trimmedRange)
+      case rangeRegex(v1, v2) =>
+        BobbyVersionRange(
+          lowerBound = Version.parse(v1).map(BobbyVersion(_, inclusive = trimmedRange.startsWith("["))),
+          upperBound = Version.parse(v2).map(BobbyVersion(_, inclusive = trimmedRange.endsWith("]"))),
+          qualifier  = None,
+          range      = trimmedRange
+        )
+      case qualifier(q) if q.length() > 1 =>
+        BobbyVersionRange(lowerBound = None, upperBound = None, qualifier = Some(q), range = trimmedRange)
+      case _ => BobbyVersionRange(lowerBound = None, upperBound = None, qualifier = None, range = trimmedRange)
+    }
+  }
+
+  val reads: Reads[BobbyVersionRange] =
+    JsPath.read[String].map(BobbyVersionRange.apply)
+
+}
+
+// TODO avoid caching LocalDate, and provide to isActive function
+case class BobbyRuleViolation(reason: String, range: BobbyVersionRange, from: LocalDate)(implicit now: LocalDate = LocalDate.now()) {
+  def isActive: Boolean = now.isAfter(from)
+}
+
+
 object Dependencies {
   val reads: Reads[Dependencies] = {
     implicit val dtr = RestFormats.dateTimeFormats
+    implicit val bvr = BobbyVersionRange.reads
     implicit val brvf =
       ( (__ \ "reason" ).read[String]
-      ~ (__ \ "range"  ).read[JsValue].map(j => (j \ "range").as[String])
+      ~ (__ \ "range"  ).read[BobbyVersionRange]
       ~ (__ \ "from"   ).read[LocalDate]
       )(BobbyRuleViolation.apply _)
 

app/views/BobbyExplorerPage.scala.html

@@ -45,7 +45,7 @@ <h1>Bobby Rules</h1>
                 <thead>
                     <tr>
                         <th>@artifactType</th>
-                        <th>Version</th>
+                        <th>Banned Versions</th>
                         <th>Reason</th>
                         <th>Active from</th>
                     </tr>
@@ -61,8 +61,14 @@ <h1>Bobby Rules</h1>
 @bobbyRuleRow(rule: BobbyRule) = {
     <tr class="bobby-rule">
         <td><a name="@rule.name">@rule.groupArtifactName</a></td>
-        <td>@rule.range</td>
+        <td data-toggle="tooltip" data-placement="top" title="@rule.range.range">@rule.range.description</td>
         <td>@rule.reason</td>
         <td>@rule.from</td>
     </tr>
-}
+}
+
+<script type="text/javascript">
+    ready(function() {
+        document.querySelector('[data-toggle="tooltip"]').tooltip();
+    });
+</script>