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

Implemented permissions (predicate on each node)

Browse source
This commit is contained in:
Nathan Adams 2017-06-26 14:49:55 +02:00
parent 014caa2905
commit 6575257e0d
12 changed files with 70 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -19,6 +19,7 @@ import java.util.stream.Collectors;
public class CommandDispatcher<S> {
public static final SimpleCommandExceptionType ERROR_UNKNOWN_COMMAND = new SimpleCommandExceptionType("command.unknown", "Unknown command");
public static final SimpleCommandExceptionType ERROR_IMPERMISSIBLE = new SimpleCommandExceptionType("command.impermissible", "Command not allowed");
public static final String ARGUMENT_SEPARATOR = " ";
private static final String USAGE_OPTIONAL_OPEN = "[";
private static final String USAGE_OPTIONAL_CLOSE = "]";
@ -45,8 +46,13 @@ public class CommandDispatcher<S> {
private CommandContext<S> parseNodes(CommandNode<S> node, String command, CommandContextBuilder<S> contextBuilder) throws CommandException {
CommandException exception = null;
final S source = contextBuilder.getSource();
for (CommandNode<S> child : node.getChildren()) {
if (!child.canUse(source)) {
exception = ERROR_IMPERMISSIBLE.create();
continue;
}
try {
CommandContextBuilder<S> context = contextBuilder.copy();
String remaining = child.parse(command, context);
@ -113,7 +119,11 @@ public class CommandDispatcher<S> {
}
private Set<String> findSuggestions(CommandNode<S> node, String command, CommandContextBuilder<S> contextBuilder, Set<String> result) {
final S source = contextBuilder.getSource();
for (CommandNode<S> child : node.getChildren()) {
if (!child.canUse(source)) {
continue;
}
try {
CommandContextBuilder<S> context = contextBuilder.copy();
String remaining = child.parse(command, context);

11
src/main/java/com/mojang/brigadier/builder/ArgumentBuilder.java
View file

@ -5,10 +5,12 @@ import com.mojang.brigadier.tree.CommandNode;
import com.mojang.brigadier.tree.RootCommandNode;
import java.util.Collection;
import java.util.function.Predicate;
public abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, ?>> {
private final RootCommandNode<S> arguments = new RootCommandNode<>();
private Command<S> command;
private Predicate<S> requirement = s -> true;
protected abstract T getThis();
@ -30,5 +32,14 @@ public abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, ?>> {
return command;
}
public T requires(Predicate<S> requirement) {
this.requirement = requirement;
return getThis();
}
public Predicate<S> getRequirement() {
return requirement;
}
public abstract CommandNode<S> build();
}

2
src/main/java/com/mojang/brigadier/builder/LiteralArgumentBuilder.java
View file

@ -25,7 +25,7 @@ public class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumen
@Override
public LiteralCommandNode<S> build() {
LiteralCommandNode<S> result = new LiteralCommandNode<>(getLiteral(), getCommand());
LiteralCommandNode<S> result = new LiteralCommandNode<>(getLiteral(), getCommand(), getRequirement());
for (CommandNode<S> argument : getArguments()) {
result.addChild(argument);

2
src/main/java/com/mojang/brigadier/builder/RequiredArgumentBuilder.java
View file

@ -31,7 +31,7 @@ public class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredAr
}
public ArgumentCommandNode<S, T> build() {
ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand());
ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement());
for (CommandNode<S> argument : getArguments()) {
result.addChild(argument);

4
src/main/java/com/mojang/brigadier/context/CommandContextBuilder.java
View file

@ -16,6 +16,10 @@ public class CommandContextBuilder<S> {
this.source = source;
}
public S getSource() {
return source;
}
public CommandContextBuilder<S> withArgument(String name, ParsedArgument<?> argument) {
this.arguments.put(name, argument);
return this;

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

@ -7,6 +7,7 @@ import com.mojang.brigadier.context.ParsedArgument;
import com.mojang.brigadier.exceptions.CommandException;
import java.util.Set;
import java.util.function.Predicate;
public class ArgumentCommandNode<S, T> extends CommandNode<S> {
private static final String USAGE_ARGUMENT_OPEN = "<";
@ -15,8 +16,8 @@ public class ArgumentCommandNode<S, T> extends CommandNode<S> {
private final String name;
private final CommandArgumentType<T> type;
public ArgumentCommandNode(String name, CommandArgumentType<T> type, Command<S> command) {
super(command);
public ArgumentCommandNode(String name, CommandArgumentType<T> type, Command<S> command, Predicate<S> requirement) {
super(command, requirement);
this.name = name;
this.type = type;
}

9
src/main/java/com/mojang/brigadier/tree/CommandNode.java
View file

@ -8,13 +8,16 @@ import com.mojang.brigadier.exceptions.CommandException;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
public abstract class CommandNode<S> {
private final Map<Object, CommandNode<S>> children = Maps.newLinkedHashMap();
private Command<S> command;
private Predicate<S> requirement;
protected CommandNode(Command<S> command) {
protected CommandNode(Command<S> command, Predicate<S> requirement) {
this.command = command;
this.requirement = requirement;
}
public Command<S> getCommand() {
@ -25,6 +28,10 @@ public abstract class CommandNode<S> {
return children.values();
}
public boolean canUse(S source) {
return requirement.test(source);
}
public void addChild(CommandNode<S> node) {
CommandNode<S> child = children.get(node.getMergeKey());
if (child != null) {

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

@ -7,14 +7,15 @@ import com.mojang.brigadier.exceptions.CommandException;
import com.mojang.brigadier.exceptions.ParameterizedCommandExceptionType;
import java.util.Set;
import java.util.function.Predicate;
public class LiteralCommandNode<S> extends CommandNode<S> {
public static final ParameterizedCommandExceptionType ERROR_INCORRECT_LITERAL = new ParameterizedCommandExceptionType("argument.literal.incorrect", "Expected literal ${expected}", "expected");
private final String literal;
public LiteralCommandNode(String literal, Command<S> command) {
super(command);
public LiteralCommandNode(String literal, Command<S> command, Predicate<S> requirement) {
super(command, requirement);
this.literal = literal;
}

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

@ -7,7 +7,7 @@ import java.util.Set;
public class RootCommandNode<S> extends CommandNode<S> {
public RootCommandNode() {
super(null);
super(null, c -> true);
}
@Override

3
src/test/java/com/mojang/brigadier/CommandDispatcherCompletionsTest.java
View file

@ -35,6 +35,7 @@ public class CommandDispatcherCompletionsTest {
public void testCommand() throws Exception {
subject.register(literal("foo"));
subject.register(literal("bar"));
subject.register(literal("baz").requires(s -> false));
assertThat(subject.getCompletionSuggestions("", source), equalTo(new String[] {"foo", "bar"}));
assertThat(subject.getCompletionSuggestions("f", source), equalTo(new String[] {"foo"}));
assertThat(subject.getCompletionSuggestions("b", source), equalTo(new String[] {"bar"}));
@ -43,7 +44,7 @@ public class CommandDispatcherCompletionsTest {
@Test
public void testSubCommand() throws Exception {
subject.register(literal("foo").then(literal("abc")).then(literal("def")));
subject.register(literal("foo").then(literal("abc")).then(literal("def")).then(literal("ghi").requires(s -> false)));
subject.register(literal("bar"));
assertThat(subject.getCompletionSuggestions("", source), equalTo(new String[] {"foo", "bar"}));
assertThat(subject.getCompletionSuggestions("f", source), equalTo(new String[] {"foo"}));

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

@ -99,6 +99,19 @@ public class CommandDispatcherTest {
}
}
@Test
public void testExecuteImpermissibleCommand() throws Exception {
subject.register(literal("foo").requires(s -> false));
try {
subject.execute("foo", source);
fail();
} catch (CommandException ex) {
assertThat(ex.getType(), is(CommandDispatcher.ERROR_IMPERMISSIBLE));
assertThat(ex.getData(), is(Collections.<String, Object>emptyMap()));
}
}
@Test
public void testExecuteUnknownSubcommand() throws Exception {
subject.register(literal("foo").executes(command));

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

@ -42,6 +42,19 @@ public class CommandDispatcherUsagesTest {
}
}
@Test
public void testInaccessibleCommand() throws Exception {
subject.register(literal("foo").requires(s -> false));
try {
subject.getUsage("foo", source);
fail();
} catch (CommandException ex) {
assertThat(ex.getType(), is(CommandDispatcher.ERROR_IMPERMISSIBLE));
assertThat(ex.getData(), is(Collections.<String, Object>emptyMap()));
}
}
@Test
public void testSubcommandUsage() throws Exception {
subject.register(