Improve tokenizer errors

Author: vaperion

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "io.github.vaperion.blade"
-version = "1.1.4"
+version = "1.1.5"
 
 subprojects {
     apply(plugin = "io.freefair.lombok")

bukkit/src/main/java/me/vaperion/blade/bukkit/container/BukkitContainer.java

@@ -318,7 +318,7 @@ public boolean execute(@NotNull CommandSender sender,
                     context.sender().sendMessage(blade.configuration().messages().error(error.formatForChat()));
                     command.usageMessage(context).sendTo(context);
 
-                    if (!error.type().isSilent()) {
+                    if (error.type().shouldLog()) {
                         blade.logger().error(
                             "Failed to parse %s's command input for command `%s`: %s",
                             sender.getName(),
@@ -475,15 +475,8 @@ public void tabComplete(@NotNull CommandSender sender,
                 sender.getName(), commandLine);
         } catch (BladeFatalError ex) {
             wrap(sender).sendMessage(blade.configuration().messages().error(ex.getMessage()));
-        } catch (TokenizerError error) {
-            // Don't send tokenizer errors to the user during tab completion - just log them.
-
-            if (!error.type().isSilent()) {
-                blade.logger().error(
-                    "Failed to parse %s's command input for command `%s`: %s",
-                    sender.getName(),
-                    commandLine, TokenizerError.generateFancyMessage(error));
-            }
+        } catch (TokenizerError ignored) {
+            // Incomplete input is normal during tab completion.
         } catch (Throwable t) {
             blade.logger().error(t, "An error occurred while %s was tab completing the command `%s`.",
                 sender.getName(), commandLine);

core/src/main/java/me/vaperion/blade/tokenizer/AbstractStringTokenizer.java

@@ -65,7 +65,11 @@ public char take() throws TokenizerError {
      * Expects the current character to be whitespace.
      */
     public void expectWhitespace() throws TokenizerError {
-        expect(WHITESPACE_PRED);
+        if (peekWhitespace()) {
+            return;
+        }
+
+        throw TokenizerError.expectedWhitespace(this, peek());
     }
 
     /**
@@ -81,6 +85,26 @@ public void expect(char expected) throws TokenizerError {
         throw TokenizerError.unexpectedCharacter(this, expected, peek());
     }
 
+    /**
+     * Expects the current character to match one of the given characters.
+     *
+     * @param expected the accepted characters
+     */
+    public void expectOneOf(char @NotNull ... expected) throws TokenizerError {
+        if (expected.length == 0) {
+            throw new IllegalArgumentException("At least one expected character is required.");
+        }
+
+        char actual = peek();
+        for (char candidate : expected) {
+            if (actual == candidate) {
+                return;
+            }
+        }
+
+        throw TokenizerError.expectedOneOf(this, expected, actual);
+    }
+
     /**
      * Expects the current character to pass the given test.
      *

core/src/main/java/me/vaperion/blade/tokenizer/TokenizerError.java

@@ -4,6 +4,8 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.StringJoiner;
+
 @Getter
 @SuppressWarnings("unused")
 public class TokenizerError extends RuntimeException {
@@ -18,6 +20,34 @@ public static TokenizerError unexpectedEnd(@NotNull AbstractStringTokenizer toke
         );
     }
 
+    @NotNull
+    public static TokenizerError expectedWhitespace(@NotNull AbstractStringTokenizer tokenizer,
+                                                    char actual) {
+        return new TokenizerError(
+            Type.EXPECTED_WHITESPACE,
+            tokenizer,
+            0,
+            String.format("expected whitespace but found '%c'", actual)
+        );
+    }
+
+    @NotNull
+    public static TokenizerError expectedOneOf(@NotNull AbstractStringTokenizer tokenizer,
+                                               char @NotNull [] expected,
+                                               char actual) {
+        StringJoiner formattedExpected = new StringJoiner(", ", "[", "]");
+        for (char character : expected) {
+            formattedExpected.add(formatCharacter(character));
+        }
+
+        return new TokenizerError(
+            Type.EXPECTED_ONE_OF,
+            tokenizer,
+            0,
+            String.format("expected one of %s but found %s", formattedExpected, formatCharacter(actual))
+        );
+    }
+
     @NotNull
     public static TokenizerError unexpectedCharacter(@NotNull AbstractStringTokenizer tokenizer,
                                                      @Nullable Character expected,
@@ -87,6 +117,23 @@ public synchronized Throwable fillInStackTrace() {
         return this;
     }
 
+    @NotNull
+    private static String formatCharacter(char character) {
+        switch (character) {
+            case '\\':
+            case '\'':
+                return "'\\" + character + "'";
+            case '\n':
+                return "'\\n'";
+            case '\r':
+                return "'\\r'";
+            case '\t':
+                return "'\\t'";
+            default:
+                return "'" + character + "'";
+        }
+    }
+
     @NotNull
     public String formatForChat() {
         return String.format(
@@ -101,17 +148,19 @@ public enum Type {
         UNEXPECTED_END,
         UNEXPECTED_CHARACTER,
         REQUIRED_N_CHARACTERS,
-        MISSING_FLAG_VALUE(true),
+        EXPECTED_WHITESPACE(false),
+        EXPECTED_ONE_OF(false),
+        MISSING_FLAG_VALUE(false),
         ;
 
-        private final boolean isSilent;
+        private final boolean shouldLog;
 
         Type() {
-            this(false);
+            this(true);
         }
 
-        Type(boolean isSilent) {
-            this.isSilent = isSilent;
+        Type(boolean shouldLog) {
+            this.shouldLog = shouldLog;
         }
     }
 

core/src/test/java/me/vaperion/blade/tokenizer/StringTokenizerTest.java

@@ -0,0 +1,48 @@
+package me.vaperion.blade.tokenizer;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class StringTokenizerTest {
+
+    @Test
+    public void acceptsOneOfExpectedCharacters() {
+        StringTokenizer tokenizer = new StringTokenizer(":");
+
+        tokenizer.expectOneOf(';', ':');
+
+        Assertions.assertEquals(':', tokenizer.take());
+    }
+
+    @Test
+    public void logsUnexpectedCharactersByDefault() {
+        StringTokenizer tokenizer = new StringTokenizer(":");
+
+        TokenizerError error = Assertions.assertThrows(TokenizerError.class, () -> tokenizer.expect(';'));
+
+        Assertions.assertTrue(error.type().shouldLog());
+    }
+
+    @Test
+    public void reportsInvalidArgumentSeparatorAsUserInputError() {
+        StringTokenizer tokenizer = new StringTokenizer(":");
+
+        TokenizerError error = Assertions.assertThrows(TokenizerError.class, tokenizer::expectWhitespace);
+
+        Assertions.assertEquals("expected whitespace but found ':'", error.getMessage());
+        Assertions.assertFalse(error.type().shouldLog());
+    }
+
+    @Test
+    public void reportsExpectedCharactersAsUserInputError() {
+        StringTokenizer tokenizer = new StringTokenizer(":");
+
+        TokenizerError error = Assertions.assertThrows(
+            TokenizerError.class,
+            () -> tokenizer.expectOneOf('"', '\'')
+        );
+
+        Assertions.assertEquals("expected one of ['\"', '\\''] but found ':'", error.getMessage());
+        Assertions.assertFalse(error.type().shouldLog());
+    }
+}

fabric-legacy/src/main/java/me/vaperion/blade/fabric/container/FabricContainer.java

@@ -183,7 +183,7 @@ public boolean execute(@NotNull CommandContext<CommandSourceStack> ctx) {
                     context.sender().sendMessage(blade.configuration().messages().error(error.formatForChat()));
                     command.usageMessage(context).sendTo(context);
 
-                    if (!error.type().isSilent()) {
+                    if (error.type().shouldLog()) {
                         blade.logger().error(
                             "Failed to parse %s's command input for command `%s`: %s",
                             sender.getTextName(),
@@ -296,15 +296,8 @@ public void suggest(@NotNull CommandContext<CommandSourceStack> ctx,
                 sender.getTextName(), label);
         } catch (BladeFatalError ex) {
             new FabricSender(blade, sender).sendMessage(blade.configuration().messages().error(ex.getMessage()));
-        } catch (TokenizerError error) {
-            // Don't send tokenizer errors to the user during tab completion - just log them.
-
-            if (!error.type().isSilent()) {
-                blade.logger().error(
-                    "Failed to parse %s's command input for command `%s`: %s",
-                    sender.getTextName(),
-                    label, TokenizerError.generateFancyMessage(error));
-            }
+        } catch (TokenizerError ignored) {
+            // Incomplete input is normal during tab completion.
         } catch (Throwable t) {
             blade.logger().error(t, "An error occurred while %s was tab completing the command `%s`.",
                 sender.getTextName(), label);

fabric/src/main/java/me/vaperion/blade/fabric/container/FabricContainer.java

@@ -183,7 +183,7 @@ public boolean execute(@NotNull CommandContext<CommandSourceStack> ctx) {
                     context.sender().sendMessage(blade.configuration().messages().error(error.formatForChat()));
                     command.usageMessage(context).sendTo(context);
 
-                    if (!error.type().isSilent()) {
+                    if (error.type().shouldLog()) {
                         blade.logger().error(
                             "Failed to parse %s's command input for command `%s`: %s",
                             sender.getTextName(),
@@ -296,15 +296,8 @@ public void suggest(@NotNull CommandContext<CommandSourceStack> ctx,
                 sender.getTextName(), label);
         } catch (BladeFatalError ex) {
             new FabricSender(blade, sender).sendMessage(blade.configuration().messages().error(ex.getMessage()));
-        } catch (TokenizerError error) {
-            // Don't send tokenizer errors to the user during tab completion - just log them.
-
-            if (!error.type().isSilent()) {
-                blade.logger().error(
-                    "Failed to parse %s's command input for command `%s`: %s",
-                    sender.getTextName(),
-                    label, TokenizerError.generateFancyMessage(error));
-            }
+        } catch (TokenizerError ignored) {
+            // Incomplete input is normal during tab completion.
         } catch (Throwable t) {
             blade.logger().error(t, "An error occurred while %s was tab completing the command `%s`.",
                 sender.getTextName(), label);

hytale/src/main/java/me/vaperion/blade/hytale/container/HytaleContainer.java

@@ -188,7 +188,7 @@ public void unregister() {
                 } catch (TokenizerError error) {
                     context.sender().sendMessage(blade.configuration().messages().error(error.formatForChat()));
 
-                    if (!error.type().isSilent()) {
+                    if (error.type().shouldLog()) {
                         blade.logger().error(
                             "Failed to parse %s's command input for command `%s`: %s",
                             sender.toString(),

minestom/src/main/java/me/vaperion/blade/minestom/container/MinestomContainer.java

@@ -215,7 +215,7 @@ private void execute(@NotNull CommandSender sender,
                         messages.error(error.formatForChat())
                     );
 
-                    if (!error.type().isSilent()) {
+                    if (error.type().shouldLog()) {
                         blade.logger().error(
                             "Failed to parse %s's command input for command `%s`: %s",
                             sender.toString(),
@@ -351,15 +351,8 @@ private List<String> doSuggest(@NotNull CommandSender sender,
             sender.sendMessage(
                 blade.configuration().messages().error(ex.getMessage())
             );
-        } catch (TokenizerError error) {
-            // Don't send tokenizer errors to the user during tab completion - just log them.
-
-            if (!error.type().isSilent()) {
-                blade.logger().error(
-                    "Failed to parse %s's command input for command `%s`: %s",
-                    sender.toString(),
-                    label, TokenizerError.generateFancyMessage(error));
-            }
+        } catch (TokenizerError ignored) {
+            // Incomplete input is normal during tab completion.
         } catch (Throwable t) {
             blade.logger().error(t, "An error occurred while %s was tab completing the command `%s`.",
                 sender.toString(), label);

velocity/src/main/java/me/vaperion/blade/velocity/container/VelocityContainer.java

@@ -203,7 +203,7 @@ public void execute(Invocation invocation) {
                         messages.error(error.formatForChat())
                     );
 
-                    if (!error.type().isSilent()) {
+                    if (error.type().shouldLog()) {
                         blade.logger().error(
                             "Failed to parse %s's command input for command `%s`: %s",
                             sender.toString(),
@@ -306,15 +306,8 @@ public List<String> suggest(Invocation invocation) {
             sender.sendMessage(
                 blade.configuration().messages().error(ex.getMessage())
             );
-        } catch (TokenizerError error) {
-            // Don't send tokenizer errors to the user during tab completion - just log them.
-
-            if (!error.type().isSilent()) {
-                blade.logger().error(
-                    "Failed to parse %s's command input for command `%s`: %s",
-                    sender.toString(),
-                    label, TokenizerError.generateFancyMessage(error));
-            }
+        } catch (TokenizerError ignored) {
+            // Incomplete input is normal during tab completion.
         } catch (Throwable t) {
             blade.logger().error(t, "An error occurred while %s was tab completing the command `%s`.",
                 sender.toString(), label);