Pass StringReader instead of strings to CommandDispatcher

src/main/java/com/mojang/brigadier/CommandDispatcher.java

@@ -64,6 +64,10 @@ public class CommandDispatcher<S> {
     }
 
     public int execute(final String input, final S source) throws CommandSyntaxException {
+        return execute(new StringReader(input), source);
+    }
+
+    public int execute(final StringReader input, final S source) throws CommandSyntaxException {
         final ParseResults<S> parse = parse(input, source);
         return execute(parse);
     }
@@ -151,9 +155,12 @@ public class CommandDispatcher<S> {
     }
 
     public ParseResults<S> parse(final String command, final S source) {
-        final StringReader reader = new StringReader(command);
+        return parse(new StringReader(command), source);
+    }
+
+    public ParseResults<S> parse(final StringReader command, final S source) {
         final CommandContextBuilder<S> context = new CommandContextBuilder<>(this, source, 0);
-        return parseNodes(root, reader, context);
+        return parseNodes(root, command, context);
     }
 
     private static class PartialParse<S> {
@@ -206,7 +213,7 @@ public class CommandDispatcher<S> {
                     childContext.withNode(child.getRedirect(), StringRange.between(cursor, reader.getCursor() - 1));
                     final ParseResults<S> parse = parseNodes(child.getRedirect(), reader, childContext);
                     context.withChild(parse.getContext());
-                    return new ParseResults<>(context, parse.getReader(), parse.getExceptions());
+                    return new ParseResults<>(context, originalReader.getCursor(), parse.getReader(), parse.getExceptions());
                 } else {
                     final ParseResults<S> parse = parseNodes(child, reader, context);
                     if (potentials == null) {
@@ -218,7 +225,7 @@ public class CommandDispatcher<S> {
                 if (potentials == null) {
                     potentials = new ArrayList<>(1);
                 }
-                potentials.add(new PartialParse<>(context, new ParseResults<>(context, reader, Collections.emptyMap())));
+                potentials.add(new PartialParse<>(context, new ParseResults<>(context, originalReader.getCursor(), reader, Collections.emptyMap())));
             }
         }
 
@@ -243,7 +250,7 @@ public class CommandDispatcher<S> {
             return potentials.get(0).parse;
         }
 
-        return new ParseResults<>(contextSoFar, originalReader, errors == null ? Collections.emptyMap() : errors);
+        return new ParseResults<>(contextSoFar, originalReader.getCursor(), originalReader, errors == null ? Collections.emptyMap() : errors);
     }
 
     public String[] getAllUsage(final CommandNode<S> node, final S source, final boolean restricted) {
@@ -346,7 +353,7 @@ public class CommandDispatcher<S> {
 
         if (context.getNodes().isEmpty()) {
             parent = root;
-            start = 0;
+            start = parse.getStartIndex();
         } else if (parse.getReader().canRead()) {
             final Map.Entry<CommandNode<S>, StringRange> entry = Iterables.getLast(context.getNodes().entrySet());
             parent = entry.getKey();
@@ -361,7 +368,7 @@ public class CommandDispatcher<S> {
             start = entry.getValue().getEnd() + 1;
         } else {
             parent = root;
-            start = 0;
+            start = parse.getStartIndex();
         }
 
         @SuppressWarnings("unchecked") final CompletableFuture<Suggestions>[] futures = new CompletableFuture[parent.getChildren().size()];

src/main/java/com/mojang/brigadier/ParseResults.java

@@ -10,16 +10,22 @@ import java.util.Map;
 public class ParseResults<S> {
     private final CommandContextBuilder<S> context;
     private final Map<CommandNode<S>, CommandSyntaxException> exceptions;
+    private final int startIndex;
     private final ImmutableStringReader reader;
 
-    public ParseResults(final CommandContextBuilder<S> context, final ImmutableStringReader reader, final Map<CommandNode<S>, CommandSyntaxException> exceptions) {
+    public ParseResults(final CommandContextBuilder<S> context, final int startIndex, final ImmutableStringReader reader, final Map<CommandNode<S>, CommandSyntaxException> exceptions) {
         this.context = context;
+        this.startIndex = startIndex;
         this.reader = reader;
         this.exceptions = exceptions;
     }
 
     public ParseResults(final CommandContextBuilder<S> context) {
-        this(context, new StringReader(""), Collections.emptyMap());
+        this(context, 0, new StringReader(""), Collections.emptyMap());
+    }
+
+    public int getStartIndex() {
+        return startIndex;
     }
 
     public CommandContextBuilder<S> getContext() {

src/main/java/com/mojang/brigadier/tree/ArgumentCommandNode.java

@@ -120,4 +120,9 @@ public class ArgumentCommandNode<S, T> extends CommandNode<S> {
     public Collection<String> getExamples() {
         return type.getExamples();
     }
+
+    @Override
+    public String toString() {
+        return "<argument " + name + ":" + type +">";
+    }
 }

src/main/java/com/mojang/brigadier/tree/LiteralCommandNode.java

@@ -118,4 +118,9 @@ public class LiteralCommandNode<S> extends CommandNode<S> {
     public Collection<String> getExamples() {
         return Collections.singleton(literal);
     }
+
+    @Override
+    public String toString() {
+        return "<literal " + literal + ">";
+    }
 }

src/main/java/com/mojang/brigadier/tree/RootCommandNode.java

@@ -62,4 +62,9 @@ public class RootCommandNode<S> extends CommandNode<S> {
     public Collection<String> getExamples() {
         return Collections.emptyList();
     }
+
+    @Override
+    public String toString() {
+        return "<root>";
+    }
 }

src/test/java/com/mojang/brigadier/CommandDispatcherTest.java

@@ -43,6 +43,12 @@ public class CommandDispatcherTest {
         when(command.run(any())).thenReturn(42);
     }
 
+    private static StringReader inputWithOffset(final String input, final int offset) {
+        final StringReader result = new StringReader(input);
+        result.setCursor(offset);
+        return result;
+    }
+
     @SuppressWarnings("unchecked")
     @Test
     public void testCreateAndExecuteCommand() throws Exception {
@@ -52,6 +58,15 @@ public class CommandDispatcherTest {
         verify(command).run(any(CommandContext.class));
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testCreateAndExecuteOffsetCommand() throws Exception {
+        subject.register(literal("foo").executes(command));
+
+        assertThat(subject.execute(inputWithOffset("/foo", 1), source), is(42));
+        verify(command).run(any(CommandContext.class));
+    }
+
     @SuppressWarnings("unchecked")
     @Test
     public void testCreateAndMergeCommands() throws Exception {

src/test/java/com/mojang/brigadier/CommandDispatcherUsagesTest.java

@@ -102,6 +102,10 @@ public class CommandDispatcherUsagesTest {
         return Iterators.getLast(subject.parse(command, source).getContext().getNodes().keySet().iterator());
     }
 
+    private CommandNode<Object> get(final StringReader command) {
+        return Iterators.getLast(subject.parse(command, source).getContext().getNodes().keySet().iterator());
+    }
+
     @Test
     public void testAllUsage_noCommands() throws Exception {
         subject = new CommandDispatcher<>();
@@ -174,4 +178,18 @@ public class CommandDispatcherUsagesTest {
             .build()
         ));
     }
+
+    @Test
+    public void testSmartUsage_offsetH() throws Exception {
+        final StringReader offsetH = new StringReader("/|/|/h");
+        offsetH.setCursor(5);
+
+        final Map<CommandNode<Object>, String> results = subject.getSmartUsage(get(offsetH), source);
+        assertThat(results, equalTo(ImmutableMap.builder()
+                .put(get("h 1"), "[1] i")
+                .put(get("h 2"), "[2] i ii")
+                .put(get("h 3"), "[3]")
+                .build()
+        ));
+    }
 }

src/test/java/com/mojang/brigadier/CommandSuggestionsTest.java

@@ -30,6 +30,12 @@ public class CommandSuggestionsTest {
         subject = new CommandDispatcher<>();
     }
 
+    private static StringReader inputWithOffset(final String input, final int offset) {
+        final StringReader result = new StringReader(input);
+        result.setCursor(offset);
+        return result;
+    }
+
     @Test
     public void getCompletionSuggestions_rootCommands() throws Exception {
         subject.register(literal("foo"));
@@ -42,6 +48,18 @@ public class CommandSuggestionsTest {
         assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.at(0), "bar"), new Suggestion(StringRange.at(0), "baz"), new Suggestion(StringRange.at(0), "foo"))));
     }
 
+    @Test
+    public void getCompletionSuggestions_rootCommands_withInputOffset() throws Exception {
+        subject.register(literal("foo"));
+        subject.register(literal("bar"));
+        subject.register(literal("baz"));
+
+        final Suggestions result = subject.getCompletionSuggestions(subject.parse(inputWithOffset("OOO", 3), source)).join();
+
+        assertThat(result.getRange(), equalTo(StringRange.at(3)));
+        assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.at(3), "bar"), new Suggestion(StringRange.at(3), "baz"), new Suggestion(StringRange.at(3), "foo"))));
+    }
+
     @Test
     public void getCompletionSuggestions_rootCommands_partial() throws Exception {
         subject.register(literal("foo"));
@@ -54,6 +72,18 @@ public class CommandSuggestionsTest {
         assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.between(0, 1), "bar"), new Suggestion(StringRange.between(0, 1), "baz"))));
     }
 
+    @Test
+    public void getCompletionSuggestions_rootCommands_partial_withInputOffset() throws Exception {
+        subject.register(literal("foo"));
+        subject.register(literal("bar"));
+        subject.register(literal("baz"));
+
+        final Suggestions result = subject.getCompletionSuggestions(subject.parse(inputWithOffset("Zb", 1), source)).join();
+
+        assertThat(result.getRange(), equalTo(StringRange.between(1, 2)));
+        assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.between(1, 2), "bar"), new Suggestion(StringRange.between(1, 2), "baz"))));
+    }
+
     @Test
     public void getCompletionSuggestions_subCommands() throws Exception {
         subject.register(
@@ -85,6 +115,22 @@ public class CommandSuggestionsTest {
         assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.between(7, 8), "bar"), new Suggestion(StringRange.between(7, 8), "baz"))));
     }
 
+    @Test
+    public void getCompletionSuggestions_subCommands_partial_withInputOffset() throws Exception {
+        subject.register(
+                literal("parent")
+                        .then(literal("foo"))
+                        .then(literal("bar"))
+                        .then(literal("baz"))
+        );
+
+        final ParseResults<Object> parse = subject.parse(inputWithOffset("junk parent b", 5), source);
+        final Suggestions result = subject.getCompletionSuggestions(parse).join();
+
+        assertThat(result.getRange(), equalTo(StringRange.between(12, 13)));
+        assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.between(12, 13), "bar"), new Suggestion(StringRange.between(12, 13), "baz"))));
+    }
+
     @Test
     public void getCompletionSuggestions_redirect() throws Exception {
         final LiteralCommandNode<Object> actual = subject.register(literal("actual").then(literal("sub")));
@@ -109,6 +155,19 @@ public class CommandSuggestionsTest {
         assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.between(9, 10), "sub"))));
     }
 
+
+    @Test
+    public void getCompletionSuggestions_redirectPartial_withInputOffset() throws Exception {
+        final LiteralCommandNode<Object> actual = subject.register(literal("actual").then(literal("sub")));
+        subject.register(literal("redirect").redirect(actual));
+
+        final ParseResults<Object> parse = subject.parse(inputWithOffset("/redirect s", 1), source);
+        final Suggestions result = subject.getCompletionSuggestions(parse).join();
+
+        assertThat(result.getRange(), equalTo(StringRange.between(10, 11)));
+        assertThat(result.getList(), equalTo(Lists.newArrayList(new Suggestion(StringRange.between(10, 11), "sub"))));
+    }
+
     @Test
     public void getCompletionSuggestions_redirect_lots() throws Exception {
         final LiteralCommandNode<Object> loop = subject.register(literal("redirect"));