com.mojang.brigadier.StringReader Java Examples

private static NbtPathArgumentType.NbtPath cachePath(String arg)
{
    NbtPathArgumentType.NbtPath res = pathCache.get(arg);
    if (res != null)
        return res;
    try
    {
        res = NbtPathArgumentType.nbtPath().parse(new StringReader(arg));
    }
    catch (CommandSyntaxException exc)
    {
        throw new InternalExpressionException("Incorrect nbt path: "+arg);
    }
    if (pathCache.size() > 1024)
        pathCache.clear();
    pathCache.put(arg, res);
    return res;
}
 

public static ItemStackArgument parseItem(String itemString, CompoundTag customTag)
{
    try
    {
        ItemStackArgument res = itemCache.get(itemString);
        if (res != null)
            if (customTag == null)
                return res;
            else
                return new ItemStackArgument(res.getItem(), customTag);

        ItemStringReader parser = (new ItemStringReader(new StringReader(itemString), false)).consume();
        res = new ItemStackArgument(parser.getItem(), parser.getTag());
        itemCache.put(itemString, res);
        if (itemCache.size()>64000)
            itemCache.clear();
        if (customTag == null)
            return res;
        else
            return new ItemStackArgument(res.getItem(), customTag);
    }
    catch (CommandSyntaxException e)
    {
        throw new InternalExpressionException("Incorrect item: "+itemString);
    }
}
 

@Override
public Advancement parse(StringReader reader) throws CommandSyntaxException {
    int start = reader.getCursor();

    String achievementName = reader.readUnquotedString();
    if (!achievementName.startsWith("achievement.")) {
        reader.setCursor(start);
        throw NO_SUCH_ACHIEVEMENT_EXCEPTION.createWithContext(reader, achievementName);
    }

    Advancement achievement = Achievements_1_11_2.ACHIEVEMENTS.get(achievementName.substring("achievement.".length()));
    if (achievement == null) {
        reader.setCursor(start);
        throw NO_SUCH_ACHIEVEMENT_EXCEPTION.createWithContext(reader, achievementName);
    }

    return achievement;
}
 

@Override
public Vector parse(StringReader reader) throws CommandSyntaxException {
    var vector = new Vector();
    
    reader.skipWhitespace();
    vector.setX(reader.readDouble());
    
    if (cubic) {
        reader.skipWhitespace();
        vector.setY(reader.readDouble());
    }
    
    reader.skipWhitespace();
    vector.setZ(reader.readDouble());
    
    return vector;
}
 

public static ParticleEffect getParticleData(String name)
{
    ParticleEffect particle = particleCache.get(name);
    if (particle != null)
        return particle;
    try
    {
        particle = ParticleArgumentType.readParameters(new StringReader(name));
    }
    catch (CommandSyntaxException e)
    {
        throw new InternalExpressionException("No such particle: "+name);
    }
    particleCache.put(name, particle);
    return particle;
}
 

@SuppressWarnings("unchecked")
@Override
public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
    if (!(context.getSource() instanceof CommandSource))
        return builder.buildFuture();

    StringReader reader = new StringReader(builder.getInput());
    reader.setCursor(builder.getStart());

    CompletableFuture<Suggestions> playerCompletions;
    if ((reader.canRead() && reader.peek() == '@') || !suggestPlayerNames) {
        playerCompletions = Suggestions.empty();
    } else {
        playerCompletions = ((CommandSource) context.getSource()).getCompletions((CommandContext<CommandSource>) context, builder.restart());
    }

    EntitySelectorParser parser = new EntitySelectorParser(reader, singleTarget, playersOnly);
    try {
        parser.parse();
    } catch (CommandSyntaxException ignore) {
    }
    CompletableFuture<Suggestions> selectorCompletions = parser.suggestor.apply(builder.restart());

    return CompletableFuture.allOf(playerCompletions, selectorCompletions)
            .thenCompose(v -> UnionArgumentType.mergeSuggestions(playerCompletions.join(), selectorCompletions.join()));
}
 

@Nonnull
@Override
public LaserParticleData deserialize(@Nonnull ParticleType<LaserParticleData> type, @Nonnull StringReader reader) throws CommandSyntaxException {
    reader.expect(' ');
    BlockState state = (new BlockStateParser(reader, false)).parse(false).getState();
    reader.expect(' ');
    float size = reader.readFloat();
    reader.expect(' ');
    float r = reader.readFloat();
    reader.expect(' ');
    float g = reader.readFloat();
    reader.expect(' ');
    float b = reader.readFloat();
    reader.expect(' ');
    float mam = reader.readFloat();
    boolean depth = true;
    if (reader.canRead()) {
        reader.expect(' ');
        depth = reader.readBoolean();
    }
    return new LaserParticleData(state, size, r, g, b, mam, depth);
}
 

public Collection<? extends CommandNode<S>> getRelevantNodes(final StringReader input) {
    if (literals.size() > 0) {
        final int cursor = input.getCursor();
        while (input.canRead() && input.peek() != ' ') {
            input.skip();
        }
        final String text = input.getString().substring(cursor, input.getCursor());
        input.setCursor(cursor);
        final LiteralCommandNode<S> literal = literals.get(text);
        if (literal != null) {
            return Collections.singleton(literal);
        } else {
            return arguments.values();
        }
    } else {
        return arguments.values();
    }
}
 

@Test
public void testParseWord() throws Exception {
    final StringReader reader = mock(StringReader.class);
    when(reader.readUnquotedString()).thenReturn("hello");
    assertThat(word().parse(reader), equalTo("hello"));
    verify(reader).readUnquotedString();
}
 

@Override
public void parse(final StringReader reader, final CommandContextBuilder<S> contextBuilder) throws CommandSyntaxException {
    final int start = reader.getCursor();
    final T result = type.parse(reader);
    final ParsedArgument<S, T> parsed = new ParsedArgument<>(start, reader.getCursor(), result);

    contextBuilder.withArgument(name, parsed);
    contextBuilder.withNode(this, parsed.getRange());
}
 

@Test
public void testParseSimilar() throws Exception {
    final StringReader reader = new StringReader("foobar");
    try {
        node.parse(reader, contextBuilder);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@Test
public void testParseString() throws Exception {
    final StringReader reader = mock(StringReader.class);
    when(reader.readString()).thenReturn("hello world");
    assertThat(string().parse(reader), equalTo("hello world"));
    verify(reader).readString();
}
 

@Override
public Long parse(final StringReader reader) throws CommandSyntaxException {
    final int start = reader.getCursor();
    final long result = reader.readLong();
    if (result < minimum) {
        reader.setCursor(start);
        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.longTooLow().createWithContext(reader, result, minimum);
    }
    if (result > maximum) {
        reader.setCursor(start);
        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.longTooHigh().createWithContext(reader, result, maximum);
    }
    return result;
}
 

@Test
public void createWithContext() throws Exception {
    final SimpleCommandExceptionType type = new SimpleCommandExceptionType(new LiteralMessage("error"));
    final StringReader reader = new StringReader("Foo bar");
    reader.setCursor(5);
    final CommandSyntaxException exception = type.createWithContext(reader);
    assertThat(exception.getType(), is(type));
    assertThat(exception.getInput(), is("Foo bar"));
    assertThat(exception.getCursor(), is(5));
}
 

@Test
public void createWithContext() throws Exception {
    final StringReader reader = new StringReader("Foo bar");
    reader.setCursor(5);
    final CommandSyntaxException exception = type.createWithContext(reader, "World");
    assertThat(exception.getType(), is(type));
    assertThat(exception.getInput(), is("Foo bar"));
    assertThat(exception.getCursor(), is(5));
}
 

@Test
public void testParse() throws Exception {
    final StringReader reader = new StringReader("123 456");
    node.parse(reader, contextBuilder);

    assertThat(contextBuilder.getArguments().containsKey("foo"), is(true));
    assertThat(contextBuilder.getArguments().get("foo").getResult(), is(123));
}
 

@Test
public void parse_tooBig() throws Exception {
    final StringReader reader = new StringReader("5");
    try {
        floatArg(-100, 0).parse(reader);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.floatTooHigh()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@Test
public void testParseInvalid() throws Exception {
    final StringReader reader = new StringReader("bar");
    try {
        node.parse(reader, contextBuilder);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@Test
void parse() throws CommandSyntaxException {
    Enchantment enchantment = mock(Enchantment.class);
    EnchantmentType.ENCHANTMENTS.put("channeling", enchantment);
            
    assertEquals(enchantment, type.parse(new StringReader("CHANNELING")));
}
 

private int parse(final StringReader reader) {
    final int start = reader.getCursor();
    if (reader.canRead(literal.length())) {
        final int end = start + literal.length();
        if (reader.getString().substring(start, end).equals(literal)) {
            reader.setCursor(end);
            if (!reader.canRead() || reader.peek() == ' ') {
                return end;
            } else {
                reader.setCursor(start);
            }
        }
    }
    return -1;
}
 

@Override
public void parse(final StringReader reader, final CommandContextBuilder<S> contextBuilder) throws CommandSyntaxException {
    final int start = reader.getCursor();
    final int end = parse(reader);
    if (end > -1) {
        contextBuilder.withNode(this, StringRange.between(start, end));
        return;
    }

    throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect().createWithContext(reader, literal);
}
 

@Test
public void parse_tooSmall() throws Exception {
    final StringReader reader = new StringReader("-5");
    try {
        longArg(0, 100).parse(reader);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.longTooLow()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@Override
public HexColor parse(StringReader reader) throws CommandSyntaxException {
    String value = reader.getRemaining().split(" ")[0].toLowerCase();
    if (value.isEmpty()) {
        throw EXPECTED_HEX_COLOR.createWithContext(reader);
    }

    HexColor color = HexColor.from(value);
    if (color != null) {
        reader.setCursor(reader.getCursor() + 7);
        return color;
    }

    throw INVALID_HEX_COLOR.createWithContext(reader, value);
}
 

@Test
public void parse_tooBig() throws Exception {
    final StringReader reader = new StringReader("5");
    try {
        doubleArg(-100, 0).parse(reader);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.doubleTooHigh()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@Test
public void parse_tooBig() throws Exception {
    final StringReader reader = new StringReader("5");
    try {
        longArg(-100, 0).parse(reader);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.longTooHigh()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@Test
public void parse_tooBig() throws Exception {
    final StringReader reader = new StringReader("5");
    try {
        integer(-100, 0).parse(reader);
        fail();
    } catch (final CommandSyntaxException ex) {
        assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.integerTooHigh()));
        assertThat(ex.getCursor(), is(0));
    }
}
 

@ParameterizedTest
@CsvSource("'^1 2 3', 1 ^2 3")
void parse_throws_exception(String line) throws CommandSyntaxException {
    assertEquals(
        "Cannot mix world and local coordinates (everything must either use ^ or not)",
        assertThrows(CommandSyntaxException.class, () -> type.parse(new StringReader(line))).getRawMessage().toString()
    );
}
 

@Test
void parse_throws_exception() throws CommandSyntaxException {
    assertEquals(
        "Unknown player: invalid",
        assertThrows(CommandSyntaxException.class, () -> type.parse(new StringReader("invalid"))).getRawMessage().toString()
    );
}
 

@Test
void parse_throws_exception() throws CommandSyntaxException {
    assertEquals(
        "Unknown enchantment: invalid",
        assertThrows(CommandSyntaxException.class, () -> type.parse(new StringReader("invalid"))).getRawMessage().toString()
    );
}
 

@Test
void parse_throws_exception() throws CommandSyntaxException {
    assertEquals(
        "Unknown world: \"something\" at position 9: something<--[HERE]", 
        assertThrows(CommandSyntaxException.class, () -> type.parse(new StringReader("something"))).getMessage()
    );
}