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

Author: Steve Ramage

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

@@ -0,0 +1,42 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+import kotlin.math.max
+
+/**
+ * This is a sequence of tokens that must match any of them.
+ */
+class AlternativeCombinator(vararg val tokens: Combinator) : Combinator {
+
+  fun match(value: String, offset: Int, f: (Combinator, String, Int) -> MatchResult): MatchResult {
+
+
+    var longestTokenMatch = emptyList<String>()
+    var longestTerminalMatch = emptyList<TerminalCombinator>()
+    var maxLength = 0
+
+    for (token in tokens) {
+      val match = f(token, value, offset)
+      if (match.matchResult != -1) {
+        return match
+      }
+
+
+
+      if (match.tokens.size > longestTerminalMatch.size) {
+        longestTerminalMatch = match.terminals
+        longestTokenMatch = match.tokens
+        maxLength = max(maxLength, match.longestMatch)
+      }
+    }
+
+    return MatchResult(longestTokenMatch, -1, longestTerminalMatch, maxLength)
+  }
+
+  override fun SyntacticMatch(value: String, offset: Int): MatchResult {
+    return match(value, offset, Combinator::SyntacticMatch)
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): MatchResult {
+    return match(value, offset, Combinator::SemanticMatch)
+  }
+}

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

@@ -0,0 +1,39 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+interface Combinator {
+
+  // TODO add longest prefix match
+  // Note about coloring on this.
+
+  /**
+   * WARNING: At the current time this combinator implementation doesn't necessarily guarantee a match.
+   *
+   * Seq(ZeroOrMore(Literal("fizz")), Literal("fizz"))
+   *
+   * If you try and match "fizz", the ZeroOrMore would greedily consume the fizz, and the second wouldn't match.
+   *
+   * I'm unclear if this will actually be a problem, and whether it's worth fixing.
+   */
+
+  /**
+   * This checks the value string, starting at offset for a syntactic match.
+   *
+   * In a nutshell a syntactic match might accept things that we should color and try and analyze
+   * but might be incorrect.
+   *
+   * For example if you something accepts a positive number, a syntactic regex should match any number even negative or floats
+   *
+   * The return value is -1 for no match, or a new offset if this token matched something.
+   */
+  fun SyntacticMatch(value : String, offset: Int): MatchResult
+
+  /**
+   * This checks the value string, starting at offset for a semantic match.
+   *
+   * In a nutshell a semantic match means we understood and it valid as far as the grammar is concerned.
+   *
+   * The return value is -1 for no match, or a new offset if this token matched something.
+   */
+  fun SemanticMatch(value : String, offset: Int): MatchResult
+
+}

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

@@ -0,0 +1,5 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+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*")

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

@@ -0,0 +1,19 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+class EOF : Combinator {
+  override fun SyntacticMatch(value: String, offset: Int): MatchResult {
+    return if (offset == value.length) {
+      MatchResult(emptyList(), offset, emptyList(), value.length)
+    } else {
+      NoMatch
+    }
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): MatchResult {
+    return if (offset == value.length) {
+      MatchResult(emptyList(), offset, emptyList(), value.length)
+    } else {
+      NoMatch
+    }
+  }
+}

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

@@ -0,0 +1,89 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+import kotlin.math.max
+
+class FlexibleLiteralChoiceTerminal(vararg val choices: String) : TerminalCombinator {
+
+  init {
+    choices.sortBy { -it.length }
+  }
+
+  val syntaticMatch: Regex
+
+  init {
+
+    var dash = false
+    var specialChars = ""
+    var lowerCase = false
+    var upperCase = false
+    var numbers = false
+    var maxLength = 0
+
+    for (choice in choices) {
+      maxLength = max(maxLength, choice.length)
+      for (char in choice) {
+        if (char in 'a'..'z') {
+          lowerCase = true
+          continue
+        }
+
+        if (char in 'A'..'Z') {
+          upperCase = true
+          continue
+        }
+
+        if (char in '0'..'9') {
+          numbers = true
+          continue
+        }
+
+        if (char == '-') {
+          dash = true
+          continue
+        }
+
+        specialChars += char
+      }
+    }
+
+    var regexClass = ""
+
+    if (lowerCase) {
+      regexClass += "a-z"
+    }
+
+    if (upperCase) {
+      regexClass += "A-Z"
+    }
+
+    if (numbers) {
+      regexClass += "0-9"
+    }
+
+    regexClass += specialChars
+
+    if (dash) {
+      regexClass += "-"
+    }
+
+    syntaticMatch = ("[" + regexClass + "]{1,$maxLength}").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, listOf(this), offset + matchResult.value.length)
+  }
+
+  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, listOf(this), offset + choice.length)
+      }
+    }
+    return NoMatch.copy(longestMatch = offset)
+  }
+
+
+}