Examples with Inserting net.kyori.adventure.text.minimessage.tag.Inserting used on opensource projects

Example 1 with Inserting

use of net.kyori.adventure.text.minimessage.tag.Inserting in project adventure by KyoriPowered.

the class MiniMessageParser method treeToComponent.

@NotNull
Component treeToComponent(@NotNull final ElementNode node, @NotNull final ContextImpl context) {
    Component comp = Component.empty();
    Tag tag = null;
    if (node instanceof ValueNode) {
        comp = Component.text(((ValueNode) node).value());
    } else if (node instanceof TagNode) {
        final TagNode tagNode = (TagNode) node;
        tag = tagNode.tag();
        // special case for gradient and stuff
        if (tag instanceof Modifying) {
            final Modifying modTransformation = (Modifying) tag;
            // first walk the tree
            this.visitModifying(modTransformation, tagNode, 0);
            modTransformation.postVisit();
        }
        if (tag instanceof Inserting) {
            comp = ((Inserting) tag).value();
        }
    }
    if (!node.unsafeChildren().isEmpty()) {
        final List<Component> children = new ArrayList<>(comp.children().size() + node.children().size());
        children.addAll(comp.children());
        for (final ElementNode child : node.unsafeChildren()) {
            children.add(this.treeToComponent(child, context));
        }
        comp = comp.children(children);
    }
    // special case for gradient and stuff
    if (tag instanceof Modifying) {
        comp = this.handleModifying((Modifying) tag, comp, 0);
    }
    final Consumer<String> debug = context.debugOutput();
    if (debug != null) {
        debug.accept("==========\ntreeToComponent \n");
        debug.accept(node.toString());
        debug.accept("\n");
        debug.accept(comp.examine(MultiLineStringExaminer.simpleEscaping()).collect(Collectors.joining("\n")));
        debug.accept("\n==========\n");
    }
    return comp;
}

Example 2 with Inserting

use of net.kyori.adventure.text.minimessage.tag.Inserting in project adventure by KyoriPowered.

the class TokenParser method buildTree.

/*
   * Build a tree from the OPEN_TAG and CLOSE_TAG tokens
   */
private static RootNode buildTree(@NotNull final TagProvider tagProvider, @NotNull final Predicate<String> tagNameChecker, @NotNull final List<Token> tokens, @NotNull final String message, @NotNull final String originalMessage, final boolean strict) throws ParsingException {
    final RootNode root = new RootNode(message, originalMessage);
    ElementNode node = root;
    for (final Token token : tokens) {
        final TokenType type = token.type();
        switch(type) {
            case TEXT:
                node.addChild(new TextNode(node, token, message));
                break;
            case OPEN_TAG:
            case OPEN_CLOSE_TAG:
                // Check if this even is a valid tag
                final Token tagNamePart = token.childTokens().get(0);
                final String tagName = message.substring(tagNamePart.startIndex(), tagNamePart.endIndex());
                if (!TagInternals.sanitizeAndCheckValidTagName(tagName)) {
                    // This wouldn't be a valid tag, just parse it as text instead!
                    node.addChild(new TextNode(node, token, message));
                    break;
                }
                final TagNode tagNode = new TagNode(node, token, message, tagProvider);
                if (tagNameChecker.test(tagNode.name())) {
                    final Tag tag = tagProvider.resolve(tagNode);
                    if (tag == null) {
                        // something went wrong, ignore it
                        // if strict mode is enabled this will throw an exception for us
                        node.addChild(new TextNode(node, token, message));
                    } else if (tag == ParserDirective.RESET) {
                        // instead, they close all currently open tags
                        if (strict) {
                            throw new ParsingExceptionImpl("<reset> tags are not allowed when strict mode is enabled", message, token);
                        }
                        node = root;
                    } else {
                        // This is a recognized tag, goes in the tree
                        tagNode.tag(tag);
                        node.addChild(tagNode);
                        if (type != TokenType.OPEN_CLOSE_TAG && (!(tag instanceof Inserting) || ((Inserting) tag).allowsChildren())) {
                            node = tagNode;
                        }
                    }
                } else {
                    // not recognized, plain text
                    node.addChild(new TextNode(node, token, message));
                }
                // OPEN_TAG
                break;
            case CLOSE_TAG:
                final List<Token> childTokens = token.childTokens();
                if (childTokens.isEmpty()) {
                    throw new IllegalStateException("CLOSE_TAG token somehow has no children - " + "the parser should not allow this. Original text: " + message);
                }
                final ArrayList<String> closeValues = new ArrayList<>(childTokens.size());
                for (final Token childToken : childTokens) {
                    closeValues.add(TagPart.unquoteAndEscape(message, childToken.startIndex(), childToken.endIndex()));
                }
                final String closeTagName = closeValues.get(0);
                if (tagNameChecker.test(closeTagName)) {
                    final Tag tag = tagProvider.resolve(closeTagName);
                    if (tag == ParserDirective.RESET) {
                        // This is a synthetic node, closing it means nothing in the context of building a tree
                        continue;
                    }
                } else {
                    // tag does not exist, so treat it as text
                    node.addChild(new TextNode(node, token, message));
                    continue;
                }
                ElementNode parentNode = node;
                while (parentNode instanceof TagNode) {
                    final List<TagPart> openParts = ((TagNode) parentNode).parts();
                    if (tagCloses(closeValues, openParts)) {
                        if (parentNode != node && strict) {
                            final String msg = "Unclosed tag encountered; " + ((TagNode) node).name() + " is not closed, because " + closeValues.get(0) + " was closed first.";
                            throw new ParsingExceptionImpl(msg, message, parentNode.token(), node.token(), token);
                        }
                        final ElementNode par = parentNode.parent();
                        if (par != null) {
                            node = par;
                        } else {
                            throw new IllegalStateException("Root node matched with close tag value, " + "this should not be possible. Original text: " + message);
                        }
                        break;
                    }
                    parentNode = parentNode.parent();
                }
                if (parentNode == null || parentNode instanceof RootNode) {
                    // This means the closing tag didn't match to anything
                    // Since open tags which don't match to anything is never an error, neither is this
                    node.addChild(new TextNode(node, token, message));
                    break;
                }
                // CLOSE_TAG
                break;
            default:
                // ignore other tags
                break;
        }
    }
    if (strict && root != node) {
        final ArrayList<TagNode> openTags = new ArrayList<>();
        {
            ElementNode n = node;
            while (n != null) {
                if (n instanceof TagNode) {
                    openTags.add((TagNode) n);
                } else {
                    break;
                }
                n = n.parent();
            }
        }
        final Token[] errorTokens = new Token[openTags.size()];
        final StringBuilder sb = new StringBuilder("All tags must be explicitly closed while in strict mode. " + "End of string found with open tags: ");
        int i = 0;
        final ListIterator<TagNode> iter = openTags.listIterator(openTags.size());
        while (iter.hasPrevious()) {
            final TagNode n = iter.previous();
            errorTokens[i++] = n.token();
            sb.append(n.name());
            if (iter.hasPrevious()) {
                sb.append(", ");
            }
        }
        throw new ParsingExceptionImpl(sb.toString(), message, errorTokens);
    }
    return root;
}