Merge 75ea508375 into f20bede62a

src/main/java/com/mojang/brigadier/arguments/StringArgumentType.java

@@ -13,7 +13,7 @@ import java.util.Collection;
 public class StringArgumentType implements ArgumentType<String> {
     private final StringType type;
 
-    private StringArgumentType(final StringType type) {
+    protected StringArgumentType(final StringType type) {
         this.type = type;
     }
 
@@ -87,7 +87,8 @@ public class StringArgumentType implements ArgumentType<String> {
     public enum StringType {
         SINGLE_WORD("word", "words_with_underscores"),
         QUOTABLE_PHRASE("\"quoted phrase\"", "word", "\"\""),
-        GREEDY_PHRASE("word", "words with spaces", "\"and symbols\""),;
+        GREEDY_PHRASE("word", "words with spaces", "\"and symbols\""),
+        TERM("predefined_token", "red", "green", "blue"),;
 
         private final Collection<String> examples;
 

src/main/java/com/mojang/brigadier/arguments/TermArgumentType.java

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+package com.mojang.brigadier.arguments;
+
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+public class TermArgumentType extends StringArgumentType {
+    private final Set<String> options;
+
+    private TermArgumentType(final Collection<String> options) {
+        super(StringType.TERM);
+        this.options = new LinkedHashSet<>(options);
+    }
+
+    public static TermArgumentType term(Collection<String> options) {
+        return new TermArgumentType(options);
+    }
+
+    public static TermArgumentType term(String ... options) {
+        return term(Arrays.asList(options));
+    }
+
+    @Override
+    public String parse(final StringReader reader) throws CommandSyntaxException {
+        final String term = reader.readUnquotedString();
+        if (!options.contains(term)) {
+            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.termInvalid().createWithContext(reader, term);
+        }
+        return term;
+    }
+
+    @Override
+    public String toString() {
+        return "term(" + options + ")";
+    }
+
+    @Override
+    public Collection<String> getExamples() {
+        return options;
+    }
+
+    @Override
+    public <S> CompletableFuture<Suggestions> listSuggestions(final CommandContext<S> context, final SuggestionsBuilder builder) {
+        options.stream().filter((s) -> s.toLowerCase(Locale.ROOT).startsWith(builder.getRemaining().toLowerCase(Locale.ROOT))).sorted().forEachOrdered(builder::suggest);
+        return builder.buildFuture();
+    }
+}

src/main/java/com/mojang/brigadier/exceptions/BuiltInExceptionProvider.java

@@ -20,6 +20,8 @@ public interface BuiltInExceptionProvider {
 
     Dynamic2CommandExceptionType longTooHigh();
 
+    DynamicCommandExceptionType termInvalid();
+
     DynamicCommandExceptionType literalIncorrect();
 
     SimpleCommandExceptionType readerExpectedStartOfQuote();

src/main/java/com/mojang/brigadier/exceptions/BuiltInExceptions.java

@@ -18,6 +18,8 @@ public class BuiltInExceptions implements BuiltInExceptionProvider {
     private static final Dynamic2CommandExceptionType LONG_TOO_SMALL = new Dynamic2CommandExceptionType((found, min) -> new LiteralMessage("Long must not be less than " + min + ", found " + found));
     private static final Dynamic2CommandExceptionType LONG_TOO_BIG = new Dynamic2CommandExceptionType((found, max) -> new LiteralMessage("Long must not be more than " + max + ", found " + found));
 
+    private static final DynamicCommandExceptionType TERM_INVALID = new DynamicCommandExceptionType(term -> new LiteralMessage("Invalid term '" + term + "'"));
+
     private static final DynamicCommandExceptionType LITERAL_INCORRECT = new DynamicCommandExceptionType(expected -> new LiteralMessage("Expected literal " + expected));
 
     private static final SimpleCommandExceptionType READER_EXPECTED_START_OF_QUOTE = new SimpleCommandExceptionType(new LiteralMessage("Expected quote to start a string"));
@@ -80,6 +82,11 @@ public class BuiltInExceptions implements BuiltInExceptionProvider {
         return LONG_TOO_BIG;
     }
 
+    @Override
+    public DynamicCommandExceptionType termInvalid() {
+        return TERM_INVALID;
+    }
+
     @Override
     public DynamicCommandExceptionType literalIncorrect() {
         return LITERAL_INCORRECT;

src/test/java/com/mojang/brigadier/arguments/TermArgumentTypeTest.java

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+package com.mojang.brigadier.arguments;
+
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.context.CommandContextBuilder;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static com.mojang.brigadier.arguments.TermArgumentType.term;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TermArgumentTypeTest {
+    @Mock
+    private CommandContextBuilder<Object> context;
+
+    @Test
+    public void testParseTerm() throws Exception {
+        final StringReader reader = mock(StringReader.class);
+        when(reader.readUnquotedString()).thenReturn("hello");
+        assertThat(term("hello","world").parse(reader), equalTo("hello"));
+        verify(reader).readUnquotedString();
+    }
+
+    @Test
+    public void testParseTermFails() {
+        final StringReader reader = mock(StringReader.class);
+        when(reader.readUnquotedString()).thenReturn("foo");
+        try {
+            term("hello","world").parse(reader);
+            fail();
+        } catch (final CommandSyntaxException ex) {
+            assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.termInvalid()));
+        }
+    }
+}