Examples with MacroClose com.vladsch.flexmark.ext.xwiki.macros.MacroClose used on opensource projects

Example 1 with MacroClose

use of com.vladsch.flexmark.ext.xwiki.macros.MacroClose in project flexmark-java by vsch.

the class MacroBlockParser method parseInlines.

@Override
public void parseInlines(InlineParser inlineParser) {
    Node node = block.getLastChild();
    if (node instanceof MacroClose) {
        node.unlink();
    }
    inlineParser.parse(block.getContentChars(), block);
    if (node instanceof MacroClose) {
        block.appendChild(node);
    }
}

Example 2 with MacroClose

use of com.vladsch.flexmark.ext.xwiki.macros.MacroClose in project flexmark-java by vsch.

the class MacroBlockParser method tryContinue.

@Override
public BlockContinue tryContinue(ParserState state) {
    if (hadClose) {
        return BlockContinue.none();
    }
    final BasedSequence line = state.getLine();
    final Matcher closeMatcher = parsing.MACRO_CLOSE.matcher(line);
    if (closeMatcher.find()) {
        // check if this close belongs to a nested child block macro
        if (macroName.equals(closeMatcher.group(1))) {
            final List<BlockParser> parsers = state.getActiveBlockParsers();
            boolean isChildClose = false;
            for (int i = parsers.size(); i-- > 0; ) {
                final BlockParser parser = parsers.get(i);
                if (parser == this)
                    break;
                if (parser instanceof MacroBlockParser) {
                    if (!((MacroBlockParser) parser).hadClose && ((MacroBlockParser) parser).macroName.equals(macroName)) {
                        isChildClose = true;
                    }
                }
            }
            if (!isChildClose) {
                hadClose = true;
                MacroClose macroClose = new MacroClose(line.subSequence(closeMatcher.start(), closeMatcher.start() + 3), line.subSequence(closeMatcher.start(1), closeMatcher.end(1)), line.subSequence(closeMatcher.end() - 2, closeMatcher.end()));
                macroClose.setCharsFromContent();
                block.appendChild(macroClose);
                return BlockContinue.atIndex(state.getLineEndIndex());
            }
        }
    }
    return BlockContinue.atIndex(state.getIndex());
}

Example 3 with MacroClose

use of com.vladsch.flexmark.ext.xwiki.macros.MacroClose in project flexmark-java by vsch.

the class MacroBlockParser method closeBlock.

@Override
public void closeBlock(ParserState state) {
    // first line is macro open and possibly close
    if (oneLine) {
        List<BasedSequence> lines = new ArrayList<BasedSequence>();
        Macro macro = (Macro) block.getFirstChild();
        Node node = block.getLastChild();
        BasedSequence contentLine;
        if (node instanceof MacroClose) {
            contentLine = macro.getChars().baseSubSequence(macro.getEndOffset(), node.getStartOffset());
        } else {
            contentLine = macro.getChars().baseSubSequence(macro.getEndOffset(), macro.getEndOffset());
        }
        lines.add(contentLine);
        block.setContent(lines);
    } else {
        // last line is close, first line is open
        if (hadClose) {
            final List<BasedSequence> lines = content.getLines();
            block.setContent(lines);
        } else {
            final List<BasedSequence> lines = content.getLines();
            block.setContent(lines.subList(0, lines.size()));
        }
    }
    block.setCharsFromContent();
    content = null;
}

Example 4 with MacroClose

use of com.vladsch.flexmark.ext.xwiki.macros.MacroClose in project flexmark-java by vsch.

the class MacroInlineParser method parse.

@Override
public boolean parse(final InlineParser inlineParser) {
    if (inlineParser.peek(1) == '{') {
        BasedSequence input = inlineParser.getInput();
        int index = inlineParser.getIndex();
        Matcher matcher = inlineParser.matcher(parsing.MACRO_TAG);
        if (matcher != null) {
            BasedSequence macroOpen = input.subSequence(matcher.start(), matcher.end());
            // see what we have
            if (macroOpen.charAt(2) == '/') {
                // close
                BasedSequence macroName = input.subSequence(matcher.start(2), matcher.end(2));
                for (int i = openMacros.size(); i-- > 0; ) {
                    if (openMacros.get(i).getName().equals(macroName)) {
                        // this one is now closed, we close all intervening ones too
                        inlineParser.flushTextNode();
                        for (int j = openMacros.size(); j-- > i; ) {
                            inlineParser.moveNodes(openMacros.get(j), inlineParser.getBlock().getLastChild());
                        }
                        MacroClose macroClose = new MacroClose(macroOpen.subSequence(0, 3), macroName, macroOpen.endSequence(2));
                        inlineParser.getBlock().appendChild(macroClose);
                        inlineParser.moveNodes(openMacros.get(i), macroClose);
                        if (i == 0) {
                            openMacros.clear();
                        } else {
                            openMacros = openMacros.subList(0, i);
                        }
                        return true;
                    }
                }
            } else {
                // open, see if open/close
                BasedSequence macroName = input.subSequence(matcher.start(1), matcher.end(1));
                boolean isClosedTag = macroOpen.endCharAt(3) == '/';
                Macro macro = new Macro(macroOpen.subSequence(0, 2), macroName, macroOpen.endSequence(isClosedTag ? 3 : 2));
                macro.setCharsFromContent();
                inlineParser.flushTextNode();
                inlineParser.getBlock().appendChild(macro);
                if (!isClosedTag) {
                    openMacros.add(macro);
                }
                BasedSequence attributeText = macroOpen.baseSubSequence(macroName.getEndOffset(), macro.getClosingMarker().getStartOffset()).trim();
                if (!attributeText.isEmpty()) {
                    // have some attribute text
                    macro.setAttributeText(attributeText);
                    // parse attributes
                    Matcher attributeMatcher = parsing.MACRO_ATTRIBUTE.matcher(attributeText);
                    while (attributeMatcher.find()) {
                        BasedSequence attributeName = attributeText.subSequence(attributeMatcher.start(1), attributeMatcher.end(1));
                        BasedSequence attributeSeparator = attributeMatcher.groupCount() == 1 || attributeMatcher.start(2) == -1 ? BasedSequence.NULL : attributeText.subSequence(attributeMatcher.end(1), attributeMatcher.start(2)).trim();
                        BasedSequence attributeValue = attributeMatcher.groupCount() == 1 || attributeMatcher.start(2) == -1 ? BasedSequence.NULL : attributeText.subSequence(attributeMatcher.start(2), attributeMatcher.end(2));
                        boolean isQuoted = attributeValue.length() >= 2 && (attributeValue.charAt(0) == '"' && attributeValue.endCharAt(1) == '"' || attributeValue.charAt(0) == '\'' && attributeValue.endCharAt(1) == '\'');
                        BasedSequence attributeOpen = !isQuoted ? BasedSequence.NULL : attributeValue.subSequence(0, 1);
                        BasedSequence attributeClose = !isQuoted ? BasedSequence.NULL : attributeValue.endSequence(1, 0);
                        if (isQuoted) {
                            attributeValue = attributeValue.midSequence(1, -1);
                        }
                        MacroAttribute attribute = new MacroAttribute(attributeName, attributeSeparator, attributeOpen, attributeValue, attributeClose);
                        macro.appendChild(attribute);
                    }
                }
                return true;
            }
            // did not process, reset to where we started
            inlineParser.setIndex(index);
        }
    }
    return false;
}