renamed kind to meta

Author: jchapuis

README.md

@@ -228,8 +228,8 @@ Completing on the same expressions (`2`, `2+`, `(10*2`) now leads to the followi
 |`%`     |defines the completions tag|<code>("+" &#124; "-") % "operators"</code>|
 |`%`     |followed by an `Int`, defines the completion tag score|<code>("+" &#124; "-") % 10</code>|
 |`%?`    |defines the description of the completions tag|<code>("+" &#124; "-") %? "arithmetic operators"</code>|
-|`%%`    |defines the completions tag kind (can be used to encode properties for the tag, e.g. visual decorations)|<code>("+" &#124; "-") %% "style: highlight"</code>|
-|`%-%`   |defines the completion kind (can be used to encode properties for each completion entry, e.g. visual decorations)|<code>("+" %-% "style: highlight" &#124; "-")</code>|   
+|`%%`    |defines the completions tag meta-data (can be used to encode properties for the tag, e.g. visual decorations)|<code>("+" &#124; "-") %% "style: highlight"</code>|
+|`%-%`   |defines the completion meta-data (can be used to encode properties for each completion entry, e.g. visual decorations)|<code>("+" %-% "style: highlight" &#124; "-")</code>|   
 
 ## Fuzzy completion
 

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

@@ -60,7 +60,7 @@ trait CompletionExpansionSupport extends RegexCompletionSupport {
               .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))))
+                  Completions(in.pos, CompletionSet(cSet.tag, Set(Completion(completedInput, c.score, c.meta))))
                 } else {
                   exploreCompletionsRec(completedInput, p.completions(ExplorerReader(p, completedInput)))
                 }

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

@@ -29,7 +29,7 @@ import scala.language.implicitConversions
   *  with `RegexParsers` to automatically obtain completion behavior for string literals.
   *
   *  A set of additional operators allow defining completions and specifying structural properties of completions
-  *  (tag, score, kind, etc.) for a `Parser`.
+  *  (tag, score, meta, etc.) for a `Parser`.
   *
   *  @author Jonas Chapuis
   */
@@ -153,11 +153,11 @@ trait CompletionSupport extends Parsers with CompletionTypes {
       Parser(this,
              in => updateCompletionsTag(this.completions(in), Some(tag), Some(tagScore), Some(tagDescription), None))
 
-    /** An operator to specify the completion tag, score, description and kind of a parser
+    /** An operator to specify the completion tag, score, description and meta of a parser
       * @param tag the completion tag
       * @param tagScore the completion tag score
       * @param tagDescription the completion tag description
-      * @param tagKind the completion tag kind
+      * @param tagKind the completion tag meta
       * @return wrapper `Parser` instance specifying completion tag
       */
     def %(tag: String, tagScore: Int, tagDescription: String, tagKind: String): Parser[T] =
@@ -173,7 +173,7 @@ trait CompletionSupport extends Parsers with CompletionTypes {
     def %(tag: CompletionTag): Parser[T] =
       Parser(
         this,
-        in => updateCompletionsTag(this.completions(in), Some(tag.label), Some(tag.score), tag.description, tag.kind))
+        in => updateCompletionsTag(this.completions(in), Some(tag.label), Some(tag.score), tag.description, tag.meta))
 
     /** An operator to specify the completion tag description of a parser (empty by default)
       * @param tagDescription the completion description (to be used e.g. to add information to a completion entry)
@@ -182,19 +182,19 @@ trait CompletionSupport extends Parsers with CompletionTypes {
     def %?(tagDescription: String): Parser[T] =
       Parser(this, in => updateCompletionsTag(this.completions(in), None, None, Some(tagDescription), None))
 
-    /** An operator to specify the completion tag kind of a parser (empty by default)
-      * @param tagKind the completion tag kind (to be used e.g. to specify the visual style for a completion tag in the menu)
-      * @return wrapper `Parser` instance specifying the completion tag kind
+    /** An operator to specify the completion tag meta of a parser (empty by default)
+      * @param tagMeta the completion tag meta-data (to be used e.g. to specify the visual style for a completion tag in the menu)
+      * @return wrapper `Parser` instance specifying the completion tag meta-data
       */
-    def %%(tagKind: String): Parser[T] =
-      Parser(this, in => updateCompletionsTag(this.completions(in), None, None, None, Some(tagKind)))
+    def %%(tagMeta: String): Parser[T] =
+      Parser(this, in => updateCompletionsTag(this.completions(in), None, None, None, Some(tagMeta)))
 
-    /** An operator to specify the kind for completions of a parser (empty by default)
-      * @param kind the completion kind (to be used e.g. to specify the visual style for a completion entry in the menu)
-      * @return wrapper `Parser` instance specifying the completion kind
+    /** An operator to specify the meta for completions of a parser (empty by default)
+      * @param meta the completion meta-data (to be used e.g. to specify the visual style for a completion entry in the menu)
+      * @return wrapper `Parser` instance specifying the completion meta-data
       */
-    def %-%(kind: String): Parser[T] =
-      Parser(this, in => updateCompletions(this.completions(in), Some(kind)))
+    def %-%(meta: String): Parser[T] =
+      Parser(this, in => updateCompletions(this.completions(in), Some(meta)))
 
     def flatMap[U](f: T => Parser[U]): Parser[U] =
       Parser(super.flatMap(f), completions)

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

@@ -19,11 +19,11 @@ import org.json4s.native.JsonMethods._
   *  `Completion` entries and is tagged with a `CompletionTag`.
   *
   *  Sets allow structuring the completion entries into groups, each group tagged with a `label` (plus optional
-  *  `description` and `kind`, the latter allowing e.g. encoding visual attributes for the set).
+  *  `description` and `meta`, the latter allowing e.g. encoding visual attributes for the set).
   *  Sets also feature a score, which defines the order between sets within the `Completions` instance.
   *
-  *  Each `Completion` entry within a set has a `value`, a `score` and a `kind`:
-  *  the score allows ordering the entries within a set, and the kind can e.g. be used to assign a representation style
+  *  Each `Completion` entry within a set has a `value`, a `score` and a `meta`:
+  *  the score allows ordering the entries within a set, and the meta can e.g. be used to assign a representation style
   *  for a particular completion entry.
   *
   *  Note that specifying tags and sets is optional: if no tag is specified upon creation,
@@ -41,19 +41,19 @@ trait CompletionTypes {
     * @param label tag label
     * @param score tag score (the higher the better, 0 by default)
     * @param description tag description (optional) - can be used for additional information e.g. for a tooltip
-    * @param kind tag kind (optional) - can be used e.g. to define visual style
+    * @param meta tag meta (optional) - can be used e.g. to define visual style
     */
-  case class CompletionTag(label: String, score: Int, description: Option[String], kind: Option[String]) {
-    def update(newTag: Option[String], newScore: Option[Int], newDescription: Option[String], newKind: Option[String]): CompletionTag =
+  case class CompletionTag(label: String, score: Int, description: Option[String], meta: Option[String]) {
+    def update(newTag: Option[String], newScore: Option[Int], newDescription: Option[String], newMeta: Option[String]): CompletionTag =
       copy(
         label = newTag.getOrElse(label),
         score = newScore.getOrElse(score),
         description = newDescription.map(Some(_)).getOrElse(description),
-        kind = newKind.map(Some(_)).getOrElse(kind)
+        meta = newMeta.map(Some(_)).getOrElse(meta)
       )
 
     private[CompletionTypes] def serializeJson: json4s.JObject = {
-      ("label" -> label) ~ ("score" -> score) ~ ("description" -> description) ~ ("kind" -> kind)
+      ("label" -> label) ~ ("score" -> score) ~ ("description" -> description) ~ ("meta" -> meta)
     }
 
     override def toString: String = pretty(render(serializeJson))
@@ -77,7 +77,7 @@ trait CompletionTypes {
     def label: String               = tag.label
     def score: Int                  = tag.score
     def description: Option[String] = tag.description
-    def kind: Option[String]        = tag.kind
+    def meta: Option[String]        = tag.meta
     def completionStrings: Seq[String] =
       completions.toSeq.sorted.map(_.value.toString)
 
@@ -119,14 +119,14 @@ trait CompletionTypes {
   /** Completion entry
     * @param value entry value (e.g. string literal)
     * @param score entry score (defines the order of entries within a set, the higher the better)
-    * @param kind entry kind (e.g. visual style)
+    * @param meta entry meta (e.g. visual style)
     */
-  case class Completion(value: Elems, score: Int = DefaultCompletionScore, kind: Option[String] = None) {
+  case class Completion(value: Elems, score: Int = DefaultCompletionScore, meta: Option[String] = None) {
     require(value.nonEmpty, "empty completion")
-    def updateKind(newKind: Option[String]): Completion =
-      copy(kind = newKind.map(Some(_)).getOrElse(kind))
+    def updateKind(newMeta: Option[String]): Completion =
+      copy(meta = newMeta.map(Some(_)).getOrElse(meta))
 
-    private[CompletionTypes] def serializeJson = ("value" -> value.toString()) ~ ("score" -> score) ~ ("kind" -> kind)
+    private[CompletionTypes] def serializeJson = ("value" -> value.toString()) ~ ("score" -> score) ~ ("meta" -> meta)
 
     def toJson: String = compact(render(serializeJson))
 
@@ -160,11 +160,11 @@ trait CompletionTypes {
         val isOffsetRequired =
           set.completions.map(_.score).exists(_ < set.score)
         if (isOffsetRequired)
-          set.completions.map(c => Completion(c.value, set.score + c.score, c.kind))
+          set.completions.map(c => Completion(c.value, set.score + c.score, c.meta))
         else set.completions
       }
       CompletionSet(
-        CompletionTag(left.tag.label, left.score.min(right.score), left.description, left.kind.orElse(right.kind)),
+        CompletionTag(left.tag.label, left.score.min(right.score), left.description, left.meta.orElse(right.meta)),
         offsetCompletions(left) ++ offsetCompletions(right)
       )
     }
@@ -210,7 +210,7 @@ trait CompletionTypes {
       val sortedEntries =
         allEntries
           .sortBy {
-            case (Completion(_, score, kind), CompletionTag(_, tagScore, _, _)) =>
+            case (Completion(_, score, meta), CompletionTag(_, tagScore, _, _)) =>
               (tagScore, score)
           }
           .reverse

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

@@ -20,7 +20,7 @@ class CompletionForIntoTest {
   object TestParser extends RegexParsers with RegexCompletionSupport {
     val animalParser  = bear | lion
     val machineParser = "plane" | "car"
-    val test          = (animal | machine) >> { kind: String => if (kind == animal) animalParser else machineParser }
+    val test          = (animal | machine) >> { meta: String => if (meta == animal) animalParser else machineParser }
   }
 
   @Test

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

@@ -23,14 +23,14 @@ class CompletionOperatorsTest {
     val score                       = 10
     val description                 = "some description"
     val tag                         = "some tag"
-    val kind                        = "some kind"
+    val meta                        = "some meta"
 
-    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % (tag, score) %? description %% kind,
+    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % (tag, score) %? description %% meta,
                            completions,
                            Some(tag),
                            Some(score),
                            Some(description),
-                           Some(kind))
+                           Some(meta))
 
     assertCompletionsMatch(TestParser.someParser %> (completions: _*) % (tag, score, description),
                            completions,
@@ -39,43 +39,43 @@ class CompletionOperatorsTest {
                            Some(description),
                            None)
 
-    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % (tag, score, description, kind),
+    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % (tag, score, description, meta),
                            completions,
                            Some(tag),
                            Some(score),
                            Some(description),
-                           Some(kind))
+                           Some(meta))
 
     assertCompletionsMatch(
-      TestParser.someParser %> (completions: _*) % TestParser.CompletionTag(tag, score, Some(description), Some(kind)),
+      TestParser.someParser %> (completions: _*) % TestParser.CompletionTag(tag, score, Some(description), Some(meta)),
       completions,
       Some(tag),
       Some(score),
       Some(description),
-      Some(kind)
+      Some(meta)
     )
 
-    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % tag %? description % score %% kind,
+    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % tag %? description % score %% meta,
                            completions,
                            Some(tag),
                            Some(score),
                            Some(description),
-                           Some(kind))
+                           Some(meta))
 
-    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % tag % score %? description %% kind,
+    assertCompletionsMatch(TestParser.someParser %> (completions: _*) % tag % score %? description %% meta,
                            completions,
                            Some(tag),
                            Some(score),
                            Some(description),
-                           Some(kind))
+                           Some(meta))
   }
 
   def assertCompletionsMatch[T](sut: TestParser.Parser[T],
                                 completions: Seq[Seq[Char]],
                                 tag: Option[String],
                                 score: Option[Int],
                                 description: Option[String],
-                                kind: Option[String]): Unit = {
+                                meta: Option[String]): Unit = {
     // Act
     val result = TestParser.complete(sut, "")
 
@@ -85,7 +85,7 @@ class CompletionOperatorsTest {
     Assert.assertEquals(tag.getOrElse(""), completionSet.tag.label)
     Assert.assertEquals(score.getOrElse(0), completionSet.tag.score)
     Assert.assertEquals(description, completionSet.tag.description)
-    Assert.assertEquals(kind, completionSet.tag.kind)
+    Assert.assertEquals(meta, completionSet.tag.meta)
     Assert.assertEquals(completions.toSet, completionSet.completions.map(_.value))
   }