Merge pull request #335 from ua-parser/some-performance-improvements

Some performance improvements

Author: thyandrecardoso

build.sbt

@@ -18,7 +18,7 @@ val scalac2Flags = Seq(
 )
 
 lazy val commonSettings = Seq(
-  scalaVersion       := "2.13.14",
+  scalaVersion       := "2.13.18",
   crossScalaVersions := Seq("2.12.21", "2.13.18", "3.3.7"),
   scalacOptions      := {
     CrossVersion.partialVersion(scalaVersion.value) match {

modules/lib/src/main/scala/org/uaparser/scala/DeviceParser.scala

@@ -1,15 +1,24 @@
 package org.uaparser.scala
 
 case class DeviceParser(patterns: List[DevicePattern]) {
-  def parse(agent: String): Device = patterns
-    .foldLeft[Option[Device]](None) {
-      case (None, pattern) => pattern.process(agent)
-      case (result, _)     => result
+  private val patternsArray = patterns.toArray
+  private val length = patternsArray.length
+  def parse(agent: String): Device = {
+    var i = 0
+    while (i < length) {
+      patternsArray(i).process(agent) match {
+        case Some(d) => return d
+        case None    => ()
+      }
+      i += 1
     }
-    .getOrElse(Device("Other"))
+    DeviceParser.Other
+  }
 }
 
 object DeviceParser {
+  private val Other = Device("Other")
+
   def fromList(config: List[Map[String, String]]): DeviceParser =
     DeviceParser(config.flatMap(DevicePattern.fromMap))
 }

modules/lib/src/main/scala/org/uaparser/scala/DevicePattern.scala

@@ -1,6 +1,6 @@
 package org.uaparser.scala
 
-import java.util.regex.{Matcher, Pattern}
+import java.util.regex.Pattern
 
 import org.uaparser.scala.MatcherOps.MatcherImprovements
 
@@ -10,31 +10,29 @@ private[scala] case class DevicePattern(
     brandReplacement: Option[String],
     modelReplacement: Option[String]
 ) {
+
   def process(agent: String): Option[Device] = {
     val matcher = pattern.matcher(agent)
     if (!matcher.find()) None
     else {
-      val family = familyReplacement.map(r => replace(r, matcher)).orElse(matcher.groupAt(1))
-      val brand = brandReplacement.map(r => replace(r, matcher)).filterNot(s => s.isEmpty)
-      val model = modelReplacement.map(r => replace(r, matcher)).orElse(matcher.groupAt(1)).filterNot(s => s.isEmpty)
+      val family = familyReplacement
+        .map(r => Util.patternReplacementWithMatcherGroups(r, matcher, agent))
+        .orElse(matcher.groupAt(1))
+      val brand =
+        brandReplacement.map(r => Util.patternReplacementWithMatcherGroups(r, matcher, agent)).filterNot(s => s.isEmpty)
+      val model = modelReplacement
+        .map(r => Util.patternReplacementWithMatcherGroups(r, matcher, agent))
+        .orElse(matcher.groupAt(1))
+        .filterNot(s => s.isEmpty)
       family.map(Device(_, brand, model))
     }
   }
-
-  private def replace(replacement: String, matcher: Matcher): String = {
-    (if (replacement.contains("$") && matcher.groupCount() >= 1) {
-       (1 to matcher.groupCount()).foldLeft(replacement) { (rep, i) =>
-         val toInsert = if (matcher.group(i) ne null) matcher.group(i) else ""
-         rep.replaceFirst("\\$" + i, Matcher.quoteReplacement(toInsert))
-       }
-     } else replacement).trim
-  }
 }
 
 private object DevicePattern {
   def fromMap(m: Map[String, String]): Option[DevicePattern] = m.get("regex").map { r =>
     val pattern =
-      m.get("regex_flag").map(flag => Pattern.compile(r, Pattern.CASE_INSENSITIVE)).getOrElse(Pattern.compile(r))
+      m.get("regex_flag").map(_ => Pattern.compile(r, Pattern.CASE_INSENSITIVE)).getOrElse(Pattern.compile(r))
     DevicePattern(pattern, m.get("device_replacement"), m.get("brand_replacement"), m.get("model_replacement"))
   }
 }

modules/lib/src/main/scala/org/uaparser/scala/MatcherOps.scala

@@ -7,14 +7,11 @@ object MatcherOps {
     // Tries to safely return the matching group at index i wrapped in an Option.
     // We also take care of converting empty strings to a None, because it seems possible in uap-core to define matching
     // groups that capture empty strings. At the time, the semantics of None and empty strings seemed to match.
-    def groupAt(i: Int): Option[String] = {
-      try {
+    @inline def groupAt(i: Int): Option[String] = {
+      if (i <= m.groupCount()) {
         val matched = m.group(i)
-        if (matched == null || matched.isEmpty) None
-        else Some(matched)
-      } catch {
-        case _: IndexOutOfBoundsException => None
-      }
+        if (matched == null || matched.isEmpty) None else Some(matched)
+      } else None
     }
   }
 }

modules/lib/src/main/scala/org/uaparser/scala/OSParser.scala

@@ -1,14 +1,22 @@
 package org.uaparser.scala
 
 case class OSParser(patterns: List[OSPattern]) {
-  def parse(agent: String): OS = patterns
-    .foldLeft[Option[OS]](None) {
-      case (None, pattern) => pattern.process(agent)
-      case (result, _)     => result
+  private val patternsArray = patterns.toArray
+  private val length = patternsArray.length
+  def parse(agent: String): OS = {
+    var i = 0
+    while (i < length) {
+      patternsArray(i).process(agent) match {
+        case Some(d) => return d
+        case None    => ()
+      }
+      i += 1
     }
-    .getOrElse(OS("Other"))
+    OSParser.Other
+  }
 }
 
 object OSParser {
+  private val Other = OS("Other")
   def fromList(config: List[Map[String, String]]): OSParser = OSParser(config.flatMap(OSPattern.fromMap))
 }

modules/lib/src/main/scala/org/uaparser/scala/OSPattern.scala

@@ -2,66 +2,144 @@ package org.uaparser.scala
 
 import java.util.regex.{Matcher, Pattern}
 
-import scala.util.control.Exception.allCatch
+import scala.collection.mutable.ListBuffer
 
 import org.uaparser.scala.MatcherOps.MatcherImprovements
-import org.uaparser.scala.OSPattern.{replaceBackreference, replacementBack1}
 
-private[scala] case class OSPattern(
+private[scala] final case class OSPattern(
     pattern: Pattern,
-    osReplacement: Option[String],
-    v1Replacement: Option[String],
-    v2Replacement: Option[String],
-    v3Replacement: Option[String],
-    v4Replacement: Option[String]
+    osReplacement: Option[OSPattern.FamilyReplacement],
+    v1Replacement: Option[OSPattern.VersionReplacement],
+    v2Replacement: Option[OSPattern.VersionReplacement],
+    v3Replacement: Option[OSPattern.VersionReplacement],
+    v4Replacement: Option[OSPattern.VersionReplacement]
 ) {
+
   def process(agent: String): Option[OS] = {
-    val matcher = pattern.matcher(agent)
-    if (!matcher.find()) None
+    val m = pattern.matcher(agent)
+    if (!m.find()) None
     else {
-      osReplacement
-        .map(replacementBack1(matcher))
-        .orElse(matcher.groupAt(1))
-        .map { family =>
-          val major = v1Replacement.flatMap(replaceBackreference(matcher)).orElse(matcher.groupAt(2))
-          val minor = v2Replacement.flatMap(replaceBackreference(matcher)).orElse(matcher.groupAt(3))
-          val patch = v3Replacement.flatMap(replaceBackreference(matcher)).orElse(matcher.groupAt(4))
-          val patchMinor = v4Replacement.flatMap(replaceBackreference(matcher)).orElse(matcher.groupAt(5))
-          OS(family, major, minor, patch, patchMinor)
+      val familyOpt: Option[String] =
+        osReplacement match {
+          case Some(rep) => Some(rep.render(agent, m))
+          case None      => m.groupAt(1)
         }
+
+      familyOpt.map { family =>
+        val major = OSPattern.resolveVersion(v1Replacement, m, fallbackGroup = 2)
+        val minor = OSPattern.resolveVersion(v2Replacement, m, fallbackGroup = 3)
+        val patch = OSPattern.resolveVersion(v3Replacement, m, fallbackGroup = 4)
+        val patchMinor = OSPattern.resolveVersion(v4Replacement, m, fallbackGroup = 5)
+        OS(family, major, minor, patch, patchMinor)
+      }
     }
   }
 }
 
 private object OSPattern {
-  private[this] val quotedBack1: Pattern = Pattern.compile(s"(${Pattern.quote("$1")})")
-
-  private[this] def getBackreferenceGroup(replacement: String): Option[Int] =
-    for {
-      ref <- Option(replacement).filter(_.contains("$"))
-      groupOpt = allCatch.opt(ref.substring(1).toInt)
-      group <- groupOpt
-    } yield group
-
-  private def replacementBack1(matcher: Matcher)(replacement: String): String =
-    if (matcher.groupCount() >= 1) {
-      quotedBack1.matcher(replacement).replaceAll(matcher.group(1))
-    } else replacement
-
-  private def replaceBackreference(matcher: Matcher)(replacement: String): Option[String] =
-    getBackreferenceGroup(replacement) match {
-      case Some(group) => matcher.groupAt(group)
-      case None        => Some(replacement)
+
+  private val Dollar1 = "$1"
+
+  sealed trait FamilyReplacement {
+    def render(agent: String, m: Matcher): String
+  }
+
+  private final case class FamilyLiteral(value: String) extends FamilyReplacement {
+    override def render(agent: String, m: Matcher): String = value
+  }
+  private final case class FamilyWithGroup1(parts: Array[String]) extends FamilyReplacement {
+
+    // We insert group 1 between each part.
+    override def render(agent: String, m: Matcher): String = {
+      val stringBuilder = new java.lang.StringBuilder()
+      val hasGroup1 = m.groupCount() >= 1 && m.start(1) >= 0
+      val partsLength = parts.length
+
+      var i = 0
+      parts.foreach { part =>
+        stringBuilder.append(part)
+        if (i < partsLength - 1) {
+          if (hasGroup1) stringBuilder.append(agent, m.start(1), m.end(1))
+        }
+        i += 1
+      }
+      stringBuilder.toString
+    }
+  }
+
+  private def compileFamilyReplacement(replacementDef: String): FamilyReplacement = {
+    val first = replacementDef.indexOf(Dollar1)
+    if (first < 0) FamilyLiteral(replacementDef)
+    else {
+      // Split by "$1". Keep empty segments.
+      val buf = ListBuffer.empty[String]
+      var from = 0
+      var idx = first
+      while (idx >= 0) {
+        buf += replacementDef.substring(from, idx)
+        from = idx + Dollar1.length
+        idx = replacementDef.indexOf(Dollar1, from)
+      }
+      buf += replacementDef.substring(from)
+      FamilyWithGroup1(buf.toArray)
     }
+  }
 
-  def fromMap(m: Map[String, String]): Option[OSPattern] = m.get("regex").map { r =>
-    OSPattern(
-      Pattern.compile(r),
-      m.get("os_replacement"),
-      m.get("os_v1_replacement"),
-      m.get("os_v2_replacement"),
-      m.get("os_v3_replacement"),
-      m.get("os_v4_replacement")
-    )
+  sealed trait VersionReplacement
+  private final case class VersionLiteral(value: String) extends VersionReplacement
+  private final case class VersionGroupRef(group: Int) extends VersionReplacement
+
+  private def compileVersionReplacement(replacementDef: String): VersionReplacement = {
+    // Treat only the whole string "$<digits>" as a group reference, otherwise it will be treated as a literal.
+    if (replacementDef != null && replacementDef.length >= 2 && replacementDef.charAt(0) == '$') {
+      var i = 1
+      var n = 0
+      var hasDigits = false
+      while (i < replacementDef.length) {
+        val ch = replacementDef.charAt(i)
+        if (ch >= '0' && ch <= '9') {
+          hasDigits = true
+          n = n * 10 + (ch - '0')
+          i += 1
+        } else {
+          return VersionLiteral(replacementDef)
+        }
+      }
+      if (hasDigits && n > 0) VersionGroupRef(n) else VersionLiteral(replacementDef)
+    } else VersionLiteral(replacementDef)
   }
+
+  private def evalVersion(rep: VersionReplacement, m: Matcher): Option[String] =
+    rep match {
+      case VersionLiteral(v)   => if (v == null || v.isEmpty) None else Some(v)
+      case VersionGroupRef(gr) => m.groupAt(gr)
+    }
+
+  // - replacement is a backref and missing, fall back to the default captured group
+  // - replacement is a literal, use it (unless empty)
+  // - no replacement provided, use fallback captured group
+  private def resolveVersion(repOpt: Option[VersionReplacement], matcher: Matcher, fallbackGroup: Int): Option[String] =
+    repOpt match {
+      case Some(VersionGroupRef(gr)) => matcher.groupAt(gr).orElse(matcher.groupAt(fallbackGroup))
+      case Some(litOrOther)          => evalVersion(litOrOther, matcher).orElse(matcher.groupAt(fallbackGroup))
+      case None                      => matcher.groupAt(fallbackGroup)
+    }
+
+  def fromMap(m: Map[String, String]): Option[OSPattern] =
+    m.get("regex").map { r =>
+      val osRep = m.get("os_replacement").map(compileFamilyReplacement)
+      val v1 = m.get("os_v1_replacement").map(compileVersionReplacement)
+      val v2 = m.get("os_v2_replacement").map(compileVersionReplacement)
+      val v3 = m.get("os_v3_replacement").map(compileVersionReplacement)
+      val v4 = m.get("os_v4_replacement").map(compileVersionReplacement)
+
+      OSPattern(
+        pattern = Pattern.compile(r),
+        osReplacement = osRep,
+        v1Replacement = v1,
+        v2Replacement = v2,
+        v3Replacement = v3,
+        v4Replacement = v4
+      )
+    }
 }

modules/lib/src/main/scala/org/uaparser/scala/UserAgentParser.scala

@@ -1,15 +1,23 @@
 package org.uaparser.scala
 
 case class UserAgentParser(patterns: List[UserAgentPattern]) {
-  def parse(agent: String): UserAgent = patterns
-    .foldLeft[Option[UserAgent]](None) {
-      case (None, pattern) => pattern.process(agent)
-      case (result, _)     => result
+  private val patternsArray = patterns.toArray
+  private val length = patternsArray.length
+  def parse(agent: String): UserAgent = {
+    var i = 0
+    while (i < length) {
+      patternsArray(i).process(agent) match {
+        case Some(d) => return d
+        case None    => ()
+      }
+      i += 1
     }
-    .getOrElse(UserAgent("Other"))
+    UserAgentParser.Other
+  }
 }
 
 object UserAgentParser {
+  private val Other = UserAgent("Other")
   def fromList(config: List[Map[String, String]]): UserAgentParser =
     UserAgentParser(config.flatMap(UserAgentPattern.fromMap))
 }