static boolean isMarker(ParserState state, int index) { CharSequence line = state.getLine(); return state.getIndent() < state.getParsing().CODE_BLOCK_INDENT && index < line.length() && line.charAt(index) == '|'; }
@Override public BlockContinue tryContinue(ParserState state) { if (hadClose) { return BlockContinue.none(); } final int index = state.getIndex(); BasedSequence line = state.getLineWithEOL(); final Matcher matcher = GIT_LAB_BLOCK_END.matcher(line.subSequence(index)); if (!matcher.matches()) { return BlockContinue.atIndex(index); } else { // if have open gitlab block quote last child then let them handle it Node lastChild = block.getLastChild(); if (lastChild instanceof GitLabBlockQuote) { final BlockParser parser = state.getActiveBlockParser((Block) lastChild); if (parser instanceof GitLabBlockQuoteParser && !((GitLabBlockQuoteParser) parser).hadClose) { // let the child handle it return BlockContinue.atIndex(index); } } hadClose = true; block.setClosingMarker(state.getLine().subSequence(index, index + 3)); block.setClosingTrailing(state.getLineWithEOL().subSequence(matcher.start(1), matcher.end(1))); return BlockContinue.atIndex(state.getLineEndIndex()); } }
@Override public BlockContinue tryContinue(ParserState state) { if (ZZZZZZ_BLOCK_CONTINUE.matcher(state.getLine()).matches()) { return BlockContinue.atIndex(state.getIndex()); } else { return BlockContinue.none(); } }
@Override public BlockContinue tryContinue(ParserState state) { if (state.getLine().toString().contains("|")) { return BlockContinue.atIndex(state.getIndex()); } else { return BlockContinue.none(); } }
@Override public BlockContinue tryContinue(ParserState state) { final BasedSequence line = state.getLine(); if (inYAMLBlock) { Matcher matcher = JEKYLL_FRONT_MATTER_BLOCK_END.matcher(line); if (matcher.matches()) { block.setClosingMarker(line.subSequence(matcher.start(1), matcher.end(1))); return BlockContinue.finished(); } return BlockContinue.atIndex(state.getIndex()); } else if (JEKYLL_FRONT_MATTER_BLOCK_START.matcher(line).matches()) { inYAMLBlock = true; return BlockContinue.atIndex(state.getIndex()); } return BlockContinue.none(); }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { BasedSequence line = state.getLine(); if (ZZZZZZ_BLOCK_START.matcher(line).matches()) { return BlockStart.of(new ZzzzzzBlockParser(state.getProperties())) .atIndex(state.getIndex()) //.replaceActiveBlockParser() ; } return BlockStart.none(); } }
static boolean isMarker( final ParserState state, final int index, final boolean inParagraph, final boolean inParagraphListItem, final boolean allowLeadingSpace, final boolean interruptsParagraph, final boolean interruptsItemParagraph, final boolean withLeadSpacesInterruptsItemParagraph ) { CharSequence line = state.getLine(); if ((!inParagraph || interruptsParagraph) && index < line.length() && line.charAt(index) == '>') { if ((allowLeadingSpace || state.getIndent() == 0) && (!inParagraphListItem || interruptsItemParagraph)) { if (inParagraphListItem && !withLeadSpacesInterruptsItemParagraph) { return state.getIndent() == 0; } else { return state.getIndent() < state.getParsing().CODE_BLOCK_INDENT; } } } return false; }
@Override public BlockContinue tryContinue(ParserState state) { BasedSequence line = state.getLine(); if (line.startsWith(myOptions.exampleBreak)) { block.setClosingMarker(line.subSequence(0, myOptions.exampleBreak.length())); return BlockContinue.finished(); } return BlockContinue.atIndex(0); }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { BasedSequence line = state.getLine(); List<BasedSequence> paragraphLines = matchedBlockParser.getParagraphLines(); if (paragraphLines != null && paragraphLines.size() >= 1 && paragraphLines.size() <= maxHeaderRows && paragraphLines.get(0).toString().contains("|")) { BasedSequence separatorLine = line.subSequence(state.getIndex(), line.length()); if (TABLE_HEADER_SEPARATOR.matcher(separatorLine).matches()) { BasedSequence paragraph = paragraphLines.get(0); List<BasedSequence> headParts = split(paragraph); List<BasedSequence> separatorParts = split(separatorLine); if (separatorParts.size() >= headParts.size()) { TableBlockParser tableBlockParser = new TableBlockParser(); tableBlockParser.addLine(state, paragraph); tableBlockParser.nextIsSeparatorLine = true; return BlockStart.of(tableBlockParser) .atIndex(state.getIndex()) .replaceActiveBlockParser(); } } } return BlockStart.none(); } }
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { int nextNonSpace = state.getNextNonSpaceIndex(); if (isMarker(state, nextNonSpace) && !endsWithMarker(state.getLine())) { int newColumn = state.getColumn() + state.getIndent() + 1; // optional following space or tab if (Parsing.isSpaceOrTab(state.getLine(), nextNonSpace + 1)) { newColumn++; } return BlockStart.of(new AsideBlockParser(state.getProperties(), state.getLine().subSequence(nextNonSpace, nextNonSpace + 1))).atColumn(newColumn); } else { return BlockStart.none(); } } }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { CharSequence line = state.getLine(); BlockParser parentParser = matchedBlockParser.getBlockParser(); // check whether this line is the first line of whole document or not if (parentParser instanceof DocumentBlockParser && parentParser.getBlock().getFirstChild() == null && REGEX_BEGIN.matcher(line).matches()) { return BlockStart.of(new YamlFrontMatterBlockParser()).atIndex(state.getNextNonSpaceIndex()); } return BlockStart.none(); } }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { int nextNonSpace = state.getNextNonSpaceIndex(); BasedSequence line = state.getLine(); Matcher matcher; if (state.getIndent() < 4) { BasedSequence trySequence = line.subSequence(nextNonSpace, line.length()); if ((matcher = OPENING_FENCE.matcher(trySequence)).find()) { int fenceLength = matcher.group(0).length(); char fenceChar = matcher.group(0).charAt(0); FencedCodeBlockParser blockParser = new FencedCodeBlockParser(state.getProperties(), fenceChar, fenceLength, state.getIndent(), nextNonSpace); blockParser.block.setOpeningMarker(trySequence.subSequence(0, fenceLength)); return BlockStart.of(blockParser).atIndex(nextNonSpace + fenceLength); } } return BlockStart.none(); } }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { BasedSequence line = state.getLine(); if (state.getIndex() == 0) { int breakLength = myOptions.exampleBreak.length(); if (line.length() >= breakLength + 1 + EXAMPLE_KEYWORD.length() && line.startsWith(myOptions.exampleBreak) && line.matchChars(EXAMPLE_KEYWORD, breakLength + 1) && " \t\u00A0".contains(String.valueOf(line.charAt(breakLength)))) { SpecExampleBlockParser blockParser = new SpecExampleBlockParser(state.getProperties()); blockParser.block.setOpeningMarker(line.subSequence(0, breakLength)); //blockParser.addLine(state, state.getLineWithEOL()); return BlockStart.of(blockParser).atIndex(-1); } } return BlockStart.none(); } }
@Override public BlockContinue tryContinue(ParserState state) { // we stop on a blank line if blank line spacer is not enabled or we already had one if ((!options.isBlankLineSpacer || haveChildren != 0) && state.isBlank()) { return BlockContinue.none(); } else { if (state.isBlank()) { haveChildren |= HAVE_BLANK_LINE; blankLineSpacer = state.getLine(); } return BlockContinue.atIndex(state.getIndex()); } }
static boolean isMarker( final ParserState state, final int index, final boolean inParagraph, final boolean inParagraphListItem, final AdmonitionOptions options ) { final boolean allowLeadingSpace = options.allowLeadingSpace; final boolean interruptsParagraph = options.interruptsParagraph; final boolean interruptsItemParagraph = options.interruptsItemParagraph; final boolean withLeadSpacesInterruptsItemParagraph = options.withSpacesInterruptsItemParagraph; CharSequence line = state.getLine(); if (!inParagraph || interruptsParagraph) { if ((allowLeadingSpace || state.getIndent() == 0) && (!inParagraphListItem || interruptsItemParagraph)) { if (inParagraphListItem && !withLeadSpacesInterruptsItemParagraph) { return state.getIndent() == 0; } else { return state.getIndent() < state.getParsing().CODE_BLOCK_INDENT; } } } return false; }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { BasedSequence line = state.getLine(); BlockParser parentParser = matchedBlockParser.getBlockParser(); if (parentParser instanceof DocumentBlockParser && parentParser.getBlock().getFirstChild() == null) { Matcher matcher = JEKYLL_FRONT_MATTER_BLOCK_START.matcher(line); if (matcher.matches()) { BasedSequence openingMarker = line.subSequence(0, 3); JekyllFrontMatterBlockParser parser = new JekyllFrontMatterBlockParser(state.getProperties(), openingMarker); return BlockStart.of(parser).atIndex(-1); } } return BlockStart.none(); } }
@Override public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { if (state.getIndent() >= 4 || matchedBlockParser.getBlockParser().isParagraphParser() && !options.relaxedStart) { return BlockStart.none(); } BasedSequence line = state.getLine(); final BasedSequence input = line.subSequence(state.getNextNonSpaceIndex(), line.length()); if (PATTERN.matcher(input).matches()) { return BlockStart.of(new ThematicBreakParser(line.subSequence(state.getIndex()))).atIndex(line.length()); } else { return BlockStart.none(); } } }
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) { int nextNonSpace = state.getNextNonSpaceIndex(); BlockParser matched = matchedBlockParser.getBlockParser(); boolean inParagraph = matched.isParagraphParser(); boolean inParagraphListItem = inParagraph && matched.getBlock().getParent() instanceof ListItem && matched.getBlock() == matched.getBlock().getParent().getFirstChild(); if (isMarker(state, nextNonSpace, inParagraph, inParagraphListItem, allowLeadingSpace, interruptsParagraph, interruptsItemParagraph, withLeadSpacesInterruptsItemParagraph)) { int newColumn = state.getColumn() + state.getIndent() + 1; // optional following space or tab if (Parsing.isSpaceOrTab(state.getLine(), nextNonSpace + 1)) { newColumn++; } return BlockStart.of(new BlockQuoteParser(state.getProperties(), state.getLine().subSequence(nextNonSpace, nextNonSpace + 1))).atColumn(newColumn); } else { return BlockStart.none(); } } }
@Override public BlockContinue tryContinue(ParserState state) { int nextNonSpace = state.getNextNonSpaceIndex(); boolean isMarker; if (!state.isBlank() && ((isMarker = isMarker(state, nextNonSpace)) || (continueToBlankLine && lastWasBlankLine == 0))) { int newColumn = state.getColumn() + state.getIndent(); lastWasBlankLine = 0; if (isMarker) { newColumn++; // optional following space or tab if (Parsing.isSpaceOrTab(state.getLine(), nextNonSpace + 1)) { newColumn++; } } return BlockContinue.atColumn(newColumn); } else { if (ignoreBlankLine && state.isBlank()) { lastWasBlankLine++; int newColumn = state.getColumn() + state.getIndent(); return BlockContinue.atColumn(newColumn); } return BlockContinue.none(); } }
@Override public BlockContinue tryContinue(ParserState state) { int nextNonSpace = state.getNextNonSpaceIndex(); boolean isMarker; if (!state.isBlank() && ((isMarker = isMarker(state, nextNonSpace, false, false, allowLeadingSpace, interruptsParagraph, interruptsItemParagraph, withLeadSpacesInterruptsItemParagraph)) || (continueToBlankLine && lastWasBlankLine == 0))) { int newColumn = state.getColumn() + state.getIndent(); lastWasBlankLine = 0; if (isMarker) { newColumn++; // optional following space or tab if (Parsing.isSpaceOrTab(state.getLine(), nextNonSpace + 1)) { newColumn++; } } return BlockContinue.atColumn(newColumn); } else { if (ignoreBlankLine && state.isBlank()) { lastWasBlankLine++; int newColumn = state.getColumn() + state.getIndent(); return BlockContinue.atColumn(newColumn); } return BlockContinue.none(); } }