adjusted namings in CompletionExpansionSupport

Author: jchapuis

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

@@ -20,26 +20,26 @@ trait CompletionExpansionSupport extends RegexCompletionSupport {
     * @tparam T the parser type
     * @return a parser adapter performing completion expansion
     */
-  def allExpandedCompletions[T](p: Parser[T], onlyAtInputEnd: Boolean = true): Parser[T] = expandedCompletions(p, p, onlyAtInputEnd)
+  def expandedCompletions[T](p: Parser[T], onlyAtInputEnd: Boolean = true): Parser[T] = expandedCompletionsWithLimiter(p, p, onlyAtInputEnd)
 
   /**
     * 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.
+    * where the passed `limiter` 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)
+    * selecting the relevant limiter parser is critical to avoid infinite recursion)
     * @param p the parser
     * @param onlyAtInputEnd expansion happens only when input is positioned exactly at the end upon completion
-    * @param stop the parser signalling the end of exploration upon successful parse
+    * @param limiter 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
+    * @return a parser adapter performing completion expansion limited according to `limiter` parser
     */
-  def expandedCompletions[T](p: Parser[T], stop: Parser[Any], onlyAtInputEnd: Boolean = true): Parser[T] =
+  def expandedCompletionsWithLimiter[T](p: Parser[T], limiter: Parser[Any], onlyAtInputEnd: Boolean = true): Parser[T] =
     Parser(
       p,
       in => {
         lazy val isAtInputEnd = dropAnyWhiteSpace(in).atEnd
         if (!onlyAtInputEnd || isAtInputEnd) {
-          val Completions(_, sets) = exploreCompletions(p, stop, in)
+          val Completions(_, sets) = exploreCompletions(p, limiter, in)
           Completions(OffsetPosition(in.source, handleWhiteSpace(in)), sets)
         } else
           p.completions(in)

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

@@ -20,7 +20,7 @@ class CompletionExpansionSupportTest {
     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() = allExpandedCompletions(expr(1))
+    def exprWithExpandedCompletions() = expandedCompletions(expr(1))
   }
 
   @Test
@@ -41,7 +41,7 @@ class CompletionExpansionSupportTest {
     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)
+    def which(): Parser[Any]     = expandedCompletionsWithLimiter(parser, limiter = jumpsOverDogOrCat ~ jumpsOverDogOrCat)
     lazy val infiniteDogsAndCats = fox ~ which
   }