expansion mechanism

Author: jchapuis

src/main/scala/com/nexthink/utils/parsing/combinator/completion/RegexCompletionSupportWithExpansion.scala

@@ -11,7 +11,26 @@ import scala.util.parsing.input.{CharSequenceReader, Position, Reader}
 
 trait RegexCompletionSupportWithExpansion extends RegexCompletionSupport {
 
-  def expandedCompletions[T](p: Parser[T]): Parser[T]                  = expandedCompletions(p, p)
+  /**
+    * Adapts a parser so that completing it will list all possible expanded completions (which successfully parse)
+    * (note that if this is used within the context of a grammar allowing for infinitely growing expressions, this
+    * will trigger infinite recursion and will end up in a `StackOverflowException`)
+    * @param p the parser
+    * @tparam T the parser type
+    * @return a parser adapter performing completion expansion
+    */
+  def expandedCompletions[T](p: Parser[T]): Parser[T] = expandedCompletions(p, p)
+
+  /**
+    * Adapts a parser so that completing it will construct the list of all possible alternatives up to the point
+    * where the passed `stop` parser successfully parses the expansions.
+    * (note that if this is used within the context of a grammar allowing for infinitely growing expressions,
+    * selecting the relevant stop parser is critical to avoid infinite recursion)
+    * @param p the parser
+    * @param stop the parser signalling the end of exploration upon successful parse
+    * @tparam T the parser type
+    * @return a parser adapter performing completion expansion limited according to `stop` parser
+    */
   def expandedCompletions[T](p: Parser[T], stop: Parser[T]): Parser[T] =
     Parser(p, in => {
       exploreCompletions(p, stop, in)
@@ -24,25 +43,19 @@ trait RegexCompletionSupportWithExpansion extends RegexCompletionSupport {
       else
         completions.allSets
           .map(cSet => {
-            val completionPos                     = completions.position.column
-            val inputCompletedWithFirstSetElement = ExplorerReader(p, completeString(str, completionPos, cSet.completions.head))
-            if (stop(inputCompletedWithFirstSetElement).successful) {
-              // we consider we have reached stop condition with this completion set
-              Completions(in.pos, CompletionSet(cSet.tag, cSet.completions.map(c => Completion(completeString(str, completionPos, c), c.score, c.kind))))
-            } else {
-              // continue exploring
-              cSet.completions
-                .map(c => {
-                  val completedInput = completeString(str, completionPos, c)
-                  println(completedInput)
+            cSet.completions
+              .map(c => {
+                val completedInput = completeString(str, completions.position.column, c)
+                if (stop(new CharSequenceReader(completedInput)).successful) {
+                  Completions(in.pos, CompletionSet(cSet.tag, Set(Completion(completedInput, c.score, c.kind))))
+                } else {
                   exploreCompletionsRec(completedInput, p.completions(ExplorerReader(p, completedInput)))
-                })
-                .reduce((a, b) => a | b)
-            }
+                }
+              })
+              .reduce((a, b) => a | b)
           })
           .reduce((a, b) => a | b)
     }
-
     if (in match {
           case ExplorerReader(exploredParser, _, _) if exploredParser == p => true
           case _                                                           => false

src/test/scala/com/nexthink/utils/parsing/combinator/completion/ExpandedCompletionsTest.scala

@@ -7,60 +7,67 @@
 
 package com.nexthink.utils.parsing.combinator.completion
 
+import com.nexthink.utils.parsing.combinator.completion.CompletionTestDefinitions.Tagged
 import org.junit.{Assert, Test}
 
 import scala.util.parsing.combinator.Parsers
 
 class ExpandedCompletionsTest {
 
   object FiniteArithmeticParser extends Parsers with RegexCompletionSupportWithExpansion {
-    val number                   = "[0-9]+".r %> "99"
+    val number                               = "[0-9]+".r %> "99"
     def expr(maxNesting: Int)                = term(maxNesting) ~ ("+" | "-") ~! term(maxNesting)
-    def term(maxNesting: Int)                = factor(maxNesting) ~ ("*" | "/") ~! factor(maxNesting)
+    def term(maxNesting: Int)                = factor(maxNesting) ~ "*" ~! factor(maxNesting)
     def factor(maxNesting: Int): Parser[Any] = if (maxNesting == 0) number else number | "(" ~> expr(maxNesting - 1) <~ ")"
 
     def exprWithExpandedCompletions() = expandedCompletions(expr(1))
   }
 
   @Test
   def finiteExpressionParses(): Unit = {
-    val result = FiniteArithmeticParser.parse(FiniteArithmeticParser.exprWithExpandedCompletions(), "( 99 / 99 - 99 / 99 ) / ( 99 / 99 + 99 / 99 ) - ( 99 * 99 - 99 * 99 ) / ( 99 * 99 - 99 / 99 )")
-    println(result)
+    val result = FiniteArithmeticParser.parse(FiniteArithmeticParser.exprWithExpandedCompletions(),
+                                              "( 99 * 99 + 99 * 99 ) * ( 99 * 99 + 99 * 99 ) + ( 99 * 99 + 99 * 99 ) * ( 99 * 99 + 99 * 99 )")
     assert(result.successful)
   }
 
   @Test
   def finiteExpressionCompletesToAllAlternatives(): Unit = {
     val completions = FiniteArithmeticParser.completeString(FiniteArithmeticParser.exprWithExpandedCompletions(), "")
-    println(completions)
+    Assert.assertEquals(completions.length, 162)
   }
 
-  object InfiniteExpressionParser extends Parsers with RegexCompletionSupportWithExpansion {
+  object InfiniteExpressionParser extends Parsers with RegexCompletionSupportWithExpansion with CompletionTestParser {
     val fox                      = "the quick brown fox"
-    val jumpsOver                = "which jumps over the lazy"
-    val jumpsOverDogOrCat        = jumpsOver ~ ("dog" | "cat")
+    val jumpsOver                = "which jumps over the lazy" % "action"
+    val jumpsOverDogOrCat        = jumpsOver ~ ("dog" | "cat") % "animal" %? "dogs and cats" % 10
     lazy val parser              = jumpsOverDogOrCat | jumpsOverDogOrCat ~ which()
     def which(): Parser[Any]     = expandedCompletions(parser, stop = jumpsOverDogOrCat ~ jumpsOverDogOrCat)
     lazy val infiniteDogsAndCats = fox ~ which
   }
 
   @Test
   def infiniteExpressionParses(): Unit = {
-    val result = InfiniteExpressionParser.parse(InfiniteExpressionParser.infiniteDogsAndCats,
-                                  "the quick brown fox which jumps over the lazy cat which jumps over the lazy dog which jumps over the lazy cat")
+    val result = InfiniteExpressionParser.parse(
+      InfiniteExpressionParser.infiniteDogsAndCats,
+      "the quick brown fox which jumps over the lazy cat which jumps over the lazy dog which jumps over the lazy cat"
+    )
     assert(result.successful)
   }
 
   @Test
   def infiniteExpressionCompletesToAlternativesUpToStop(): Unit = {
-    val completions = InfiniteExpressionParser.completeString(InfiniteExpressionParser.infiniteDogsAndCats, "the quick brown fox ")
-    Assert.assertEquals(
-      Seq(
-        " which jumps over the lazy cat which jumps over the lazy cat",
-        " which jumps over the lazy cat which jumps over the lazy dog",
-        " which jumps over the lazy dog which jumps over the lazy cat",
-        " which jumps over the lazy dog which jumps over the lazy dog"
-      ),
+    val completions = InfiniteExpressionParser.complete(InfiniteExpressionParser.infiniteDogsAndCats, "the quick brown fox ")
+    InfiniteExpressionParser.assertHasCompletions(
+      Set(
+        Tagged(
+          "animal",
+          Some("dogs and cats"),
+          10,
+          " which jumps over the lazy cat which jumps over the lazy cat",
+          " which jumps over the lazy cat which jumps over the lazy dog",
+          " which jumps over the lazy dog which jumps over the lazy cat",
+          " which jumps over the lazy dog which jumps over the lazy dog"
+        )),
       completions
     )
   }