Implement JsonPath Parser

compiler.sbt

@@ -0,0 +1,3 @@
+import org.typelevel.scalacoptions.ScalacOptions
+
+tpolecatExcludeOptions += ScalacOptions.warnUnusedImports

dependencies.sbt

@@ -1,5 +1,12 @@
 ThisBuild / scalaVersion := "2.13.14"
 
+/**
+ * Parsley is a fast and modern parser combinator library for Scala.
+ * @see [[https://github.com/j-mie6/parsley]]
+ */
+libraryDependencies +=
+  "com.github.j-mie6" %% "parsley" % "4.5.2"
+
 /**
  * ScalaTest is the most flexible and most popular testing tool in the Scala ecosystem.
  * @see [[https://www.scalatest.org/]]

src/main/scala/ahlers/tree/path/Mapped.scala

@@ -0,0 +1,26 @@
+package ahlers.tree.path
+
+case class Mapped()
+object Mapped {
+
+  case class Path(toSegments: Seq[Path.Segment])
+
+  object Path {
+    sealed trait Segment
+
+    object Segment {
+      case class Key(toKey: String)  extends Segment
+      case class Index(toIndex: Int) extends Segment
+    }
+  }
+
+  sealed trait Value
+
+  object Value {
+    case class Text(toText: String)              extends Value
+    case class Integer(toBigInt: BigInt)         extends Value
+    case class Decimal(toBigDecimal: BigDecimal) extends Value
+    case class Boolean(toBoolean: Boolean)       extends Value
+  }
+
+}

src/main/scala/ahlers/tree/path/expressions/Expression.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.expressions
+
+trait Expression {
+  def toText: String
+}

src/main/scala/ahlers/tree/path/expressions/Logical.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.expressions
+
+case class Logical() extends Expression {
+  override val toText: String = "Logical"
+}

src/main/scala/ahlers/tree/path/expressions/Selector.scala

@@ -0,0 +1,7 @@
+package ahlers.tree.path.expressions
+
+import ahlers.tree.path.operators.Operator
+
+case class Selector(toOperators: Seq[Operator]) extends Expression {
+  val toText: String = toOperators.map(_.toText).mkString
+}

src/main/scala/ahlers/tree/path/filterOperators/FilterOperator.scala

@@ -0,0 +1,8 @@
+package ahlers.tree.path.filterOperators
+
+/**
+ * @see [[https://github.com/json-path/JsonPath/blob/45333e0a310af70ad48d34d306da30af1e8e6314/README.md#filter-operators]]
+ */
+trait FilterOperator {
+  def toText: String
+}

src/main/scala/ahlers/tree/path/filterOperators/HasSize.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object HasSize extends FilterOperator {
+  override val toText: String = "size"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsAnyOf.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsAnyOf extends FilterOperator {
+  override val toText: String = "anyof"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsEmpty.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsEmpty extends FilterOperator {
+  override val toText: String = "empty"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsEqualTo.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsEqualTo extends FilterOperator {
+  override val toText: String = "=="
+}

src/main/scala/ahlers/tree/path/filterOperators/IsGreaterThan.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsGreaterThan extends FilterOperator {
+  override val toText: String = ">"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsGreaterThanOrEqualTo.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsGreaterThanOrEqualTo extends FilterOperator {
+  override val toText: String = ">="
+}

src/main/scala/ahlers/tree/path/filterOperators/IsIn.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsIn extends FilterOperator {
+  override val toText: String = "in"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsLessThan.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsLessThan extends FilterOperator {
+  override val toText: String = "<"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsLessThanOrEqualTo.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsLessThanOrEqualTo extends FilterOperator {
+  override val toText: String = "<="
+}

src/main/scala/ahlers/tree/path/filterOperators/IsMatchOf.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsMatchOf extends FilterOperator {
+  override val toText: String = "=~"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsNoneOf.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsNoneOf extends FilterOperator {
+  override val toText: String = "noneof"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsNotEqualTo.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsNotEqualTo extends FilterOperator {
+  override val toText: String = "!="
+}

src/main/scala/ahlers/tree/path/filterOperators/IsNotIn.scala

@@ -0,0 +1,7 @@
+package ahlers.tree.path.filterOperators
+
+object IsNotIn extends FilterOperator {
+
+  /** \m/ */
+  override val toText: String = "nin"
+}

src/main/scala/ahlers/tree/path/filterOperators/IsSubsetOf.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.filterOperators
+
+object IsSubsetOf extends FilterOperator {
+  override val toText: String = "subsetof"
+}

src/main/scala/ahlers/tree/path/operators/ArrayIndexes.scala

@@ -0,0 +1,7 @@
+package ahlers.tree.path.operators
+
+import ahlers.tree.path.terms.Index
+
+case class ArrayIndexes(toIndexes: Seq[Index]) extends Operator {
+  override val toText: String = toIndexes.map(_.toText).mkString("[", ",", "]")
+}

src/main/scala/ahlers/tree/path/operators/ArraySlice.scala

@@ -0,0 +1,17 @@
+package ahlers.tree.path.operators
+
+import ahlers.tree.path.terms.Index
+
+sealed trait ArraySlice extends Operator
+
+object ArraySlice {
+  case class LeftBounded(start: Index) extends ArraySlice {
+    val toText: String = s"[${start.toText}:]"
+  }
+  case class RightBounded(end: Index) extends ArraySlice {
+    val toText: String = s"[:${end.toText}]"
+  }
+  case class Bounded(start: Index, end: Index) extends ArraySlice {
+    val toText: String = s"[${start.toText}:${end.toText}]"
+  }
+}

src/main/scala/ahlers/tree/path/operators/BracketNotatedChildren.scala

@@ -0,0 +1,23 @@
+package ahlers.tree.path.operators
+
+import ahlers.tree.path.terms.Name
+
+case class BracketNotatedChildren(toNames: Seq[BracketNotatedChildren.Child]) extends Operator {
+  override val toText: String = toNames.map(_.toText).mkString("[", ",", "]")
+}
+
+object BracketNotatedChildren {
+  sealed trait Child {
+    def toText: String
+  }
+  object Child {
+    case class MatchingName(toName: Name) extends Child {
+      val toText: String = s"'${toName.toText}'"
+    }
+
+    case object MatchingWildcard extends Child {
+      val toWildcard: Wildcard.type = Wildcard
+      val toText: String            = s"${toWildcard.toText}"
+    }
+  }
+}

src/main/scala/ahlers/tree/path/operators/CurrentNode.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.operators
+
+case object CurrentNode extends Operator {
+  override val toText: String = "@"
+}

src/main/scala/ahlers/tree/path/operators/DeepScan.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.operators
+
+case object DeepScan extends Operator {
+  override val toText: String = ".."
+}

src/main/scala/ahlers/tree/path/operators/DotNotatedChild.scala

@@ -0,0 +1,16 @@
+package ahlers.tree.path.operators
+
+import ahlers.tree.path.terms.Name
+
+sealed trait DotNotatedChild extends Operator
+
+object DotNotatedChild {
+  case class MatchingName(toName: Name) extends DotNotatedChild {
+    val toText: String = s".${toName.toText}"
+  }
+
+  case object MatchingWildcard extends DotNotatedChild {
+    val toWildcard: Wildcard.type = Wildcard
+    val toText: String            = s".${toWildcard.toText}"
+  }
+}

src/main/scala/ahlers/tree/path/operators/Operator.scala

@@ -0,0 +1,8 @@
+package ahlers.tree.path.operators
+
+/**
+ * @see [[https://github.com/json-path/JsonPath/blob/45333e0a310af70ad48d34d306da30af1e8e6314/README.md#operators]]
+ */
+trait Operator {
+  def toText: String
+}

src/main/scala/ahlers/tree/path/operators/RootElement.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.operators
+
+case object RootElement extends Operator {
+  override val toText: String = "$"
+}

src/main/scala/ahlers/tree/path/operators/Wildcard.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.operators
+
+case object Wildcard extends Operator {
+  override val toText: String = "*"
+}

src/main/scala/ahlers/tree/path/parsers/expression.scala

@@ -0,0 +1,14 @@
+package ahlers.tree.path.parsers
+
+import ahlers.tree.path.expressions.Expression
+import ahlers.tree.path.expressions.Selector
+import parsley.Parsley
+import parsley.Parsley.some
+
+object expression {
+
+  val selector: Parsley[Selector] = some(operator.any).map(Selector)
+
+  val any: Parsley[Expression] = selector
+
+}

src/main/scala/ahlers/tree/path/parsers/filterOperator.scala

@@ -0,0 +1,38 @@
+package ahlers.tree.path.parsers
+
+import ahlers.tree.path.filterOperators.HasSize
+import ahlers.tree.path.filterOperators.IsAnyOf
+import ahlers.tree.path.filterOperators.IsEmpty
+import ahlers.tree.path.filterOperators.IsEqualTo
+import ahlers.tree.path.filterOperators.IsGreaterThan
+import ahlers.tree.path.filterOperators.IsGreaterThanOrEqualTo
+import ahlers.tree.path.filterOperators.IsIn
+import ahlers.tree.path.filterOperators.IsLessThan
+import ahlers.tree.path.filterOperators.IsLessThanOrEqualTo
+import ahlers.tree.path.filterOperators.IsMatchOf
+import ahlers.tree.path.filterOperators.IsNoneOf
+import ahlers.tree.path.filterOperators.IsNotEqualTo
+import ahlers.tree.path.filterOperators.IsNotIn
+import ahlers.tree.path.filterOperators.IsSubsetOf
+import parsley.Parsley
+import parsley.character.char
+import parsley.character.string
+
+object filterOperator {
+
+  val isEqualTo: Parsley[IsEqualTo.type]                           = string("==").as(IsEqualTo)
+  val isNotEqualTo: Parsley[IsNotEqualTo.type]                     = string("!=").as(IsNotEqualTo)
+  val isLessThan: Parsley[IsLessThan.type]                         = char('<').as(IsLessThan)
+  val isLessThanOrEqualTo: Parsley[IsLessThanOrEqualTo.type]       = string("<=").as(IsLessThanOrEqualTo)
+  val isGreaterThan: Parsley[IsGreaterThan.type]                   = char('>').as(IsGreaterThan)
+  val isGreaterThanOrEqualTo: Parsley[IsGreaterThanOrEqualTo.type] = string(">=").as(IsGreaterThanOrEqualTo)
+  val isMatchOf: Parsley[IsMatchOf.type]                           = string("=~").as(IsMatchOf)
+  val isIn: Parsley[IsIn.type]                                     = string("in").as(IsIn)
+  val isNotIn: Parsley[IsNotIn.type]                               = string("nin").as(IsNotIn)
+  val isSubsetOf: Parsley[IsSubsetOf.type]                         = string("subsetof").as(IsSubsetOf)
+  val isAnyOf: Parsley[IsAnyOf.type]                               = string("anyof").as(IsAnyOf)
+  val isNoneOf: Parsley[IsNoneOf.type]                             = string("noneof").as(IsNoneOf)
+  val hasSize: Parsley[HasSize.type]                               = string("size").as(HasSize)
+  val isEmpty: Parsley[IsEmpty.type]                               = string("empty").as(IsEmpty)
+
+}

src/main/scala/ahlers/tree/path/parsers/operator.scala

@@ -0,0 +1,59 @@
+package ahlers.tree.path.parsers
+
+import ahlers.tree.path.operators.ArrayIndexes
+import ahlers.tree.path.operators.ArraySlice
+import ahlers.tree.path.operators.BracketNotatedChildren
+import ahlers.tree.path.operators.CurrentNode
+import ahlers.tree.path.operators.DeepScan
+import ahlers.tree.path.operators.DotNotatedChild
+import ahlers.tree.path.operators.Operator
+import ahlers.tree.path.operators.RootElement
+import ahlers.tree.path.operators.Wildcard
+import ahlers.tree.path.parsers.term.index
+import ahlers.tree.path.parsers.term.name
+import parsley.Parsley
+import parsley.Parsley.atomic
+import parsley.character.char
+import parsley.character.string
+import parsley.character.whitespaces
+import parsley.combinator.sepBy1
+
+object operator {
+
+  val rootElement: Parsley[RootElement.type] = char('$').as(RootElement)
+
+  val currentNode: Parsley[CurrentNode.type] = char('@').as(CurrentNode)
+
+  val wildcard: Parsley[Wildcard.type] = char('*').as(Wildcard)
+
+  val deepScan: Parsley[DeepScan.type] = string("..").as(DeepScan)
+
+  val dotNotatedChildMatchingName: Parsley[DotNotatedChild.MatchingName]              = (char('.') *> name).map(DotNotatedChild.MatchingName)
+  val dotNotatedChildMatchingWildcard: Parsley[DotNotatedChild.MatchingWildcard.type] = (char('.') *> wildcard).as(DotNotatedChild.MatchingWildcard)
+  val dotNotatedChild: Parsley[DotNotatedChild]                                       = atomic(dotNotatedChildMatchingName) | atomic(dotNotatedChildMatchingWildcard)
+
+  val bracketNotatedChildren: Parsley[BracketNotatedChildren] = {
+    import BracketNotatedChildren.Child
+    val childMatchingName: Parsley[Child.MatchingName]              = (char('\'') *> name <* char('\'')).map(Child.MatchingName)
+    val childMatchingWildcard: Parsley[Child.MatchingWildcard.type] = wildcard.as(Child.MatchingWildcard)
+    (char('[') *> sepBy1(atomic(childMatchingName) | atomic(childMatchingWildcard), whitespaces *> char(',') <* whitespaces) <* char(']')).map(BracketNotatedChildren(_))
+  }
+
+  val arrayIndexes: Parsley[ArrayIndexes] = (char('[') *> sepBy1(index, whitespaces *> char(',') <* whitespaces) <* char(']')).map(ArrayIndexes)
+
+  val arraySliceLeftBounded: Parsley[ArraySlice.LeftBounded]   = (char('[') *> index <~ char(':') <* char(']')).map(ArraySlice.LeftBounded)
+  val arraySliceRightBounded: Parsley[ArraySlice.RightBounded] = (char('[') *> char(':') ~> index <~ char(']')).map(ArraySlice.RightBounded)
+  val arraySliceBounded: Parsley[ArraySlice.Bounded]           = (char('[') *> index <~> char(':') *> index <~ char(']')).map((ArraySlice.Bounded(_, _)).tupled)
+  val arraySlice: Parsley[ArraySlice]                          = atomic(arraySliceLeftBounded) | atomic(arraySliceRightBounded) | atomic(arraySliceBounded)
+
+  val any: Parsley[Operator] =
+    atomic(rootElement) |
+      atomic(currentNode) |
+      atomic(wildcard) |
+      atomic(deepScan) |
+      atomic(dotNotatedChild) |
+      atomic(bracketNotatedChildren) |
+      atomic(arrayIndexes) |
+      atomic(arraySlice)
+
+}

src/main/scala/ahlers/tree/path/parsers/term.scala

@@ -0,0 +1,16 @@
+package ahlers.tree.path.parsers
+
+import ahlers.tree.path.terms.Index
+import ahlers.tree.path.terms.Name
+import parsley.Parsley
+import parsley.character.satisfy
+import parsley.character.stringOfSome
+
+object term {
+  val index: Parsley[Index] = stringOfSome(_.isDigit).map(_.toInt).map(Index)
+
+  val name: Parsley[Name] = {
+    val isValid: Set[Char] = ('a' to 'z').toSet ++ ('A' to 'Z').toSet ++ ('0' to '9').toSet
+    stringOfSome(satisfy(isValid)).map(Name)
+  }
+}

src/main/scala/ahlers/tree/path/terms/Index.scala

@@ -0,0 +1,5 @@
+package ahlers.tree.path.terms
+
+case class Index(toInt: Int) {
+  val toText: String = toInt.toString
+}

src/main/scala/ahlers/tree/path/terms/Name.scala

@@ -0,0 +1,3 @@
+package ahlers.tree.path.terms
+
+case class Name(toText: String)