feat: Add support for Token Based validators

Author: Steve Ramage

src/main/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/semanticdata/SemanticDataRepository.kt

@@ -12,6 +12,9 @@ import com.intellij.openapi.util.NotNullLazyValue
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.util.ObjectUtils
 import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.*
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar.AllGrammarOptions
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar.GrammarOptionValue
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar.IOLimitOptionValue
 import org.apache.commons.io.IOUtils
 import java.io.BufferedReader
 import java.io.IOException
@@ -87,6 +90,8 @@ class SemanticDataRepository private constructor() {
           validatorMap.putAll(AllowedCpuSetOptionValue.validators)
           validatorMap.putAll(TtySizeOptionValue.validators)
           validatorMap.putAll(ExecDirectoriesOptionValue.validators)
+          validatorMap.putAll(IOLimitOptionValue.validators)
+          validatorMap.putAll(AllGrammarOptions.validators)
 
          // Scopes are not supported since they aren't standard unit files.
 

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

@@ -0,0 +1,298 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.grammar
+
+import com.intellij.openapi.project.Project
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.Validator
+import net.sjrx.intellij.plugins.systemdunitfiles.semanticdata.optionvalues.OptionValueInformation
+
+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): Int
+
+  /**
+   * 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): Int
+
+
+}
+
+
+
+class RegexTerminal(val syntaticMatchStr : String, val semanticMatchStr: String ) : Combinator {
+
+  val syntaticMatch = syntaticMatchStr.toRegex()
+  val semanticMatch = semanticMatchStr.toRegex()
+
+  override fun SyntacticMatch(value: String, offset: Int): Int {
+    val matchResult = syntaticMatch.matchAt(value, offset) ?: return -1
+
+    return offset + matchResult.value.length
+
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    val matchResult = semanticMatch.matchAt(value, offset)  ?: return -1
+
+    return offset + matchResult.value.length
+  }
+}
+
+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): Int {
+    for (choice in choices) {
+      if (value.substring(offset).startsWith(choice)) {
+        return offset + choice.length
+      }
+    }
+    return -1
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    for (choice in choices) {
+      if (value.substring(offset).startsWith(choice)) {
+        return offset + choice.length
+      }
+    }
+    return -1
+  }
+}
+
+// Image Polcies
+// https://www.freedesktop.org/software/systemd/man/latest/systemd.image-policy.html#
+val IMAGE_POLICY_SEPARATOR = LiteralChoiceTerminal(":")
+val PARTITION_IDENTIFIER = LiteralChoiceTerminal("root", "usr", "home", "srv", "esp", "xbootldr", "swap", "root-verity", "root-verity-sig", "usr-verity", "usr-verity-sig", "tmp", "var")
+val PARTITION_POLICY_FLAG = LiteralChoiceTerminal("unprotected", "verity", "signed", "encrypted", "unused", "absent", "read-only-off", "read-only-on", "growfs-off", "growfs-on")
+val PARTITION_POLICY_FLAG_SEPARATOR = LiteralChoiceTerminal("+")
+val PARTITION_IDENTIFIER_FLAG_SEPARATOR = LiteralChoiceTerminal("=")
+
+
+val PARTITION_POLICY_FLAGS = SequenceCombinator(PARTITION_POLICY_FLAG, ZeroOrMore(SequenceCombinator(PARTITION_POLICY_FLAG_SEPARATOR, PARTITION_POLICY_FLAG)))
+val SINGLE_EXPLICIT_IMAGE_POLICY = SequenceCombinator(PARTITION_IDENTIFIER, PARTITION_IDENTIFIER_FLAG_SEPARATOR, PARTITION_POLICY_FLAGS)
+val DEFAULT_IMAGE_POLICY = SequenceCombinator(PARTITION_POLICY_FLAG_SEPARATOR, PARTITION_POLICY_FLAGS)
+var IMAGE_POLICY=AlternativeCombinator(SINGLE_EXPLICIT_IMAGE_POLICY, DEFAULT_IMAGE_POLICY)
+val IMAGE_POLICY_COMBINATOR = SequenceCombinator(IMAGE_POLICY, ZeroOrMore(SequenceCombinator(IMAGE_POLICY_SEPARATOR, IMAGE_POLICY)), EOF())
+
+
+/**
+ * This is a sequence of tokens that must match all of them.
+ */
+class SequenceCombinator(vararg val tokens: Combinator) : Combinator{
+  override fun SyntacticMatch(value: String, offset: Int): Int {
+    var index = offset
+    for (token in tokens) {
+      val match = token.SyntacticMatch(value, index)
+      if (match == -1) {
+        // No forward progress
+        return -1
+      }
+      index = match
+    }
+    return index
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    var index = offset
+    for (token in tokens) {
+      val match = token.SemanticMatch(value, index)
+      if (match == -1) {
+        // No forward progress
+        return -1
+      }
+      index = match
+    }
+    return index
+  }
+}
+
+
+/**
+ * This is a sequence of tokens that must match any of them.
+ */
+class AlternativeCombinator(vararg val tokens: Combinator) : Combinator {
+  override fun SyntacticMatch(value: String, offset: Int): Int {
+    for (token in tokens) {
+      val match = token.SyntacticMatch(value, offset)
+      if (match != -1) {
+        return match
+      }
+    }
+    return -1
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    for (token in tokens) {
+      val match = token.SemanticMatch(value, offset)
+      if (match != -1) {
+        return match
+      }
+    }
+    return -1
+  }
+}
+
+/**
+ * One Or More Combinator
+ */
+
+class OneOrMore(val combinator : Combinator) : Combinator {
+  override fun SyntacticMatch(value: String, offset: Int): Int {
+    var index = offset
+    var match = combinator.SyntacticMatch(value, index)
+
+    if (match == -1) {
+      return -1
+    }
+
+    while (match != -1) {
+      index = match
+      match = combinator.SyntacticMatch(value, index)
+    }
+    return index
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    var index = offset
+    var match = combinator.SemanticMatch(value, index)
+
+    if (match == -1) {
+      return -1
+    }
+
+    while (match != -1) {
+      index = match
+      match = combinator.SemanticMatch(value, index)
+    }
+    return index
+  }
+}
+
+/**
+ * One Or More Combinator
+ */
+
+class ZeroOrMore(val combinator : Combinator) : Combinator {
+  override fun SyntacticMatch(value: String, offset: Int): Int {
+    var index = offset
+    var match = combinator.SyntacticMatch(value, index)
+
+    if (match == -1) {
+      return offset
+    }
+
+    while (match != -1) {
+      index = match
+      match = combinator.SyntacticMatch(value, index)
+    }
+    return index
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    var index = offset
+    var match = combinator.SemanticMatch(value, index)
+
+    if (match == -1) {
+      return offset
+    }
+
+    while (match != -1) {
+      index = match
+      match = combinator.SemanticMatch(value, index)
+    }
+    return index
+  }
+}
+
+
+class EOF : Combinator {
+  override fun SyntacticMatch(value: String, offset: Int): Int {
+    return if (offset == value.length) {
+      offset
+    } else {
+      -1
+    }
+  }
+
+  override fun SemanticMatch(value: String, offset: Int): Int {
+    return if (offset == value.length) {
+      offset
+    } else {
+      -1
+    }
+  }
+}
+
+open class GrammarOptionValue(
+  override val validatorName: String,
+  val combinator: Combinator
+
+) : OptionValueInformation {
+
+  override fun getAutoCompleteOptions(project: Project): Set<String> {
+    return emptySet()
+  }
+
+  override fun getErrorMessage(value: String): String? {
+    val syntaticMatch = combinator.SyntacticMatch(value, 0)
+
+    if (syntaticMatch == -1) {
+      return "Could not parse value"
+    }
+
+    val semanticMatch = combinator.SemanticMatch(value, 0)
+
+    if (semanticMatch == -1) {
+      return "Value did not semantically match"
+    }
+
+    return null
+  }
+}
+
+class IOLimitOptionValue() : GrammarOptionValue("config_parse_io_limit", SequenceCombinator(OneOrMore(SequenceCombinator(BYTES, DEVICE)), EOF())) {
+  companion object {
+    val validators = mapOf(
+      Validator("config_parse_io_limit", "0") to IOLimitOptionValue()
+    )
+  }
+}
+
+class AllGrammarOptions {
+  companion object {
+    val validators = mapOf(
+      Validator("config_parse_image_policy", "0") to GrammarOptionValue("config_parse_image_policy", IMAGE_POLICY_COMBINATOR),
+    )
+  }
+}
+
+

src/test/kotlin/net/sjrx/intellij/plugins/systemdunitfiles/inspections/InvalidValidInspectionForIOReadBandwidthMax.kt

@@ -0,0 +1,48 @@
+package net.sjrx.intellij.plugins.systemdunitfiles.inspections
+
+import junit.framework.TestCase
+import net.sjrx.intellij.plugins.systemdunitfiles.AbstractUnitFileTest
+
+class InvalidValidInspectionForIOReadBandwidthMax : AbstractUnitFileTest() {
+
+  fun testNoWarningWhenNumberSpecifiedWithoutUnit() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+           [Service]
+           IOReadBandwidthMax=2 /home
+           """.trimIndent()
+
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(0, highlights)
+
+  }
+
+  fun testWeakWarningWhenNegativeIntegerSpecified() {
+    // Fixture Setup
+    // language="unit file (systemd)"
+    val file = """
+           [Service]
+           IOReadBandwidthMax=-5
+           """.trimIndent()
+
+
+    // Execute SUT
+    setupFileInEditor("file.service", file)
+    enableInspection(InvalidValueInspection::class.java)
+    val highlights = myFixture.doHighlighting()
+
+    // Verification
+    assertSize(1, highlights)
+    val info = highlights[0]
+    AbstractUnitFileTest.Companion.assertStringContains("Could not parse value", info!!.description)
+    TestCase.assertEquals("-5", info.text)
+  }
+
+}