fix: fix json parsing of IgnoredSelectors

Author: giacomocavalieri

src/main/scala/dev/atedeg/Configuration.scala

@@ -17,7 +17,7 @@ final case class IgnoredEnumCase(caseName: String) extends IgnoredSelector
 
 object IgnoredSelector {
 
-  def fromKind(kind: String, name: String): Option[IgnoredSelector] = kind match {
+  def fromKind(name: String, kind: String): Option[IgnoredSelector] = kind match {
     case "class" => Some(IgnoredClass(name))
     case "trait" => Some(IgnoredTrait(name))
     case "type" => Some(IgnoredType(name))
@@ -70,17 +70,18 @@ object AllEntities {
   def read(workingDir: File): Either[Error, Set[IgnoredSelector]] =
     Utils.parseFileWith(allEntitiesFile(workingDir))(parse)
 
-  private[atedeg] def parse(raw: String): Either[Error, Set[IgnoredSelector]] =
-    parseJsonString(raw).leftMap(CirceParsingFailure).flatMap(parseJson)
+  private[atedeg] def parse(raw: String): Either[Error, Set[IgnoredSelector]] = {
+    val sanitizedRaw = raw.replaceFirst("pages = ", "").replaceFirst(";", "")
+    parseJsonString(sanitizedRaw).leftMap(CirceParsingFailure).flatMap(parseJson)
+  }
 
   private def parseJson(json: Json): Either[Error, Set[IgnoredSelector]] = {
     implicit val decodeIgnoredSelector: Decoder[Option[IgnoredSelector]] =
       Decoder.forProduct2("n", "k")(IgnoredSelector.fromKind)
-
-    for {
-      pagesField <- json.findAllByKey("pages").headOption.toRight[Error](ParseError(File(entitiesFileName), "pages"))
-      res <- pagesField.as[Set[Option[IgnoredSelector]]].leftMap(CirceDecodingFailure)
-    } yield res.collect { case Some(s) => s }
+    json
+      .as[Set[Option[IgnoredSelector]]]
+      .map(_.collect { case Some(s) => s })
+      .leftMap(CirceDecodingFailure)
   }
 }
 

src/test/scala/dev/atedeg/ConfigParserTests.scala

@@ -6,11 +6,11 @@ import org.scalatest.matchers.should.Matchers
 @SuppressWarnings(Array("org.wartremover.warts.NonUnitStatements"))
 class ConfigParserTests extends AnyFlatSpec with Matchers {
 
-  "parse" should " fail with an empty string" in {
+  "parse" should "fail with an empty string" in {
     Configuration.parse("") should matchPattern { case Left(_) => }
   }
 
-  it should " fail with a malformed string" in {
+  it should "fail with a malformed string" in {
     val malformedString =
       """
         |ignored: []
@@ -21,7 +21,7 @@ class ConfigParserTests extends AnyFlatSpec with Matchers {
     Configuration.parse(malformedString) should matchPattern { case Left(_) => }
   }
 
-  it should " parse a correct string" in {
+  it should "parse a correct string" in {
     val correctString =
       """
         |ignored:

src/test/scala/dev/atedeg/EntitiesParserTest.scala

@@ -0,0 +1,79 @@
+package dev.atedeg
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+@SuppressWarnings(Array("org.wartremover.warts.NonUnitStatements"))
+class EntitiesParserTest extends AnyFlatSpec with Matchers {
+
+  "parse" should "fail with an empty string" in {
+    AllEntities.parse("") should matchPattern { case Left(_) => }
+  }
+
+  it should "fail with a malformed string" in {
+    val malformedString = "pages: [error]"
+    AllEntities.parse(malformedString) should matchPattern { case Left(_) => }
+  }
+
+  it should "parse a correct string" in {
+    val correctString =
+      """
+        |pages = [{
+        |        "l": "",
+        |        "e": false,
+        |        "i": "",
+        |        "n": "Type",
+        |        "t": "",
+        |        "d": "",
+        |        "k": "type"
+        |    },
+        |{
+        |        "l": "",
+        |        "e": false,
+        |        "i": "",
+        |        "n": "Enum",
+        |        "t": "",
+        |        "d": "",
+        |        "k": "enum"
+        |    },
+        |    {
+        |        "l": "",
+        |        "e": false,
+        |        "i": "",
+        |        "n": "Case",
+        |        "t": "",
+        |        "d": "",
+        |        "k": "case"
+        |    },
+        |    {
+        |        "l": "",
+        |        "e": false,
+        |        "i": "",
+        |        "n": "Trait",
+        |        "t": "",
+        |        "d": "",
+        |        "k": "trait"
+        |    },
+        |    {
+        |        "l": "",
+        |        "e": false,
+        |        "i": "",
+        |        "n": "Class",
+        |        "t": "",
+        |        "d": "",
+        |        "k": "class"
+        |    },
+        |    {
+        |        "n": "ignore me",
+        |        "k": "package"
+        |    }];""".stripMargin
+    val expected: Set[IgnoredSelector] = Set(
+      IgnoredClass("Class"),
+      IgnoredEnum("Enum"),
+      IgnoredTrait("Trait"),
+      IgnoredEnumCase("Case"),
+      IgnoredType("Type"),
+    )
+    AllEntities.parse(correctString) shouldBe Right(expected)
+  }
+}