feat: Add support for Token Based validators (WIP #2)

Author: Steve Ramage

src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/optionvalues/grammar/GrammarOptionValue.kt

@@ -1,6 +1,7 @@
 package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
 
 import com.intellij.openapi.project.Project
+import com.jediterm.terminal.Terminal
 import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.Validator
 import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.OptionValueInformation
 import org.apache.ivy.plugins.version.Match
@@ -41,53 +42,54 @@ interface Combinator {
    */
   fun SemanticMatch(value : String, offset: Int): MatchResult
 
-
 }
 
-data class MatchResult(val tokens: List<String>, val matchResult: Int)
+interface TerminalCombinator : Combinator
+
+data class MatchResult(val tokens: List<String>, val matchResult: Int, val terminals: List<TerminalCombinator> )
 
-val NoMatch = MatchResult(emptyList(), -1)
+val NoMatch = MatchResult(emptyList(), -1, emptyList())
 
-class RegexTerminal(val syntaticMatchStr : String, val semanticMatchStr: String ) : Combinator {
+class RegexTerminal(val syntaticMatchStr : String, val semanticMatchStr: String ) : TerminalCombinator {
 
   val syntaticMatch = syntaticMatchStr.toRegex()
   val semanticMatch = semanticMatchStr.toRegex()
 
   override fun SyntacticMatch(value: String, offset: Int): MatchResult {
     val matchResult = syntaticMatch.matchAt(value, offset) ?: return NoMatch
 
-    return MatchResult(listOf(matchResult.value), offset + matchResult.value.length)
+    return MatchResult(listOf(matchResult.value), offset + matchResult.value.length, listOf(this))
 
   }
 
   override fun SemanticMatch(value: String, offset: Int): MatchResult {
     val matchResult = semanticMatch.matchAt(value, offset)  ?: return NoMatch
 
-    return MatchResult(listOf(matchResult.value), offset + matchResult.value.length)
+    return MatchResult(listOf(matchResult.value), offset + matchResult.value.length, listOf())
   }
 }
 
 val BYTES = RegexTerminal("[0-9]+[a-zA-Z]*\\s*", "[0-9]+[KMGT]?\\s*")
 val DEVICE = RegexTerminal("\\S+\\s*", "/[^\\u0000.]+\\s*")
 val IOPS = RegexTerminal("[0-9]+[a-zA-Z]*\\s*", "[0-9]+[KMGT]?\\s*")
 
-class LiteralChoiceTerminal(vararg val choices: String) : Combinator {
-  override fun SyntacticMatch(value: String, offset: Int): MatchResult {
+class LiteralChoiceTerminal(vararg val choices: String) : TerminalCombinator {
+
+  private fun match(value: String, offset: Int): MatchResult {
     for (choice in choices) {
       if (value.substring(offset).startsWith(choice)) {
-        return MatchResult(listOf(choice), offset + choice.length)
+        return MatchResult(listOf(choice), offset + choice.length, listOf(this))
       }
     }
     return NoMatch
   }
 
+  override fun SyntacticMatch(value: String, offset: Int): MatchResult {
+    return match(value, offset)
+  }
+
   override fun SemanticMatch(value: String, offset: Int): MatchResult {
-    for (choice in choices) {
-      if (value.substring(offset).startsWith(choice)) {
-        return MatchResult(listOf(choice), offset + choice.length)
-      }
-    }
-    return NoMatch
+    return match(value, offset)
   }
 }
 
@@ -114,6 +116,7 @@ class SequenceCombinator(vararg val tokens: Combinator) : Combinator{
   override fun SyntacticMatch(value: String, offset: Int): MatchResult {
     var index = offset
     val resultTokens = mutableListOf<String>()
+    val resultTerminals = mutableListOf<TerminalCombinator>()
 
     for (token in tokens) {
       val match = token.SyntacticMatch(value, index)
@@ -124,14 +127,17 @@ class SequenceCombinator(vararg val tokens: Combinator) : Combinator{
       }
       index = match.matchResult
       resultTokens.addAll(match.tokens)
+      resultTerminals.addAll(match.terminals)
+
     }
-    return MatchResult(resultTokens, index)
+    return MatchResult(resultTokens, index, resultTerminals)
   }
 
   override fun SemanticMatch(value: String, offset: Int): MatchResult {
     var index = offset
 
     val resultTokens = mutableListOf<String>()
+    val resultTerminals = mutableListOf<TerminalCombinator>()
 
     for (token in tokens) {
       val match = token.SemanticMatch(value, index)
@@ -141,9 +147,10 @@ class SequenceCombinator(vararg val tokens: Combinator) : Combinator{
       }
       index = match.matchResult
       resultTokens.addAll(match.tokens)
+      resultTerminals.addAll(match.terminals)
 
     }
-    return MatchResult(resultTokens, index)
+    return MatchResult(resultTokens, index, resultTerminals)
   }
 }
 
@@ -184,6 +191,8 @@ class OneOrMore(val combinator : Combinator) : Combinator {
     var match = f(value, index)
 
     val tokens = mutableListOf<String>()
+    val terminals = mutableListOf<TerminalCombinator>()
+
     if (match.matchResult == -1) {
       return NoMatch
     }
@@ -193,9 +202,10 @@ class OneOrMore(val combinator : Combinator) : Combinator {
       tokens.addAll(match.tokens)
 
       match = f(value, index)
+      terminals.addAll(match.terminals)
     }
 
-    return MatchResult(tokens, index)
+    return MatchResult(tokens, index, terminals)
   }
 
   override fun SyntacticMatch(value: String, offset: Int): MatchResult {
@@ -218,18 +228,21 @@ class ZeroOrMore(val combinator : Combinator) : Combinator {
     var match = f(value, index)
 
     val tokens = mutableListOf<String>()
+    val terminals = mutableListOf<TerminalCombinator>()
+
     if (match.matchResult == -1) {
-      return MatchResult(tokens, offset)
+      return MatchResult(tokens, offset, terminals)
     }
 
     while (match.matchResult != -1) {
       index = match.matchResult
       tokens.addAll(match.tokens)
 
       match = f(value, index)
+      terminals.addAll(match.terminals)
     }
 
-    return MatchResult(tokens, index)
+    return MatchResult(tokens, index, terminals)
   }
 
   override fun SyntacticMatch(value: String, offset: Int): MatchResult {
@@ -245,15 +258,15 @@ class ZeroOrMore(val combinator : Combinator) : Combinator {
 class EOF : Combinator {
   override fun SyntacticMatch(value: String, offset: Int): MatchResult {
     return if (offset == value.length) {
-      MatchResult(emptyList(), offset)
+      MatchResult(emptyList(), offset, emptyList())
     } else {
       NoMatch
     }
   }
 
   override fun SemanticMatch(value: String, offset: Int): MatchResult {
     return if (offset == value.length) {
-      MatchResult(emptyList(), offset)
+      MatchResult(emptyList(), offset, emptyList())
     } else {
       NoMatch
     }