Merge pull request #5 from odd/extract-regex

lrytz · web-flow · commit 474c9d1a6d68 · 2020-05-11T10:36:22.000+02:00
diff --git a/core/src/main/scala/com/lightbend/benchdb/Main.scala b/core/src/main/scala/com/lightbend/benchdb/Main.scala
@@ -62,15 +62,16 @@ object Main extends Logging {
     val runs = Opts.options[String]("run", short = "r", help = "IDs of the test runs to include (or 'last').").map(_.toList).orElse(Opts(Nil))
     val benchs = Opts.options[String]("benchmark", short = "b", help = "Glob patterns of benchmark names to include.").map(_.toList).orElse(Opts(Nil))
     val extract = Opts.options[String]("extract", help = "Extractor pattern to generate parameters from names.").map(_.toList).orElse(Opts(Nil))
+    val regex = Opts.flag("regex", short = "re", help = "Interpret extract pattern as a Java regular expression.").orFalse
     val scorePrecision = Opts.option[Int]("score-precision", help = "Precision of score and error in tables (default: 3)").withDefault(3)
     val queryResultsCommand = Command[GlobalOptions => Unit](name = "results", header =
       "Query the database for test results and print them.") {
       val pivot = Opts.options[String]("pivot", help = "Parameter names to pivot in table output.").map(_.toList).orElse(Opts(Nil))
       val raw = Opts.flag("raw", "Print raw JSON data instead of a table.").orFalse
-      (runs, benchs, extract, scorePrecision, pivot, raw).mapN { case (runs, benchs, extract, sp, pivot, raw) =>
+      (runs, benchs, extract, regex, scorePrecision, pivot, raw).mapN { case (runs, benchs, extract, regex, sp, pivot, raw) =>
       { go =>
         if(raw && pivot.nonEmpty) logger.error("Cannot pivot in raw output mode.")
-        else queryResults(go, runs, benchs, extract, sp, pivot, raw)
+        else queryResults(go, runs, benchs, extract, regex, sp, pivot, raw)
       }
       }
     }
@@ -79,8 +80,8 @@ object Main extends Logging {
       val template = Opts.option[Path]("template", "HTML template containing file.").orNone
       val out = Opts.option[Path]("out", short = "o", help = "Output file to generate, or '-' for stdout.").orNone
       val pivot = Opts.options[String]("pivot", help = "Parameter names to combine in a chart.").map(_.toList).orElse(Opts(Nil))
-      (runs, benchs, extract, scorePrecision, pivot, template, out).mapN { case (runs, benchs, extract, sp, pivot, template, out) =>
-        createChart(_, runs, benchs, extract, sp, pivot, template, out, args)
+      (runs, benchs, extract, regex, scorePrecision, pivot, template, out).mapN { case (runs, benchs, extract, regex, sp, pivot, template, out) =>
+        createChart(_, runs, benchs, extract, regex, sp, pivot, template, out, args)
       }
     }
 
@@ -168,12 +169,12 @@ object Main extends Logging {
     }
   }
 
-  def queryResults(go: GlobalOptions, runs: Seq[String], benchs: Seq[String], extract: Seq[String], scorePrecision: Int, pivot: Seq[String], raw: Boolean): Unit = try {
+  def queryResults(go: GlobalOptions, runs: Seq[String], benchs: Seq[String], extract: Seq[String], regex: Boolean, scorePrecision: Int, pivot: Seq[String], raw: Boolean): Unit = try {
     new Global(go).use { g =>
       val multi = runs.size > 1
       val allRs = g.dao.run(g.dao.checkVersion andThen g.dao.queryResults(runs))
         .map { case (rr, runId) => RunResult.fromDb(rr, runId, multi) }
-      val rs = RunResult.extract(extract, RunResult.filterByName(benchs, allRs)).toSeq
+      val rs = RunResult.extract(extract, regex, RunResult.filterByName(benchs, allRs)).toSeq
       if(raw) {
         print("[")
         rs.zipWithIndex.foreach { case (r, idx) =>
@@ -258,12 +259,12 @@ object Main extends Logging {
     case ex: PatternSyntaxException => logger.error(ex.toString)
   }
 
-  def createChart(go: GlobalOptions, runs: Seq[String], benchs: Seq[String], extract: Seq[String], scorePrecision: Int, pivot: Seq[String], template: Option[Path], out: Option[Path], cmdLine: Array[String]): Unit = {
+  def createChart(go: GlobalOptions, runs: Seq[String], benchs: Seq[String], extract: Seq[String], regex: Boolean, scorePrecision: Int, pivot: Seq[String], template: Option[Path], out: Option[Path], cmdLine: Array[String]): Unit = {
     new Global(go).use { g =>
       val multi = runs.size > 1
       val allRs = g.dao.run(g.dao.checkVersion andThen g.dao.queryResults(runs))
         .map { case (rr, runId) => RunResult.fromDb(rr, runId, multi) }
-      val rs = RunResult.extract(extract, RunResult.filterByName(benchs, allRs)).toSeq
+      val rs = RunResult.extract(extract, regex, RunResult.filterByName(benchs, allRs)).toSeq
       val allParamNames = rs.flatMap(_.params.keys).distinct.toVector
       val pivotSet = pivot.toSet
       val paramNames = allParamNames.filterNot(pivotSet.contains)
diff --git a/core/src/main/scala/com/lightbend/benchdb/RunResult.scala b/core/src/main/scala/com/lightbend/benchdb/RunResult.scala
@@ -1,9 +1,8 @@
 package com.lightbend.benchdb
 
+import java.lang.reflect.{Field, Method}
 import java.util.regex.{Pattern, PatternSyntaxException}
-
 import com.typesafe.config.{Config, ConfigFactory, ConfigRenderOptions}
-
 import scala.collection.JavaConverters._
 import scala.collection.mutable.ArrayBuffer
 
@@ -87,43 +86,66 @@ object RunResult extends Logging {
     Pattern.compile(b.toString)
   }
 
-  private def compileExtractorPattern(expr: String): (Pattern, ArrayBuffer[String]) = {
-    val b = new StringBuilder
-    var i = 0
-    var inGroup = false
-    val groups = new ArrayBuffer[String]
-    while(i < expr.length) {
-      val c = expr.charAt(i)
-      i += 1
-      c match {
-        case '(' if inGroup => throw new PatternSyntaxException("Capture groups must not be nested", expr, i-1)
-        case ')' if !inGroup => throw new PatternSyntaxException("Unexpected end of capture group", expr, i-1)
-        case '(' =>
-          b.append('(')
-          inGroup = true
-          var nextEq = expr.indexOf('=', i)
-          val nextClose = expr.indexOf(')', i)
-          if(nextClose == -1) throw new PatternSyntaxException("Capture group not closed", expr, i)
-          if(nextEq == -1 || nextEq > nextClose) groups += ""
-          else {
-            val n = expr.substring(i, nextEq)
-            groups += n
-            i = nextEq+1
-          }
-        case ')' =>
-          b.append(')')
-          inGroup = false
-        case '*' => b.append(".*")
-        case c => b.append(Pattern.quote(String.valueOf(c)))
+  private def compileExtractorPattern(expr: String, regex: Boolean): (Pattern, ArrayBuffer[String]) = {
+    if (regex) {
+      val patternLiteral = expr.replaceAll("\\(([^)=]+)=", "(?<$1>")
+      val pattern = Pattern.compile(patternLiteral)
+      val namedGroups = pattern.namedGroups.toSeq.sortBy(_._2)
+      val groups = ArrayBuffer.empty[String]
+      var i = 1
+      for ((name, n) <- namedGroups) {
+        while (i < n) {
+          groups.append("")
+          i += 1
+        }
+        groups.append(name)
+        i += 1
+      }
+      val m = pattern.groupCount - 1
+      while (i < m) {
+        groups.append("")
+        i += 1
+      }
+      logger.debug(s"Compiled regex extractor '$expr' to $groups, $namedGroups")
+      (pattern, groups)
+    } else {
+      val b = new StringBuilder
+      var i = 0
+      var inGroup = false
+      val groups = new ArrayBuffer[String]
+      while(i < expr.length) {
+        val c = expr.charAt(i)
+        i += 1
+        c match {
+          case '(' if inGroup => throw new PatternSyntaxException("Capture groups must not be nested", expr, i-1)
+          case ')' if !inGroup => throw new PatternSyntaxException("Unexpected end of capture group", expr, i-1)
+          case '(' =>
+            b.append('(')
+            inGroup = true
+            var nextEq = expr.indexOf('=', i)
+            val nextClose = expr.indexOf(')', i)
+            if(nextClose == -1) throw new PatternSyntaxException("Capture group not closed", expr, i)
+            if(nextEq == -1 || nextEq > nextClose) groups += ""
+            else {
+              val n = expr.substring(i, nextEq)
+              groups += n
+              i = nextEq+1
+            }
+          case ')' =>
+            b.append(')')
+            inGroup = false
+          case '*' => b.append(".*")
+          case c => b.append(Pattern.quote(String.valueOf(c)))
+        }
       }
+      logger.debug(s"Compiled extractor '$expr' to $b, $groups")
+        (Pattern.compile(b.toString), groups)
     }
-    logger.debug(s"Compiled extractor '$expr' to $b, $groups")
-    (Pattern.compile(b.toString), groups)
   }
 
-  def extract(extractors: Seq[String], rs: Iterable[RunResult]): Iterable[RunResult] = {
+  def extract(extractors: Seq[String], regex: Boolean, rs: Iterable[RunResult]): Iterable[RunResult] = {
     if(extractors.isEmpty) rs else {
-      val patterns = extractors.map(compileExtractorPattern).filter(_._2.nonEmpty)
+      val patterns = extractors.map(extractor => compileExtractorPattern(extractor, regex)).filter(_._2.nonEmpty)
       rs.map { r =>
         val name = r.name
         val matcherOpt = patterns.iterator.map(p => (p._1.matcher(name), p._2)).find(_._1.matches)
@@ -217,4 +239,27 @@ object RunResult extends Logging {
       0
     }
   }
+
+  object RichPattern {
+    lazy val namedGroupsMethod: Method = {
+      val m = classOf[Pattern].getDeclaredMethod("namedGroups")
+      m.setAccessible(true)
+      m
+    }
+    lazy val capturingGroupCount: Field = {
+      val f = classOf[Pattern].getDeclaredField("capturingGroupCount")
+      f.setAccessible(true)
+      f
+    }
+  }
+  implicit class RichPattern(val pattern: Pattern) extends AnyVal {
+    import RichPattern._
+    import collection.JavaConverters._
+    def namedGroups: Map[String, Int] = {
+      Map.empty ++ namedGroupsMethod.invoke(pattern).asInstanceOf[java.util.Map[String, Int]].asScala
+    }
+    def groupCount: Int = {
+      capturingGroupCount.get(pattern).asInstanceOf[Int]
+    }
+  }
 }
