ChomeNS/brigadier
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Pass StringReader instead of strings to CommandDispatcher

Browse source
This commit is contained in:
boq 2018-07-16 16:21:03 +02:00
parent 235f0c9b28
commit 75dcc36066
8 changed files with 129 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
src/main/java/com/mojang/brigadier/CommandDispatcher.java
View file

@ -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()];

10
src/main/java/com/mojang/brigadier/ParseResults.java
View file

@ -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() {

5
src/main/java/com/mojang/brigadier/tree/ArgumentCommandNode.java
View file

@ -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 +">";
}
}

5
src/main/java/com/mojang/brigadier/tree/LiteralCommandNode.java
View file

@ -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 + ">";
}
}

5
src/main/java/com/mojang/brigadier/tree/RootCommandNode.java
View file

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

15
src/test/java/com/mojang/brigadier/CommandDispatcherTest.java
View file

@ -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 {

18
src/test/java/com/mojang/brigadier/CommandDispatcherUsagesTest.java
View file

@ -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()
));
}
}

59
src/test/java/com/mojang/brigadier/CommandSuggestionsTest.java
View file

@ -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"));