Merge pull request #282 from ua-parser/scalafmt

Remove scalastyle and adopt scalafix and scalafmt

Author: thyandrecardoso

Diff for: .github/workflows/scala.yml

@@ -23,5 +23,7 @@ jobs:
           cache: sbt
       - name: Setup sbt
         uses: sbt/setup-sbt@v1
+      - name: Check formatting
+        run: sbt -v "scalafixAll --check; scalafmtCheck"
       - name: Run tests
-        run: sbt -v "++${{ matrix.scala-version }} clean; test; scalastyle;"
+        run: sbt -v "++${{ matrix.scala-version }} clean; test;"

Diff for: .scalafix.conf

@@ -0,0 +1,19 @@
+rules = [OrganizeImports, LeakingImplicitClassVal, ProcedureSyntax, RedundantSyntax, ExplicitResultTypes]
+
+OrganizeImports {
+  targetDialect = Scala3
+  coalesceToWildcardImportThreshold = 2147483647 # Int.MaxValue
+  expandRelative = true
+  groupExplicitlyImportedImplicitsSeparately = false
+  groupedImports = AggressiveMerge
+  groups = ["re:javax?\\.", "scala.", "*", "org.uaparser."]
+  importSelectorsOrder = Ascii
+  importsOrder = Ascii
+  removeUnused = false
+}
+
+ExplicitResultTypes {
+  memberVisibility = [Public]
+  memberKind = [Def]
+  skipSimpleDefinitions = false
+}

Diff for: .scalafmt.conf

@@ -0,0 +1,13 @@
+version = 3.9.4
+
+runner.dialect = scala3
+maxColumn = 120
+newlines.topLevelStatementBlankLines = [
+  { blanks: { after: 0 } }
+]
+fileOverride {
+  "glob:**/*.sbt" {
+    runner.dialect = sbt1
+    align.preset = most
+  }
+}

Diff for: build.sbt

@@ -1,15 +1,16 @@
 import ReleaseTransformations._
 
-name := "uap-scala"
+name         := "uap-scala"
 organization := "org.uaparser"
 
-scalaVersion := "2.13.14"
+scalaVersion       := "2.13.14"
 crossScalaVersions := Seq("2.12.20", "2.13.16", "3.3.5")
 
 scalacOptions ++= Seq(
   "-Xfatal-warnings",
   "-deprecation",
-  "-encoding", "UTF-8",
+  "-encoding",
+  "UTF-8",
   "-feature",
   "-unchecked"
 )
@@ -23,43 +24,47 @@ val scala2Flags = Seq(
 )
 
 scalacOptions := {
-    CrossVersion.partialVersion(scalaVersion.value) match {
-      case Some((3, _)) =>
-        scalacOptions.value :+ "-language:implicitConversions"
-      case Some((2, _)) =>
-        scalacOptions.value ++ scala2Flags
-      case _ =>
-        scalacOptions.value
-    }
+  CrossVersion.partialVersion(scalaVersion.value) match {
+    case Some((3, _)) =>
+      scalacOptions.value :+ "-language:implicitConversions"
+    case Some((2, _)) =>
+      scalacOptions.value ++ scala2Flags
+    case _            =>
+      scalacOptions.value
+  }
 }
 
-libraryDependencies +=  "org.yaml" % "snakeyaml" % "2.4"
+// Enable scalafix
+semanticdbEnabled := true
+semanticdbVersion := scalafixSemanticdb.revision
+
+libraryDependencies += "org.yaml" % "snakeyaml" % "2.4"
 
 libraryDependencies := {
   CrossVersion.partialVersion(scalaVersion.value) match {
-    case Some((3, _)) =>
+    case Some((3, _))                              =>
       libraryDependencies.value ++ Seq("org.specs2" %% "specs2-core" % "5.5.8" % "test")
     case Some((2, scalaMajor)) if scalaMajor >= 11 =>
       libraryDependencies.value ++ Seq("org.specs2" %% "specs2-core" % "4.20.9" % "test")
-    case _ =>
+    case _                                         =>
       libraryDependencies.value ++ Seq("org.specs2" %% "specs2-core" % "3.10.0" % "test")
-    }
   }
+}
 
 mimaPreviousArtifacts := Set("org.uaparser" %% "uap-scala" % "0.3.0")
 
 Compile / unmanagedResourceDirectories += baseDirectory.value / "core"
 Compile / unmanagedResources / includeFilter := "regexes.yaml"
 Test / unmanagedResourceDirectories += baseDirectory.value / "core"
-Test / unmanagedResources / includeFilter := "*.yaml"
+Test / unmanagedResources / includeFilter    := "*.yaml"
 
 // Publishing
-publishMavenStyle := true
-publishTo := sonatypePublishToBundle.value
+publishMavenStyle      := true
+publishTo              := sonatypePublishToBundle.value
 Test / publishArtifact := false
 
-releaseCrossBuild := true
-releaseTagComment := s"Release ${(ThisBuild / version).value}"
+releaseCrossBuild    := true
+releaseTagComment    := s"Release ${(ThisBuild / version).value}"
 releaseCommitMessage := s"Set version to ${(ThisBuild / version).value}"
 
 releaseProcess := Seq[ReleaseStep](
@@ -77,8 +82,7 @@ releaseProcess := Seq[ReleaseStep](
   pushChanges
 )
 
-pomExtra := (
-  <url>https://github.com/ua-parser/uap-scala</url>
+pomExtra := (<url>https://github.com/ua-parser/uap-scala</url>
   <licenses>
       <license>
         <name>WTFPL</name>

Diff for: project/plugins.sbt

@@ -1,5 +1,6 @@
-addSbtPlugin("com.github.sbt" % "sbt-pgp"                % "2.3.1")
-addSbtPlugin("com.github.sbt" % "sbt-release"            % "1.4.0")
-addSbtPlugin("com.typesafe"   % "sbt-mima-plugin"        % "1.1.4")
-addSbtPlugin("org.scalastyle" %% "scalastyle-sbt-plugin" % "1.0.0")
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype"           % "3.12.2")
+addSbtPlugin("com.github.sbt" % "sbt-pgp"         % "2.3.1")
+addSbtPlugin("com.github.sbt" % "sbt-release"     % "1.4.0")
+addSbtPlugin("com.typesafe"   % "sbt-mima-plugin" % "1.1.4")
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype"    % "3.12.2")
+addSbtPlugin("ch.epfl.scala"  % "sbt-scalafix"    % "0.14.2")
+addSbtPlugin("org.scalameta"  % "sbt-scalafmt"    % "2.5.4")

Diff for: scalastyle-config.xml

@@ -1,12 +1,14 @@
 package org.uaparser.scala
 
 import java.io.InputStream
-import java.util.{ Collections, LinkedHashMap, Map => JMap }
+import java.util
+import java.util.{Collections, Map as JMap}
+
 import scala.util.Try
 
 case class CachingParser(parser: Parser, maxEntries: Int) extends UserAgentStringParser {
   lazy val clients: JMap[String, Client] = Collections.synchronizedMap(
-    new LinkedHashMap[String, Client](maxEntries + 1, 1.0f, true) {
+    new util.LinkedHashMap[String, Client](maxEntries + 1, 1.0f, true) {
       override protected def removeEldestEntry(eldest: JMap.Entry[String, Client]): Boolean =
         super.size > maxEntries
     }
@@ -19,7 +21,7 @@ case class CachingParser(parser: Parser, maxEntries: Int) extends UserAgentStrin
 }
 
 object CachingParser {
-  val defaultCacheSize: Int = 1000
+  private val defaultCacheSize: Int = 1000
   def fromInputStream(source: InputStream, size: Int = defaultCacheSize): Try[CachingParser] =
     Parser.fromInputStream(source).map(CachingParser(_, size))
   def default(size: Int = defaultCacheSize): CachingParser = CachingParser(Parser.default, size)

Diff for: src/main/scala/org/uaparser/scala/CachingParser.scala

@@ -1,49 +1,56 @@
 package org.uaparser.scala
 
-import java.util.regex.{ Matcher, Pattern }
-import org.uaparser.scala.MatcherOps._
+import java.util.regex.{Matcher, Pattern}
+
+import org.uaparser.scala.MatcherOps.*
 
 case class Device(family: String, brand: Option[String] = None, model: Option[String] = None)
 
 object Device {
   private[scala] def fromMap(m: Map[String, String]) = m.get("family").map(Device(_, m.get("brand"), m.get("model")))
 
-  private[scala] case class DevicePattern(pattern: Pattern, familyReplacement: Option[String],
-                                           brandReplacement: Option[String], modelReplacement: Option[String]) {
+  private[scala] case class DevicePattern(
+      pattern: Pattern,
+      familyReplacement: Option[String],
+      brandReplacement: Option[String],
+      modelReplacement: Option[String]
+  ) {
     def process(agent: String): Option[Device] = {
       val matcher = pattern.matcher(agent)
-      if (!matcher.find()) None else {
+      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)
         family.map(Device(_, brand, model))
       }
     }
 
-    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 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)
-      )
+      val pattern =
+        m.get("regex_flag").map(flag => Pattern.compile(r, Pattern.CASE_INSENSITIVE)).getOrElse(Pattern.compile(r))
       DevicePattern(pattern, m.get("device_replacement"), m.get("brand_replacement"), m.get("model_replacement"))
     }
   }
 
   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
-    }.getOrElse(Device("Other"))
+    def parse(agent: String): Device = patterns
+      .foldLeft[Option[Device]](None) {
+        case (None, pattern) => pattern.process(agent)
+        case (result, _)     => result
+      }
+      .getOrElse(Device("Other"))
   }
 
   object DeviceParser {

Diff for: src/main/scala/org/uaparser/scala/Device.scala

@@ -3,7 +3,7 @@ package org.uaparser.scala
 import java.util.regex.Matcher
 
 object MatcherOps {
-  implicit class MatcherImprovements(val m: Matcher) extends AnyVal {
+  implicit class MatcherImprovements(private val m: Matcher) extends AnyVal {
     // 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.