proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/EnumeratedReferences.java
|
EnumeratedReferences
|
add
|
class EnumeratedReferences {
final public static String EMPTY_TYPE = "";
final public static int[] EMPTY_ORDINALS = new int[0];
final private EnumeratedReferenceRepository referenceRepository;
final private HashMap<String, Integer> enumerationCounters;
final private HashMap<String, int[]> enumeratedReferenceOrdinals;
public EnumeratedReferences(DataHolder options) {
referenceRepository = EnumeratedReferenceExtension.ENUMERATED_REFERENCES.get(options);
enumerationCounters = new HashMap<>();
enumeratedReferenceOrdinals = new HashMap<>();
}
public void add(String text) {<FILL_FUNCTION_BODY>}
public EnumeratedReferenceRendering[] getEnumeratedReferenceOrdinals(String text) {
String type = EnumeratedReferenceRepository.getType(text);
String[] types = type.split(":");
EnumeratedReferenceRendering[] renderings = new EnumeratedReferenceRendering[types.length];
int[] ordinals = enumeratedReferenceOrdinals.get(text);
if (ordinals == null) {
ordinals = EMPTY_ORDINALS;
}
int iMax = types.length;
for (int i = 0; i < iMax; i++) {
String typeText = types[i];
EnumeratedReferenceBlock referenceFormat = referenceRepository.get(typeText);
int ordinal = i < ordinals.length ? ordinals[i] : 0;
renderings[i] = new EnumeratedReferenceRendering(referenceFormat, typeText, ordinal);
}
return renderings;
}
public void renderReferenceOrdinals(String text, EnumeratedOrdinalRenderer renderer) {
EnumeratedReferenceRendering[] renderings = getEnumeratedReferenceOrdinals(text);
renderReferenceOrdinals(renderings, renderer);
}
public static void renderReferenceOrdinals(EnumeratedReferenceRendering[] renderings, EnumeratedOrdinalRenderer renderer) {
renderer.startRendering(renderings);
// need to accumulate all compound formats and output on final format's [#]
ArrayList<CompoundEnumeratedReferenceRendering> compoundReferences = new ArrayList<>();
EnumeratedReferenceRendering lastRendering = renderings[renderings.length - 1];
for (EnumeratedReferenceRendering rendering : renderings) {
int ordinal = rendering.referenceOrdinal;
String defaultText = rendering.referenceType;
boolean needSeparator = false;
if (rendering != lastRendering) {
if (rendering.referenceFormat != null) {
Node lastChild = rendering.referenceFormat.getLastChild();
while (lastChild != null && !(lastChild instanceof EnumeratedReferenceBase)) {
lastChild = lastChild.getLastChild();
}
needSeparator = lastChild instanceof EnumeratedReferenceBase && ((EnumeratedReferenceBase) lastChild).getText().isEmpty();
} else {
needSeparator = true;
}
}
compoundReferences.add(new CompoundEnumeratedReferenceRendering(ordinal, rendering.referenceFormat, defaultText, needSeparator));
}
int iMax = compoundReferences.size() - 1;
Runnable wasRunnable = renderer.getEnumOrdinalRunnable();
renderer.setEnumOrdinalRunnable(() -> {
for (int i = 0; i < iMax; i++) {
CompoundEnumeratedReferenceRendering rendering = compoundReferences.get(i);
Runnable wasRunnable1 = renderer.getEnumOrdinalRunnable();
renderer.setEnumOrdinalRunnable(null);
renderer.render(rendering.ordinal, rendering.referenceFormat, rendering.defaultText, rendering.needSeparator);
renderer.setEnumOrdinalRunnable(wasRunnable1);
}
});
CompoundEnumeratedReferenceRendering rendering = compoundReferences.get(iMax);
renderer.render(rendering.ordinal, rendering.referenceFormat, rendering.defaultText, rendering.needSeparator);
renderer.setEnumOrdinalRunnable(wasRunnable);
renderer.endRendering();
}
}
|
String type = EnumeratedReferenceRepository.getType(text);
String[] types = type.split(":");
int[] ordinals = new int[types.length];
// replace all types but the last with ordinal of that type
StringBuilder nestedType = new StringBuilder();
int iMax = types.length;
for (int i = 0; i < iMax; i++) {
String typeText = types[i];
nestedType.append(typeText);
String nestedTypeKey = nestedType.toString();
if (i < iMax - 1) {
Integer ordinalInt = enumerationCounters.get(nestedTypeKey);
int typeOrdinal = ordinalInt == null ? 0 : ordinalInt;
nestedType.append(':').append(typeOrdinal).append(':');
ordinals[i] = typeOrdinal;
} else {
// last type gets defined if it does not exist
int ordinal;
if (!enumerationCounters.containsKey(nestedTypeKey)) {
enumerationCounters.put(nestedTypeKey, 1);
ordinal = 1;
} else {
ordinal = enumerationCounters.get(nestedTypeKey) + 1;
enumerationCounters.put(nestedTypeKey, ordinal);
}
ordinals[i] = ordinal;
}
}
// save the ordinal for this reference and type
enumeratedReferenceOrdinals.put(text, ordinals);
| 1,090
| 382
| 1,472
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumRefTextCollectingVisitor.java
|
OrdinalRenderer
|
render
|
class OrdinalRenderer implements EnumeratedOrdinalRenderer {
final EnumRefTextCollectingVisitor renderer;
public OrdinalRenderer(EnumRefTextCollectingVisitor renderer) {
this.renderer = renderer;
}
@Override
public void startRendering(EnumeratedReferenceRendering[] renderings) {
}
@Override
public void setEnumOrdinalRunnable(Runnable runnable) {
renderer.ordinalRunnable = runnable;
}
@Override
public Runnable getEnumOrdinalRunnable() {
return renderer.ordinalRunnable;
}
@Override
public void render(int referenceOrdinal, EnumeratedReferenceBlock referenceFormat, String defaultText, boolean needSeparator) {<FILL_FUNCTION_BODY>}
@Override
public void endRendering() {
}
}
|
Runnable compoundRunnable = renderer.ordinalRunnable;
if (referenceFormat != null) {
renderer.ordinalRunnable = () -> {
if (compoundRunnable != null) compoundRunnable.run();
renderer.out.add(String.valueOf(referenceOrdinal));
if (needSeparator) renderer.out.add(".");
};
renderer.visitor.visitChildren(referenceFormat);
} else {
renderer.out.add(defaultText + " ");
if (compoundRunnable != null) compoundRunnable.run();
renderer.out.add(String.valueOf(referenceOrdinal));
if (needSeparator) renderer.out.add(".");
}
| 238
| 200
| 438
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumeratedReferenceBlockParser.java
|
EnumeratedReferenceBlockParser
|
closeBlock
|
class EnumeratedReferenceBlockParser extends AbstractBlockParser {
static String ENUM_REF_ID = "(?:[^0-9].*)?";
static Pattern ENUM_REF_ID_PATTERN = Pattern.compile("\\[[\\@|#]\\s*(" + ENUM_REF_ID + ")\\s*\\]");
static Pattern ENUM_REF_DEF_PATTERN = Pattern.compile("^(\\[[\\@]\\s*(" + ENUM_REF_ID + ")\\s*\\]:)\\s+");
final EnumeratedReferenceBlock block = new EnumeratedReferenceBlock();
private BlockContent content = new BlockContent();
public EnumeratedReferenceBlockParser(EnumeratedReferenceOptions options, int contentOffset) {
}
public BlockContent getBlockContent() {
return content;
}
@Override
public Block getBlock() {
return block;
}
@Override
public BlockContinue tryContinue(ParserState state) {
return BlockContinue.none();
}
@Override
public void addLine(ParserState state, BasedSequence line) {
throw new IllegalStateException("Abbreviation Blocks hold a single line");
}
@Override
public void closeBlock(ParserState state) {<FILL_FUNCTION_BODY>}
@Override
public void parseInlines(InlineParser inlineParser) {
Node paragraph = block.getFirstChild();
if (paragraph != null) {
inlineParser.parse(paragraph.getChars(), paragraph);
}
}
@Override
public boolean isContainer() {
return true;
}
@Override
public boolean canContain(ParserState state, BlockParser blockParser, Block block) {
return blockParser.isParagraphParser();
}
public static class Factory implements CustomBlockParserFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@Override
public boolean affectsGlobalScope() {
return false;
}
@NotNull
@Override
public BlockParserFactory apply(@NotNull DataHolder options) {
return new BlockFactory(options);
}
}
private static class BlockFactory extends AbstractBlockParserFactory {
final private EnumeratedReferenceOptions options;
BlockFactory(DataHolder options) {
super(options);
this.options = new EnumeratedReferenceOptions(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {
if (state.getIndent() >= 4) {
return BlockStart.none();
}
BasedSequence line = state.getLineWithEOL();
int nextNonSpace = state.getNextNonSpaceIndex();
BasedSequence trySequence = line.subSequence(nextNonSpace, line.length());
Matcher matcher = ENUM_REF_DEF_PATTERN.matcher(trySequence);
if (matcher.find()) {
// abbreviation definition
int openingStart = nextNonSpace + matcher.start(1);
int openingEnd = nextNonSpace + matcher.end(1);
BasedSequence openingMarker = line.subSequence(openingStart, openingStart + 2);
BasedSequence text = line.subSequence(matcher.start(2), matcher.end(2));
BasedSequence closingMarker = line.subSequence(openingEnd - 2, openingEnd);
int contentOffset = options.contentIndent;
EnumeratedReferenceBlockParser enumeratedReferenceBlockParser = new EnumeratedReferenceBlockParser(options, contentOffset);
enumeratedReferenceBlockParser.block.setOpeningMarker(openingMarker);
enumeratedReferenceBlockParser.block.setText(text);
enumeratedReferenceBlockParser.block.setClosingMarker(closingMarker);
BasedSequence enumeratedReference = trySequence.subSequence(matcher.end());
enumeratedReferenceBlockParser.block.setEnumeratedReference(enumeratedReference);
Paragraph paragraph = new Paragraph(enumeratedReference);
enumeratedReferenceBlockParser.block.appendChild(paragraph);
enumeratedReferenceBlockParser.block.setCharsFromContent();
return BlockStart.of(enumeratedReferenceBlockParser)
.atIndex(line.length());
} else {
return BlockStart.none();
}
}
}
}
|
// set the enumeratedReference from closingMarker to end
block.setCharsFromContent();
block.setEnumeratedReference(block.getChars().subSequence(block.getClosingMarker().getEndOffset() - block.getStartOffset()).trimStart());
content = null;
// add block to reference repository
EnumeratedReferenceRepository enumeratedReferences = EnumeratedReferenceExtension.ENUMERATED_REFERENCES.get(state.getProperties());
enumeratedReferences.put(block.getText().toString(), block);
| 1,124
| 133
| 1,257
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumeratedReferenceLinkRefProcessor.java
|
EnumeratedReferenceLinkRefProcessor
|
isMatch
|
class EnumeratedReferenceLinkRefProcessor implements LinkRefProcessor {
static final boolean WANT_EXCLAMATION_PREFIX = false;
static final int BRACKET_NESTING_LEVEL = 0;
final private EnumeratedReferenceRepository enumeratedReferenceRepository;
public EnumeratedReferenceLinkRefProcessor(Document document) {
this.enumeratedReferenceRepository = EnumeratedReferenceExtension.ENUMERATED_REFERENCES.get(document);
}
@Override
public boolean getWantExclamationPrefix() {
return WANT_EXCLAMATION_PREFIX;
}
@Override
public int getBracketNestingLevel() {
return BRACKET_NESTING_LEVEL;
}
@Override
public boolean isMatch(@NotNull BasedSequence nodeChars) {<FILL_FUNCTION_BODY>}
@NotNull
@Override
public Node createNode(@NotNull BasedSequence nodeChars) {
BasedSequence enumeratedReferenceId = nodeChars.midSequence(2, -1).trim();
EnumeratedReferenceBlock enumeratedReferenceBlock = enumeratedReferenceId.length() > 0 ? enumeratedReferenceRepository.get(enumeratedReferenceId.toString()) : null;
if (nodeChars.charAt(1) == '@') {
// reference link
EnumeratedReferenceLink enumeratedReference = new EnumeratedReferenceLink(nodeChars.subSequence(0, 2), enumeratedReferenceId, nodeChars.endSequence(1));
enumeratedReference.setEnumeratedReferenceBlock(enumeratedReferenceBlock);
return enumeratedReference;
} else {
// reference text
EnumeratedReferenceText enumeratedReferenceText = new EnumeratedReferenceText(nodeChars.subSequence(0, 2), enumeratedReferenceId, nodeChars.endSequence(1));
enumeratedReferenceText.setEnumeratedReferenceBlock(enumeratedReferenceBlock);
return enumeratedReferenceText;
}
}
@NotNull
@Override
public BasedSequence adjustInlineText(@NotNull Document document, @NotNull Node node) {
assert node instanceof EnumeratedReferenceBase;
return ((EnumeratedReferenceBase) node).getText();
}
@Override
public boolean allowDelimiters(@NotNull BasedSequence chars, @NotNull Document document, @NotNull Node node) {
return true;
}
@Override
public void updateNodeElements(@NotNull Document document, @NotNull Node node) {
}
public static class Factory implements LinkRefProcessorFactory {
@NotNull
@Override
public LinkRefProcessor apply(@NotNull Document document) {
return new EnumeratedReferenceLinkRefProcessor(document);
}
@Override
public boolean getWantExclamationPrefix(@NotNull DataHolder options) {
return WANT_EXCLAMATION_PREFIX;
}
@Override
public int getBracketNestingLevel(@NotNull DataHolder options) {
return BRACKET_NESTING_LEVEL;
}
}
}
|
return nodeChars.length() >= 3 && nodeChars.charAt(0) == '[' && (nodeChars.charAt(1) == '@' || nodeChars.charAt(1) == '#') && nodeChars.endCharAt(1) == ']' && (nodeChars.length() == 3 || !Character.isDigit(nodeChars.charAt(2)));
| 743
| 97
| 840
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumeratedReferenceNodeFormatter.java
|
EnumeratedReferenceNodeFormatter
|
render
|
class EnumeratedReferenceNodeFormatter extends NodeRepositoryFormatter<EnumeratedReferenceRepository, EnumeratedReferenceBlock, EnumeratedReferenceText> {
final private EnumeratedReferenceFormatOptions options;
public EnumeratedReferenceNodeFormatter(DataHolder options) {
super(options, null, AttributesNodeFormatter.ATTRIBUTE_UNIQUIFICATION_CATEGORY_MAP);
this.options = new EnumeratedReferenceFormatOptions(options);
}
@Override
public EnumeratedReferenceRepository getRepository(DataHolder options) {
return EnumeratedReferenceExtension.ENUMERATED_REFERENCES.get(options);
}
@Override
public ElementPlacement getReferencePlacement() {
return options.enumeratedReferencePlacement;
}
@Override
public ElementPlacementSort getReferenceSort() {
return options.enumeratedReferenceSort;
}
@Override
protected void renderReferenceBlock(EnumeratedReferenceBlock node, NodeFormatterContext context, MarkdownWriter markdown) {
markdown.blankLine().append("[@").appendNonTranslating(node.getText()).append("]: ");
markdown.pushPrefix().addPrefix(" ", true);
context.renderChildren(node);
markdown.popPrefix();
markdown.blankLine();
}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeFormattingHandler<>(EnumeratedReferenceText.class, EnumeratedReferenceNodeFormatter.this::render),
new NodeFormattingHandler<>(EnumeratedReferenceLink.class, EnumeratedReferenceNodeFormatter.this::render),
new NodeFormattingHandler<>(EnumeratedReferenceBlock.class, EnumeratedReferenceNodeFormatter.this::render)
));
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
if (options.enumeratedReferencePlacement.isNoChange() || !options.enumeratedReferenceSort.isUnused()) return null;
// noinspection ArraysAsListWithZeroOrOneArgument
return new HashSet<>(Arrays.asList(
EnumeratedReferenceBlock.class
));
}
private void render(EnumeratedReferenceBlock node, NodeFormatterContext context, MarkdownWriter markdown) {
renderReference(node, context, markdown);
}
private static void renderReferenceText(BasedSequence text, NodeFormatterContext context, MarkdownWriter markdown) {
if (!text.isEmpty()) {
BasedSequence valueChars = text;
int pos = valueChars.indexOf(':');
String category;
String id = null;
if (pos == -1) {
category = text.toString();
} else {
category = valueChars.subSequence(0, pos).toString();
id = valueChars.subSequence(pos + 1).toString();
}
String encoded = AttributesNodeFormatter.getEncodedIdAttribute(category, id, context, markdown);
markdown.append(encoded);
}
}
private void render(EnumeratedReferenceText node, NodeFormatterContext context, MarkdownWriter markdown) {<FILL_FUNCTION_BODY>}
private void render(EnumeratedReferenceLink node, NodeFormatterContext context, MarkdownWriter markdown) {
markdown.append("[@");
if (context.isTransformingText()) {
renderReferenceText(node.getText(), context, markdown);
} else {
context.renderChildren(node);
}
markdown.append("]");
}
public static class Factory implements NodeFormatterFactory {
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new EnumeratedReferenceNodeFormatter(options);
}
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
// run before attributes formatter so categories are uniquified first
// renderers are sorted in reverse order for backward compatibility
Set<Class<?>> aSet = new HashSet<>();
aSet.add(AttributesNodeFormatter.Factory.class);
return aSet;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
}
}
|
markdown.append("[#");
if (context.isTransformingText()) {
renderReferenceText(node.getText(), context, markdown);
} else {
context.renderChildren(node);
}
markdown.append("]");
| 1,095
| 66
| 1,161
|
<methods>public void <init>(com.vladsch.flexmark.util.data.DataHolder, DataKey<Map<java.lang.String,java.lang.String>>, DataKey<Map<java.lang.String,java.lang.String>>) ,public @Nullable Set<FormattingPhase> getFormattingPhases() ,public Comparator<com.vladsch.flexmark.ext.enumerated.reference.EnumeratedReferenceBlock> getReferenceComparator() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacement getReferencePlacement() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacementSort getReferenceSort() ,public abstract com.vladsch.flexmark.ext.enumerated.reference.EnumeratedReferenceRepository getRepository(com.vladsch.flexmark.util.data.DataHolder) ,public java.lang.String modifyTransformedReference(java.lang.String, com.vladsch.flexmark.formatter.NodeFormatterContext) ,public void renderDocument(@NotNull NodeFormatterContext, @NotNull MarkdownWriter, @NotNull Document, @NotNull FormattingPhase) <variables>public static final HashSet<com.vladsch.flexmark.formatter.FormattingPhase> FORMATTING_PHASES,protected final non-sealed com.vladsch.flexmark.ext.enumerated.reference.EnumeratedReferenceBlock lastReference,protected final non-sealed Comparator<com.vladsch.flexmark.ext.enumerated.reference.EnumeratedReferenceBlock> myComparator,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceMapKey,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceUniqificationMapKey,protected boolean recheckUndefinedReferences,protected final non-sealed List<com.vladsch.flexmark.ext.enumerated.reference.EnumeratedReferenceBlock> referenceList,protected final non-sealed com.vladsch.flexmark.ext.enumerated.reference.EnumeratedReferenceRepository referenceRepository,private Map<java.lang.String,java.lang.String> referenceTranslationMap,protected Map<java.lang.String,java.lang.String> referenceUniqificationMap,protected boolean repositoryNodesDone,protected final non-sealed HashSet<com.vladsch.flexmark.util.ast.Node> unusedReferences
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumeratedReferenceNodePostProcessor.java
|
EnumeratedReferenceNodePostProcessor
|
process
|
class EnumeratedReferenceNodePostProcessor extends NodePostProcessor {
final private EnumeratedReferences enumeratedReferences;
final private HtmlIdGenerator headerIdGenerator;
public EnumeratedReferenceNodePostProcessor(Document document) {
enumeratedReferences = EnumeratedReferenceExtension.ENUMERATED_REFERENCE_ORDINALS.get(document);
headerIdGenerator = new HeaderIdGenerator.Factory().create();
headerIdGenerator.generateIds(document);
}
@Override
public void process(@NotNull NodeTracker state, @NotNull Node node) {<FILL_FUNCTION_BODY>}
public static class Factory extends NodePostProcessorFactory {
public Factory() {
super(false);
addNodes(AttributesNode.class, Heading.class);
}
@NotNull
@Override
public NodePostProcessor apply(@NotNull Document document) {
return new EnumeratedReferenceNodePostProcessor(document);
}
}
}
|
if (node instanceof AttributesNode) {
AttributesNode attributesNode = (AttributesNode) node;
for (Node attributeNode : attributesNode.getChildren()) {
if (attributeNode instanceof AttributeNode) {
if (((AttributeNode) attributeNode).isId()) {
final String text = ((AttributeNode) attributeNode).getValue().toString();
enumeratedReferences.add(text);
break;
}
}
}
} else if (node instanceof Heading) {
// see if it has bare enum reference text
for (Node child : node.getChildren()) {
if (child instanceof EnumeratedReferenceText) {
BasedSequence text = ((EnumeratedReferenceText) child).getText();
String type = EnumeratedReferenceRepository.getType(text.toString());
if (type.isEmpty() || text.equals(type + ":")) {
String id = (type.isEmpty() ? text : type) + ":" + headerIdGenerator.getId(node);
enumeratedReferences.add(id);
}
}
}
}
| 239
| 265
| 504
|
<methods>public non-sealed void <init>() ,public final @NotNull Document processDocument(@NotNull Document) <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumeratedReferenceNodeRenderer.java
|
OrdinalRenderer
|
render
|
class OrdinalRenderer implements EnumeratedOrdinalRenderer {
final EnumeratedReferenceNodeRenderer renderer;
final NodeRendererContext context;
final HtmlWriter html;
public OrdinalRenderer(EnumeratedReferenceNodeRenderer renderer, NodeRendererContext context, HtmlWriter html) {
this.renderer = renderer;
this.context = context;
this.html = html;
}
@Override
public void startRendering(EnumeratedReferenceRendering[] renderings) {
}
@Override
public void setEnumOrdinalRunnable(Runnable runnable) {
renderer.ordinalRunnable = runnable;
}
@Override
public Runnable getEnumOrdinalRunnable() {
return renderer.ordinalRunnable;
}
@Override
public void render(int referenceOrdinal, EnumeratedReferenceBlock referenceFormat, String defaultText, boolean needSeparator) {<FILL_FUNCTION_BODY>}
@Override
public void endRendering() {
}
}
|
Runnable compoundRunnable = renderer.ordinalRunnable;
if (referenceFormat != null) {
renderer.ordinalRunnable = () -> {
if (compoundRunnable != null) compoundRunnable.run();
html.text(String.valueOf(referenceOrdinal));
if (needSeparator) html.text(".");
};
context.renderChildren(referenceFormat);
} else {
html.text(defaultText + " ");
if (compoundRunnable != null) compoundRunnable.run();
html.text(String.valueOf(referenceOrdinal));
if (needSeparator) html.text(".");
}
| 277
| 180
| 457
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-enumerated-reference/src/main/java/com/vladsch/flexmark/ext/enumerated/reference/internal/EnumeratedReferenceParagraphPreProcessor.java
|
EnumeratedReferenceParagraphPreProcessor
|
preProcessBlock
|
class EnumeratedReferenceParagraphPreProcessor implements ParagraphPreProcessor {
static String ENUM_REF_ID = "(?:[^0-9].*)?";
static Pattern ENUM_REF_DEF_PARAGRAPH_PATTERN = Pattern.compile("\\s{0,3}(\\[[\\@]\\s*(" + ENUM_REF_ID + ")\\s*\\]:)\\s+(.*\n)");
@SuppressWarnings("FieldCanBeLocal") final private EnumeratedReferenceOptions options;
final private EnumeratedReferenceRepository enumeratedReferences;
EnumeratedReferenceParagraphPreProcessor(DataHolder options) {
this.options = new EnumeratedReferenceOptions(options);
enumeratedReferences = EnumeratedReferenceExtension.ENUMERATED_REFERENCES.get(options);
}
@Override
public int preProcessBlock(Paragraph block, ParserState state) {<FILL_FUNCTION_BODY>}
public static ParagraphPreProcessorFactory Factory() {
return new ParagraphPreProcessorFactory() {
@Override
public boolean affectsGlobalScope() {
return true;
}
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public Set<Class<?>> getBeforeDependents() {
HashSet<Class<?>> set = new HashSet<>();
set.add(ReferencePreProcessorFactory.class);
return set;
}
@Override
public ParagraphPreProcessor apply(ParserState state) {
return new EnumeratedReferenceParagraphPreProcessor(state.getProperties());
}
};
}
}
|
BasedSequence trySequence = block.getChars();
Matcher matcher = ENUM_REF_DEF_PARAGRAPH_PATTERN.matcher(trySequence);
int lastFound = 0;
while (matcher.find()) {
if (matcher.start() != lastFound) break;
lastFound = matcher.end();
int openingStart = matcher.start(1);
int openingEnd = matcher.end(1);
BasedSequence openingMarker = trySequence.subSequence(openingStart, openingStart + 2);
BasedSequence text = trySequence.subSequence(openingStart + 2, openingEnd - 2).trim();
BasedSequence closingMarker = trySequence.subSequence(openingEnd - 2, openingEnd);
EnumeratedReferenceBlock enumeratedReferenceBlock = new EnumeratedReferenceBlock();
enumeratedReferenceBlock.setOpeningMarker(openingMarker);
enumeratedReferenceBlock.setText(text);
enumeratedReferenceBlock.setClosingMarker(closingMarker);
BasedSequence enumeratedReference = trySequence.subSequence(matcher.start(3), matcher.end(3));
enumeratedReferenceBlock.setEnumeratedReference(enumeratedReference);
Paragraph paragraph = new Paragraph(enumeratedReference);
enumeratedReferenceBlock.appendChild(paragraph);
enumeratedReferenceBlock.setCharsFromContent();
block.insertBefore(enumeratedReferenceBlock);
state.blockAdded(enumeratedReferenceBlock);
enumeratedReferences.put(enumeratedReferenceBlock.getText().toString(), enumeratedReferenceBlock);
}
return lastFound;
| 425
| 400
| 825
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-escaped-character/src/main/java/com/vladsch/flexmark/ext/escaped/character/EscapedCharacterExtension.java
|
EscapedCharacterExtension
|
extend
|
class EscapedCharacterExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
private EscapedCharacterExtension() {
}
public static EscapedCharacterExtension create() {
return new EscapedCharacterExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.postProcessorFactory(new EscapedCharacterNodePostProcessor.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new EscapedCharacterNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
| 188
| 59
| 247
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-escaped-character/src/main/java/com/vladsch/flexmark/ext/escaped/character/internal/EscapedCharacterNodePostProcessor.java
|
EscapedCharacterNodePostProcessor
|
process
|
class EscapedCharacterNodePostProcessor extends NodePostProcessor {
public EscapedCharacterNodePostProcessor(Document document) {
}
@Override
public void process(@NotNull NodeTracker state, @NotNull Node node) {<FILL_FUNCTION_BODY>}
public static class Factory extends NodePostProcessorFactory {
public Factory() {
super(false);
addNodeWithExclusions(Text.class, DoNotDecorate.class);
}
@NotNull
@Override
public NodePostProcessor apply(@NotNull Document document) {
return new EscapedCharacterNodePostProcessor(document);
}
}
}
|
BasedSequence original = node.getChars();
ReplacedTextMapper textMapper = new ReplacedTextMapper(original);
// NOTE: needed for its side-effects
Escaping.unescape(original, textMapper);
int lastEscaped = 0;
boolean wrapInTextBase = !(node.getParent() instanceof TextBase);
TextBase textBase = wrapInTextBase ? null : (TextBase) node.getParent();
ArrayList<ReplacedTextRegion> replacedRegions = textMapper.getRegions();
for (ReplacedTextRegion region : replacedRegions) {
int startOffset = region.getOriginalRange().getStart();
int endOffset = region.getOriginalRange().getEnd();
if (original.charAt(startOffset) == '\\' && region.getReplacedRange().getSpan() == 1
// fix for #19, ArrayIndexOutOfBounds while parsing markdown with backslash as last character of text block
&& startOffset + 1 < original.length()) {
if (wrapInTextBase) {
wrapInTextBase = false;
textBase = new TextBase(original);
node.insertBefore(textBase);
state.nodeAdded(textBase);
}
if (startOffset != lastEscaped) {
BasedSequence escapedChars = original.subSequence(lastEscaped, startOffset);
Node node1 = new Text(escapedChars);
textBase.appendChild(node1);
state.nodeAdded(node1);
}
BasedSequence origToDecorateText = original.subSequence(startOffset, endOffset);
BasedSequence text = origToDecorateText.subSequence(1);
EscapedCharacter decorationNode = new EscapedCharacter(origToDecorateText.subSequence(0, 1), text);
textBase.appendChild(decorationNode);
state.nodeAdded(decorationNode);
lastEscaped = endOffset;
}
}
if (lastEscaped > 0) {
if (lastEscaped != original.length()) {
BasedSequence escapedChars = original.subSequence(lastEscaped, original.length());
Node node1 = new Text(escapedChars);
textBase.appendChild(node1);
state.nodeAdded(node1);
}
node.unlink();
state.nodeRemoved(node);
}
| 156
| 589
| 745
|
<methods>public non-sealed void <init>() ,public final @NotNull Document processDocument(@NotNull Document) <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-escaped-character/src/main/java/com/vladsch/flexmark/ext/escaped/character/internal/EscapedCharacterNodeRenderer.java
|
EscapedCharacterNodeRenderer
|
getNodeRenderingHandlers
|
class EscapedCharacterNodeRenderer implements NodeRenderer {
final private EscapedCharacterOptions options;
public EscapedCharacterNodeRenderer(DataHolder options) {
this.options = new EscapedCharacterOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
private void render(EscapedCharacter node, NodeRendererContext context, HtmlWriter html) {
html.text(node.getChars().unescape());
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new EscapedCharacterNodeRenderer(options);
}
}
}
|
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(EscapedCharacter.class, this::render));
return set;
| 184
| 51
| 235
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/FootnoteExtension.java
|
FootnoteExtension
|
extend
|
class FootnoteExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension, Parser.ReferenceHoldingExtension, Formatter.FormatterExtension {
final public static DataKey<KeepType> FOOTNOTES_KEEP = new DataKey<>("FOOTNOTES_KEEP", KeepType.FIRST);
final public static DataKey<FootnoteRepository> FOOTNOTES = new DataKey<>("FOOTNOTES", new FootnoteRepository(null), FootnoteRepository::new);
final public static DataKey<String> FOOTNOTE_REF_PREFIX = new DataKey<>("FOOTNOTE_REF_PREFIX", "");
final public static DataKey<String> FOOTNOTE_REF_SUFFIX = new DataKey<>("FOOTNOTE_REF_SUFFIX", "");
final public static DataKey<String> FOOTNOTE_BACK_REF_STRING = new DataKey<>("FOOTNOTE_BACK_REF_STRING", "↩");
final public static DataKey<String> FOOTNOTE_LINK_REF_CLASS = new DataKey<>("FOOTNOTE_LINK_REF_CLASS", "footnote-ref");
final public static DataKey<String> FOOTNOTE_BACK_LINK_REF_CLASS = new DataKey<>("FOOTNOTE_BACK_LINK_REF_CLASS", "footnote-backref");
// formatter options
final public static DataKey<ElementPlacement> FOOTNOTE_PLACEMENT = new DataKey<>("FOOTNOTE_PLACEMENT", ElementPlacement.AS_IS);
final public static DataKey<ElementPlacementSort> FOOTNOTE_SORT = new DataKey<>("FOOTNOTE_SORT", ElementPlacementSort.AS_IS);
private FootnoteExtension() {
}
public static FootnoteExtension create() {
return new FootnoteExtension();
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new FootnoteNodeFormatter.Factory());
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public boolean transferReferences(MutableDataHolder document, DataHolder included) {
if (document.contains(FOOTNOTES) && included.contains(FOOTNOTES)) {
return Parser.transferReferences(FOOTNOTES.get(document), FOOTNOTES.get(included), FOOTNOTES_KEEP.get(document) == KeepType.FIRST);
}
return false;
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customBlockParserFactory(new FootnoteBlockParser.Factory());
parserBuilder.linkRefProcessorFactory(new FootnoteLinkRefProcessor.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new FootnoteNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
| 746
| 58
| 804
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/FootnoteVisitorExt.java
|
FootnoteVisitorExt
|
VISIT_HANDLERS
|
class FootnoteVisitorExt {
public static <V extends FootnoteVisitor> VisitHandler<?>[] VISIT_HANDLERS(V visitor) {<FILL_FUNCTION_BODY>}
}
|
return new VisitHandler<?>[] {
new VisitHandler<>(FootnoteBlock.class, visitor::visit),
new VisitHandler<>(Footnote.class, visitor::visit),
};
| 53
| 50
| 103
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/internal/FootnoteBlockParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
final private FootnoteOptions options;
private BlockFactory(DataHolder options) {
super(options);
this.options = new FootnoteOptions(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
if (state.getIndent() >= 4) {
return BlockStart.none();
}
BasedSequence line = state.getLine();
int nextNonSpace = state.getNextNonSpaceIndex();
BasedSequence trySequence = line.subSequence(nextNonSpace, line.length());
Matcher matcher = FOOTNOTE_DEF_PATTERN.matcher(trySequence);
if (matcher.find()) {
// abbreviation definition
int openingStart = nextNonSpace + matcher.start();
int openingEnd = nextNonSpace + matcher.end();
BasedSequence openingMarker = line.subSequence(openingStart, openingStart + 2);
BasedSequence text = line.subSequence(openingStart + 2, openingEnd - 2).trim();
BasedSequence closingMarker = line.subSequence(openingEnd - 2, openingEnd);
int contentOffset = options.contentIndent;
FootnoteBlockParser footnoteBlockParser = new FootnoteBlockParser(options, contentOffset);
footnoteBlockParser.block.setOpeningMarker(openingMarker);
footnoteBlockParser.block.setText(text);
footnoteBlockParser.block.setClosingMarker(closingMarker);
return BlockStart.of(footnoteBlockParser)
.atIndex(openingEnd);
} else {
return BlockStart.none();
}
| 94
| 337
| 431
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/internal/FootnoteLinkRefProcessor.java
|
FootnoteLinkRefProcessor
|
createNode
|
class FootnoteLinkRefProcessor implements LinkRefProcessor {
static final boolean WANT_EXCLAMATION_PREFIX = false;
static final int BRACKET_NESTING_LEVEL = 0;
final private FootnoteRepository footnoteRepository;
public FootnoteLinkRefProcessor(Document document) {
this.footnoteRepository = FootnoteExtension.FOOTNOTES.get(document);
}
@Override
public boolean getWantExclamationPrefix() {
return WANT_EXCLAMATION_PREFIX;
}
@Override
public int getBracketNestingLevel() {
return BRACKET_NESTING_LEVEL;
}
@Override
public boolean isMatch(@NotNull BasedSequence nodeChars) {
return nodeChars.length() >= 3 && nodeChars.charAt(0) == '[' && nodeChars.charAt(1) == '^' && nodeChars.endCharAt(1) == ']';
}
@NotNull
@Override
public Node createNode(@NotNull BasedSequence nodeChars) {<FILL_FUNCTION_BODY>}
@NotNull
@Override
public BasedSequence adjustInlineText(@NotNull Document document, @NotNull Node node) {
assert node instanceof Footnote;
return ((Footnote) node).getText();
}
@Override
public boolean allowDelimiters(@NotNull BasedSequence chars, @NotNull Document document, @NotNull Node node) {
return true;
}
@Override
public void updateNodeElements(@NotNull Document document, @NotNull Node node) {
}
public static class Factory implements LinkRefProcessorFactory {
@NotNull
@Override
public LinkRefProcessor apply(@NotNull Document document) {
return new FootnoteLinkRefProcessor(document);
}
@Override
public boolean getWantExclamationPrefix(@NotNull DataHolder options) {
return WANT_EXCLAMATION_PREFIX;
}
@Override
public int getBracketNestingLevel(@NotNull DataHolder options) {
return BRACKET_NESTING_LEVEL;
}
}
}
|
BasedSequence footnoteId = nodeChars.midSequence(2, -1).trim();
FootnoteBlock footnoteBlock = footnoteId.length() > 0 ? footnoteRepository.get(footnoteId.toString()) : null;
Footnote footnote = new Footnote(nodeChars.subSequence(0, 2), footnoteId, nodeChars.endSequence(1));
footnote.setFootnoteBlock(footnoteBlock);
if (footnoteBlock != null) {
footnoteRepository.addFootnoteReference(footnoteBlock, footnote);
}
return footnote;
| 527
| 143
| 670
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/internal/FootnoteNodeFormatter.java
|
FootnoteNodeFormatter
|
render
|
class FootnoteNodeFormatter extends NodeRepositoryFormatter<FootnoteRepository, FootnoteBlock, Footnote> {
final public static DataKey<Map<String, String>> FOOTNOTE_TRANSLATION_MAP = new DataKey<>("FOOTNOTE_TRANSLATION_MAP", new HashMap<>()); // translated references
final public static DataKey<Map<String, String>> FOOTNOTE_UNIQUIFICATION_MAP = new DataKey<>("FOOTNOTE_UNIQUIFICATION_MAP", new HashMap<>()); // uniquified references
final private FootnoteFormatOptions options;
public FootnoteNodeFormatter(DataHolder options) {
super(options, FOOTNOTE_TRANSLATION_MAP, FOOTNOTE_UNIQUIFICATION_MAP);
this.options = new FootnoteFormatOptions(options);
}
@Override
public FootnoteRepository getRepository(DataHolder options) {
return FootnoteExtension.FOOTNOTES.get(options);
}
@Override
public ElementPlacement getReferencePlacement() {
return options.footnotePlacement;
}
@Override
public ElementPlacementSort getReferenceSort() {
return options.footnoteSort;
}
@Override
public void renderReferenceBlock(FootnoteBlock node, NodeFormatterContext context, MarkdownWriter markdown) {
markdown.blankLine().append("[^");
markdown.append(transformReferenceId(node.getText().toString(), context));
markdown.append("]: ");
markdown.pushPrefix().addPrefix(" ");
context.renderChildren(node);
markdown.popPrefix();
markdown.blankLine();
}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeFormattingHandler<>(Footnote.class, FootnoteNodeFormatter.this::render),
new NodeFormattingHandler<>(FootnoteBlock.class, FootnoteNodeFormatter.this::render)
));
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
if (options.footnotePlacement.isNoChange() || !options.footnoteSort.isUnused()) return null;
// noinspection ArraysAsListWithZeroOrOneArgument
return new HashSet<>(Arrays.asList(
Footnote.class
));
}
private void render(FootnoteBlock node, NodeFormatterContext context, MarkdownWriter markdown) {
renderReference(node, context, markdown);
}
private void render(Footnote node, NodeFormatterContext context, MarkdownWriter markdown) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeFormatterFactory {
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new FootnoteNodeFormatter(options);
}
}
}
|
markdown.append("[^");
if (context.isTransformingText()) {
String referenceId = transformReferenceId(node.getText().toString(), context);
context.nonTranslatingSpan((context1, markdown1) -> markdown1.append(referenceId));
} else {
markdown.append(node.getText());
}
markdown.append("]");
| 722
| 99
| 821
|
<methods>public void <init>(com.vladsch.flexmark.util.data.DataHolder, DataKey<Map<java.lang.String,java.lang.String>>, DataKey<Map<java.lang.String,java.lang.String>>) ,public @Nullable Set<FormattingPhase> getFormattingPhases() ,public Comparator<com.vladsch.flexmark.ext.footnotes.FootnoteBlock> getReferenceComparator() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacement getReferencePlacement() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacementSort getReferenceSort() ,public abstract com.vladsch.flexmark.ext.footnotes.internal.FootnoteRepository getRepository(com.vladsch.flexmark.util.data.DataHolder) ,public java.lang.String modifyTransformedReference(java.lang.String, com.vladsch.flexmark.formatter.NodeFormatterContext) ,public void renderDocument(@NotNull NodeFormatterContext, @NotNull MarkdownWriter, @NotNull Document, @NotNull FormattingPhase) <variables>public static final HashSet<com.vladsch.flexmark.formatter.FormattingPhase> FORMATTING_PHASES,protected final non-sealed com.vladsch.flexmark.ext.footnotes.FootnoteBlock lastReference,protected final non-sealed Comparator<com.vladsch.flexmark.ext.footnotes.FootnoteBlock> myComparator,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceMapKey,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceUniqificationMapKey,protected boolean recheckUndefinedReferences,protected final non-sealed List<com.vladsch.flexmark.ext.footnotes.FootnoteBlock> referenceList,protected final non-sealed com.vladsch.flexmark.ext.footnotes.internal.FootnoteRepository referenceRepository,private Map<java.lang.String,java.lang.String> referenceTranslationMap,protected Map<java.lang.String,java.lang.String> referenceUniqificationMap,protected boolean repositoryNodesDone,protected final non-sealed HashSet<com.vladsch.flexmark.util.ast.Node> unusedReferences
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/internal/FootnoteNodeRenderer.java
|
FootnoteNodeRenderer
|
renderDocument
|
class FootnoteNodeRenderer implements PhasedNodeRenderer {
final private FootnoteRepository footnoteRepository;
final private FootnoteOptions options;
final private boolean recheckUndefinedReferences;
public FootnoteNodeRenderer(DataHolder options) {
this.options = new FootnoteOptions(options);
this.footnoteRepository = FootnoteExtension.FOOTNOTES.get(options);
this.recheckUndefinedReferences = HtmlRenderer.RECHECK_UNDEFINED_REFERENCES.get(options);
this.footnoteRepository.resolveFootnoteOrdinals();
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeRenderingHandler<>(Footnote.class, this::render),
new NodeRenderingHandler<>(FootnoteBlock.class, this::render)
));
}
@Override
public Set<RenderingPhase> getRenderingPhases() {
Set<RenderingPhase> set = new HashSet<>();
set.add(RenderingPhase.BODY_TOP);
set.add(RenderingPhase.BODY_BOTTOM);
return set;
}
@Override
public void renderDocument(@NotNull NodeRendererContext context, @NotNull HtmlWriter html, @NotNull Document document, @NotNull RenderingPhase phase) {<FILL_FUNCTION_BODY>}
private void render(FootnoteBlock node, NodeRendererContext context, HtmlWriter html) {
}
private void render(Footnote node, NodeRendererContext context, HtmlWriter html) {
FootnoteBlock footnoteBlock = node.getFootnoteBlock();
if (footnoteBlock == null) {
//just text
html.raw("[^");
context.renderChildren(node);
html.raw("]");
} else {
int footnoteOrdinal = footnoteBlock.getFootnoteOrdinal();
int i = node.getReferenceOrdinal();
html.attr("id", "fnref-" + footnoteOrdinal + (i == 0 ? "" : String.format(Locale.US, "-%d", i)));
html.srcPos(node.getChars()).withAttr().tag("sup", false, false, () -> {
if (!options.footnoteLinkRefClass.isEmpty()) html.attr("class", options.footnoteLinkRefClass);
html.attr("href", "#fn-" + footnoteOrdinal);
html.withAttr().tag("a");
html.raw(options.footnoteRefPrefix + footnoteOrdinal + options.footnoteRefSuffix);
html.tag("/a");
});
}
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new FootnoteNodeRenderer(options);
}
}
}
|
if (phase == RenderingPhase.BODY_TOP) {
if (recheckUndefinedReferences) {
// need to see if have undefined footnotes that were defined after parsing
boolean[] hadNewFootnotes = { false };
NodeVisitor visitor = new NodeVisitor(
new VisitHandler<>(Footnote.class, node -> {
if (!node.isDefined()) {
FootnoteBlock footonoteBlock = node.getFootnoteBlock(footnoteRepository);
if (footonoteBlock != null) {
footnoteRepository.addFootnoteReference(footonoteBlock, node);
node.setFootnoteBlock(footonoteBlock);
hadNewFootnotes[0] = true;
}
}
})
);
visitor.visit(document);
if (hadNewFootnotes[0]) {
this.footnoteRepository.resolveFootnoteOrdinals();
}
}
}
if (phase == RenderingPhase.BODY_BOTTOM) {
// here we dump the footnote blocks that were referenced in the document body, ie. ones with footnoteOrdinal > 0
if (footnoteRepository.getReferencedFootnoteBlocks().size() > 0) {
html.attr("class", "footnotes").withAttr().tagIndent("div", () -> {
html.tagVoidLine("hr");
html.tagIndent("ol", () -> {
for (FootnoteBlock footnoteBlock : footnoteRepository.getReferencedFootnoteBlocks()) {
int footnoteOrdinal = footnoteBlock.getFootnoteOrdinal();
html.attr("id", "fn-" + footnoteOrdinal);
html.withAttr().tagIndent("li", () -> {
context.renderChildren(footnoteBlock);
int iMax = footnoteBlock.getFootnoteReferences();
for (int i = 0; i < iMax; i++) {
html.attr("href", "#fnref-" + footnoteOrdinal + (i == 0 ? "" : String.format(Locale.US, "-%d", i)));
if (!options.footnoteBackLinkRefClass.isEmpty()) html.attr("class", options.footnoteBackLinkRefClass);
html.line().withAttr().tag("a");
html.raw(options.footnoteBackRefString);
html.tag("/a");
}
});
}
});
});
}
}
| 718
| 601
| 1,319
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-footnotes/src/main/java/com/vladsch/flexmark/ext/footnotes/internal/FootnoteRepository.java
|
FootnoteRepository
|
resolveFootnotes
|
class FootnoteRepository extends NodeRepository<FootnoteBlock> {
private ArrayList<FootnoteBlock> referencedFootnoteBlocks = new ArrayList<>();
public static void resolveFootnotes(Document document) {<FILL_FUNCTION_BODY>}
public void addFootnoteReference(FootnoteBlock footnoteBlock, Footnote footnote) {
if (!footnoteBlock.isReferenced()) {
referencedFootnoteBlocks.add(footnoteBlock);
}
footnoteBlock.setFirstReferenceOffset(footnote.getStartOffset());
int referenceOrdinal = footnoteBlock.getFootnoteReferences();
footnoteBlock.setFootnoteReferences(referenceOrdinal + 1);
footnote.setReferenceOrdinal(referenceOrdinal);
}
public void resolveFootnoteOrdinals() {
// need to sort by first referenced offset then set each to its ordinal position in the array+1
Collections.sort(referencedFootnoteBlocks, (f1, f2) -> f1.getFirstReferenceOffset() - f2.getFirstReferenceOffset());
int ordinal = 0;
for (FootnoteBlock footnoteBlock : referencedFootnoteBlocks) {
footnoteBlock.setFootnoteOrdinal(++ordinal);
}
}
public List<FootnoteBlock> getReferencedFootnoteBlocks() {
return referencedFootnoteBlocks;
}
public FootnoteRepository(DataHolder options) {
super(FootnoteExtension.FOOTNOTES_KEEP.get(options));
}
@NotNull
@Override
public DataKey<FootnoteRepository> getDataKey() {
return FootnoteExtension.FOOTNOTES;
}
@NotNull
@Override
public DataKey<KeepType> getKeepDataKey() {
return FootnoteExtension.FOOTNOTES_KEEP;
}
@NotNull
@Override
public Set<FootnoteBlock> getReferencedElements(Node parent) {
HashSet<FootnoteBlock> references = new HashSet<>();
visitNodes(parent, value -> {
if (value instanceof Footnote) {
FootnoteBlock reference = ((Footnote) value).getReferenceNode(FootnoteRepository.this);
if (reference != null) {
references.add(reference);
}
}
}, Footnote.class);
return references;
}
}
|
FootnoteRepository footnoteRepository = FootnoteExtension.FOOTNOTES.get(document);
boolean[] hadNewFootnotes = { false };
NodeVisitor visitor = new NodeVisitor(
new VisitHandler<>(Footnote.class, node -> {
if (!node.isDefined()) {
FootnoteBlock footonoteBlock = node.getFootnoteBlock(footnoteRepository);
if (footonoteBlock != null) {
footnoteRepository.addFootnoteReference(footonoteBlock, node);
node.setFootnoteBlock(footonoteBlock);
hadNewFootnotes[0] = true;
}
}
})
);
visitor.visit(document);
if (hadNewFootnotes[0]) {
footnoteRepository.resolveFootnoteOrdinals();
}
| 572
| 201
| 773
|
<methods>public void <init>(@Nullable KeepType) ,public void clear() ,public boolean containsKey(@NotNull Object) ,public boolean containsValue(java.lang.Object) ,public @NotNull Set<Map.Entry<String,FootnoteBlock>> entrySet() ,public boolean equals(java.lang.Object) ,public @Nullable FootnoteBlock get(@NotNull Object) ,public abstract @NotNull DataKey<? extends NodeRepository<FootnoteBlock>> getDataKey() ,public @Nullable FootnoteBlock getFromRaw(@NotNull CharSequence) ,public abstract @NotNull DataKey<KeepType> getKeepDataKey() ,public abstract @NotNull Set<FootnoteBlock> getReferencedElements(com.vladsch.flexmark.util.ast.Node) ,public @NotNull Collection<FootnoteBlock> getValues() ,public int hashCode() ,public boolean isEmpty() ,public @NotNull Set<String> keySet() ,public @NotNull String normalizeKey(@NotNull CharSequence) ,public @Nullable FootnoteBlock put(@NotNull String, @NotNull FootnoteBlock) ,public void putAll(@NotNull Map<? extends String,? extends FootnoteBlock>) ,public @Nullable FootnoteBlock putRawKey(@NotNull CharSequence, @NotNull FootnoteBlock) ,public @Nullable FootnoteBlock remove(@NotNull Object) ,public int size() ,public static boolean transferReferences(@NotNull NodeRepository<T>, @NotNull NodeRepository<T>, boolean, @Nullable Map<String,String>) ,public @NotNull List<FootnoteBlock> values() <variables>protected final non-sealed com.vladsch.flexmark.util.ast.KeepType keepType,protected final ArrayList<com.vladsch.flexmark.ext.footnotes.FootnoteBlock> nodeList,protected final Map<java.lang.String,com.vladsch.flexmark.ext.footnotes.FootnoteBlock> nodeMap
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-issues/src/main/java/com/vladsch/flexmark/ext/gfm/issues/GfmIssuesExtension.java
|
GfmIssuesExtension
|
extend
|
class GfmIssuesExtension implements Parser.ParserExtension
, HtmlRenderer.HtmlRendererExtension
{
final public static DataKey<String> GIT_HUB_ISSUES_URL_ROOT = new DataKey<>("GIT_HUB_ISSUES_URL_ROOT", "issues");
final public static DataKey<String> GIT_HUB_ISSUE_URL_PREFIX = new DataKey<>("GIT_HUB_ISSUE_URL_PREFIX", "/");
final public static DataKey<String> GIT_HUB_ISSUE_URL_SUFFIX = new DataKey<>("GIT_HUB_ISSUE_URL_SUFFIX", "");
final public static DataKey<String> GIT_HUB_ISSUE_HTML_PREFIX = new DataKey<>("GIT_HUB_ISSUE_HTML_PREFIX", "");
final public static DataKey<String> GIT_HUB_ISSUE_HTML_SUFFIX = new DataKey<>("GIT_HUB_ISSUE_HTML_SUFFIX", "");
private GfmIssuesExtension() {
}
public static GfmIssuesExtension create() {
return new GfmIssuesExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customInlineParserExtensionFactory(new GfmIssuesInlineParserExtension.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new GfmIssuesNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new GfmIssuesJiraRenderer.Factory());
}
| 441
| 81
| 522
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-issues/src/main/java/com/vladsch/flexmark/ext/gfm/issues/internal/GfmIssuesInlineParserExtension.java
|
GfmIssuesInlineParserExtension
|
parse
|
class GfmIssuesInlineParserExtension implements InlineParserExtension {
final public static Pattern GITHUB_ISSUE = Pattern.compile("^(#)(\\d+)\\b");
public GfmIssuesInlineParserExtension(LightInlineParser inlineParser) {
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "#";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser inlineParser) {
return new GfmIssuesInlineParserExtension(inlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
BasedSequence[] matches = inlineParser.matchWithGroups(GITHUB_ISSUE);
if (matches != null) {
inlineParser.flushTextNode();
BasedSequence openMarker = matches[1];
BasedSequence text = matches[2];
GfmIssue gfmIssue = new GfmIssue(openMarker, text);
inlineParser.getBlock().appendChild(gfmIssue);
return true;
}
return false;
| 330
| 119
| 449
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-issues/src/main/java/com/vladsch/flexmark/ext/gfm/issues/internal/GfmIssuesJiraRenderer.java
|
GfmIssuesJiraRenderer
|
render
|
class GfmIssuesJiraRenderer implements NodeRenderer {
final private GfmIssuesOptions options;
public GfmIssuesJiraRenderer(DataHolder options) {
this.options = new GfmIssuesOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
return new HashSet<>(Collections.singletonList(
new NodeRenderingHandler<>(GfmIssue.class, this::render)
));
}
private void render(GfmIssue node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new GfmIssuesJiraRenderer(options);
}
}
}
|
if (context.isDoNotRenderLinks()) {
html.raw(node.getChars());
} else {
StringBuilder sb = new StringBuilder();
sb.append(options.gitHubIssuesUrlRoot).append(options.gitHubIssueUrlPrefix).append(node.getText()).append(options.gitHubIssueUrlSuffix);
html.raw("[");
html.raw(node.getChars());
html.raw("|").raw(sb.toString()).raw("]");
}
| 216
| 132
| 348
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-issues/src/main/java/com/vladsch/flexmark/ext/gfm/issues/internal/GfmIssuesNodeRenderer.java
|
GfmIssuesNodeRenderer
|
render
|
class GfmIssuesNodeRenderer implements NodeRenderer
// , PhasedNodeRenderer
{
final private GfmIssuesOptions options;
public GfmIssuesNodeRenderer(DataHolder options) {
this.options = new GfmIssuesOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
Set<NodeRenderingHandler<?>> set = new HashSet<>();
// @formatter:off
set.add(new NodeRenderingHandler<>(GfmIssue.class, GfmIssuesNodeRenderer.this::render));
// @formatter:on
return set;
}
private void render(GfmIssue node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new GfmIssuesNodeRenderer(options);
}
}
}
|
if (context.isDoNotRenderLinks()) {
html.text(node.getChars());
} else {
StringBuilder sb = new StringBuilder();
sb.append(options.gitHubIssuesUrlRoot).append(options.gitHubIssueUrlPrefix).append(node.getText()).append(options.gitHubIssueUrlSuffix);
html.srcPos(node.getChars()).attr("href", sb.toString()).withAttr().tag("a");
html.raw(options.gitHubIssueTextPrefix);
html.text(node.getChars());
html.raw(options.gitHubIssueTextSuffix);
html.tag("/a");
}
| 254
| 174
| 428
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-issues/src/main/java/com/vladsch/flexmark/ext/gfm/issues/internal/GfmIssuesOptions.java
|
GfmIssuesOptions
|
setIn
|
class GfmIssuesOptions implements MutableDataSetter {
final public String gitHubIssuesUrlRoot;
final public String gitHubIssueUrlPrefix;
final public String gitHubIssueUrlSuffix;
final public String gitHubIssueTextPrefix;
final public String gitHubIssueTextSuffix;
public GfmIssuesOptions(DataHolder options) {
gitHubIssuesUrlRoot = GfmIssuesExtension.GIT_HUB_ISSUES_URL_ROOT.get(options);
gitHubIssueUrlPrefix = GfmIssuesExtension.GIT_HUB_ISSUE_URL_PREFIX.get(options);
gitHubIssueUrlSuffix = GfmIssuesExtension.GIT_HUB_ISSUE_URL_SUFFIX.get(options);
gitHubIssueTextPrefix = GfmIssuesExtension.GIT_HUB_ISSUE_HTML_PREFIX.get(options);
gitHubIssueTextSuffix = GfmIssuesExtension.GIT_HUB_ISSUE_HTML_SUFFIX.get(options);
}
@NotNull
@Override
public MutableDataHolder setIn(@NotNull MutableDataHolder dataHolder) {<FILL_FUNCTION_BODY>}
}
|
dataHolder.set(GfmIssuesExtension.GIT_HUB_ISSUES_URL_ROOT, gitHubIssuesUrlRoot);
dataHolder.set(GfmIssuesExtension.GIT_HUB_ISSUE_URL_PREFIX, gitHubIssueUrlPrefix);
dataHolder.set(GfmIssuesExtension.GIT_HUB_ISSUE_URL_SUFFIX, gitHubIssueUrlSuffix);
dataHolder.set(GfmIssuesExtension.GIT_HUB_ISSUE_HTML_PREFIX, gitHubIssueTextPrefix);
dataHolder.set(GfmIssuesExtension.GIT_HUB_ISSUE_HTML_SUFFIX, gitHubIssueTextSuffix);
return dataHolder;
| 314
| 190
| 504
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/StrikethroughExtension.java
|
StrikethroughExtension
|
extend
|
class StrikethroughExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
final public static NullableDataKey<String> STRIKETHROUGH_STYLE_HTML_OPEN = StrikethroughSubscriptExtension.STRIKETHROUGH_STYLE_HTML_OPEN;
final public static NullableDataKey<String> STRIKETHROUGH_STYLE_HTML_CLOSE = StrikethroughSubscriptExtension.STRIKETHROUGH_STYLE_HTML_CLOSE;
private StrikethroughExtension() {
}
public static StrikethroughExtension create() {
return new StrikethroughExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customDelimiterProcessor(new StrikethroughDelimiterProcessor());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("YOUTRACK")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughYouTrackRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughJiraRenderer.Factory());
}
| 305
| 122
| 427
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/StrikethroughSubscriptExtension.java
|
StrikethroughSubscriptExtension
|
extend
|
class StrikethroughSubscriptExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
final public static NullableDataKey<String> STRIKETHROUGH_STYLE_HTML_OPEN = new NullableDataKey<>("STRIKETHROUGH_STYLE_HTML_OPEN");
final public static NullableDataKey<String> STRIKETHROUGH_STYLE_HTML_CLOSE = new NullableDataKey<>("STRIKETHROUGH_STYLE_HTML_CLOSE");
final public static NullableDataKey<String> SUBSCRIPT_STYLE_HTML_OPEN = new NullableDataKey<>("SUBSCRIPT_STYLE_HTML_OPEN");
final public static NullableDataKey<String> SUBSCRIPT_STYLE_HTML_CLOSE = new NullableDataKey<>("SUBSCRIPT_STYLE_HTML_CLOSE");
private StrikethroughSubscriptExtension() {
}
public static StrikethroughSubscriptExtension create() {
return new StrikethroughSubscriptExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customDelimiterProcessor(new StrikethroughSubscriptDelimiterProcessor());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("YOUTRACK")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughYouTrackRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughJiraRenderer.Factory());
}
| 403
| 122
| 525
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/SubscriptExtension.java
|
SubscriptExtension
|
extend
|
class SubscriptExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
final public static NullableDataKey<String> SUBSCRIPT_STYLE_HTML_OPEN = StrikethroughSubscriptExtension.SUBSCRIPT_STYLE_HTML_OPEN;
final public static NullableDataKey<String> SUBSCRIPT_STYLE_HTML_CLOSE = StrikethroughSubscriptExtension.SUBSCRIPT_STYLE_HTML_CLOSE;
private SubscriptExtension() {
}
public static SubscriptExtension create() {
return new SubscriptExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customDelimiterProcessor(new SubscriptDelimiterProcessor());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("YOUTRACK")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughYouTrackRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new StrikethroughJiraRenderer.Factory());
}
| 277
| 122
| 399
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/internal/StrikethroughDelimiterProcessor.java
|
StrikethroughDelimiterProcessor
|
process
|
class StrikethroughDelimiterProcessor implements DelimiterProcessor {
@Override
public char getOpeningCharacter() {
return '~';
}
@Override
public char getClosingCharacter() {
return '~';
}
@Override
public int getMinLength() {
return 2;
}
@Override
public boolean canBeOpener(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return leftFlanking;
}
@Override
public boolean canBeCloser(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return rightFlanking;
}
@Override
public Node unmatchedDelimiterNode(InlineParser inlineParser, DelimiterRun delimiter) {
return null;
}
@Override
public boolean skipNonOpenerCloser() {
return false;
}
@Override
public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {
if (opener.length() >= 2 && closer.length() >= 2) {
// Use exactly two delimiters even if we have more, and don't care about internal openers/closers.
return 2;
} else {
return 0;
}
}
@Override
public void process(Delimiter opener, Delimiter closer, int delimitersUsed) {<FILL_FUNCTION_BODY>}
}
|
// wrap nodes between delimiters in strikethrough.
Strikethrough strikethrough = new Strikethrough(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed));
opener.moveNodesBetweenDelimitersTo(strikethrough, closer);
| 439
| 87
| 526
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/internal/StrikethroughJiraRenderer.java
|
StrikethroughJiraRenderer
|
getNodeRenderingHandlers
|
class StrikethroughJiraRenderer implements NodeRenderer {
public StrikethroughJiraRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
private void render(Strikethrough node, NodeRendererContext context, HtmlWriter html) {
html.raw("-");
context.renderChildren(node);
html.raw("-");
}
private void render(Subscript node, NodeRendererContext context, HtmlWriter html) {
html.raw("~");
context.renderChildren(node);
html.raw("~");
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new StrikethroughJiraRenderer(options);
}
}
}
|
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Strikethrough.class, this::render));
set.add(new NodeRenderingHandler<>(Subscript.class, this::render));
return set;
| 227
| 73
| 300
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/internal/StrikethroughNodeRenderer.java
|
StrikethroughNodeRenderer
|
render
|
class StrikethroughNodeRenderer implements NodeRenderer {
final private String strikethroughStyleHtmlOpen;
final private String strikethroughStyleHtmlClose;
final private String subscriptStyleHtmlOpen;
final private String subscriptStyleHtmlClose;
public StrikethroughNodeRenderer(DataHolder options) {
strikethroughStyleHtmlOpen = StrikethroughSubscriptExtension.STRIKETHROUGH_STYLE_HTML_OPEN.get(options);
strikethroughStyleHtmlClose = StrikethroughSubscriptExtension.STRIKETHROUGH_STYLE_HTML_CLOSE.get(options);
subscriptStyleHtmlOpen = StrikethroughSubscriptExtension.SUBSCRIPT_STYLE_HTML_OPEN.get(options);
subscriptStyleHtmlClose = StrikethroughSubscriptExtension.SUBSCRIPT_STYLE_HTML_CLOSE.get(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Strikethrough.class, this::render));
set.add(new NodeRenderingHandler<>(Subscript.class, this::render));
return set;
}
private void render(Strikethrough node, NodeRendererContext context, HtmlWriter html) {
if (strikethroughStyleHtmlOpen == null || strikethroughStyleHtmlClose == null) {
if (context.getHtmlOptions().sourcePositionParagraphLines) {
html.withAttr().tag("del");
} else {
html.srcPos(node.getText()).withAttr().tag("del");
}
context.renderChildren(node);
html.tag("/del");
} else {
html.raw(strikethroughStyleHtmlOpen);
context.renderChildren(node);
html.raw(strikethroughStyleHtmlClose);
}
}
private void render(Subscript node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new StrikethroughNodeRenderer(options);
}
}
}
|
if (subscriptStyleHtmlOpen == null || subscriptStyleHtmlClose == null) {
if (context.getHtmlOptions().sourcePositionParagraphLines) {
html.withAttr().tag("sub");
} else {
html.srcPos(node.getText()).withAttr().tag("sub");
}
context.renderChildren(node);
html.tag("/sub");
} else {
html.raw(subscriptStyleHtmlOpen);
context.renderChildren(node);
html.raw(subscriptStyleHtmlClose);
}
| 579
| 137
| 716
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/internal/StrikethroughSubscriptDelimiterProcessor.java
|
StrikethroughSubscriptDelimiterProcessor
|
process
|
class StrikethroughSubscriptDelimiterProcessor implements DelimiterProcessor {
@Override
public char getOpeningCharacter() {
return '~';
}
@Override
public char getClosingCharacter() {
return '~';
}
@Override
public int getMinLength() {
return 1;
}
@Override
public boolean canBeOpener(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return leftFlanking;
}
@Override
public boolean canBeCloser(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return rightFlanking;
}
@Override
public boolean skipNonOpenerCloser() {
return false;
}
@Override
public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {
// "multiple of 3" rule for internal delimiter runs
if ((opener.canClose() || closer.canOpen()) && (opener.length() + closer.length()) % 3 == 0) {
return 0;
}
// calculate actual number of delimiters used from this closer
if (opener.length() < 3 || closer.length() < 3) {
return closer.length() <= opener.length() ?
closer.length() : opener.length();
} else {
return closer.length() % 2 == 0 ? 2 : 1;
}
}
@Override
public Node unmatchedDelimiterNode(InlineParser inlineParser, DelimiterRun delimiter) {
return null;
}
@Override
public void process(Delimiter opener, Delimiter closer, int delimitersUsed) {<FILL_FUNCTION_BODY>}
}
|
// wrap nodes between delimiters in strikethrough.
DelimitedNode emphasis = delimitersUsed == 1
? new Subscript(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed))
: new Strikethrough(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed));
opener.moveNodesBetweenDelimitersTo(emphasis, closer);
| 521
| 130
| 651
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/internal/StrikethroughYouTrackRenderer.java
|
StrikethroughYouTrackRenderer
|
getNodeRenderingHandlers
|
class StrikethroughYouTrackRenderer implements NodeRenderer {
public StrikethroughYouTrackRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
private void render(Strikethrough node, NodeRendererContext context, HtmlWriter html) {
html.raw("--");
context.renderChildren(node);
html.raw("--");
}
private void render(Subscript node, NodeRendererContext context, HtmlWriter html) {
html.raw("~");
context.renderChildren(node);
html.raw("~");
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new StrikethroughYouTrackRenderer(options);
}
}
}
|
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Strikethrough.class, this::render));
set.add(new NodeRenderingHandler<>(Subscript.class, this::render));
return set;
| 227
| 73
| 300
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-strikethrough/src/main/java/com/vladsch/flexmark/ext/gfm/strikethrough/internal/SubscriptDelimiterProcessor.java
|
SubscriptDelimiterProcessor
|
getDelimiterUse
|
class SubscriptDelimiterProcessor implements DelimiterProcessor {
@Override
public char getOpeningCharacter() {
return '~';
}
@Override
public char getClosingCharacter() {
return '~';
}
@Override
public int getMinLength() {
return 1;
}
@Override
public boolean canBeOpener(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return leftFlanking;
}
@Override
public boolean canBeCloser(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return rightFlanking;
}
@Override
public boolean skipNonOpenerCloser() {
return false;
}
@Override
public Node unmatchedDelimiterNode(InlineParser inlineParser, DelimiterRun delimiter) {
return null;
}
@Override
public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {<FILL_FUNCTION_BODY>}
@Override
public void process(Delimiter opener, Delimiter closer, int delimitersUsed) {
// wrap nodes between delimiters in strikethrough.
Subscript node = new Subscript(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed));
opener.moveNodesBetweenDelimitersTo(node, closer);
}
}
|
if (opener.length() >= 1 && closer.length() >= 1) {
// Use exactly two delimiters even if we have more, and don't care about internal openers/closers.
return 1;
} else {
return 0;
}
| 443
| 71
| 514
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-tasklist/src/main/java/com/vladsch/flexmark/ext/gfm/tasklist/TaskListExtension.java
|
TaskListExtension
|
extend
|
class TaskListExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension, Formatter.FormatterExtension {
final public static Map<Character, Integer> DEFAULT_PRIORITIES = new HashMap<>();
static {
DEFAULT_PRIORITIES.put('+', 1);
DEFAULT_PRIORITIES.put('*', 0);
DEFAULT_PRIORITIES.put('-', -1);
}
final public static DataKey<String> ITEM_DONE_MARKER = new DataKey<>("ITEM_DONE_MARKER", "<input type=\"checkbox\" class=\"task-list-item-checkbox\" checked=\"checked\" disabled=\"disabled\" readonly=\"readonly\" /> ");
final public static DataKey<String> ITEM_NOT_DONE_MARKER = new DataKey<>("ITEM_NOT_DONE_MARKER", "<input type=\"checkbox\" class=\"task-list-item-checkbox\" disabled=\"disabled\" readonly=\"readonly\" /> ");
final public static DataKey<String> TIGHT_ITEM_CLASS = new DataKey<>("TIGHT_ITEM_CLASS", "task-list-item");
final public static DataKey<String> LOOSE_ITEM_CLASS = new DataKey<>("LOOSE_ITEM_CLASS", TIGHT_ITEM_CLASS);
final public static DataKey<String> PARAGRAPH_CLASS = new DataKey<>("PARAGRAPH_CLASS", "");
final public static DataKey<String> ITEM_DONE_CLASS = new DataKey<>("ITEM_DONE_CLASS", "");
final public static DataKey<String> ITEM_NOT_DONE_CLASS = new DataKey<>("ITEM_NOT_DONE_CLASS", "");
// formatting options
final public static DataKey<TaskListItemCase> FORMAT_LIST_ITEM_CASE = new DataKey<>("FORMAT_LIST_ITEM_CASE", TaskListItemCase.AS_IS);
final public static DataKey<TaskListItemPlacement> FORMAT_LIST_ITEM_PLACEMENT = new DataKey<>("FORMAT_LIST_ITEM_PLACEMENT", TaskListItemPlacement.AS_IS);
final public static DataKey<Integer> FORMAT_ORDERED_TASK_ITEM_PRIORITY = new DataKey<>("FORMAT_ORDERED_TASK_ITEM_PRIORITY", 0);
final public static DataKey<Integer> FORMAT_DEFAULT_TASK_ITEM_PRIORITY = new DataKey<>("FORMAT_DEFAULT_TASK_ITEM_PRIORITY", 0);
final public static DataKey<Boolean> FORMAT_PRIORITIZED_TASK_ITEMS = new DataKey<>("FORMAT_PRIORITIZED_TASK_ITEMS", false);
/**
* Priorities corresponding to {@link Parser#LISTS_ITEM_PREFIX_CHARS}
* If shorter than item prefix chars then any missing priorities are set to 0
*/
final public static DataKey<Map<Character, Integer>> FORMAT_TASK_ITEM_PRIORITIES = new DataKey<>("FORMAT_TASK_ITEM_PRIORITIES", DEFAULT_PRIORITIES);
private TaskListExtension() {
}
public static TaskListExtension create() {
return new TaskListExtension();
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(TaskListNodeFormatter::new);
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
ListOptions.addItemMarkerSuffixes(options, "[ ]", "[x]", "[X]");
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.blockPreProcessorFactory(new TaskListItemBlockPreProcessor.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new TaskListNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
| 1,050
| 58
| 1,108
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-tasklist/src/main/java/com/vladsch/flexmark/ext/gfm/tasklist/TaskListItem.java
|
TaskListItem
|
isParagraphWrappingDisabled
|
class TaskListItem extends ListItem {
protected boolean isOrderedItem = false;
protected boolean canChangeMarker = true;
@Override
public void getAstExtra(@NotNull StringBuilder out) {
super.getAstExtra(out);
if (isOrderedItem) out.append(" isOrderedItem");
out.append(isItemDoneMarker() ? " isDone" : " isNotDone");
}
@Override
public boolean isParagraphWrappingDisabled(Paragraph node, ListOptions listOptions, DataHolder options) {<FILL_FUNCTION_BODY>}
public TaskListItem() {
}
public TaskListItem(BasedSequence chars) {
super(chars);
}
public TaskListItem(BasedSequence chars, List<BasedSequence> segments) {
super(chars, segments);
}
public TaskListItem(BlockContent blockContent) {
super(blockContent);
}
public TaskListItem(ListItem block) {
super(block);
isOrderedItem = block instanceof OrderedListItem;
}
@Override
public void setOpeningMarker(BasedSequence openingMarker) {
throw new IllegalStateException();
}
public boolean isItemDoneMarker() {
return !markerSuffix.matches("[ ]");
}
@Override
public boolean isOrderedItem() {
return isOrderedItem;
}
public void setOrderedItem(boolean orderedItem) {
isOrderedItem = orderedItem;
}
@Override
public boolean canChangeMarker() {
return canChangeMarker;
}
public void setCanChangeMarker(boolean canChangeMarker) {
this.canChangeMarker = canChangeMarker;
}
}
|
assert node.getParent() == this;
// see if this is the first paragraph child item we handle our own paragraph wrapping for that one
Node child = getFirstChild();
while (child != null && !(child instanceof Paragraph)) child = child.getNext();
return child == node;
| 446
| 76
| 522
|
<methods>public void <init>() ,public void <init>(com.vladsch.flexmark.ast.ListItem) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, List<com.vladsch.flexmark.util.sequence.BasedSequence>) ,public void <init>(com.vladsch.flexmark.util.ast.BlockContent) ,public boolean canChangeMarker() ,public void getAstExtra(@NotNull StringBuilder) ,public com.vladsch.flexmark.util.ast.Node getLastBlankLineChild() ,public com.vladsch.flexmark.util.sequence.BasedSequence getMarkerSuffix() ,public com.vladsch.flexmark.util.sequence.BasedSequence getOpeningMarker() ,public int getPriority() ,public @NotNull BasedSequence [] getSegments() ,public boolean isContainsBlankLine() ,public boolean isHadBlankAfterItemParagraph() ,public boolean isInTightList() ,public boolean isItemParagraph(com.vladsch.flexmark.ast.Paragraph) ,public boolean isLoose() ,public boolean isOrderedItem() ,public boolean isOwnTight() ,public boolean isParagraphEndWrappingDisabled(com.vladsch.flexmark.ast.Paragraph) ,public boolean isParagraphInTightListItem(com.vladsch.flexmark.ast.Paragraph) ,public boolean isParagraphStartWrappingDisabled(com.vladsch.flexmark.ast.Paragraph) ,public boolean isParagraphWrappingDisabled(com.vladsch.flexmark.ast.Paragraph, com.vladsch.flexmark.parser.ListOptions, com.vladsch.flexmark.util.data.DataHolder) ,public boolean isTight() ,public void setContainsBlankLine(boolean) ,public void setHadBlankAfterItemParagraph(boolean) ,public void setLoose(boolean) ,public void setMarkerSuffix(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setOpeningMarker(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setPriority(int) ,public void setTight(boolean) <variables>private boolean containsBlankLine,private boolean hadBlankAfterItemParagraph,protected com.vladsch.flexmark.util.sequence.BasedSequence markerSuffix,protected com.vladsch.flexmark.util.sequence.BasedSequence openingMarker,private int priority,private boolean tight
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-tasklist/src/main/java/com/vladsch/flexmark/ext/gfm/tasklist/internal/TaskListFormatOptions.java
|
TaskListFormatOptions
|
setIn
|
class TaskListFormatOptions implements MutableDataSetter {
final public TaskListItemCase taskListItemCase;
final public TaskListItemPlacement taskListItemPlacement;
final public int formatOrderedTaskItemPriority;
final public int formatDefaultTaskItemPriority;
final public boolean formatPrioritizedTaskItems;
final public Map<Character, Integer> formatTaskItemPriorities;
public TaskListFormatOptions() {
this(null);
}
public TaskListFormatOptions(DataHolder options) {
taskListItemCase = TaskListExtension.FORMAT_LIST_ITEM_CASE.get(options);
taskListItemPlacement = TaskListExtension.FORMAT_LIST_ITEM_PLACEMENT.get(options);
formatOrderedTaskItemPriority = TaskListExtension.FORMAT_ORDERED_TASK_ITEM_PRIORITY.get(options);
formatDefaultTaskItemPriority = TaskListExtension.FORMAT_DEFAULT_TASK_ITEM_PRIORITY.get(options);
formatTaskItemPriorities = TaskListExtension.FORMAT_TASK_ITEM_PRIORITIES.get(options);
formatPrioritizedTaskItems = TaskListExtension.FORMAT_PRIORITIZED_TASK_ITEMS.get(options);
}
@NotNull
@Override
public MutableDataHolder setIn(@NotNull MutableDataHolder dataHolder) {<FILL_FUNCTION_BODY>}
}
|
dataHolder.set(TaskListExtension.FORMAT_LIST_ITEM_CASE, taskListItemCase);
dataHolder.set(TaskListExtension.FORMAT_LIST_ITEM_PLACEMENT, taskListItemPlacement);
dataHolder.set(TaskListExtension.FORMAT_ORDERED_TASK_ITEM_PRIORITY, formatOrderedTaskItemPriority);
dataHolder.set(TaskListExtension.FORMAT_TASK_ITEM_PRIORITIES, formatTaskItemPriorities);
dataHolder.set(TaskListExtension.FORMAT_PRIORITIZED_TASK_ITEMS, formatPrioritizedTaskItems);
return dataHolder;
| 349
| 162
| 511
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-tasklist/src/main/java/com/vladsch/flexmark/ext/gfm/tasklist/internal/TaskListItemBlockPreProcessor.java
|
TaskListItemBlockPreProcessor
|
preProcess
|
class TaskListItemBlockPreProcessor implements BlockPreProcessor {
public TaskListItemBlockPreProcessor(DataHolder options) {
}
@Override
public void preProcess(ParserState state, Block block) {<FILL_FUNCTION_BODY>}
public static class Factory implements BlockPreProcessorFactory {
@NotNull
@Override
public Set<Class<? extends Block>> getBlockTypes() {
HashSet<Class<? extends Block>> set = new HashSet<>();
set.add(BulletListItem.class);
set.add(OrderedListItem.class);
return set;
}
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@Override
public boolean affectsGlobalScope() {
return true;
}
@NotNull
@Override
public BlockPreProcessor apply(@NotNull ParserState state) {
return new TaskListItemBlockPreProcessor(state.getProperties());
}
}
}
|
if (block instanceof BulletListItem || block instanceof OrderedListItem) {
// we chop up the previous paragraph into definition terms and add the definition item to the last one
// we add all these to the previous DefinitionList or add a new one if there isn't one
final ListItem listItem = (ListItem) block;
final BasedSequence markerSuffix = listItem.getMarkerSuffix();
if (markerSuffix.matches("[ ]") || markerSuffix.matches("[x]") || markerSuffix.matches("[X]")) {
TaskListItem taskListItem = new TaskListItem(listItem);
taskListItem.setTight(listItem.isOwnTight());
listItem.insertBefore(taskListItem);
listItem.unlink();
state.blockAdded(taskListItem);
state.blockRemoved(listItem);
}
}
| 288
| 227
| 515
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-tasklist/src/main/java/com/vladsch/flexmark/ext/gfm/tasklist/internal/TaskListNodeFormatter.java
|
TaskListNodeFormatter
|
render
|
class TaskListNodeFormatter implements NodeFormatter {
final private TaskListFormatOptions taskListFormatOptions;
final private ListOptions listOptions;
public TaskListNodeFormatter(DataHolder options) {
taskListFormatOptions = new TaskListFormatOptions(options);
listOptions = ListOptions.get(options);
}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeFormattingHandler<>(TaskListItem.class, TaskListNodeFormatter.this::render),
new NodeFormattingHandler<>(BulletList.class, TaskListNodeFormatter.this::render),
new NodeFormattingHandler<>(OrderedList.class, TaskListNodeFormatter.this::render)
));
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
return null;
}
private void render(TaskListItem node, NodeFormatterContext context, MarkdownWriter markdown) {<FILL_FUNCTION_BODY>}
private void render(BulletList node, NodeFormatterContext context, MarkdownWriter markdown) {
renderList(node, context, markdown);
}
private void render(OrderedList node, NodeFormatterContext context, MarkdownWriter markdown) {
renderList(node, context, markdown);
}
public static boolean hasIncompleteDescendants(Node node) {
Node item = node.getFirstChild();
while (item != null) {
if (item instanceof TaskListItem) {
if (!((TaskListItem) item).isItemDoneMarker()) {
return true;
}
}
if (item instanceof Block && !(item instanceof Paragraph) && hasIncompleteDescendants(item)) {
return true;
}
item = item.getNext();
}
return false;
}
public int taskItemPriority(Node node) {
if (node instanceof TaskListItem) {
if (((TaskListItem) node).isOrderedItem()) {
return taskListFormatOptions.formatOrderedTaskItemPriority;
} else {
BasedSequence openingMarker = ((ListItem) node).getOpeningMarker();
if (openingMarker.length() > 0) {
Integer priority = taskListFormatOptions.formatTaskItemPriorities.get(openingMarker.charAt(0));
if (priority != null) {
return priority;
} else {
return taskListFormatOptions.formatDefaultTaskItemPriority;
}
}
}
}
return Integer.MIN_VALUE;
}
public int itemPriority(Node node) {
Node item = node.getFirstChild();
int priority = Integer.MIN_VALUE;
if (node instanceof TaskListItem) {
if (!((TaskListItem) node).isItemDoneMarker()) {
priority = Math.max(priority, taskItemPriority(node));
}
}
while (item != null) {
if (item instanceof TaskListItem) {
if (!((TaskListItem) item).isItemDoneMarker()) {
priority = Math.max(priority, taskItemPriority(item));
}
}
if (item instanceof Block && !(item instanceof Paragraph)) {
priority = Math.max(priority, itemPriority(item));
}
item = item.getNext();
}
return priority;
}
public void renderList(
ListBlock node,
NodeFormatterContext context,
MarkdownWriter markdown
) {
if (context.isTransformingText()) {
context.renderChildren(node);
} else {
ArrayList<Node> itemList = new ArrayList<>();
TaskListItemPlacement taskListItemPlacement = taskListFormatOptions.taskListItemPlacement;
if (taskListItemPlacement != TaskListItemPlacement.AS_IS) {
ArrayList<ListItem> incompleteTasks = new ArrayList<>();
ArrayList<ListItem> completeItems = new ArrayList<>();
boolean incompleteDescendants = taskListItemPlacement == TaskListItemPlacement.INCOMPLETE_NESTED_FIRST || taskListItemPlacement == TaskListItemPlacement.COMPLETE_NESTED_TO_NON_TASK;
Node item = node.getFirstChild();
while (item != null) {
if (item instanceof TaskListItem) {
TaskListItem taskItem = (TaskListItem) item;
if (!taskItem.isItemDoneMarker() || (incompleteDescendants && hasIncompleteDescendants(item))) {
incompleteTasks.add((ListItem) item);
} else {
completeItems.add((ListItem) item);
}
} else if (item instanceof ListItem) {
if (incompleteDescendants && hasIncompleteDescendants(item)) {
incompleteTasks.add((ListItem) item);
} else {
completeItems.add((ListItem) item);
}
}
item = item.getNext();
}
if (taskListFormatOptions.formatPrioritizedTaskItems) {
// have prioritized tasks
for (ListItem listItem : incompleteTasks) {
listItem.setPriority(itemPriority(listItem));
}
incompleteTasks.sort((o1, o2) -> Integer.compare(o2.getPriority(), o1.getPriority()));
itemList.addAll(incompleteTasks);
} else {
itemList.addAll(incompleteTasks);
}
itemList.addAll(completeItems);
} else {
Node item = node.getFirstChild();
while (item != null) {
itemList.add(item);
item = item.getNext();
}
}
FormatterUtils.renderList(node, context, markdown, itemList);
}
}
}
|
if (context.isTransformingText()) {
FormatterUtils.renderListItem(node, context, markdown, listOptions, node.getMarkerSuffix(), false);
} else {
BasedSequence markerSuffix = node.getMarkerSuffix();
switch (taskListFormatOptions.taskListItemCase) {
case AS_IS:
break;
case LOWERCASE:
markerSuffix = markerSuffix.toLowerCase();
break;
case UPPERCASE:
markerSuffix = markerSuffix.toUpperCase();
break;
default:
throw new IllegalStateException("Missing case for TaskListItemCase " + taskListFormatOptions.taskListItemCase.name());
}
if (node.isItemDoneMarker()) {
switch (taskListFormatOptions.taskListItemPlacement) {
case AS_IS:
case INCOMPLETE_FIRST:
case INCOMPLETE_NESTED_FIRST:
break;
case COMPLETE_TO_NON_TASK:
case COMPLETE_NESTED_TO_NON_TASK:
markerSuffix = markerSuffix.getEmptySuffix();
break;
default:
throw new IllegalStateException("Missing case for ListItemPlacement " + taskListFormatOptions.taskListItemPlacement.name());
}
}
if (markerSuffix.isNotEmpty() && taskListFormatOptions.formatPrioritizedTaskItems) {
node.setCanChangeMarker(false);
}
// task list item node overrides isParagraphWrappingDisabled which affects empty list item blank line rendering
boolean forceLooseItem = node.isLoose() && (node.hasChildren() && node.getFirstChildAnyNot(BlankLine.class) != null);
FormatterUtils.renderListItem(node, context, markdown, listOptions, markerSuffix.isEmpty() ? markerSuffix
: markerSuffix.getBuilder().append(markerSuffix).append(" ").append(markerSuffix.baseSubSequence(markerSuffix.getEndOffset() + 1, markerSuffix.getEndOffset() + 1)).toSequence(), forceLooseItem);
}
| 1,473
| 564
| 2,037
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-tasklist/src/main/java/com/vladsch/flexmark/ext/gfm/tasklist/internal/TaskListNodeRenderer.java
|
TaskListNodeRenderer
|
render
|
class TaskListNodeRenderer implements NodeRenderer {
final public static AttributablePart TASK_ITEM_PARAGRAPH = new AttributablePart("TASK_ITEM_PARAGRAPH");
final String doneMarker;
final String notDoneMarker;
final private String tightItemClass;
final private String looseItemClass;
final private String itemDoneClass;
final private String itemNotDoneClass;
final String paragraphClass;
final private ListOptions listOptions;
public TaskListNodeRenderer(DataHolder options) {
doneMarker = TaskListExtension.ITEM_DONE_MARKER.get(options);
notDoneMarker = TaskListExtension.ITEM_NOT_DONE_MARKER.get(options);
tightItemClass = TaskListExtension.TIGHT_ITEM_CLASS.get(options);
looseItemClass = TaskListExtension.LOOSE_ITEM_CLASS.get(options);
itemDoneClass = TaskListExtension.ITEM_DONE_CLASS.get(options);
itemNotDoneClass = TaskListExtension.ITEM_NOT_DONE_CLASS.get(options);
paragraphClass = TaskListExtension.PARAGRAPH_CLASS.get(options);
listOptions = ListOptions.get(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(TaskListItem.class, TaskListNodeRenderer.this::render));
return set;
}
void render(TaskListItem node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new TaskListNodeRenderer(options);
}
}
}
|
BasedSequence sourceText = context.getHtmlOptions().sourcePositionParagraphLines || node.getFirstChild() == null ? node.getChars() : node.getFirstChild().getChars();
String itemDoneStatusClass = node.isItemDoneMarker() ? itemDoneClass : itemNotDoneClass;
if (listOptions.isTightListItem(node)) {
if (!tightItemClass.isEmpty()) html.attr("class", tightItemClass);
if (!itemDoneStatusClass.isEmpty() && !itemDoneStatusClass.equals(tightItemClass)) html.attr("class", itemDoneStatusClass);
html.srcPos(sourceText.getStartOffset(), sourceText.getEndOffset()).withAttr(CoreNodeRenderer.TIGHT_LIST_ITEM).withCondIndent().tagLine("li", () -> {
html.raw(node.isItemDoneMarker() ? doneMarker : notDoneMarker);
context.renderChildren(node);
});
} else {
if (!looseItemClass.isEmpty()) html.attr("class", looseItemClass);
if (!itemDoneStatusClass.isEmpty() && !itemDoneStatusClass.equals(looseItemClass)) html.attr("class", itemDoneStatusClass);
html.withAttr(CoreNodeRenderer.LOOSE_LIST_ITEM).tagIndent("li", () -> {
if (!paragraphClass.isEmpty()) html.attr("class", paragraphClass);
html.srcPos(sourceText.getStartOffset(), sourceText.getEndOffset()).withAttr(TASK_ITEM_PARAGRAPH).tagLine("p", () -> {
html.raw(node.isItemDoneMarker() ? doneMarker : notDoneMarker);
context.renderChildren(node);
});
});
}
| 475
| 424
| 899
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-users/src/main/java/com/vladsch/flexmark/ext/gfm/users/GfmUsersExtension.java
|
GfmUsersExtension
|
extend
|
class GfmUsersExtension implements Parser.ParserExtension
, HtmlRenderer.HtmlRendererExtension
{
final public static DataKey<String> GIT_HUB_USERS_URL_ROOT = new DataKey<>("GIT_HUB_USERS_URL_ROOT", "https://github.com");
final public static DataKey<String> GIT_HUB_USER_URL_PREFIX = new DataKey<>("GIT_HUB_USER_URL_PREFIX", "/");
final public static DataKey<String> GIT_HUB_USER_URL_SUFFIX = new DataKey<>("GIT_HUB_USER_URL_SUFFIX", "");
final public static DataKey<String> GIT_HUB_USER_HTML_PREFIX = new DataKey<>("GIT_HUB_USER_HTML_PREFIX", "<strong>");
final public static DataKey<String> GIT_HUB_USER_HTML_SUFFIX = new DataKey<>("GIT_HUB_USER_HTML_SUFFIX", "</strong>");
private GfmUsersExtension() {
}
public static GfmUsersExtension create() {
return new GfmUsersExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customInlineParserExtensionFactory(new GfmUsersInlineParserExtension.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new GfmUsersNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new GfmUsersJiraRenderer.Factory());
}
| 429
| 79
| 508
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-users/src/main/java/com/vladsch/flexmark/ext/gfm/users/internal/GfmUsersInlineParserExtension.java
|
GfmUsersInlineParserExtension
|
parse
|
class GfmUsersInlineParserExtension implements InlineParserExtension {
final public static Pattern GITHUB_USER = Pattern.compile("^(@)([a-z\\d](?:[a-z\\d]|-(?=[a-z\\d])){0,38})\\b", Pattern.CASE_INSENSITIVE);
public GfmUsersInlineParserExtension(LightInlineParser inlineParser) {
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "@";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser lightInlineParser) {
return new GfmUsersInlineParserExtension(lightInlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
int index = inlineParser.getIndex();
boolean isPossible = index == 0;
if (!isPossible) {
char c = inlineParser.getInput().charAt(index - 1);
if (!Character.isUnicodeIdentifierPart(c) && c != '-' && c != '.') {
isPossible = true;
}
}
if (isPossible) {
BasedSequence[] matches = inlineParser.matchWithGroups(GITHUB_USER);
if (matches != null) {
inlineParser.flushTextNode();
BasedSequence openMarker = matches[1];
BasedSequence text = matches[2];
GfmUser gitHubIssue = new GfmUser(openMarker, text);
inlineParser.getBlock().appendChild(gitHubIssue);
return true;
}
}
return false;
| 369
| 218
| 587
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-users/src/main/java/com/vladsch/flexmark/ext/gfm/users/internal/GfmUsersJiraRenderer.java
|
GfmUsersJiraRenderer
|
render
|
class GfmUsersJiraRenderer implements NodeRenderer {
final private GfmUsersOptions options;
public GfmUsersJiraRenderer(DataHolder options) {
this.options = new GfmUsersOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
return new HashSet<>(Collections.singletonList(
new NodeRenderingHandler<>(GfmUser.class, this::render)
));
}
private void render(GfmUser node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new GfmUsersJiraRenderer(options);
}
}
}
|
if (context.isDoNotRenderLinks()) {
html.raw(node.getChars());
} else {
StringBuilder sb = new StringBuilder();
sb.append(options.gitHubIssuesUrlRoot).append(options.gitHubIssueUrlPrefix).append(node.getText()).append(options.gitHubIssueUrlSuffix);
html.raw("[");
html.raw(node.getChars());
html.raw("|").raw(sb.toString()).raw("]");
}
| 209
| 132
| 341
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-users/src/main/java/com/vladsch/flexmark/ext/gfm/users/internal/GfmUsersNodeRenderer.java
|
GfmUsersNodeRenderer
|
render
|
class GfmUsersNodeRenderer implements NodeRenderer
// , PhasedNodeRenderer
{
final private GfmUsersOptions options;
public GfmUsersNodeRenderer(DataHolder options) {
this.options = new GfmUsersOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
Set<NodeRenderingHandler<?>> set = new HashSet<>();
// @formatter:off
set.add(new NodeRenderingHandler<>(GfmUser.class, GfmUsersNodeRenderer.this::render));
// @formatter:on
return set;
}
private void render(GfmUser node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new GfmUsersNodeRenderer(options);
}
}
}
|
if (context.isDoNotRenderLinks()) {
html.text(node.getChars());
} else {
StringBuilder sb = new StringBuilder();
sb.append(options.gitHubIssuesUrlRoot).append(options.gitHubIssueUrlPrefix).append(node.getText()).append(options.gitHubIssueUrlSuffix);
html.srcPos(node.getChars()).attr("href", sb.toString()).withAttr().tag("a");
html.raw(options.gitHubUserTextPrefix);
html.text(node.getChars());
html.raw(options.gitHubUserTextSuffix);
html.tag("/a");
}
| 246
| 172
| 418
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gfm-users/src/main/java/com/vladsch/flexmark/ext/gfm/users/internal/GfmUsersOptions.java
|
GfmUsersOptions
|
setIn
|
class GfmUsersOptions implements MutableDataSetter {
final public String gitHubIssuesUrlRoot;
final public String gitHubIssueUrlPrefix;
final public String gitHubIssueUrlSuffix;
final public String gitHubUserTextPrefix;
final public String gitHubUserTextSuffix;
public GfmUsersOptions(DataHolder options) {
gitHubIssuesUrlRoot = GfmUsersExtension.GIT_HUB_USERS_URL_ROOT.get(options);
gitHubIssueUrlPrefix = GfmUsersExtension.GIT_HUB_USER_URL_PREFIX.get(options);
gitHubIssueUrlSuffix = GfmUsersExtension.GIT_HUB_USER_URL_SUFFIX.get(options);
gitHubUserTextPrefix = GfmUsersExtension.GIT_HUB_USER_HTML_PREFIX.get(options);
gitHubUserTextSuffix = GfmUsersExtension.GIT_HUB_USER_HTML_SUFFIX.get(options);
}
@NotNull
@Override
public MutableDataHolder setIn(@NotNull MutableDataHolder dataHolder) {<FILL_FUNCTION_BODY>}
}
|
dataHolder.set(GfmUsersExtension.GIT_HUB_USERS_URL_ROOT, gitHubIssuesUrlRoot);
dataHolder.set(GfmUsersExtension.GIT_HUB_USER_URL_PREFIX, gitHubIssueUrlPrefix);
dataHolder.set(GfmUsersExtension.GIT_HUB_USER_URL_SUFFIX, gitHubIssueUrlSuffix);
dataHolder.set(GfmUsersExtension.GIT_HUB_USER_HTML_PREFIX, gitHubUserTextPrefix);
dataHolder.set(GfmUsersExtension.GIT_HUB_USER_HTML_SUFFIX, gitHubUserTextSuffix);
return dataHolder;
| 294
| 174
| 468
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/GitLabBlockQuote.java
|
GitLabBlockQuote
|
getAstExtra
|
class GitLabBlockQuote extends Block implements ParagraphContainer {
private BasedSequence openingMarker = BasedSequence.NULL;
private BasedSequence openingTrailing = BasedSequence.NULL;
private BasedSequence closingMarker = BasedSequence.NULL;
private BasedSequence closingTrailing = BasedSequence.NULL;
@Override
public void getAstExtra(@NotNull StringBuilder out) {<FILL_FUNCTION_BODY>}
@NotNull
@Override
public BasedSequence[] getSegments() {
return new BasedSequence[] { openingMarker, openingTrailing, closingMarker, closingTrailing };
}
@Override
public boolean isParagraphEndWrappingDisabled(Paragraph node) {
return node == getLastChild() || node.getNext() instanceof GitLabBlockQuote;
}
@Override
public boolean isParagraphStartWrappingDisabled(Paragraph node) {
return node == getFirstChild() || node.getPrevious() instanceof GitLabBlockQuote;
}
public GitLabBlockQuote() {
}
public GitLabBlockQuote(BasedSequence chars) {
super(chars);
}
public GitLabBlockQuote(BasedSequence chars, List<BasedSequence> segments) {
super(chars, segments);
}
public GitLabBlockQuote(BlockContent blockContent) {
super(blockContent);
}
public BasedSequence getOpeningMarker() {
return openingMarker;
}
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
public BasedSequence getClosingMarker() {
return closingMarker;
}
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
public BasedSequence getOpeningTrailing() {
return openingTrailing;
}
public void setOpeningTrailing(BasedSequence openingTrailing) {
this.openingTrailing = openingTrailing;
}
public BasedSequence getClosingTrailing() {
return closingTrailing;
}
public void setClosingTrailing(BasedSequence closingTrailing) {
this.closingTrailing = closingTrailing;
}
}
|
segmentSpanChars(out, openingMarker, "open");
segmentSpanChars(out, openingTrailing, "openTrail");
segmentSpanChars(out, closingMarker, "close");
segmentSpanChars(out, closingTrailing, "closeTrail");
| 559
| 69
| 628
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void <init>(@NotNull BasedSequence, @NotNull List<BasedSequence>) ,public void <init>(@NotNull List<BasedSequence>) ,public void <init>(com.vladsch.flexmark.util.ast.BlockContent) ,public @Nullable Block getParent() <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/GitLabExtension.java
|
GitLabExtension
|
extend
|
class GitLabExtension implements Parser.ParserExtension
, HtmlRenderer.HtmlRendererExtension
, Formatter.FormatterExtension
// , Parser.ReferenceHoldingExtension
{
final private static String[] DEFAULT_MATH_LANGUAGES = {"math"};
final private static String[] DEFAULT_MERMAID_LANGUAGES = {"mermaid"};
final public static DataKey<Boolean> INS_PARSER = new DataKey<>("INS_PARSER", true);
final public static DataKey<Boolean> DEL_PARSER = new DataKey<>("DEL_PARSER", true);
final public static DataKey<Boolean> BLOCK_QUOTE_PARSER = new DataKey<>("BLOCK_QUOTE_PARSER", true);
final public static DataKey<Boolean> NESTED_BLOCK_QUOTES = new DataKey<>("NESTED_BLOCK_QUOTES", true);
final public static DataKey<Boolean> INLINE_MATH_PARSER = new DataKey<>("INLINE_MATH_PARSER", true);
final public static DataKey<Boolean> RENDER_BLOCK_MATH = new DataKey<>("RENDER_BLOCK_MATH", true);
final public static DataKey<Boolean> RENDER_BLOCK_MERMAID = new DataKey<>("RENDER_BLOCK_MERMAID", true);
final public static DataKey<Boolean> RENDER_VIDEO_IMAGES = new DataKey<>("RENDER_VIDEO_IMAGES", true);
final public static DataKey<Boolean> RENDER_VIDEO_LINK = new DataKey<>("RENDER_VIDEO_LINK", true);
final public static DataKey<String[]> MATH_LANGUAGES = new DataKey<>("MATH_LANGUAGES", DEFAULT_MATH_LANGUAGES);
final public static DataKey<String[]> MERMAID_LANGUAGES = new DataKey<>("MERMAID_LANGUAGES", DEFAULT_MERMAID_LANGUAGES);
final public static DataKey<String> INLINE_MATH_CLASS = new DataKey<>("INLINE_MATH_CLASS", "katex");
final public static DataKey<String> BLOCK_MATH_CLASS = new DataKey<>("BLOCK_MATH_CLASS", "katex");
final public static DataKey<String> BLOCK_MERMAID_CLASS = new DataKey<>("BLOCK_MERMAID_CLASS", "mermaid");
final public static DataKey<String> VIDEO_IMAGE_CLASS = new DataKey<>("VIDEO_IMAGE_CLASS", "video-container");
final public static DataKey<String> VIDEO_IMAGE_LINK_TEXT_FORMAT = new DataKey<>("VIDEO_IMAGE_LINK_TEXT_FORMAT", "Download '%s'");
/**
* @deprecated use {@link HtmlRenderer#FENCED_CODE_LANGUAGE_DELIMITERS} instead
*/
@Deprecated
final public static DataKey<String> BLOCK_INFO_DELIMITERS = HtmlRenderer.FENCED_CODE_LANGUAGE_DELIMITERS;
final public static DataKey<String> VIDEO_IMAGE_EXTENSIONS = new DataKey<>("VIDEO_IMAGE_EXTENSIONS", "mp4,m4v,mov,webm,ogv");
private GitLabExtension() {
}
public static GitLabExtension create() {
return new GitLabExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new GitLabNodeFormatter.Factory());
}
@Override
public void extend(Parser.Builder parserBuilder) {<FILL_FUNCTION_BODY>}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new GitLabNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
//rendererBuilder.nodeRendererFactory(new GitLabJiraRenderer.Factory());
}
}
}
|
GitLabOptions options = new GitLabOptions(parserBuilder);
if (options.blockQuoteParser) {
parserBuilder.customBlockParserFactory(new GitLabBlockQuoteParser.Factory());
}
if (options.delParser || options.insParser) {
parserBuilder.customInlineParserExtensionFactory(new GitLabInlineParser.Factory());
}
if (options.inlineMathParser) {
parserBuilder.customInlineParserExtensionFactory(new GitLabInlineMathParser.Factory());
}
| 1,113
| 130
| 1,243
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/GitLabVisitorExt.java
|
GitLabVisitorExt
|
VISIT_HANDLERS
|
class GitLabVisitorExt {
public static <V extends GitLabVisitor> VisitHandler<?>[] VISIT_HANDLERS(V visitor) {<FILL_FUNCTION_BODY>}
}
|
return new VisitHandler<?>[] {
new VisitHandler<>(GitLabIns.class, visitor::visit),
new VisitHandler<>(GitLabDel.class, visitor::visit),
new VisitHandler<>(GitLabInlineMath.class, visitor::visit),
new VisitHandler<>(GitLabBlockQuote.class, visitor::visit),
};
| 53
| 97
| 150
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/internal/GitLabBlockQuoteParser.java
|
BlockFactory
|
haveBlockQuoteParser
|
class BlockFactory extends AbstractBlockParserFactory {
final private GitLabOptions options;
BlockFactory(DataHolder options) {
super(options);
this.options = new GitLabOptions(options);
}
boolean haveBlockQuoteParser(ParserState state) {<FILL_FUNCTION_BODY>}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {
if (options.nestedBlockQuotes || !haveBlockQuoteParser(state)) {
BasedSequence line = state.getLineWithEOL();
Matcher matcher = GIT_LAB_BLOCK_START.matcher(line);
if (matcher.matches()) {
return BlockStart.of(new GitLabBlockQuoteParser(state.getProperties(), line.subSequence(0, 3), line.subSequence(matcher.start(1), matcher.end(1))))
.atIndex(state.getLineEndIndex())
//.replaceActiveBlockParser()
;
}
}
return BlockStart.none();
}
}
|
List<BlockParser> parsers = state.getActiveBlockParsers();
int i = parsers.size();
while (i-- > 0) {
if (parsers.get(i) instanceof GitLabBlockQuoteParser) return true;
}
return false;
| 271
| 75
| 346
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/internal/GitLabInlineMathParser.java
|
GitLabInlineMathParser
|
parse
|
class GitLabInlineMathParser implements InlineParserExtension {
Pattern MATH_PATTERN = Pattern.compile("\\$`((?:.|\n)*?)`\\$");
public GitLabInlineMathParser(LightInlineParser inlineParser) {
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "$";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser lightInlineParser) {
return new GitLabInlineMathParser(lightInlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
if (inlineParser.peek(1) == '`') {
BasedSequence input = inlineParser.getInput();
Matcher matcher = inlineParser.matcher(MATH_PATTERN);
if (matcher != null) {
inlineParser.flushTextNode();
BasedSequence mathOpen = input.subSequence(matcher.start(), matcher.start(1));
BasedSequence mathClosed = input.subSequence(matcher.end(1), matcher.end());
GitLabInlineMath inlineMath = new GitLabInlineMath(mathOpen, mathOpen.baseSubSequence(mathOpen.getEndOffset(), mathClosed.getStartOffset()), mathClosed);
inlineParser.getBlock().appendChild(inlineMath);
return true;
}
}
return false;
| 329
| 198
| 527
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/internal/GitLabInlineParser.java
|
GitLabInlineParser
|
parse
|
class GitLabInlineParser implements InlineParserExtension {
final private List<GitLabInline> openInlines;
final private GitLabOptions options;
public GitLabInlineParser(LightInlineParser inlineParser) {
openInlines = new ArrayList<>();
options = new GitLabOptions(inlineParser.getDocument());
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
// convert any unclosed ones to text
for (int j = openInlines.size(); j-- > 0; ) {
GitLabInline gitLabInline = openInlines.get(j);
Text textNode = new Text(gitLabInline.getChars());
gitLabInline.insertBefore(textNode);
gitLabInline.unlink();
}
openInlines.clear();
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "{[-+";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser lightInlineParser) {
return new GitLabInlineParser(lightInlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
char firstChar = inlineParser.peek();
char secondChar = inlineParser.peek(1);
if ((firstChar == '{' || firstChar == '[') && (options.insParser && secondChar == '+' || options.delParser && secondChar == '-')) {
// possible open, if matched close
BasedSequence input = inlineParser.getInput().subSequence(inlineParser.getIndex());
GitLabInline open = secondChar == '+' ? new GitLabIns(input.subSequence(0, 2)) : new GitLabDel(input.subSequence(0, 2));
inlineParser.flushTextNode();
inlineParser.getBlock().appendChild(open);
openInlines.add(open);
inlineParser.setIndex(inlineParser.getIndex() + 2);
return true;
}
if (((options.insParser && firstChar == '+' || options.delParser && firstChar == '-')) && (secondChar == ']' || secondChar == '}')) {
// possible closed, if matches open
BasedSequence input = inlineParser.getInput().subSequence(inlineParser.getIndex());
CharSequence charSequence = secondChar == ']' ? (firstChar == '+' ? "[+" : "[-") : (firstChar == '+' ? "{+" : "{-");
BasedSequence matchOpen = BasedSequence.of(charSequence);
for (int i = openInlines.size(); i-- > 0; ) {
GitLabInline open = openInlines.get(i);
BasedSequence openMarker = open.getChars();
if (openMarker.equals(matchOpen)) {
// this one is now closed, we remove all intervening ones since they did not match
inlineParser.setIndex(inlineParser.getIndex() + 2);
BasedSequence closingMarker = input.subSequence(0, 2);
open.setOpeningMarker(openMarker);
open.setClosingMarker(closingMarker);
open.setText(openMarker.baseSubSequence(openMarker.getEndOffset(), closingMarker.getStartOffset()));
inlineParser.flushTextNode();
Node last = inlineParser.getBlock().getLastChild();
inlineParser.moveNodes(open, last);
//open.appendChild(textNode);
//inlineParser.getBlock().appendChild(open);
if (i == 0) {
openInlines.clear();
} else {
openInlines.subList(i, openInlines.size()).clear();
}
return true;
}
}
}
return false;
| 448
| 635
| 1,083
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-gitlab/src/main/java/com/vladsch/flexmark/ext/gitlab/internal/GitLabOptions.java
|
GitLabOptions
|
setIn
|
class GitLabOptions implements MutableDataSetter {
final public boolean insParser;
final public boolean delParser;
final public boolean inlineMathParser;
final public boolean blockQuoteParser;
final public boolean nestedBlockQuotes;
final public boolean renderBlockMath;
final public boolean renderBlockMermaid;
final public boolean renderVideoImages;
final public boolean renderVideoLink;
final public String inlineMathClass;
final public String blockMathClass;
final public String blockMermaidClass;
final public String[] mathLanguages;
final public String[] mermaidLanguages;
final public String videoImageClass;
final public String videoImageLinkTextFormat;
final public String videoImageExtensions;
final public HashSet<String> videoImageExtensionSet;
/**
* @deprecated use {@link com.vladsch.flexmark.html.HtmlRendererOptions#languageDelimiters} instead
*/
@Deprecated
final public String blockInfoDelimiters;
/**
* @deprecated use {@link com.vladsch.flexmark.html.HtmlRendererOptions#languageDelimiterSet} instead
*/
@Deprecated
final public CharPredicate blockInfoDelimiterSet;
public GitLabOptions(DataHolder options) {
insParser = GitLabExtension.INS_PARSER.get(options);
delParser = GitLabExtension.DEL_PARSER.get(options);
inlineMathParser = GitLabExtension.INLINE_MATH_PARSER.get(options);
blockQuoteParser = GitLabExtension.BLOCK_QUOTE_PARSER.get(options);
nestedBlockQuotes = GitLabExtension.NESTED_BLOCK_QUOTES.get(options);
inlineMathClass = GitLabExtension.INLINE_MATH_CLASS.get(options);
renderBlockMath = GitLabExtension.RENDER_BLOCK_MATH.get(options);
renderBlockMermaid = GitLabExtension.RENDER_BLOCK_MERMAID.get(options);
renderVideoImages = GitLabExtension.RENDER_VIDEO_IMAGES.get(options);
renderVideoLink = GitLabExtension.RENDER_VIDEO_LINK.get(options);
blockMathClass = GitLabExtension.BLOCK_MATH_CLASS.get(options);
blockMermaidClass = GitLabExtension.BLOCK_MERMAID_CLASS.get(options);
blockInfoDelimiters = HtmlRenderer.FENCED_CODE_LANGUAGE_DELIMITERS.get(options);
blockInfoDelimiterSet = CharPredicate.anyOf(blockInfoDelimiters);
mathLanguages = GitLabExtension.MATH_LANGUAGES.get(options);
mermaidLanguages = GitLabExtension.MERMAID_LANGUAGES.get(options);
videoImageClass = GitLabExtension.VIDEO_IMAGE_CLASS.get(options);
videoImageLinkTextFormat = GitLabExtension.VIDEO_IMAGE_LINK_TEXT_FORMAT.get(options);
videoImageExtensions = GitLabExtension.VIDEO_IMAGE_EXTENSIONS.get(options);
videoImageExtensionSet = new HashSet<>();
String[] extensions = videoImageExtensions.split(",");
for (String ext : extensions) {
String trimmed = ext.trim();
if (!trimmed.isEmpty()) {
videoImageExtensionSet.add(trimmed);
}
}
}
@NotNull
@Override
public MutableDataHolder setIn(@NotNull MutableDataHolder dataHolder) {<FILL_FUNCTION_BODY>}
}
|
dataHolder.set(GitLabExtension.INS_PARSER, insParser);
dataHolder.set(GitLabExtension.DEL_PARSER, delParser);
dataHolder.set(GitLabExtension.INLINE_MATH_PARSER, inlineMathParser);
dataHolder.set(GitLabExtension.BLOCK_QUOTE_PARSER, blockQuoteParser);
dataHolder.set(GitLabExtension.NESTED_BLOCK_QUOTES, nestedBlockQuotes);
dataHolder.set(GitLabExtension.INLINE_MATH_CLASS, inlineMathClass);
dataHolder.set(GitLabExtension.RENDER_BLOCK_MATH, renderBlockMath);
dataHolder.set(GitLabExtension.RENDER_BLOCK_MERMAID, renderBlockMermaid);
dataHolder.set(GitLabExtension.RENDER_VIDEO_IMAGES, renderVideoImages);
dataHolder.set(GitLabExtension.RENDER_VIDEO_LINK, renderVideoLink);
dataHolder.set(GitLabExtension.BLOCK_MATH_CLASS, blockMathClass);
dataHolder.set(GitLabExtension.BLOCK_MERMAID_CLASS, blockMermaidClass);
dataHolder.set(HtmlRenderer.FENCED_CODE_LANGUAGE_DELIMITERS, blockInfoDelimiters);
dataHolder.set(GitLabExtension.VIDEO_IMAGE_CLASS, videoImageClass);
dataHolder.set(GitLabExtension.VIDEO_IMAGE_LINK_TEXT_FORMAT, videoImageLinkTextFormat);
dataHolder.set(GitLabExtension.VIDEO_IMAGE_EXTENSIONS, videoImageExtensions);
return dataHolder;
| 895
| 433
| 1,328
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-ins/src/main/java/com/vladsch/flexmark/ext/ins/InsExtension.java
|
InsExtension
|
extend
|
class InsExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
final public static NullableDataKey<String> INS_STYLE_HTML_OPEN = new NullableDataKey<>("INS_STYLE_HTML_OPEN");
final public static NullableDataKey<String> INS_STYLE_HTML_CLOSE = new NullableDataKey<>("INS_STYLE_HTML_CLOSE");
private InsExtension() {
}
public static InsExtension create() {
return new InsExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customDelimiterProcessor(new InsDelimiterProcessor());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new InsNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new InsJiraRenderer.Factory());
}
| 264
| 75
| 339
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-ins/src/main/java/com/vladsch/flexmark/ext/ins/internal/InsDelimiterProcessor.java
|
InsDelimiterProcessor
|
process
|
class InsDelimiterProcessor implements DelimiterProcessor {
@Override
public char getOpeningCharacter() {
return '+';
}
@Override
public char getClosingCharacter() {
return '+';
}
@Override
public int getMinLength() {
return 2;
}
@Override
public boolean canBeOpener(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return leftFlanking;
}
@Override
public boolean canBeCloser(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return rightFlanking;
}
@Override
public boolean skipNonOpenerCloser() {
return false;
}
@Override
public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {
if (opener.length() >= 2 && closer.length() >= 2) {
return 2;
} else {
return 0;
}
}
@Override
public Node unmatchedDelimiterNode(InlineParser inlineParser, DelimiterRun delimiter) {
return null;
}
@Override
public void process(Delimiter opener, Delimiter closer, int delimitersUsed) {<FILL_FUNCTION_BODY>}
}
|
// Normal case, wrap nodes between delimiters in strikethrough.
Ins ins = new Ins(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed));
opener.moveNodesBetweenDelimitersTo(ins, closer);
| 408
| 78
| 486
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-ins/src/main/java/com/vladsch/flexmark/ext/ins/internal/InsJiraRenderer.java
|
InsJiraRenderer
|
getNodeRenderingHandlers
|
class InsJiraRenderer implements NodeRenderer {
public InsJiraRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
private void render(Ins node, NodeRendererContext context, HtmlWriter html) {
html.raw("+");
context.renderChildren(node);
html.raw("+");
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new InsJiraRenderer(options);
}
}
}
|
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Ins.class, this::render));
return set;
| 165
| 48
| 213
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-ins/src/main/java/com/vladsch/flexmark/ext/ins/internal/InsNodeRenderer.java
|
InsNodeRenderer
|
render
|
class InsNodeRenderer implements NodeRenderer {
final private String insStyleHtmlOpen;
final private String insStyleHtmlClose;
public InsNodeRenderer(DataHolder options) {
insStyleHtmlOpen = InsExtension.INS_STYLE_HTML_OPEN.get(options);
insStyleHtmlClose = InsExtension.INS_STYLE_HTML_CLOSE.get(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Ins.class, InsNodeRenderer.this::render));
return set;
}
private void render(Ins node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new InsNodeRenderer(options);
}
}
}
|
if (insStyleHtmlOpen == null || insStyleHtmlClose == null) {
if (context.getHtmlOptions().sourcePositionParagraphLines) {
html.withAttr().tag("ins");
} else {
html.srcPos(node.getText()).withAttr().tag("ins");
}
context.renderChildren(node);
html.tag("/ins");
} else {
html.raw(insStyleHtmlOpen);
context.renderChildren(node);
html.raw(insStyleHtmlClose);
}
| 257
| 133
| 390
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-front-matter/src/main/java/com/vladsch/flexmark/ext/jekyll/front/matter/JekyllFrontMatterBlock.java
|
JekyllFrontMatterBlock
|
getAstExtra
|
class JekyllFrontMatterBlock extends Block {
protected BasedSequence openingMarker = BasedSequence.NULL;
protected BasedSequence closingMarker = BasedSequence.NULL;
@Override
public void getAstExtra(@NotNull StringBuilder out) {<FILL_FUNCTION_BODY>}
@NotNull
@Override
public BasedSequence[] getSegments() {
return new BasedSequence[] { openingMarker, closingMarker };
}
public JekyllFrontMatterBlock() {
}
public JekyllFrontMatterBlock(BasedSequence chars) {
super(chars);
}
public JekyllFrontMatterBlock(Node node) {
super();
appendChild(node);
this.setCharsFromContent();
}
public BasedSequence getOpeningMarker() {
return openingMarker;
}
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
public BasedSequence getContent() {
return getContentChars();
}
public BasedSequence getClosingMarker() {
return closingMarker;
}
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
public void accept(JekyllFrontMatterVisitor visitor) {
visitor.visit(this);
}
}
|
segmentSpan(out, openingMarker, "open");
segmentSpan(out, getContent(), "content");
segmentSpan(out, closingMarker, "close");
| 350
| 42
| 392
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void <init>(@NotNull BasedSequence, @NotNull List<BasedSequence>) ,public void <init>(@NotNull List<BasedSequence>) ,public void <init>(com.vladsch.flexmark.util.ast.BlockContent) ,public @Nullable Block getParent() <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-front-matter/src/main/java/com/vladsch/flexmark/ext/jekyll/front/matter/JekyllFrontMatterExtension.java
|
JekyllFrontMatterExtension
|
extend
|
class JekyllFrontMatterExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension, Formatter.FormatterExtension {
private JekyllFrontMatterExtension() {
}
public static JekyllFrontMatterExtension create() {
return new JekyllFrontMatterExtension();
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new JekyllFrontMatterNodeFormatter.Factory());
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customBlockParserFactory(new JekyllFrontMatterBlockParser.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new JekyllFrontMatterNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
| 263
| 63
| 326
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-front-matter/src/main/java/com/vladsch/flexmark/ext/jekyll/front/matter/internal/JekyllFrontMatterBlockParser.java
|
JekyllFrontMatterBlockParser
|
tryContinue
|
class JekyllFrontMatterBlockParser extends AbstractBlockParser {
final static Pattern JEKYLL_FRONT_MATTER_BLOCK_START = Pattern.compile("^-{3}(\\s.*)?");
final static Pattern JEKYLL_FRONT_MATTER_BLOCK_END = Pattern.compile("^(-{3}|\\.{3})(\\s.*)?");
final private JekyllFrontMatterBlock block = new JekyllFrontMatterBlock();
private BlockContent content = new BlockContent();
private boolean inYAMLBlock;
JekyllFrontMatterBlockParser(DataHolder options, BasedSequence openingMarker) {
inYAMLBlock = true;
block.setOpeningMarker(openingMarker);
}
@Override
public Block getBlock() {
return block;
}
@Override
public BlockContinue tryContinue(ParserState state) {<FILL_FUNCTION_BODY>}
@Override
public void addLine(ParserState state, BasedSequence line) {
content.add(line, state.getIndent());
}
@Override
public void closeBlock(ParserState state) {
block.setContent(content.getLines().subList(1, content.getLineCount()));
block.setCharsFromContent();
content = null;
}
@Override
public void parseInlines(InlineParser inlineParser) {
}
public static class Factory implements CustomBlockParserFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@Override
public boolean affectsGlobalScope() {
return false;
}
@NotNull
@Override
public BlockParserFactory apply(@NotNull DataHolder options) {
return new BlockFactory(options);
}
}
private static class BlockFactory extends AbstractBlockParserFactory {
BlockFactory(DataHolder options) {
super(options);
}
@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();
}
}
}
|
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();
| 746
| 192
| 938
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-front-matter/src/main/java/com/vladsch/flexmark/ext/jekyll/front/matter/internal/JekyllFrontMatterNodeFormatter.java
|
JekyllFrontMatterNodeFormatter
|
renderDocument
|
class JekyllFrontMatterNodeFormatter implements PhasedNodeFormatter {
public JekyllFrontMatterNodeFormatter(DataHolder options) {
}
@Nullable
@Override
public Set<FormattingPhase> getFormattingPhases() {
return new HashSet<>(Collections.singleton(FormattingPhase.DOCUMENT_FIRST));
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
return null;
}
@Override
public void renderDocument(@NotNull NodeFormatterContext context, @NotNull MarkdownWriter markdown, @NotNull Document document, @NotNull FormattingPhase phase) {<FILL_FUNCTION_BODY>}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
return new HashSet<>(Collections.singletonList(
new NodeFormattingHandler<>(JekyllFrontMatterBlock.class, JekyllFrontMatterNodeFormatter.this::render)
));
}
private void render(JekyllFrontMatterBlock node, NodeFormatterContext context, MarkdownWriter markdown) {
}
public static class Factory implements NodeFormatterFactory {
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new JekyllFrontMatterNodeFormatter(options);
}
}
}
|
if (phase == FormattingPhase.DOCUMENT_FIRST) {
Node node = document.getFirstChild();
if (node instanceof JekyllFrontMatterBlock) {
markdown.openPreFormatted(false);
markdown.append(node.getChars()).blankLine();
markdown.closePreFormatted();
}
}
| 359
| 94
| 453
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-front-matter/src/main/java/com/vladsch/flexmark/ext/jekyll/front/matter/internal/JekyllFrontMatterNodeRenderer.java
|
JekyllFrontMatterNodeRenderer
|
getNodeRenderingHandlers
|
class JekyllFrontMatterNodeRenderer implements NodeRenderer {
public JekyllFrontMatterNodeRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
private void render(JekyllFrontMatterBlock node, NodeRendererContext context, HtmlWriter html) {
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new JekyllFrontMatterNodeRenderer(options);
}
}
}
|
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(JekyllFrontMatterBlock.class, this::render));
return set;
| 163
| 56
| 219
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/JekyllTag.java
|
JekyllTag
|
getAstExtra
|
class JekyllTag extends Block {
protected BasedSequence openingMarker = BasedSequence.NULL;
protected BasedSequence tag = BasedSequence.NULL;
protected BasedSequence parameters = BasedSequence.NULL;
protected BasedSequence closingMarker = BasedSequence.NULL;
@NotNull
@Override
public BasedSequence[] getSegments() {
//return EMPTY_SEGMENTS;
return new BasedSequence[] { openingMarker, tag, parameters, closingMarker };
}
@Override
public void getAstExtra(@NotNull StringBuilder out) {<FILL_FUNCTION_BODY>}
public JekyllTag() {
}
public JekyllTag(BasedSequence chars) {
super(chars);
}
public JekyllTag(BasedSequence openingMarker, BasedSequence tag, BasedSequence parameters, BasedSequence closingMarker) {
super(openingMarker.baseSubSequence(openingMarker.getStartOffset(), closingMarker.getEndOffset()));
this.openingMarker = openingMarker;
this.tag = tag;
this.parameters = parameters;
this.closingMarker = closingMarker;
}
public BasedSequence getOpeningMarker() {
return openingMarker;
}
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
public BasedSequence getTag() {
return tag;
}
public void setTag(BasedSequence text) {
this.tag = text;
}
public BasedSequence getParameters() {
return parameters;
}
public void setParameters(BasedSequence parameters) {
this.parameters = parameters;
}
public BasedSequence getClosingMarker() {
return closingMarker;
}
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
}
|
segmentSpanChars(out, openingMarker, "open");
segmentSpanChars(out, tag, "tag");
segmentSpanChars(out, parameters, "parameters");
segmentSpanChars(out, closingMarker, "close");
| 466
| 61
| 527
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void <init>(@NotNull BasedSequence, @NotNull List<BasedSequence>) ,public void <init>(@NotNull List<BasedSequence>) ,public void <init>(com.vladsch.flexmark.util.ast.BlockContent) ,public @Nullable Block getParent() <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/JekyllTagExtension.java
|
JekyllTagExtension
|
extend
|
class JekyllTagExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension, Formatter.FormatterExtension {
final public static DataKey<Boolean> ENABLE_INLINE_TAGS = new DataKey<>("ENABLE_INLINE_TAGS", true);
final public static DataKey<Boolean> ENABLE_BLOCK_TAGS = new DataKey<>("ENABLE_BLOCK_TAGS", true);
final public static DataKey<Boolean> LIST_INCLUDES_ONLY = new DataKey<>("LIST_INCLUDES_ONLY", true);
final public static DataKey<Boolean> EMBED_INCLUDED_CONTENT = new DataKey<>("EMBED_INCLUDED_CONTENT", false);
final public static DataKey<List<LinkResolverFactory>> LINK_RESOLVER_FACTORIES = new DataKey<>("LINK_RESOLVER_FACTORIES", Collections.emptyList());
final public static DataKey<List<UriContentResolverFactory>> CONTENT_RESOLVER_FACTORIES = new DataKey<>("LINK_RESOLVER_FACTORIES", Collections.emptyList());
final public static NullableDataKey<Map<String, String>> INCLUDED_HTML = new NullableDataKey<>("INCLUDED_HTML");
final public static DataKey<List<JekyllTag>> TAG_LIST = new DataKey<>("TAG_LIST", ArrayList::new);
/**
* 2020/04/17
* @deprecated not used nor needed
*/
@Deprecated
final public static DataKey<Boolean> ENABLE_RENDERING = new DataKey<>("ENABLE_RENDERING", false);
private JekyllTagExtension() {
}
public static JekyllTagExtension create() {
return new JekyllTagExtension();
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new JekyllTagNodeFormatter.Factory());
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {<FILL_FUNCTION_BODY>}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {
if ("HTML".equals(rendererType)) {
htmlRendererBuilder.nodeRendererFactory(new JekyllTagNodeRenderer.Factory());
}
}
}
|
if (ENABLE_BLOCK_TAGS.get(parserBuilder)) parserBuilder.customBlockParserFactory(new JekyllTagBlockParser.Factory());
if (ENABLE_INLINE_TAGS.get(parserBuilder)) parserBuilder.customInlineParserExtensionFactory(new JekyllTagInlineParserExtension.Factory());
Map<String, String> includeMap = INCLUDED_HTML.get(parserBuilder);
if (includeMap != null && !includeMap.isEmpty() || !LINK_RESOLVER_FACTORIES.get(parserBuilder).isEmpty()) {
parserBuilder.postProcessorFactory(new IncludeNodePostProcessor.Factory());
}
| 648
| 161
| 809
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/JekyllTagVisitorExt.java
|
JekyllTagVisitorExt
|
VISIT_HANDLERS
|
class JekyllTagVisitorExt {
public static <V extends JekyllTagVisitor> VisitHandler<?>[] VISIT_HANDLERS(V visitor) {<FILL_FUNCTION_BODY>}
}
|
return new VisitHandler<?>[] {
new VisitHandler<>(JekyllTag.class, visitor::visit),
new VisitHandler<>(JekyllTagBlock.class, visitor::visit),
};
| 57
| 56
| 113
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/internal/IncludeNodePostProcessor.java
|
IncludeNodePostProcessor
|
process
|
class IncludeNodePostProcessor extends NodePostProcessor {
final HashMap<JekyllTag, String> includedDocuments = new HashMap<>();
final HashMap<String, ResolvedLink> resolvedLinks = new HashMap<>();
final Parser parser;
final List<LinkResolver> linkResolvers;
final List<UriContentResolver> contentResolvers;
final boolean isIncluding = false;
final Document document;
final LinkResolverBasicContext context;
final private boolean embedIncludedContent;
final private Map<String, String> includedHtml;
public IncludeNodePostProcessor(@NotNull Document document) {
this.document = document;
parser = Parser.builder(document).build();
context = new LinkResolverBasicContext() {
@Override
public @NotNull DataHolder getOptions() {
return document;
}
@Override
public @NotNull Document getDocument() {
return document;
}
};
List<LinkResolverFactory> linkResolverFactories = DependencyResolver.resolveFlatDependencies(JekyllTagExtension.LINK_RESOLVER_FACTORIES.get(document), null, null);
linkResolvers = new ArrayList<>(linkResolverFactories.size());
for (LinkResolverFactory resolverFactory : linkResolverFactories) {
linkResolvers.add(resolverFactory.apply(context));
}
List<UriContentResolverFactory> resolverFactories = JekyllTagExtension.CONTENT_RESOLVER_FACTORIES.get(document);
if (resolverFactories.isEmpty()) {
resolverFactories = Collections.singletonList(new FileUriContentResolver.Factory());
}
List<UriContentResolverFactory> contentResolverFactories = DependencyResolver.resolveFlatDependencies(resolverFactories, null, null);
contentResolvers = new ArrayList<>(contentResolverFactories.size());
for (UriContentResolverFactory resolverFactory : contentResolverFactories) {
contentResolvers.add(resolverFactory.apply(context));
}
this.embedIncludedContent = JekyllTagExtension.EMBED_INCLUDED_CONTENT.get(document);
this.includedHtml = JekyllTagExtension.INCLUDED_HTML.get(document);
}
@Override
public void process(@NotNull NodeTracker state, @NotNull Node node) {<FILL_FUNCTION_BODY>}
public static class Factory extends NodePostProcessorFactory {
public Factory() {
super(false);
addNodes(JekyllTag.class);
}
@Override
public @Nullable Set<Class<?>> getBeforeDependents() {
// NOTE: add this as the first node post processor
return Collections.singleton(FirstDependent.class);
}
@NotNull
@Override
public NodePostProcessor apply(@NotNull Document document) {
return new IncludeNodePostProcessor(document);
}
}
}
|
if (node instanceof JekyllTag && !includedDocuments.containsKey(node)) {
JekyllTag jekyllTag = (JekyllTag) node;
//noinspection EqualsBetweenInconvertibleTypes
if (embedIncludedContent && jekyllTag.getTag().equals("include")) {
// see if can find file
BasedSequence parameters = jekyllTag.getParameters();
String rawUrl = parameters.unescape();
String fileContent = null;
if (includedHtml != null && includedHtml.containsKey(rawUrl)) {
fileContent = includedHtml.get(rawUrl);
} else {
ResolvedLink resolvedLink = resolvedLinks.get(rawUrl);
if (resolvedLink == null) {
resolvedLink = new ResolvedLink(LinkType.LINK, rawUrl);
for (LinkResolver linkResolver : linkResolvers) {
resolvedLink = linkResolver.resolveLink(node, context, resolvedLink);
if (resolvedLink.getStatus() != LinkStatus.UNKNOWN) break;
}
resolvedLinks.put(rawUrl, resolvedLink);
}
if (resolvedLink.getStatus() == LinkStatus.VALID) {
ResolvedContent resolvedContent = new ResolvedContent(resolvedLink, LinkStatus.UNKNOWN, null);
for (UriContentResolver contentResolver : contentResolvers) {
resolvedContent = contentResolver.resolveContent(node, context, resolvedContent);
if (resolvedContent.getStatus() != LinkStatus.UNKNOWN) break;
}
if (resolvedContent.getStatus() == LinkStatus.VALID) {
try {
fileContent = new String(resolvedContent.getContent(), "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
}
if (fileContent != null && !fileContent.isEmpty()) {
includedDocuments.put(jekyllTag, fileContent);
Document includedDoc = parser.parse(fileContent);
parser.transferReferences(document, includedDoc, null);
if (includedDoc.contains(Parser.REFERENCES)) {
// NOTE: if included doc has reference definitions then we need to re-evaluate ones which are missing
document.set(HtmlRenderer.RECHECK_UNDEFINED_REFERENCES, true);
}
// insert children of included documents into jekyll tag node
Node child = includedDoc.getFirstChild();
// NOTE: if this is an inline include tag and there is only one child and it is a Paragraph then we unwrap the paragraph
if (!(jekyllTag.getParent() instanceof JekyllTagBlock)) {
if (child instanceof Paragraph && child.getNext() == null) {
child = child.getFirstChild();
}
}
while (child != null) {
Node next = child.getNext();
node.appendChild(child);
state.nodeAddedWithDescendants(child);
child = next;
}
}
}
}
| 727
| 772
| 1,499
|
<methods>public non-sealed void <init>() ,public final @NotNull Document processDocument(@NotNull Document) <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/internal/JekyllTagBlockParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
final private JekyllTagParsing parsing;
final private boolean listIncludesOnly;
BlockFactory(DataHolder options) {
super(options);
this.parsing = new JekyllTagParsing(new Parsing(options));
listIncludesOnly = JekyllTagExtension.LIST_INCLUDES_ONLY.get(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
BasedSequence line = state.getLine();
int currentIndent = state.getIndent();
if (currentIndent == 0 && !(matchedBlockParser.getBlockParser().getBlock() instanceof Paragraph)) {
final BasedSequence tryLine = line.subSequence(state.getIndex());
Matcher matcher = parsing.MACRO_OPEN.matcher(tryLine);
if (matcher.find()) {
// see if it closes on the same line, then we create a block and close it
BasedSequence tag = tryLine.subSequence(0, matcher.end());
BasedSequence tagName = line.subSequence(matcher.start(1), matcher.end(1));
BasedSequence parameters = tryLine.subSequence(matcher.end(1), matcher.end() - 2).trim();
JekyllTag tagNode = new JekyllTag(tag.subSequence(0, 2), tagName, parameters, tag.endSequence(2));
tagNode.setCharsFromContent();
final JekyllTagBlockParser parser = new JekyllTagBlockParser(state.getProperties());
parser.block.appendChild(tagNode);
//noinspection EqualsBetweenInconvertibleTypes
if (!listIncludesOnly || tagName.equals(INCLUDE_TAG)) {
List<JekyllTag> tagList = JekyllTagExtension.TAG_LIST.get(state.getProperties());
tagList.add(tagNode);
}
return BlockStart.of(parser)
.atIndex(state.getLineEndIndex())
;
}
}
return BlockStart.none();
| 146
| 409
| 555
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/internal/JekyllTagInlineParserExtension.java
|
JekyllTagInlineParserExtension
|
parse
|
class JekyllTagInlineParserExtension implements InlineParserExtension {
final private JekyllTagParsing parsing;
final private boolean listIncludesOnly;
public JekyllTagInlineParserExtension(LightInlineParser lightInlineParser) {
this.parsing = new JekyllTagParsing(lightInlineParser.getParsing());
this.listIncludesOnly = JekyllTagExtension.LIST_INCLUDES_ONLY.get(lightInlineParser.getDocument());
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "{";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser lightInlineParser) {
return new JekyllTagInlineParserExtension(lightInlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
if (inlineParser.peek(1) == '%' && (inlineParser.peek(2) == ' ' || inlineParser.peek(2) == '\t')) {
BasedSequence input = inlineParser.getInput();
Matcher matcher = inlineParser.matcher(parsing.MACRO_TAG);
if (matcher != null) {
BasedSequence tag = input.subSequence(matcher.start(), matcher.end());
BasedSequence tagName = input.subSequence(matcher.start(1), matcher.end(1));
BasedSequence parameters = input.subSequence(matcher.end(1), matcher.end() - 2).trim();
JekyllTag macro = new JekyllTag(tag.subSequence(0, 2), tagName, parameters, tag.endSequence(2));
macro.setCharsFromContent();
//noinspection EqualsBetweenInconvertibleTypes
if (!listIncludesOnly || tagName.equals(JekyllTagBlockParser.INCLUDE_TAG)) {
List<JekyllTag> tagList = JekyllTagExtension.TAG_LIST.get(inlineParser.getDocument());
tagList.add(macro);
}
inlineParser.flushTextNode();
inlineParser.getBlock().appendChild(macro);
return true;
}
}
return false;
| 391
| 338
| 729
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/internal/JekyllTagNodeFormatter.java
|
JekyllTagNodeFormatter
|
render
|
class JekyllTagNodeFormatter implements PhasedNodeFormatter {
private boolean embedIncludedContent;
public JekyllTagNodeFormatter(DataHolder options) {
}
@Override
public @Nullable Set<FormattingPhase> getFormattingPhases() {
return Collections.singleton(FormattingPhase.COLLECT);
}
@Override
public void renderDocument(@NotNull NodeFormatterContext context, @NotNull MarkdownWriter markdown, @NotNull Document document, @NotNull FormattingPhase phase) {
this.embedIncludedContent = JekyllTagExtension.EMBED_INCLUDED_CONTENT.get(document);
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
return null;
}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeFormattingHandler<>(JekyllTagBlock.class, JekyllTagNodeFormatter.this::render),
new NodeFormattingHandler<>(JekyllTag.class, JekyllTagNodeFormatter.this::render)
));
}
private void render(JekyllTagBlock node, NodeFormatterContext context, MarkdownWriter markdown) {<FILL_FUNCTION_BODY>}
private void render(JekyllTag node, NodeFormatterContext context, MarkdownWriter markdown) {
if (embedIncludedContent) {
// remove jekyll tag node and just leave the included content
context.renderChildren(node);
} else {
if (!(node.getParent() instanceof JekyllTagBlock)) {
Node prev = node.getPrevious();
if (prev != null) {
BasedSequence chars = prev.getChars();
markdown.pushOptions().preserveSpaces()
.append(chars.baseSubSequence(chars.getEndOffset(), node.getStartOffset()))
.popOptions();
} else {
int startLine = node.getBaseSequence().startOfLine(node.getStartOffset());
if (startLine < node.getStartOffset()) {
BasedSequence chars = node.baseSubSequence(startLine, node.getStartOffset());
markdown.pushOptions().preserveSpaces()
.append(chars)
.popOptions();
}
}
}
markdown.append(node.getChars());
}
}
public static class Factory implements NodeFormatterFactory {
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new JekyllTagNodeFormatter(options);
}
}
}
|
// if (embedIncludedContent) {
// // remove jekyll tag node and just leave the included content
// Node child = node.getFirstChild();
//
// if (child != null) child = child.getNextAnyNot(JekyllTag.class);
//
// while (child != null) {
// Node next = child.getNextAnyNot(JekyllTag.class);
// context.render(child);
// child = next;
// }
// } else {
// Node child = node.getFirstChild();
// while (child != null) {
// Node next = child.getNextAny(JekyllTag.class);
// context.render(child);
// child = next;
// }
// }
context.renderChildren(node);
| 678
| 204
| 882
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-jekyll-tag/src/main/java/com/vladsch/flexmark/ext/jekyll/tag/internal/JekyllTagNodeRenderer.java
|
JekyllTagNodeRenderer
|
render
|
class JekyllTagNodeRenderer implements NodeRenderer {
final private boolean embedIncludes;
final private Map<String, String> includeContent;
public JekyllTagNodeRenderer(DataHolder options) {
includeContent = JekyllTagExtension.INCLUDED_HTML.get(options);
embedIncludes = JekyllTagExtension.EMBED_INCLUDED_CONTENT.get(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
Set<NodeRenderingHandler<?>> set = new HashSet<>();
// @formatter:off
set.add(new NodeRenderingHandler<>(JekyllTag.class, this::render));
set.add(new NodeRenderingHandler<>(JekyllTagBlock.class, this::render));
// @formatter:on
return set;
}
private void render(JekyllTag node, NodeRendererContext context, HtmlWriter html) {
if (embedIncludes) {
context.renderChildren(node);
} else {
// nothing to do since includes are not rendered
}
}
private void render(JekyllTagBlock node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new JekyllTagNodeRenderer(options);
}
}
}
|
// if (embedIncludes) {
// // remove jekyll tag node and just leave the included content
// Node child = node.getFirstChild();
//
// if (child != null) child = child.getNextAnyNot(JekyllTag.class);
//
// while (child != null) {
// Node next = child.getNextAnyNot(JekyllTag.class);
// context.render(child);
// child = next;
// }
// } else {
// Node child = node.getFirstChild();
// while (child != null) {
// Node next = child.getNextAny(JekyllTag.class);
// context.render(child);
// child = next;
// }
// }
context.renderChildren(node);
| 374
| 203
| 577
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/MacroDefinitionBlock.java
|
MacroDefinitionBlock
|
getAstExtra
|
class MacroDefinitionBlock extends Block implements ReferenceNode<MacroDefinitionRepository, MacroDefinitionBlock, MacroReference> {
private BasedSequence openingMarker = BasedSequence.NULL;
private BasedSequence name = BasedSequence.NULL;
private BasedSequence openingTrailing = BasedSequence.NULL;
private BasedSequence closingMarker = BasedSequence.NULL;
private BasedSequence closingTrailing = BasedSequence.NULL;
private int ordinal = 0;
private int firstReferenceOffset = Integer.MAX_VALUE;
private int footnoteReferences = 0;
private boolean inExpansion = false;
public int getFootnoteReferences() {
return footnoteReferences;
}
public void setFootnoteReferences(int footnoteReferences) {
this.footnoteReferences = footnoteReferences;
}
public int getFirstReferenceOffset() {
return firstReferenceOffset;
}
public void setFirstReferenceOffset(int firstReferenceOffset) {
this.firstReferenceOffset = firstReferenceOffset;
}
public void addFirstReferenceOffset(int firstReferenceOffset) {
if (this.firstReferenceOffset < firstReferenceOffset) this.firstReferenceOffset = firstReferenceOffset;
}
public boolean isReferenced() {
return this.firstReferenceOffset < Integer.MAX_VALUE;
}
public int getOrdinal() {
return ordinal;
}
public void setOrdinal(int ordinal) {
this.ordinal = ordinal;
}
public boolean isInExpansion() {
return inExpansion;
}
public void setInExpansion(boolean inExpansion) {
this.inExpansion = inExpansion;
}
@Override
public void getAstExtra(@NotNull StringBuilder out) {<FILL_FUNCTION_BODY>}
@NotNull
@Override
public BasedSequence[] getSegments() {
return new BasedSequence[] { openingMarker, name, openingTrailing, closingMarker, closingTrailing };
}
@Nullable
@Override
public MacroReference getReferencingNode(@NotNull Node node) {
return node instanceof MacroReference ? (MacroReference) node : null;
}
@Override
public int compareTo(MacroDefinitionBlock other) {
return SequenceUtils.compare(name, other.name, true);
}
public MacroDefinitionBlock() {
}
public MacroDefinitionBlock(BasedSequence chars) {
super(chars);
}
public MacroDefinitionBlock(BasedSequence chars, List<BasedSequence> segments) {
super(chars, segments);
}
public MacroDefinitionBlock(BlockContent blockContent) {
super(blockContent);
}
public BasedSequence getOpeningMarker() {
return openingMarker;
}
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
public BasedSequence getName() {
return name;
}
public void setName(BasedSequence name) {
this.name = name;
}
public BasedSequence getClosingMarker() {
return closingMarker;
}
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
public BasedSequence getOpeningTrailing() {
return openingTrailing;
}
public void setOpeningTrailing(BasedSequence openingTrailing) {
this.openingTrailing = openingTrailing;
}
public BasedSequence getClosingTrailing() {
return closingTrailing;
}
public void setClosingTrailing(BasedSequence closingTrailing) {
this.closingTrailing = closingTrailing;
}
}
|
segmentSpanChars(out, openingMarker, "open");
segmentSpanChars(out, name, "name");
segmentSpanChars(out, openingTrailing, "openTrail");
segmentSpanChars(out, closingMarker, "close");
segmentSpanChars(out, closingTrailing, "closeTrail");
| 937
| 83
| 1,020
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void <init>(@NotNull BasedSequence, @NotNull List<BasedSequence>) ,public void <init>(@NotNull List<BasedSequence>) ,public void <init>(com.vladsch.flexmark.util.ast.BlockContent) ,public @Nullable Block getParent() <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/MacroReference.java
|
MacroReference
|
getReferenceNode
|
class MacroReference extends Node implements DelimitedNode, DoNotDecorate, ReferencingNode<MacroDefinitionRepository, MacroDefinitionBlock> {
protected BasedSequence openingMarker = BasedSequence.NULL;
protected BasedSequence text = BasedSequence.NULL;
protected BasedSequence closingMarker = BasedSequence.NULL;
protected MacroDefinitionBlock myMacroDefinitionBlock;
@Override
public boolean isDefined() {
return myMacroDefinitionBlock != null;
}
@NotNull
@Override
public BasedSequence getReference() {
return text;
}
@Override
public MacroDefinitionBlock getReferenceNode(Document document) {<FILL_FUNCTION_BODY>}
@Override
public MacroDefinitionBlock getReferenceNode(MacroDefinitionRepository repository) {
if (myMacroDefinitionBlock != null || text.isEmpty()) return myMacroDefinitionBlock;
myMacroDefinitionBlock = getMacroDefinitionBlock(repository);
return myMacroDefinitionBlock;
}
public MacroDefinitionBlock getMacroDefinitionBlock(MacroDefinitionRepository repository) {
return text.isEmpty() ? null : repository.get(text.toString());
}
public MacroDefinitionBlock getMacroDefinitionBlock() {
return myMacroDefinitionBlock;
}
public void setMacroDefinitionBlock(MacroDefinitionBlock macroDefinitionBlock) {
this.myMacroDefinitionBlock = macroDefinitionBlock;
}
@NotNull
@Override
public BasedSequence[] getSegments() {
//return EMPTY_SEGMENTS;
return new BasedSequence[] { openingMarker, text, closingMarker };
}
@Override
public void getAstExtra(@NotNull StringBuilder out) {
delimitedSegmentSpanChars(out, openingMarker, text, closingMarker, "text");
}
public MacroReference() {
}
public MacroReference(BasedSequence chars) {
super(chars);
}
public MacroReference(BasedSequence openingMarker, BasedSequence text, BasedSequence closingMarker) {
super(openingMarker.baseSubSequence(openingMarker.getStartOffset(), closingMarker.getEndOffset()));
this.openingMarker = openingMarker;
this.text = text;
this.closingMarker = closingMarker;
}
public BasedSequence getOpeningMarker() {
return openingMarker;
}
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
public BasedSequence getText() {
return text;
}
public void setText(BasedSequence text) {
this.text = text;
}
public BasedSequence getClosingMarker() {
return closingMarker;
}
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
}
|
if (myMacroDefinitionBlock != null || text.isEmpty()) return myMacroDefinitionBlock;
myMacroDefinitionBlock = getMacroDefinitionBlock(MacrosExtension.MACRO_DEFINITIONS.get(document));
return myMacroDefinitionBlock;
| 716
| 66
| 782
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void appendChain(@NotNull Node) ,public void appendChild(com.vladsch.flexmark.util.ast.Node) ,public static void astChars(@NotNull StringBuilder, @NotNull CharSequence, @NotNull String) ,public void astExtraChars(@NotNull StringBuilder) ,public void astString(@NotNull StringBuilder, boolean) ,public com.vladsch.flexmark.util.sequence.BasedSequence baseSubSequence(int, int) ,public com.vladsch.flexmark.util.sequence.BasedSequence baseSubSequence(int) ,public transient int countAncestorsOfType(@NotNull Class<?> []) ,public transient int countDirectAncestorsOfType(@Nullable Class<?>, @NotNull Class<?> []) ,public static void delimitedSegmentSpan(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull String) ,public static void delimitedSegmentSpanChars(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull String) ,public int endOfLine(int) ,public void extractChainTo(@NotNull Node) ,public void extractToFirstInChain(@NotNull Node) ,public transient @Nullable Node getAncestorOfType(@NotNull Class<?> []) ,public void getAstExtra(@NotNull StringBuilder) ,public com.vladsch.flexmark.util.sequence.BasedSequence getBaseSequence() ,public @NotNull Node getBlankLineSibling() ,public @NotNull BasedSequence getChars() ,public @NotNull BasedSequence getCharsFromSegments() ,public com.vladsch.flexmark.util.sequence.BasedSequence getChildChars() ,public @NotNull ReversiblePeekingIterator<Node> getChildIterator() ,public transient @Nullable Node getChildOfType(@NotNull Class<?> []) ,public @NotNull ReversiblePeekingIterable<Node> getChildren() ,public @NotNull ReversiblePeekingIterable<Node> getDescendants() ,public @NotNull Document getDocument() ,public com.vladsch.flexmark.util.sequence.BasedSequence getEmptyPrefix() ,public com.vladsch.flexmark.util.sequence.BasedSequence getEmptySuffix() ,public int getEndLineNumber() ,public int getEndOfLine() ,public int getEndOffset() ,public com.vladsch.flexmark.util.sequence.BasedSequence getExactChildChars() ,public @Nullable Node getFirstChild() ,public transient @Nullable Node getFirstChildAny(@NotNull Class<?> []) ,public transient @Nullable Node getFirstChildAnyNot(@NotNull Class<?> []) ,public @NotNull Node getFirstInChain() ,public @Nullable Node getGrandParent() ,public @Nullable Node getLastBlankLineChild() ,public @Nullable Node getLastChild() ,public transient @Nullable Node getLastChildAny(@NotNull Class<?> []) ,public transient @Nullable Node getLastChildAnyNot(@NotNull Class<?> []) ,public @NotNull Node getLastInChain() ,public static @NotNull BasedSequence getLeadSegment(@NotNull BasedSequence []) ,public Pair<java.lang.Integer,java.lang.Integer> getLineColumnAtEnd() ,public int getLineNumber() ,public @Nullable Node getNext() ,public transient @Nullable Node getNextAny(@NotNull Class<?> []) ,public transient @Nullable Node getNextAnyNot(@NotNull Class<?> []) ,public @NotNull String getNodeName() ,public static transient int getNodeOfTypeIndex(@NotNull Node, @NotNull Class<?> []) ,public transient int getNodeOfTypeIndex(@NotNull Class<?> []) ,public @Nullable Node getOldestAncestorOfTypeAfter(@NotNull Class<?>, @NotNull Class<?>) ,public @Nullable Node getParent() ,public @Nullable Node getPrevious() ,public transient @Nullable Node getPreviousAny(@NotNull Class<?> []) ,public transient @Nullable Node getPreviousAnyNot(@NotNull Class<?> []) ,public @NotNull ReversiblePeekingIterator<Node> getReversedChildIterator() ,public @NotNull ReversiblePeekingIterable<Node> getReversedChildren() ,public @NotNull ReversiblePeekingIterable<Node> getReversedDescendants() ,public abstract @NotNull BasedSequence [] getSegments() ,public @NotNull BasedSequence [] getSegmentsForChars() ,public com.vladsch.flexmark.util.sequence.Range getSourceRange() ,public int getStartLineNumber() ,public int getStartOfLine() ,public int getStartOffset() ,public int getTextLength() ,public static @NotNull BasedSequence getTrailSegment(com.vladsch.flexmark.util.sequence.BasedSequence[]) ,public boolean hasChildren() ,public boolean hasOrMoreChildren(int) ,public void insertAfter(@NotNull Node) ,public void insertBefore(com.vladsch.flexmark.util.ast.Node) ,public void insertChainAfter(@NotNull Node) ,public void insertChainBefore(@NotNull Node) ,public transient boolean isOrDescendantOfType(@NotNull Class<?> []) ,public Pair<java.lang.Integer,java.lang.Integer> lineColumnAtIndex(int) ,public Pair<java.lang.Integer,java.lang.Integer> lineColumnAtStart() ,public void moveTrailingBlankLines() ,public void prependChild(@NotNull Node) ,public void removeChildren() ,public static void segmentSpan(@NotNull StringBuilder, int, int, @Nullable String) ,public static void segmentSpan(@NotNull StringBuilder, @NotNull BasedSequence, @Nullable String) ,public static void segmentSpanChars(@NotNull StringBuilder, int, int, @Nullable String, @NotNull String) ,public static void segmentSpanChars(@NotNull StringBuilder, int, int, @Nullable String, @NotNull String, @NotNull String, @NotNull String) ,public static void segmentSpanChars(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull String) ,public static void segmentSpanCharsToVisible(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull String) ,public void setChars(@NotNull BasedSequence) ,public void setCharsFromContent() ,public void setCharsFromContentOnly() ,public void setCharsFromSegments() ,public static transient @NotNull BasedSequence spanningChars(com.vladsch.flexmark.util.sequence.BasedSequence[]) ,public int startOfLine(int) ,public void takeChildren(@NotNull Node) ,public @NotNull String toAstString(boolean) ,public static @NotNull String toSegmentSpan(@NotNull BasedSequence, @Nullable String) ,public java.lang.String toString() ,public void unlink() <variables>public static final AstNode<com.vladsch.flexmark.util.ast.Node> AST_ADAPTER,public static final com.vladsch.flexmark.util.sequence.BasedSequence[] EMPTY_SEGMENTS,public static final java.lang.String SPLICE,private @NotNull BasedSequence chars,@Nullable Node firstChild,private @Nullable Node lastChild,@Nullable Node next,private @Nullable Node parent,private @Nullable Node prev
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/MacrosExtension.java
|
MacrosExtension
|
transferReferences
|
class MacrosExtension implements Parser.ParserExtension
, HtmlRenderer.HtmlRendererExtension
, Parser.ReferenceHoldingExtension
, Formatter.FormatterExtension
{
final public static DataKey<KeepType> MACRO_DEFINITIONS_KEEP = new DataKey<>("MACRO_DEFINITIONS_KEEP", KeepType.FIRST); // standard option to allow control over how to handle duplicates
final public static DataKey<MacroDefinitionRepository> MACRO_DEFINITIONS = new DataKey<>("MACRO_DEFINITIONS", new MacroDefinitionRepository(null), MacroDefinitionRepository::new);
// formatter options
final public static DataKey<ElementPlacement> MACRO_DEFINITIONS_PLACEMENT = new DataKey<>("MACRO_DEFINITIONS_PLACEMENT", ElementPlacement.AS_IS);
final public static DataKey<ElementPlacementSort> MACRO_DEFINITIONS_SORT = new DataKey<>("MACRO_DEFINITIONS_SORT", ElementPlacementSort.AS_IS);
final public static DataKey<Boolean> SOURCE_WRAP_MACRO_REFERENCES = new DataKey<>("SOURCE_WRAP_MACRO_REFERENCES", false);
private MacrosExtension() {
}
public static MacrosExtension create() {
return new MacrosExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public boolean transferReferences(MutableDataHolder document, DataHolder included) {<FILL_FUNCTION_BODY>}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new MacrosNodeFormatter.Factory());
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customBlockParserFactory(new MacroDefinitionBlockParser.Factory());
parserBuilder.customInlineParserExtensionFactory(new MacrosInlineParserExtension.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new MacrosNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
}
}
|
// cannot optimize based on macros in this document, repository is not accessed until rendering
if (/*document.contains(MACRO_DEFINITIONS) &&*/ included.contains(MACRO_DEFINITIONS)) {
return Parser.transferReferences(MACRO_DEFINITIONS.get(document), MACRO_DEFINITIONS.get(included), MACRO_DEFINITIONS_KEEP.get(document) == KeepType.FIRST);
}
return false;
| 615
| 121
| 736
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/MacrosVisitorExt.java
|
MacrosVisitorExt
|
VISIT_HANDLERS
|
class MacrosVisitorExt {
public static <V extends MacrosVisitor> VisitHandler<?>[] VISIT_HANDLERS(V visitor) {<FILL_FUNCTION_BODY>}
}
|
return new VisitHandler<?>[] {
new VisitHandler<>(MacroReference.class, visitor::visit),
new VisitHandler<>(MacroDefinitionBlock.class, visitor::visit),
};
| 53
| 54
| 107
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/internal/MacroDefinitionBlockParser.java
|
MacroDefinitionBlockParser
|
tryContinue
|
class MacroDefinitionBlockParser extends AbstractBlockParser {
static Pattern MACRO_BLOCK_START = Pattern.compile(">>>([\\w_-]+)(\\s*$)");
static Pattern MACRO_BLOCK_START_INTELLIJ = Pattern.compile(">>>([\u001f\\w_-]+)(\\s*$)");
static Pattern MACRO_BLOCK_END = Pattern.compile("<<<(\\s*$)");
final private MacroDefinitionBlock block = new MacroDefinitionBlock();
private BlockContent content = new BlockContent();
private boolean hadClose = false;
MacroDefinitionBlockParser(DataHolder options, BasedSequence openMarker, BasedSequence name, BasedSequence openTrailing) {
this.block.setOpeningMarker(openMarker);
this.block.setName(name);
this.block.setOpeningTrailing(openTrailing);
}
@Override
public Block getBlock() {
return block;
}
@Override
public BlockContinue tryContinue(ParserState state) {<FILL_FUNCTION_BODY>}
@Override
public void addLine(ParserState state, BasedSequence line) {
content.add(line, state.getIndent());
}
@Override
public void closeBlock(ParserState state) {
block.setContent(content);
block.setCharsFromContent();
content = null;
// set the footnote from closingMarker to end
block.setCharsFromContent();
// add it to the map
MacroDefinitionRepository macrosRepository = MacrosExtension.MACRO_DEFINITIONS.get(state.getProperties());
macrosRepository.put(macrosRepository.normalizeKey(block.getName()), block);
}
@Override
public boolean isContainer() {
return true;
}
@Override
public boolean canContain(ParserState state, BlockParser blockParser, Block block) {
return true; //options.nestedBlockQuotes || !(blockParser instanceof MacrosBlockQuoteParser);
}
@Override
public void parseInlines(InlineParser inlineParser) {
}
public static class Factory implements CustomBlockParserFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return new HashSet<>(Collections.singletonList(
GitLabBlockQuoteParser.Factory.class
));
}
@Override
public boolean affectsGlobalScope() {
return false;
}
@NotNull
@Override
public BlockParserFactory apply(@NotNull DataHolder options) {
return new BlockFactory(options);
}
}
private static class BlockFactory extends AbstractBlockParserFactory {
BlockFactory(DataHolder options) {
super(options);
}
boolean haveBlockQuoteParser(ParserState state) {
List<BlockParser> parsers = state.getActiveBlockParsers();
int i = parsers.size();
while (i-- > 0) {
if (parsers.get(i) instanceof MacroDefinitionBlockParser) return true;
}
return false;
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {
if (state.getIndex() == 0 && !haveBlockQuoteParser(state)) {
BasedSequence line = state.getLineWithEOL();
Matcher matcher = (state.getParsing().intellijDummyIdentifier ? MACRO_BLOCK_START_INTELLIJ : MACRO_BLOCK_START).matcher(line);
if (matcher.matches()) {
return BlockStart.of(new MacroDefinitionBlockParser(state.getProperties(), line.subSequence(0, 3), line.subSequence(matcher.start(1), matcher.end(1)), line.subSequence(matcher.start(2), matcher.end(1))))
.atIndex(state.getLineEndIndex())
//.replaceActiveBlockParser()
;
}
}
return BlockStart.none();
}
}
}
|
if (hadClose) {
return BlockContinue.none();
}
int index = state.getIndex();
BasedSequence line = state.getLineWithEOL();
Matcher matcher = MACRO_BLOCK_END.matcher(line);
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 (((GitLabBlockQuote) lastChild).getClosingMarker().isEmpty()) {
// 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());
}
| 1,062
| 294
| 1,356
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/internal/MacroDefinitionRepository.java
|
MacroDefinitionRepository
|
resolveMacrosOrdinals
|
class MacroDefinitionRepository extends NodeRepository<MacroDefinitionBlock> {
final private ArrayList<MacroDefinitionBlock> myReferencedMacroDefinitionBlocks = new ArrayList<>();
public void addMacrosReference(MacroDefinitionBlock macroDefinitionBlock, MacroReference macros) {
if (!macroDefinitionBlock.isReferenced()) {
myReferencedMacroDefinitionBlocks.add(macroDefinitionBlock);
}
macroDefinitionBlock.setFirstReferenceOffset(macros.getStartOffset());
}
public void resolveMacrosOrdinals() {<FILL_FUNCTION_BODY>}
public List<MacroDefinitionBlock> getReferencedMacroDefinitionBlocks() {
return myReferencedMacroDefinitionBlocks;
}
public MacroDefinitionRepository(DataHolder options) {
super(MacrosExtension.MACRO_DEFINITIONS_KEEP.get(options));
}
@NotNull
@Override
public DataKey<MacroDefinitionRepository> getDataKey() {
return MacrosExtension.MACRO_DEFINITIONS;
}
@NotNull
@Override
public DataKey<KeepType> getKeepDataKey() {
return MacrosExtension.MACRO_DEFINITIONS_KEEP;
}
@NotNull
@Override
public Set<MacroDefinitionBlock> getReferencedElements(Node parent) {
HashSet<MacroDefinitionBlock> references = new HashSet<>();
visitNodes(parent, value -> {
if (value instanceof MacroReference) {
MacroDefinitionBlock reference = ((MacroReference) value).getReferenceNode(MacroDefinitionRepository.this);
if (reference != null) {
references.add(reference);
}
}
}, MacroReference.class);
return references;
}
}
|
// need to sort by first referenced offset then set each to its ordinal position in the array+1
myReferencedMacroDefinitionBlocks.sort(Comparator.comparing(MacroDefinitionBlock::getFirstReferenceOffset));
int ordinal = 0;
for (MacroDefinitionBlock macroDefinitionBlock : myReferencedMacroDefinitionBlocks) {
macroDefinitionBlock.setOrdinal(++ordinal);
}
| 455
| 106
| 561
|
<methods>public void <init>(@Nullable KeepType) ,public void clear() ,public boolean containsKey(@NotNull Object) ,public boolean containsValue(java.lang.Object) ,public @NotNull Set<Map.Entry<String,MacroDefinitionBlock>> entrySet() ,public boolean equals(java.lang.Object) ,public @Nullable MacroDefinitionBlock get(@NotNull Object) ,public abstract @NotNull DataKey<? extends NodeRepository<MacroDefinitionBlock>> getDataKey() ,public @Nullable MacroDefinitionBlock getFromRaw(@NotNull CharSequence) ,public abstract @NotNull DataKey<KeepType> getKeepDataKey() ,public abstract @NotNull Set<MacroDefinitionBlock> getReferencedElements(com.vladsch.flexmark.util.ast.Node) ,public @NotNull Collection<MacroDefinitionBlock> getValues() ,public int hashCode() ,public boolean isEmpty() ,public @NotNull Set<String> keySet() ,public @NotNull String normalizeKey(@NotNull CharSequence) ,public @Nullable MacroDefinitionBlock put(@NotNull String, @NotNull MacroDefinitionBlock) ,public void putAll(@NotNull Map<? extends String,? extends MacroDefinitionBlock>) ,public @Nullable MacroDefinitionBlock putRawKey(@NotNull CharSequence, @NotNull MacroDefinitionBlock) ,public @Nullable MacroDefinitionBlock remove(@NotNull Object) ,public int size() ,public static boolean transferReferences(@NotNull NodeRepository<T>, @NotNull NodeRepository<T>, boolean, @Nullable Map<String,String>) ,public @NotNull List<MacroDefinitionBlock> values() <variables>protected final non-sealed com.vladsch.flexmark.util.ast.KeepType keepType,protected final ArrayList<com.vladsch.flexmark.ext.macros.MacroDefinitionBlock> nodeList,protected final Map<java.lang.String,com.vladsch.flexmark.ext.macros.MacroDefinitionBlock> nodeMap
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/internal/MacrosInlineParserExtension.java
|
MacrosInlineParserExtension
|
parse
|
class MacrosInlineParserExtension implements InlineParserExtension {
static Pattern MACRO_REFERENCE = Pattern.compile("<<<([\\w_-]+)>>>");
static Pattern MACRO_REFERENCE_INTELLIJ = Pattern.compile("<<<([\u001f\\w_-]+)>>>");
public MacrosInlineParserExtension(LightInlineParser inlineParser) {
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "<";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser lightInlineParser) {
return new MacrosInlineParserExtension(lightInlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
BasedSequence match = inlineParser.match(inlineParser.getParsing().intellijDummyIdentifier ? MACRO_REFERENCE_INTELLIJ : MACRO_REFERENCE);
if (match != null) {
BasedSequence name = match.midSequence(3, -3);
MacroReference macro = new MacroReference(match.subSequence(0, 3), name, match.midSequence(-3));
inlineParser.flushTextNode();
inlineParser.getBlock().appendChild(macro);
return true;
}
return false;
| 367
| 141
| 508
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/internal/MacrosNodeFormatter.java
|
MacrosNodeFormatter
|
renderReferenceBlock
|
class MacrosNodeFormatter extends NodeRepositoryFormatter<MacroDefinitionRepository, MacroDefinitionBlock, MacroReference> {
final public static DataKey<Map<String, String>> MACROS_TRANSLATION_MAP = new DataKey<>("MACROS_TRANSLATION_MAP", new HashMap<>());
final public static DataKey<Map<String, String>> MACROS_UNIQUIFICATION_MAP = new DataKey<>("MACROS_UNIQUIFICATION_MAP", new HashMap<>()); // uniquified references
final private MacroFormatOptions options;
public MacrosNodeFormatter(DataHolder options) {
super(options, MACROS_TRANSLATION_MAP, MACROS_UNIQUIFICATION_MAP);
this.options = new MacroFormatOptions(options);
}
@Override
public MacroDefinitionRepository getRepository(DataHolder options) {
return MacrosExtension.MACRO_DEFINITIONS.get(options);
}
@Override
public ElementPlacement getReferencePlacement() {
return options.macrosPlacement;
}
@Override
public ElementPlacementSort getReferenceSort() {
return options.macrosSort;
}
@Override
public void renderReferenceBlock(MacroDefinitionBlock node, NodeFormatterContext context, MarkdownWriter markdown) {<FILL_FUNCTION_BODY>}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeFormattingHandler<>(MacroReference.class, MacrosNodeFormatter.this::render),
new NodeFormattingHandler<>(MacroDefinitionBlock.class, MacrosNodeFormatter.this::render)
));
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
if (options.macrosPlacement.isNoChange() || !options.macrosSort.isUnused()) return null;
// noinspection ArraysAsListWithZeroOrOneArgument
return new HashSet<>(Arrays.asList(
MacroReference.class
));
}
private void render(MacroDefinitionBlock node, NodeFormatterContext context, MarkdownWriter markdown) {
renderReference(node, context, markdown);
}
private void render(MacroReference node, NodeFormatterContext context, MarkdownWriter markdown) {
markdown.append("<<<");
if (context.isTransformingText()) {
String referenceId = transformReferenceId(node.getText().toString(), context);
context.nonTranslatingSpan((context1, markdown1) -> markdown1.append(referenceId));
} else {
markdown.append(node.getText());
}
markdown.append(">>>");
}
public static class Factory implements NodeFormatterFactory {
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new MacrosNodeFormatter(options);
}
}
}
|
markdown.blankLine().append(">>>").append(transformReferenceId(node.getName().toString(), context)).line();
Node child = node.getFirstChild();
if (child instanceof Paragraph && child == node.getLastChild()) {
// if a single paragraph then we unwrap it and output only its children as inline text
context.renderChildren(child);
} else {
context.renderChildren(node);
}
markdown.line().append("<<<").blankLine();
| 759
| 121
| 880
|
<methods>public void <init>(com.vladsch.flexmark.util.data.DataHolder, DataKey<Map<java.lang.String,java.lang.String>>, DataKey<Map<java.lang.String,java.lang.String>>) ,public @Nullable Set<FormattingPhase> getFormattingPhases() ,public Comparator<com.vladsch.flexmark.ext.macros.MacroDefinitionBlock> getReferenceComparator() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacement getReferencePlacement() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacementSort getReferenceSort() ,public abstract com.vladsch.flexmark.ext.macros.internal.MacroDefinitionRepository getRepository(com.vladsch.flexmark.util.data.DataHolder) ,public java.lang.String modifyTransformedReference(java.lang.String, com.vladsch.flexmark.formatter.NodeFormatterContext) ,public void renderDocument(@NotNull NodeFormatterContext, @NotNull MarkdownWriter, @NotNull Document, @NotNull FormattingPhase) <variables>public static final HashSet<com.vladsch.flexmark.formatter.FormattingPhase> FORMATTING_PHASES,protected final non-sealed com.vladsch.flexmark.ext.macros.MacroDefinitionBlock lastReference,protected final non-sealed Comparator<com.vladsch.flexmark.ext.macros.MacroDefinitionBlock> myComparator,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceMapKey,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceUniqificationMapKey,protected boolean recheckUndefinedReferences,protected final non-sealed List<com.vladsch.flexmark.ext.macros.MacroDefinitionBlock> referenceList,protected final non-sealed com.vladsch.flexmark.ext.macros.internal.MacroDefinitionRepository referenceRepository,private Map<java.lang.String,java.lang.String> referenceTranslationMap,protected Map<java.lang.String,java.lang.String> referenceUniqificationMap,protected boolean repositoryNodesDone,protected final non-sealed HashSet<com.vladsch.flexmark.util.ast.Node> unusedReferences
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-macros/src/main/java/com/vladsch/flexmark/ext/macros/internal/MacrosNodeRenderer.java
|
MacrosNodeRenderer
|
renderDocument
|
class MacrosNodeRenderer implements PhasedNodeRenderer {
final private MacrosOptions options;
final MacroDefinitionRepository repository;
final private boolean recheckUndefinedReferences;
public MacrosNodeRenderer(DataHolder options) {
this.options = new MacrosOptions(options);
this.repository = MacrosExtension.MACRO_DEFINITIONS.get(options);
this.recheckUndefinedReferences = HtmlRenderer.RECHECK_UNDEFINED_REFERENCES.get(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
Set<NodeRenderingHandler<?>> set = new HashSet<>();
// @formatter:off
set.add(new NodeRenderingHandler<>(MacroReference.class, this::render));
set.add(new NodeRenderingHandler<>(MacroDefinitionBlock.class, this::render));
// @formatter:on
return set;
}
@Override
public Set<RenderingPhase> getRenderingPhases() {
Set<RenderingPhase> set = new HashSet<>();
set.add(RenderingPhase.BODY_TOP);
//set.add(RenderingPhase.BODY_BOTTOM);
return set;
}
@Override
public void renderDocument(@NotNull NodeRendererContext context, @NotNull HtmlWriter html, @NotNull Document document, @NotNull RenderingPhase phase) {<FILL_FUNCTION_BODY>}
private void render(MacroReference node, NodeRendererContext context, HtmlWriter html) {
// render contents of macro definition
MacroDefinitionBlock macroDefinitionBlock = repository.get(repository.normalizeKey(node.getText()));
if (macroDefinitionBlock != null) {
if (macroDefinitionBlock.hasChildren() && !macroDefinitionBlock.isInExpansion()) {
try {
macroDefinitionBlock.setInExpansion(true);
Node child = macroDefinitionBlock.getFirstChild();
if (child instanceof Paragraph && child == macroDefinitionBlock.getLastChild()) {
// if a single paragraph then we unwrap it and output only its children as inline text
if (options.sourceWrapMacroReferences) {
html.srcPos(node.getChars()).withAttr(AttributablePart.NODE_POSITION).tag("span");
context.renderChildren(child);
html.tag("/span");
} else {
context.renderChildren(child);
}
} else {
if (options.sourceWrapMacroReferences) {
html.srcPos(node.getChars()).withAttr(AttributablePart.NODE_POSITION).tag("div").indent().line();
context.renderChildren(macroDefinitionBlock);
html.unIndent().tag("/div");
} else {
context.renderChildren(macroDefinitionBlock);
}
}
} finally {
macroDefinitionBlock.setInExpansion(false);
}
}
} else {
html.text(node.getChars());
}
}
private void render(MacroDefinitionBlock node, NodeRendererContext context, HtmlWriter html) {
// nothing to render
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new MacrosNodeRenderer(options);
}
}
}
|
if (phase == RenderingPhase.BODY_TOP) {
if (recheckUndefinedReferences) {
// need to see if have undefined footnotes that were defined after parsing
boolean[] hadNewFootnotes = { false };
NodeVisitor visitor = new NodeVisitor(
new VisitHandler<>(MacroReference.class, node -> {
if (!node.isDefined()) {
MacroDefinitionBlock macroDefinitionBlock = node.getMacroDefinitionBlock(repository);
if (macroDefinitionBlock != null) {
repository.addMacrosReference(macroDefinitionBlock, node);
node.setMacroDefinitionBlock(macroDefinitionBlock);
hadNewFootnotes[0] = true;
}
}
})
);
visitor.visit(document);
if (hadNewFootnotes[0]) {
this.repository.resolveMacrosOrdinals();
}
}
}
| 852
| 238
| 1,090
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-media-tags/src/main/java/com/vladsch/flexmark/ext/media/tags/MediaTagsExtension.java
|
MediaTagsExtension
|
extend
|
class MediaTagsExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
private MediaTagsExtension() {
}
public static MediaTagsExtension create() {
return new MediaTagsExtension();
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.postProcessorFactory(new MediaTagsNodePostProcessor.Factory(parserBuilder));
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new MediaTagsNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
| 186
| 58
| 244
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-media-tags/src/main/java/com/vladsch/flexmark/ext/media/tags/internal/AbstractMediaLink.java
|
AbstractMediaLink
|
verifyBasedSequence
|
class AbstractMediaLink extends InlineLinkNode {
final private static String INVALID_SEQUENCE = "%s Link's CharSequence MUST start with an '%s'!";
final private String PREFIX;
final private String TYPE;
public AbstractMediaLink(String prefix, String type) {
this.PREFIX = prefix;
this.TYPE = type;
}
public AbstractMediaLink(String prefix, String type, Link other) {
super(other.baseSubSequence(other.getStartOffset() - prefix.length(), other.getEndOffset()),
other.baseSubSequence(other.getStartOffset() - prefix.length(), other.getTextOpeningMarker().getEndOffset()),
other.getText(),
other.getTextClosingMarker(),
other.getLinkOpeningMarker(),
other.getUrl(),
other.getTitleOpeningMarker(),
other.getTitle(),
other.getTitleClosingMarker(),
other.getLinkClosingMarker()
);
this.PREFIX = prefix;
this.TYPE = type;
verifyBasedSequence(other.getChars(), other.getStartOffset() - prefix.length());
}
final public String getPrefix() {
return PREFIX;
}
@Override
public void setTextChars(BasedSequence textChars) {
verifyBasedSequence(textChars, 0);
int textCharsLength = textChars.length();
textOpeningMarker = textChars.subSequence(0, PREFIX.length() + 1); // grab n characters, n - 1 for the PREFIX and 1 for the opener
text = textChars.subSequence(PREFIX.length() + 2, textCharsLength - 1).trim();
textClosingMarker = textChars.subSequence(textCharsLength - 1, textCharsLength);
}
protected final void verifyBasedSequence(BasedSequence chars, int startOffset) {<FILL_FUNCTION_BODY>}
}
|
if (!chars.baseSubSequence(startOffset, startOffset + PREFIX.length()).matches(PREFIX)) {
throw new IllegalArgumentException(String.format(INVALID_SEQUENCE, TYPE, PREFIX));
}
| 494
| 60
| 554
|
<methods>public void <init>() ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence) ,public void getAstExtra(@NotNull StringBuilder) ,public com.vladsch.flexmark.util.sequence.BasedSequence getLinkClosingMarker() ,public com.vladsch.flexmark.util.sequence.BasedSequence getLinkOpeningMarker() ,public @NotNull BasedSequence [] getSegments() ,public @NotNull BasedSequence [] getSegmentsForChars() ,public com.vladsch.flexmark.util.sequence.BasedSequence getText() ,public com.vladsch.flexmark.util.sequence.BasedSequence getTextClosingMarker() ,public com.vladsch.flexmark.util.sequence.BasedSequence getTextOpeningMarker() ,public void setLinkClosingMarker(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setLinkOpeningMarker(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setText(com.vladsch.flexmark.util.sequence.BasedSequence) ,public abstract void setTextChars(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setTextClosingMarker(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setTextOpeningMarker(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void setUrl(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence) <variables>protected com.vladsch.flexmark.util.sequence.BasedSequence linkClosingMarker,protected com.vladsch.flexmark.util.sequence.BasedSequence linkOpeningMarker,protected com.vladsch.flexmark.util.sequence.BasedSequence text,protected com.vladsch.flexmark.util.sequence.BasedSequence textClosingMarker,protected com.vladsch.flexmark.util.sequence.BasedSequence textOpeningMarker
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-media-tags/src/main/java/com/vladsch/flexmark/ext/media/tags/internal/MediaTagsNodePostProcessor.java
|
MediaTagsNodePostProcessor
|
process
|
class MediaTagsNodePostProcessor extends NodePostProcessor {
public MediaTagsNodePostProcessor(DataHolder options) {
}
@Override
public void process(@NotNull NodeTracker state, @NotNull Node node) {<FILL_FUNCTION_BODY>}
private boolean isEscaped(BasedSequence chars, String prefix) {
int backslashCount = chars.subSequence(0, chars.length() - prefix.length()).countTrailing(CharPredicate.BACKSLASH);
return (backslashCount & 1) != 0;
}
public static class Factory extends NodePostProcessorFactory {
public Factory(DataHolder options) {
super(false);
addNodes(Link.class);
}
@NotNull
@Override
public NodePostProcessor apply(@NotNull Document document) {
return new MediaTagsNodePostProcessor(document);
}
}
}
|
if (node instanceof Link) {
Node previous = node.getPrevious();
if (previous instanceof Text) {
BasedSequence chars = previous.getChars();
if (chars.isContinuedBy(node.getChars())) {
AbstractMediaLink mediaLink;
if (chars.endsWith(AudioLink.PREFIX) && !isEscaped(chars, AudioLink.PREFIX)) { // AudioLink
mediaLink = new AudioLink((Link) node);
} else if (chars.endsWith(EmbedLink.PREFIX) && !isEscaped(chars, EmbedLink.PREFIX)) { // EmbedLink
mediaLink = new EmbedLink((Link) node);
} else if (chars.endsWith(PictureLink.PREFIX) && !isEscaped(chars, PictureLink.PREFIX)) { // PictureLink
mediaLink = new PictureLink((Link) node);
} else if (chars.endsWith(VideoLink.PREFIX) && !isEscaped(chars, VideoLink.PREFIX)) { // VideoLink
mediaLink = new VideoLink((Link) node);
} else { // None of the Above, abort postprocess
return;
}
mediaLink.takeChildren(node);
node.unlink();
state.nodeRemoved(node);
previous.insertAfter(mediaLink);
state.nodeAddedWithChildren(mediaLink);
previous.setChars(chars.subSequence(0, chars.length() - mediaLink.getPrefix().length()));
if (previous.getChars().length() == 0) {
previous.unlink();
state.nodeRemoved(previous);
}
}
}
}
| 220
| 428
| 648
|
<methods>public non-sealed void <init>() ,public final @NotNull Document processDocument(@NotNull Document) <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-media-tags/src/main/java/com/vladsch/flexmark/ext/media/tags/internal/MediaTagsNodeRenderer.java
|
MediaTagsNodeRenderer
|
renderAudioLink
|
class MediaTagsNodeRenderer implements NodeRenderer {
public MediaTagsNodeRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
HashSet<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(AudioLink.class, this::renderAudioLink));
set.add(new NodeRenderingHandler<>(EmbedLink.class, this::renderEmbedLink));
set.add(new NodeRenderingHandler<>(PictureLink.class, this::renderPictureLink));
set.add(new NodeRenderingHandler<>(VideoLink.class, this::renderVideoLink));
return set;
}
private void renderAudioLink(AudioLink node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
private void renderEmbedLink(EmbedLink node, NodeRendererContext context, HtmlWriter html) {
if (context.isDoNotRenderLinks()) {
context.renderChildren(node);
} else {
ResolvedLink resolvedLink = context.resolveLink(LinkType.LINK, node.getUrl().unescape(), null);
html.attr("title", node.getText())
.attr("src", resolvedLink.getUrl())
.withAttr()
.tag("embed", true);
}
}
private void renderPictureLink(PictureLink node, NodeRendererContext context, HtmlWriter html) {
if (context.isDoNotRenderLinks()) {
context.renderChildren(node);
} else {
ResolvedLink resolvedLink = context.resolveLink(LinkType.LINK, node.getUrl().unescape(), false);
String[] sources = resolvedLink.getUrl().split("\\|");
html.tag("picture");
for (int index = 0; index < sources.length - 1; index++) {
String source = sources[index];
String encoded = context.getHtmlOptions().percentEncodeUrls ? context.encodeUrl(source) : source;
html.attr("srcset", encoded)
.withAttr()
.tag("source", true);
}
int last = sources.length - 1;
if (last >= 0) {
String source = sources[last];
String encoded = context.getHtmlOptions().percentEncodeUrls ? context.encodeUrl(source) : source;
html.attr("src", encoded)
.attr("alt", node.getText())
.withAttr()
.tag("img", true);
}
html.tag("/picture");
}
}
private void renderVideoLink(VideoLink node, NodeRendererContext context, HtmlWriter html) {
if (context.isDoNotRenderLinks()) {
context.renderChildren(node);
} else {
ResolvedLink resolvedLink = context.resolveLink(LinkType.LINK, node.getUrl().unescape(), false);
String[] sources = resolvedLink.getUrl().split("\\|");
html.attr("title", node.getText())
.attr("controls", "")
.withAttr()
.tag("video");
for (String source : sources) {
String encoded = context.getHtmlOptions().percentEncodeUrls ? context.encodeUrl(source) : source;
String type = Utilities.resolveVideoType(source);
html.attr("src", encoded);
if (type != null) html.attr("type", type);
html.withAttr().tag("source", true);
}
html.text("Your browser does not support the video element.");
html.tag("/video");
}
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new MediaTagsNodeRenderer(options);
}
}
}
|
if (context.isDoNotRenderLinks()) {
context.renderChildren(node);
} else {
ResolvedLink resolvedLink = context.resolveLink(LinkType.LINK, node.getUrl().unescape(), false);
String[] sources = resolvedLink.getUrl().split("\\|");
html.attr("title", node.getText())
.attr("controls", "")
.withAttr()
.tag("audio");
for (String source : sources) {
String encoded = context.getHtmlOptions().percentEncodeUrls ? context.encodeUrl(source) : source;
String type = Utilities.resolveAudioType(source);
html.attr("src", encoded);
if (type != null) html.attr("type", type);
html.withAttr().tag("source", true);
}
html.text("Your browser does not support the audio element.");
html.tag("/audio");
}
| 965
| 233
| 1,198
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-media-tags/src/main/java/com/vladsch/flexmark/ext/media/tags/internal/Utilities.java
|
Utilities
|
resolveAudioType
|
class Utilities {
private Utilities() {
}
static String resolveAudioType(String source) {<FILL_FUNCTION_BODY>}
static String resolveVideoType(String source) {
int period = source.lastIndexOf(".");
if (period == -1) return null;
String extension = source.substring(period + 1, source.length());
switch (extension) {
case "mp4":
return "video/mp4";
case "webm":
return "video/webm";
case "ogv":
return "video/ogg";
case "3gp":
return "video/3gp";
default:
return null;
}
}
}
|
int period = source.lastIndexOf(".");
if (period == -1) return null;
String extension = source.substring(period + 1, source.length());
switch (extension) {
case "opus":
return "audio/ogg; codecs=opus";
case "weba":
return "audio/webm";
case "webm":
return "audio/webm; codecs=opus";
case "ogg":
return "audio/ogg";
case "mp3":
return "audio/mpeg";
case "wav":
return "audio/wav";
case "flac":
return "audio/flac";
default:
return null;
}
| 183
| 186
| 369
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-resizable-image/src/main/java/com/vladsch/flexmark/ext/resizable/image/ResizableImageExtension.java
|
ResizableImageExtension
|
extend
|
class ResizableImageExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
private ResizableImageExtension() {
}
public static ResizableImageExtension create() {
return new ResizableImageExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customInlineParserExtensionFactory(new ResizableImageInlineParserExtension.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new ResizableImageNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
return;
}
| 193
| 63
| 256
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-resizable-image/src/main/java/com/vladsch/flexmark/ext/resizable/image/internal/ResizableImageInlineParserExtension.java
|
ResizableImageInlineParserExtension
|
parse
|
class ResizableImageInlineParserExtension implements InlineParserExtension {
final public static Pattern IMAGE_PATTERN = Pattern.compile("\\!\\[([^\\s\\]]*)]\\(([^\\s\\]]+)\\s*=*(\\d*)x*(\\d*)\\)",
Pattern.CASE_INSENSITIVE);
public ResizableImageInlineParserExtension(LightInlineParser inlineParser) {
}
@Override
public void finalizeDocument(@NotNull InlineParser inlineParser) {
}
@Override
public void finalizeBlock(@NotNull InlineParser inlineParser) {
}
@Override
public boolean parse(@NotNull LightInlineParser inlineParser) {<FILL_FUNCTION_BODY>}
public static class Factory implements InlineParserExtensionFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@NotNull
@Override
public CharSequence getCharacters() {
return "!";
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@NotNull
@Override
public InlineParserExtension apply(@NotNull LightInlineParser lightInlineParser) {
return new ResizableImageInlineParserExtension(lightInlineParser);
}
@Override
public boolean affectsGlobalScope() {
return false;
}
}
}
|
int index = inlineParser.getIndex();
char c = inlineParser.getInput().safeCharAt(index + 1);
if (c == '[') {
BasedSequence[] matches = inlineParser.matchWithGroups(IMAGE_PATTERN);
if (matches != null) {
inlineParser.flushTextNode();
BasedSequence text = matches[1];
BasedSequence source = matches[2];
BasedSequence width = matches[3];
BasedSequence height = matches[4];
ResizableImage image = new ResizableImage(text, source, width, height);
inlineParser.getBlock().appendChild(image);
return true;
}
}
return false;
| 369
| 175
| 544
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-resizable-image/src/main/java/com/vladsch/flexmark/ext/resizable/image/internal/ResizableImageNodeRenderer.java
|
ResizableImageNodeRenderer
|
getNodeRenderingHandlers
|
class ResizableImageNodeRenderer implements NodeRenderer
{
public ResizableImageNodeRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
public void render(ResizableImage node, NodeRendererContext context, HtmlWriter html) {
if (context.isDoNotRenderLinks()) {
context.renderChildren(node);
} else {
ResolvedLink link = context.resolveLink(LinkType.IMAGE, node.getSource(), true);
html.srcPos(node.getChars())
.attr("src", link.getUrl());
if (node.getText().isNotEmpty()){
html.attr("alt", node.getText());
}
if (node.getWidth().isNotEmpty()){
html.attr("width", node.getWidth() + "px");
}
if (node.getHeight().isNotEmpty()){
html.attr("height", node.getHeight() + "px");
}
html.withAttr().tag("img");
html.tag("/img");
}
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new ResizableImageNodeRenderer(options);
}
}
}
|
Set<NodeRenderingHandler<?>> set = new HashSet<>();
// @formatter:off
set.add(new NodeRenderingHandler<>(ResizableImage.class, ResizableImageNodeRenderer.this::render));
// @formatter:on
return set;
| 343
| 71
| 414
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-spec-example/src/main/java/com/vladsch/flexmark/ext/spec/example/SpecExampleBlock.java
|
SpecExampleBlock
|
getSegments
|
class SpecExampleBlock extends Block {
private BasedSequence openingMarker = BasedSequence.NULL;
private BasedSequence exampleKeyword = BasedSequence.NULL;
private BasedSequence coordOpeningMarker = BasedSequence.NULL;
private BasedSequence section = BasedSequence.NULL;
private BasedSequence numberSeparator = BasedSequence.NULL;
private BasedSequence number = BasedSequence.NULL;
private BasedSequence coordClosingMarker = BasedSequence.NULL;
private BasedSequence optionsKeyword = BasedSequence.NULL;
private BasedSequence optionsOpeningMarker = BasedSequence.NULL;
private BasedSequence options = BasedSequence.NULL;
private BasedSequence optionsClosingMarker = BasedSequence.NULL;
private BasedSequence source = BasedSequence.NULL;
private BasedSequence htmlSeparator = BasedSequence.NULL;
private BasedSequence html = BasedSequence.NULL;
private BasedSequence astSeparator = BasedSequence.NULL;
private BasedSequence ast = BasedSequence.NULL;
private BasedSequence closingMarker = BasedSequence.NULL;
@Override
public void getAstExtra(@NotNull StringBuilder out) {
//BasedSequence content = getContentChars();
//int lines = getSegments().length;
//segmentSpanChars(out, openingMarker, "open");
//segmentSpanChars(out, section, "info");
//segmentSpan(out, content, "content");
//out.append(" lines[").append(lines).append("]");
//segmentSpanChars(out, closingMarker, "close");
if (openingMarker.isNotNull()) segmentSpan(out, openingMarker, "openingMarker");
if (exampleKeyword.isNotNull()) segmentSpan(out, exampleKeyword, "exampleKeyword");
if (coordOpeningMarker.isNotNull()) segmentSpan(out, coordOpeningMarker, "coordOpeningMarker");
if (section.isNotNull()) segmentSpan(out, section, "section");
if (numberSeparator.isNotNull()) segmentSpan(out, numberSeparator, "numberSeparator");
if (number.isNotNull()) segmentSpan(out, number, "number");
if (coordClosingMarker.isNotNull()) segmentSpan(out, coordClosingMarker, "coordClosingMarker");
if (optionsKeyword.isNotNull()) segmentSpan(out, optionsKeyword, "optionsKeyword");
if (optionsOpeningMarker.isNotNull()) segmentSpan(out, optionsOpeningMarker, "optionsOpeningMarker");
if (options.isNotNull()) segmentSpan(out, options, "options");
if (optionsClosingMarker.isNotNull()) segmentSpan(out, optionsClosingMarker, "optionsClosingMarker");
if (source.isNotNull()) segmentSpan(out, source, "source");
if (htmlSeparator.isNotNull()) segmentSpan(out, htmlSeparator, "htmlSeparator");
if (html.isNotNull()) segmentSpan(out, html, "html");
if (astSeparator.isNotNull()) segmentSpan(out, astSeparator, "astSeparator");
if (ast.isNotNull()) segmentSpan(out, ast, "ast");
if (closingMarker.isNotNull()) segmentSpan(out, closingMarker, "closingMarker");
}
@NotNull
@Override
public BasedSequence[] getSegments() {<FILL_FUNCTION_BODY>}
public SpecExampleBlock() {
}
public SpecExampleBlock(BasedSequence chars) {
super(chars);
}
public SpecExampleBlock(BasedSequence chars, BasedSequence openingMarker, List<BasedSequence> segments, BasedSequence closingMarker) {
super(chars, segments);
this.openingMarker = openingMarker;
this.closingMarker = closingMarker;
}
public BasedSequence getOpeningMarker() {
return openingMarker;
}
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
public BasedSequence getExampleKeyword() {
return exampleKeyword;
}
public void setExampleKeyword(BasedSequence exampleKeyword) {
this.exampleKeyword = exampleKeyword;
}
public BasedSequence getCoordOpeningMarker() {
return coordOpeningMarker;
}
public void setCoordOpeningMarker(BasedSequence coordOpeningMarker) {
this.coordOpeningMarker = coordOpeningMarker;
}
public BasedSequence getSection() {
return section;
}
public void setSection(BasedSequence section) {
this.section = section;
}
public BasedSequence getNumberSeparator() {
return numberSeparator;
}
public void setNumberSeparator(BasedSequence numberSeparator) {
this.numberSeparator = numberSeparator;
}
public BasedSequence getNumber() {
return number;
}
public void setNumber(BasedSequence number) {
this.number = number;
}
public BasedSequence getCoordClosingMarker() {
return coordClosingMarker;
}
public void setCoordClosingMarker(BasedSequence coordClosingMarker) {
this.coordClosingMarker = coordClosingMarker;
}
public BasedSequence getOptionsKeyword() {
return optionsKeyword;
}
public void setOptionsKeyword(BasedSequence optionsKeyword) {
this.optionsKeyword = optionsKeyword;
}
public BasedSequence getOptionsOpeningMarker() {
return optionsOpeningMarker;
}
public void setOptionsOpeningMarker(BasedSequence optionsOpeningMarker) {
this.optionsOpeningMarker = optionsOpeningMarker;
}
public BasedSequence getOptions() {
return options;
}
public void setOptions(BasedSequence options) {
this.options = options;
}
public BasedSequence getOptionsClosingMarker() {
return optionsClosingMarker;
}
public void setOptionsClosingMarker(BasedSequence optionsClosingMarker) {
this.optionsClosingMarker = optionsClosingMarker;
}
public BasedSequence getSource() {
return source;
}
public void setSource(BasedSequence source) {
this.source = source;
}
public BasedSequence getHtmlSeparator() {
return htmlSeparator;
}
public void setHtmlSeparator(BasedSequence htmlSeparator) {
this.htmlSeparator = htmlSeparator;
}
public BasedSequence getHtml() {
return html;
}
public void setHtml(BasedSequence html) {
this.html = html;
}
public BasedSequence getAstSeparator() {
return astSeparator;
}
public void setAstSeparator(BasedSequence astSeparator) {
this.astSeparator = astSeparator;
}
public BasedSequence getAst() {
return ast;
}
public void setAst(BasedSequence ast) {
this.ast = ast;
}
public BasedSequence getClosingMarker() {
return closingMarker;
}
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
}
|
return new BasedSequence[] {
openingMarker,
exampleKeyword,
coordOpeningMarker,
section,
numberSeparator,
number,
coordClosingMarker,
optionsKeyword,
optionsOpeningMarker,
options,
optionsClosingMarker,
source,
htmlSeparator,
html,
astSeparator,
ast,
closingMarker
};
| 1,772
| 105
| 1,877
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void <init>(@NotNull BasedSequence, @NotNull List<BasedSequence>) ,public void <init>(@NotNull List<BasedSequence>) ,public void <init>(com.vladsch.flexmark.util.ast.BlockContent) ,public @Nullable Block getParent() <variables>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-spec-example/src/main/java/com/vladsch/flexmark/ext/spec/example/SpecExampleExtension.java
|
SpecExampleExtension
|
extend
|
class SpecExampleExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension, Formatter.FormatterExtension {
final private static Map<Integer, String> DEFAULT_LANGUAGE_MAPPING = new HashMap<>();
static {
DEFAULT_LANGUAGE_MAPPING.put(1, "markdown");
DEFAULT_LANGUAGE_MAPPING.put(2, "html");
DEFAULT_LANGUAGE_MAPPING.put(3, "text");
}
final private static Map<Integer, String> DEFAULT_SECTION_MAPPING = new HashMap<>();
static {
DEFAULT_SECTION_MAPPING.put(1, "Source");
DEFAULT_SECTION_MAPPING.put(2, "Html");
DEFAULT_SECTION_MAPPING.put(3, "AST");
}
final public static DataKey<Boolean> SPEC_EXAMPLE_RENDER_RAW_HTML = new DataKey<>("SPEC_EXAMPLE_RENDER_RAW_HTML", true);
final public static DataKey<String> SPEC_EXAMPLE_RENDERED_HTML_PREFIX = new DataKey<>("SPEC_EXAMPLE_RENDERED_HTML_PREFIX", "<div style=\"border:solid #cccccc 1px;padding:0 20px 10px 20px;\">");
final public static DataKey<String> SPEC_EXAMPLE_RENDERED_HTML_SUFFIX = new DataKey<>("SPEC_EXAMPLE_RENDERED_HTML_SUFFIX", "</div>");
final public static DataKey<RenderAs> SPEC_EXAMPLE_RENDER_AS = new DataKey<>("SPEC_EXAMPLE_RENDER_AS", RenderAs.FENCED_CODE);
final public static DataKey<String> SPEC_EXAMPLE_BREAK = new DataKey<>("SPEC_EXAMPLE_BREAK", SpecReader.EXAMPLE_BREAK);
final public static DataKey<String> SPEC_SECTION_BREAK = new DataKey<>("SPEC_SECTION_BREAK", SpecReader.SECTION_BREAK);
final public static DataKey<Boolean> SPEC_OPTION_NODES = new DataKey<>("SPEC_OPTION_NODES", true);
final public static DataKey<Map<Integer, String>> SPEC_EXAMPLE_SECTION_LANGUAGES = new DataKey<>("SPEC_EXAMPLE_SECTION_LANGUAGES", DEFAULT_LANGUAGE_MAPPING);
final public static DataKey<Map<Integer, String>> SPEC_EXAMPLE_SECTION_NAMES = new DataKey<>("SPEC_EXAMPLE_SECTION_NAMES", DEFAULT_SECTION_MAPPING);
@Deprecated final public static DataKey<String> SPEC_TYPE_BREAK = SPEC_SECTION_BREAK;
private SpecExampleExtension() {
}
public static SpecExampleExtension create() {
return new SpecExampleExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new SpecExampleNodeFormatter.Factory());
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customBlockParserFactory(new SpecExampleBlockParser.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new SpecExampleNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
}
| 956
| 58
| 1,014
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-spec-example/src/main/java/com/vladsch/flexmark/ext/spec/example/SpecExampleVisitorExt.java
|
SpecExampleVisitorExt
|
VISIT_HANDLERS
|
class SpecExampleVisitorExt {
public static <V extends SpecExampleVisitor> VisitHandler<?>[] VISIT_HANDLERS(V visitor) {<FILL_FUNCTION_BODY>}
}
|
return new VisitHandler<?>[] {
new VisitHandler<>(SpecExampleAst.class, visitor::visit),
new VisitHandler<>(SpecExampleBlock.class, visitor::visit),
new VisitHandler<>(SpecExampleHtml.class, visitor::visit),
new VisitHandler<>(SpecExampleOption.class, visitor::visit),
new VisitHandler<>(SpecExampleOptionSeparator.class, visitor::visit),
new VisitHandler<>(SpecExampleOptionsList.class, visitor::visit),
new VisitHandler<>(SpecExampleSeparator.class, visitor::visit),
new VisitHandler<>(SpecExampleSource.class, visitor::visit),
};
| 53
| 165
| 218
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-spec-example/src/main/java/com/vladsch/flexmark/ext/spec/example/internal/SpecExampleNodeFormatter.java
|
SpecExampleNodeFormatter
|
render
|
class SpecExampleNodeFormatter implements NodeFormatter {
final private SpecExampleOptions formatOptions;
final private String[] mySections = new String[7];// 0 is not used and signals no section when indexed by lastSectionLevel
private String mySection = "";
private int myFlexMarkExampleCount = 0;
public SpecExampleNodeFormatter(DataHolder options) {
formatOptions = new SpecExampleOptions(options);
}
@Nullable
@Override
public Set<Class<?>> getNodeClasses() {
return null;
}
// only registered if assignTextAttributes is enabled
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {
HashSet<NodeFormattingHandler<?>> set = new HashSet<>();
set.add(new NodeFormattingHandler<>(SpecExampleBlock.class, SpecExampleNodeFormatter.this::render));
set.add(new NodeFormattingHandler<>(Heading.class, SpecExampleNodeFormatter.this::render));
return set;
}
void render(Heading node, NodeFormatterContext context, MarkdownWriter markdown) {
if (!context.isTransformingText() && node.isAtxHeading()) {
Pair<String, Integer> pair = TestUtils.addSpecSection(node.getChars().toString(), node.getText().toString(), mySections);
mySection = pair.getFirst();
myFlexMarkExampleCount = 0;
}
context.delegateRender();
}
void render(SpecExampleBlock node, NodeFormatterContext context, MarkdownWriter markdown) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeFormatterFactory {
@Override
public @Nullable Set<Class<?>> getBeforeDependents() {
// NOTE: CoreNodeFormatter.Factory is always the last one in line so no need to add it as dependency
return null;//Collections.singleton(CoreNodeFormatter.Factory.class);
}
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new SpecExampleNodeFormatter(options);
}
}
}
|
if (!context.isTransformingText()) {
markdown.blankLine();
BasedSequence optionsSet = node.getOptions();
@NotNull List<BasedSequence> optionsList = optionsSet.splitList(",", 0, BasedSequence.SPLIT_INCLUDE_DELIM_PARTS | BasedSequence.SPLIT_TRIM_SKIP_EMPTY, CharPredicate.SPACE_TAB);
SequenceBuilder builder = node.getChars().getBuilder();
if (optionsList.isEmpty()) optionsSet = BasedSequence.NULL;
else {
for (BasedSequence option : optionsList) {
builder.append(option);
if (option.equals(",")) builder.append(' ');
}
optionsSet = builder.toSequence();
}
MarkdownWriter out = new MarkdownWriter(builder.getBuilder(), markdown.getOptions());
out.openPreFormatted(false).removeOptions(LineAppendable.F_WHITESPACE_REMOVAL);
String exampleNumber = Integer.toString(++myFlexMarkExampleCount);
TestUtils.addSpecExample(
node.getOpeningMarker().equals(formatOptions.exampleBreak) ? node.getOpeningMarker() : formatOptions.exampleBreak,
node.getHtmlSeparator().equals(formatOptions.sectionBreak + "\n") ? node.getHtmlSeparator() : formatOptions.sectionBreak,
node.getAstSeparator().equals(formatOptions.sectionBreak + "\n") ? node.getAstSeparator() : formatOptions.sectionBreak,
node.getClosingMarker().equals(formatOptions.exampleBreak) ? node.getClosingMarker() : formatOptions.exampleBreak,
true,
false,
out,
node.getSource(),
node.getHtml(),
node.getAst(),
optionsSet,
true,
node.getSection().equals(mySection) ? node.getSection() : builder.getBuilder().append(node.getSection().getEmptyPrefix()).append(mySection).append(node.getSection().getEmptySuffix()).toSequence(),
node.getNumber().equals(exampleNumber) ? node.getNumber() : builder.getBuilder().append(node.getNumber().getEmptyPrefix()).append(exampleNumber).append(node.getNumber().getEmptySuffix()).toSequence(),
node.getExampleKeyword(),
node.getOptionsKeyword().equals(SpecReader.OPTIONS_KEYWORD) ? node.getOptionsKeyword() : SpecReader.OPTIONS_KEYWORD);
out.line().closePreFormatted();
BasedSequence result = BasedSequence.of(out.toSequence(Integer.MAX_VALUE, Integer.MAX_VALUE));
markdown.pushOptions()
.openPreFormatted(false)
.removeOptions(LineAppendable.F_WHITESPACE_REMOVAL)
.append(result).line()
.closePreFormatted()
.blankLine(2)
.popOptions();
} else {
context.delegateRender();
}
| 540
| 741
| 1,281
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-spec-example/src/main/java/com/vladsch/flexmark/ext/spec/example/internal/SpecExampleNodeRenderer.java
|
SpecExampleNodeRenderer
|
render
|
class SpecExampleNodeRenderer implements NodeRenderer {
final private SpecExampleOptions options;
public SpecExampleNodeRenderer(DataHolder options) {
this.options = new SpecExampleOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeRenderingHandler<>(SpecExampleBlock.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleOptionsList.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleOption.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleOptionSeparator.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleSeparator.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleSource.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleHtml.class, SpecExampleNodeRenderer.this::render),
new NodeRenderingHandler<>(SpecExampleAst.class, SpecExampleNodeRenderer.this::render)
));
}
private void render(SpecExampleOptionsList node, NodeRendererContext context, HtmlWriter html) { }
private void render(SpecExampleOption node, NodeRendererContext context, HtmlWriter html) { }
private void render(SpecExampleOptionSeparator node, NodeRendererContext context, HtmlWriter html) { }
private void render(SpecExampleSeparator node, NodeRendererContext context, HtmlWriter html) {
switch (options.renderAs) {
case DEFINITION_LIST:
break;
case SECTIONS:
break;
case FENCED_CODE:
default:
break;
}
}
private void render(SpecExampleSource node, NodeRendererContext context, HtmlWriter html) {
BasedSequence text = node.getChars();
String sectionLanguage = options.sectionLanguages.getOrDefault(1, "text");
String sectionName = options.sectionNames.getOrDefault(1, sectionLanguage.substring(0, 1).toUpperCase() + sectionLanguage.substring(1));
renderSpecExampleSection(text, sectionLanguage, sectionName, context, html);
}
private void render(SpecExampleHtml node, NodeRendererContext context, HtmlWriter html) {
BasedSequence text = node.getChars();
String sectionLanguage = options.sectionLanguages.getOrDefault(2, "text");
String sectionName = options.sectionNames.getOrDefault(2, sectionLanguage.substring(0, 1).toUpperCase() + sectionLanguage.substring(1));
renderSpecExampleSection(text, sectionLanguage, sectionName, context, html);
}
private void render(SpecExampleAst node, NodeRendererContext context, HtmlWriter html) {
BasedSequence text = node.getChars();
String sectionLanguage = options.sectionLanguages.getOrDefault(3, "text");
String sectionName = options.sectionNames.getOrDefault(3, sectionLanguage.substring(0, 1).toUpperCase() + sectionLanguage.substring(1));
renderSpecExampleSection(text, sectionLanguage, sectionName, context, html);
}
private void renderSpecExampleSection(BasedSequence text, String sectionLanguage, String sectionName, NodeRendererContext context, HtmlWriter html) {
switch (options.renderAs) {
case DEFINITION_LIST:
html.tag("dt").text(sectionName).tag("/dt").line();
html.tag("dd");
render(text, sectionLanguage, context, html);
html.tag("/dd").line();
if (options.renderHtml && sectionLanguage.equals("html")) {
html.tag("dt").text("Rendered " + sectionName).tag("/dt").line();
html.tag("dd");
html.raw(options.renderedHtmlPrefix)
.rawIndentedPre(text.normalizeEOL())
.raw(options.renderedHtmlSuffix)
.line();
html.tag("/dd").line();
}
break;
case SECTIONS:
if (!text.isEmpty()) {
html.tagVoidLine("hr");
render(text, sectionLanguage, context, html);
if (options.renderHtml && sectionLanguage.equals("html")) {
html.tagVoidLine("hr");
html.raw(options.renderedHtmlPrefix)
.rawIndentedPre(text.normalizeEOL())
.raw(options.renderedHtmlSuffix)
.line();
}
}
break;
case FENCED_CODE:
default:
break;
}
}
private void render(SpecExampleBlock node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
private void render(BasedSequence contentChars, String language, NodeRendererContext context, HtmlWriter html) {
String text = contentChars.normalizeEOL();
if (!text.isEmpty()) {
if (!language.isEmpty()) {
html.attr("class", context.getHtmlOptions().languageClassMap.getOrDefault(language, context.getHtmlOptions().languageClassPrefix + language));
}
html.line();
html.tag("pre").openPre();
html.srcPos(contentChars).withAttr().tag("code");
html.text(text);
html.tag("/code");
html.tag("/pre").closePre();
html.line();
}
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new SpecExampleNodeRenderer(options);
}
}
}
|
// here we should probably prettify and display section, number and options
switch (options.renderAs) {
case DEFINITION_LIST:
html.tagVoidLine("hr");
html.tag("dl").indent();
html.tag("dt").text(SpecReader.EXAMPLE_KEYWORD);
if (node.getSection().isNotNull() || node.getNumberSeparator().isNotNull() || node.getNumber().isNotNull()) {
html.text(" ").text(node.getSection().toString()).text(": ").text(node.getNumber().toString());
}
if (node.getOptionsKeyword().isNotNull() || node.getOptionsOpeningMarker().isNotNull() || node.getOptions().isNotNull() || node.getOptionsClosingMarker().isNotNull()) {
String optionsText = "";
BasedSequence trimmed = node.getOptions().trim(CharPredicate.WHITESPACE_NBSP);
if (!trimmed.isEmpty()) {
BasedSequence[] optionsList = trimmed.split(",", 0, BasedSequence.SPLIT_TRIM_SKIP_EMPTY);
DelimitedBuilder out = new DelimitedBuilder(", ");
optionsText = out.appendAll(optionsList).getAndClear();
}
html.text(" options(").text(optionsText).text(")");
}
html.tag("/dt").line();
context.renderChildren(node);
html.unIndent().tag("/dl").line();
break;
case SECTIONS:
html.tagVoidLine("hr");
if (node.getSection().isNotNull() || node.getNumberSeparator().isNotNull() || node.getNumber().isNotNull()) {
html.tag("h5").text(node.getSection().toString()).text(": ").text(node.getNumber().toString()).tag("/h5").line();
}
context.renderChildren(node);
break;
case FENCED_CODE:
default:
render(node.getContentChars(), "text", context, html);
break;
}
| 1,442
| 519
| 1,961
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-superscript/src/main/java/com/vladsch/flexmark/ext/superscript/SuperscriptExtension.java
|
SuperscriptExtension
|
extend
|
class SuperscriptExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension {
final public static NullableDataKey<String> SUPERSCRIPT_STYLE_HTML_OPEN = new NullableDataKey<>("SUPERSCRIPT_STYLE_HTML_OPEN");
final public static NullableDataKey<String> SUPERSCRIPT_STYLE_HTML_CLOSE = new NullableDataKey<>("SUPERSCRIPT_STYLE_HTML_CLOSE");
private SuperscriptExtension() {
}
public static SuperscriptExtension create() {
return new SuperscriptExtension();
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.customDelimiterProcessor(new SuperscriptDelimiterProcessor());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new SuperscriptNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new SuperscriptJiraRenderer.Factory());
}
| 286
| 79
| 365
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-superscript/src/main/java/com/vladsch/flexmark/ext/superscript/internal/SuperscriptDelimiterProcessor.java
|
SuperscriptDelimiterProcessor
|
process
|
class SuperscriptDelimiterProcessor implements DelimiterProcessor {
@Override
public char getOpeningCharacter() {
return '^';
}
@Override
public char getClosingCharacter() {
return '^';
}
@Override
public int getMinLength() {
return 1;
}
@Override
public boolean canBeOpener(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return true;//leftFlanking;
}
@Override
public boolean canBeCloser(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return true;//rightFlanking;
}
@Override
public boolean skipNonOpenerCloser() {
return false;
}
@Override
public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {
if (opener.length() >= 1 && closer.length() >= 1) {
return 1;
} else {
return 0;
}
}
@Override
public Node unmatchedDelimiterNode(InlineParser inlineParser, DelimiterRun delimiter) {
return null;
}
@Override
public void process(Delimiter opener, Delimiter closer, int delimitersUsed) {<FILL_FUNCTION_BODY>}
}
|
// Normal case, wrap nodes between delimiters in strikethrough.
Superscript superscript = new Superscript(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed));
opener.moveNodesBetweenDelimitersTo(superscript, closer);
| 416
| 85
| 501
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-superscript/src/main/java/com/vladsch/flexmark/ext/superscript/internal/SuperscriptJiraRenderer.java
|
SuperscriptJiraRenderer
|
getNodeRenderingHandlers
|
class SuperscriptJiraRenderer implements NodeRenderer {
public SuperscriptJiraRenderer(DataHolder options) {
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {<FILL_FUNCTION_BODY>}
private void render(Superscript node, NodeRendererContext context, HtmlWriter html) {
html.raw("^");
context.renderChildren(node);
html.raw("^");
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new SuperscriptJiraRenderer(options);
}
}
}
|
Set<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Superscript.class, this::render));
return set;
| 173
| 49
| 222
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-superscript/src/main/java/com/vladsch/flexmark/ext/superscript/internal/SuperscriptNodeRenderer.java
|
SuperscriptNodeRenderer
|
render
|
class SuperscriptNodeRenderer implements NodeRenderer {
final private String superscriptStyleHtmlOpen;
final private String superscriptStyleHtmlClose;
public SuperscriptNodeRenderer(DataHolder options) {
superscriptStyleHtmlOpen = SuperscriptExtension.SUPERSCRIPT_STYLE_HTML_OPEN.get(options);
superscriptStyleHtmlClose = SuperscriptExtension.SUPERSCRIPT_STYLE_HTML_CLOSE.get(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
Set<NodeRenderingHandler<?>> set = new HashSet<>();
set.add(new NodeRenderingHandler<>(Superscript.class, this::render));
return set;
}
private void render(Superscript node, NodeRendererContext context, HtmlWriter html) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new SuperscriptNodeRenderer(options);
}
}
}
|
if (superscriptStyleHtmlOpen == null || superscriptStyleHtmlClose == null) {
if (context.getHtmlOptions().sourcePositionParagraphLines) {
html.withAttr().tag("sup");
} else {
html.srcPos(node.getText()).withAttr().tag("sup");
}
context.renderChildren(node);
html.tag("/sup");
} else {
html.raw(superscriptStyleHtmlOpen);
context.renderChildren(node);
html.raw(superscriptStyleHtmlClose);
}
| 276
| 140
| 416
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-tables/src/main/java/com/vladsch/flexmark/ext/tables/TableCell.java
|
TableCell
|
trimWhiteSpace
|
class TableCell extends Node implements DelimitedNode {
protected BasedSequence openingMarker = BasedSequence.NULL;
protected BasedSequence text = BasedSequence.NULL;
protected BasedSequence closingMarker = BasedSequence.NULL;
private boolean header;
private Alignment alignment;
private int span = 1;
public void trimWhiteSpace() {<FILL_FUNCTION_BODY>}
public void mergeWhiteSpace() {
boolean hadWhitespace = false;
Node child = getFirstChild();
while (child instanceof WhiteSpace) {
Node next = child.getNext();
Text text = new Text(child.getChars());
child.insertBefore(text);
child.unlink();
child = next;
hadWhitespace = true;
}
child = getLastChild();
while (child instanceof WhiteSpace) {
Node previous = child.getPrevious();
Text text = new Text(child.getChars());
child.insertBefore(text);
child.unlink();
child = previous;
hadWhitespace = true;
}
if (hadWhitespace) {
TextNodeConverter.mergeTextNodes(this);
}
}
@Override
public BasedSequence getOpeningMarker() {
return openingMarker;
}
@Override
public void setOpeningMarker(BasedSequence openingMarker) {
this.openingMarker = openingMarker;
}
@Override
public BasedSequence getText() {
return text;
}
@Override
public void setText(BasedSequence text) {
this.text = text;
}
@Override
public BasedSequence getClosingMarker() {
return closingMarker;
}
@Override
public void setClosingMarker(BasedSequence closingMarker) {
this.closingMarker = closingMarker;
}
public int getSpan() {
return span;
}
public void setSpan(int span) {
this.span = span;
}
@NotNull
@Override
public BasedSequence[] getSegments() {
return new BasedSequence[] { openingMarker, text, closingMarker };
}
@Override
public void getAstExtra(@NotNull StringBuilder out) {
if (alignment != null) out.append(" ").append(alignment);
if (header) out.append(" header");
if (span > 1) out.append(" span=" + span);
delimitedSegmentSpanChars(out, openingMarker, text, closingMarker, "text");
}
public TableCell() {
}
public TableCell(BasedSequence chars) {
super(chars);
}
/**
* @return whether the cell is a header or not
*/
public boolean isHeader() {
return header;
}
public void setHeader(boolean header) {
this.header = header;
}
/**
* @return the cell alignment
*/
public Alignment getAlignment() {
return alignment;
}
public void setAlignment(Alignment alignment) {
this.alignment = alignment;
}
/**
* How the cell is aligned horizontally.
*/
public enum Alignment {
LEFT, CENTER, RIGHT;
public CellAlignment cellAlignment() {
switch (this) {
case CENTER:
return CellAlignment.CENTER;
case LEFT:
return CellAlignment.LEFT;
case RIGHT:
return CellAlignment.RIGHT;
default:
return CellAlignment.NONE;
}
}
}
}
|
Node firstChild = getFirstChild();
Node child = firstChild;
while (child instanceof WhiteSpace) {
Node next = child.getNext();
child.unlink();
child = next;
}
child = getLastChild();
while (child instanceof WhiteSpace) {
Node next = child.getPrevious();
child.unlink();
child = next;
}
if (getFirstChild() == null && firstChild != null) {
// we keep a single space from the child
Node text = new Text(firstChild.getChars().subSequence(0, 1));
appendChild(text);
}
| 926
| 166
| 1,092
|
<methods>public void <init>() ,public void <init>(@NotNull BasedSequence) ,public void appendChain(@NotNull Node) ,public void appendChild(com.vladsch.flexmark.util.ast.Node) ,public static void astChars(@NotNull StringBuilder, @NotNull CharSequence, @NotNull String) ,public void astExtraChars(@NotNull StringBuilder) ,public void astString(@NotNull StringBuilder, boolean) ,public com.vladsch.flexmark.util.sequence.BasedSequence baseSubSequence(int, int) ,public com.vladsch.flexmark.util.sequence.BasedSequence baseSubSequence(int) ,public transient int countAncestorsOfType(@NotNull Class<?> []) ,public transient int countDirectAncestorsOfType(@Nullable Class<?>, @NotNull Class<?> []) ,public static void delimitedSegmentSpan(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull String) ,public static void delimitedSegmentSpanChars(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull BasedSequence, @NotNull String) ,public int endOfLine(int) ,public void extractChainTo(@NotNull Node) ,public void extractToFirstInChain(@NotNull Node) ,public transient @Nullable Node getAncestorOfType(@NotNull Class<?> []) ,public void getAstExtra(@NotNull StringBuilder) ,public com.vladsch.flexmark.util.sequence.BasedSequence getBaseSequence() ,public @NotNull Node getBlankLineSibling() ,public @NotNull BasedSequence getChars() ,public @NotNull BasedSequence getCharsFromSegments() ,public com.vladsch.flexmark.util.sequence.BasedSequence getChildChars() ,public @NotNull ReversiblePeekingIterator<Node> getChildIterator() ,public transient @Nullable Node getChildOfType(@NotNull Class<?> []) ,public @NotNull ReversiblePeekingIterable<Node> getChildren() ,public @NotNull ReversiblePeekingIterable<Node> getDescendants() ,public @NotNull Document getDocument() ,public com.vladsch.flexmark.util.sequence.BasedSequence getEmptyPrefix() ,public com.vladsch.flexmark.util.sequence.BasedSequence getEmptySuffix() ,public int getEndLineNumber() ,public int getEndOfLine() ,public int getEndOffset() ,public com.vladsch.flexmark.util.sequence.BasedSequence getExactChildChars() ,public @Nullable Node getFirstChild() ,public transient @Nullable Node getFirstChildAny(@NotNull Class<?> []) ,public transient @Nullable Node getFirstChildAnyNot(@NotNull Class<?> []) ,public @NotNull Node getFirstInChain() ,public @Nullable Node getGrandParent() ,public @Nullable Node getLastBlankLineChild() ,public @Nullable Node getLastChild() ,public transient @Nullable Node getLastChildAny(@NotNull Class<?> []) ,public transient @Nullable Node getLastChildAnyNot(@NotNull Class<?> []) ,public @NotNull Node getLastInChain() ,public static @NotNull BasedSequence getLeadSegment(@NotNull BasedSequence []) ,public Pair<java.lang.Integer,java.lang.Integer> getLineColumnAtEnd() ,public int getLineNumber() ,public @Nullable Node getNext() ,public transient @Nullable Node getNextAny(@NotNull Class<?> []) ,public transient @Nullable Node getNextAnyNot(@NotNull Class<?> []) ,public @NotNull String getNodeName() ,public static transient int getNodeOfTypeIndex(@NotNull Node, @NotNull Class<?> []) ,public transient int getNodeOfTypeIndex(@NotNull Class<?> []) ,public @Nullable Node getOldestAncestorOfTypeAfter(@NotNull Class<?>, @NotNull Class<?>) ,public @Nullable Node getParent() ,public @Nullable Node getPrevious() ,public transient @Nullable Node getPreviousAny(@NotNull Class<?> []) ,public transient @Nullable Node getPreviousAnyNot(@NotNull Class<?> []) ,public @NotNull ReversiblePeekingIterator<Node> getReversedChildIterator() ,public @NotNull ReversiblePeekingIterable<Node> getReversedChildren() ,public @NotNull ReversiblePeekingIterable<Node> getReversedDescendants() ,public abstract @NotNull BasedSequence [] getSegments() ,public @NotNull BasedSequence [] getSegmentsForChars() ,public com.vladsch.flexmark.util.sequence.Range getSourceRange() ,public int getStartLineNumber() ,public int getStartOfLine() ,public int getStartOffset() ,public int getTextLength() ,public static @NotNull BasedSequence getTrailSegment(com.vladsch.flexmark.util.sequence.BasedSequence[]) ,public boolean hasChildren() ,public boolean hasOrMoreChildren(int) ,public void insertAfter(@NotNull Node) ,public void insertBefore(com.vladsch.flexmark.util.ast.Node) ,public void insertChainAfter(@NotNull Node) ,public void insertChainBefore(@NotNull Node) ,public transient boolean isOrDescendantOfType(@NotNull Class<?> []) ,public Pair<java.lang.Integer,java.lang.Integer> lineColumnAtIndex(int) ,public Pair<java.lang.Integer,java.lang.Integer> lineColumnAtStart() ,public void moveTrailingBlankLines() ,public void prependChild(@NotNull Node) ,public void removeChildren() ,public static void segmentSpan(@NotNull StringBuilder, int, int, @Nullable String) ,public static void segmentSpan(@NotNull StringBuilder, @NotNull BasedSequence, @Nullable String) ,public static void segmentSpanChars(@NotNull StringBuilder, int, int, @Nullable String, @NotNull String) ,public static void segmentSpanChars(@NotNull StringBuilder, int, int, @Nullable String, @NotNull String, @NotNull String, @NotNull String) ,public static void segmentSpanChars(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull String) ,public static void segmentSpanCharsToVisible(@NotNull StringBuilder, @NotNull BasedSequence, @NotNull String) ,public void setChars(@NotNull BasedSequence) ,public void setCharsFromContent() ,public void setCharsFromContentOnly() ,public void setCharsFromSegments() ,public static transient @NotNull BasedSequence spanningChars(com.vladsch.flexmark.util.sequence.BasedSequence[]) ,public int startOfLine(int) ,public void takeChildren(@NotNull Node) ,public @NotNull String toAstString(boolean) ,public static @NotNull String toSegmentSpan(@NotNull BasedSequence, @Nullable String) ,public java.lang.String toString() ,public void unlink() <variables>public static final AstNode<com.vladsch.flexmark.util.ast.Node> AST_ADAPTER,public static final com.vladsch.flexmark.util.sequence.BasedSequence[] EMPTY_SEGMENTS,public static final java.lang.String SPLICE,private @NotNull BasedSequence chars,@Nullable Node firstChild,private @Nullable Node lastChild,@Nullable Node next,private @Nullable Node parent,private @Nullable Node prev
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-tables/src/main/java/com/vladsch/flexmark/ext/tables/TableExtractingVisitor.java
|
TableExtractingVisitor
|
visit
|
class TableExtractingVisitor {
final private TableFormatOptions options;
final private NodeVisitor myVisitor = new NodeVisitor(
new VisitHandler<>(TableBlock.class, this::visit),
new VisitHandler<>(TableHead.class, this::visit),
new VisitHandler<>(TableSeparator.class, this::visit),
new VisitHandler<>(TableBody.class, this::visit),
new VisitHandler<>(TableRow.class, this::visit),
new VisitHandler<>(TableCell.class, this::visit),
new VisitHandler<>(TableCaption.class, this::visit)
);
private MarkdownTable myTable;
final private List<MarkdownTable> myTables;
public TableExtractingVisitor(DataHolder options) {
this.options = new TableFormatOptions(options);
myTables = new ArrayList<>();
}
public MarkdownTable[] getTables(Node node) {
myTable = null;
myVisitor.visit(node);
return myTables.toArray(new MarkdownTable[0]);
}
private void visit(TableBlock node) {<FILL_FUNCTION_BODY>}
private void visit(TableHead node) {
myTable.setSeparator(false);
myTable.setHeader(true);
myVisitor.visitChildren(node);
}
private void visit(TableSeparator node) {
myTable.setSeparator(true);
myVisitor.visitChildren(node);
}
private void visit(TableBody node) {
myTable.setSeparator(false);
myTable.setHeader(false);
myVisitor.visitChildren(node);
}
private void visit(TableRow node) {
myVisitor.visitChildren(node);
if (!myTable.isSeparator()) myTable.nextRow();
}
private void visit(TableCaption node) {
myTable.setCaptionWithMarkers(node, node.getOpeningMarker(), node.getText(), node.getClosingMarker());
}
private void visit(TableCell node) {
BasedSequence text = node.getText();
if (options.trimCellWhitespace) {
if (text.isBlank() && !text.isEmpty()) {
text = text.subSequence(0, 1);
} else {
text = text.trim();
}
}
myTable.addCell(new com.vladsch.flexmark.util.format.TableCell(node, node.getOpeningMarker(), text, node.getClosingMarker(), 1, node.getSpan(), node.getAlignment() == null ? CellAlignment.NONE : node.getAlignment().cellAlignment()));
}
}
|
myTable = new MarkdownTable(node.getChars(), options);
myVisitor.visitChildren(node);
myTables.add(myTable);
myTable = null;
| 699
| 52
| 751
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-tables/src/main/java/com/vladsch/flexmark/ext/tables/TableVisitorExt.java
|
TableVisitorExt
|
VISIT_HANDLERS
|
class TableVisitorExt {
public static <V extends TableVisitor> VisitHandler<?>[] VISIT_HANDLERS(V visitor) {<FILL_FUNCTION_BODY>}
}
|
return new VisitHandler<?>[] {
new VisitHandler<>(TableBlock.class, visitor::visit),
new VisitHandler<>(TableHead.class, visitor::visit),
new VisitHandler<>(TableSeparator.class, visitor::visit),
new VisitHandler<>(TableBody.class, visitor::visit),
new VisitHandler<>(TableRow.class, visitor::visit),
new VisitHandler<>(TableCell.class, visitor::visit),
new VisitHandler<>(TableCaption.class, visitor::visit),
};
| 51
| 139
| 190
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-tables/src/main/java/com/vladsch/flexmark/ext/tables/TablesExtension.java
|
TablesExtension
|
extend
|
class TablesExtension implements Parser.ParserExtension, HtmlRenderer.HtmlRendererExtension, Formatter.FormatterExtension {
final public static DataKey<Boolean> TRIM_CELL_WHITESPACE = new DataKey<>("TRIM_CELL_WHITESPACE", true);
final public static DataKey<Integer> MIN_SEPARATOR_DASHES = new DataKey<>("MIN_SEPARATOR_DASHES", 3);
final public static DataKey<Integer> MAX_HEADER_ROWS = new DataKey<>("MAX_HEADER_ROWS", Integer.MAX_VALUE);
final public static DataKey<Integer> MIN_HEADER_ROWS = new DataKey<>("MIN_HEADER_ROWS", 0);
final public static DataKey<Boolean> APPEND_MISSING_COLUMNS = new DataKey<>("APPEND_MISSING_COLUMNS", false);
final public static DataKey<Boolean> DISCARD_EXTRA_COLUMNS = new DataKey<>("DISCARD_EXTRA_COLUMNS", false);
final public static DataKey<Boolean> COLUMN_SPANS = new DataKey<>("COLUMN_SPANS", true);
final public static DataKey<Boolean> HEADER_SEPARATOR_COLUMN_MATCH = new DataKey<>("HEADER_SEPARATOR_COLUMN_MATCH", false);
final public static DataKey<String> CLASS_NAME = new DataKey<>("CLASS_NAME", "");
final public static DataKey<Boolean> WITH_CAPTION = new DataKey<>("WITH_CAPTION", true);
// format options copy from TableFormatOptions
final public static DataKey<Boolean> FORMAT_TABLE_TRIM_CELL_WHITESPACE = TableFormatOptions.FORMAT_TABLE_TRIM_CELL_WHITESPACE;
final public static DataKey<Boolean> FORMAT_TABLE_LEAD_TRAIL_PIPES = TableFormatOptions.FORMAT_TABLE_LEAD_TRAIL_PIPES;
final public static DataKey<Boolean> FORMAT_TABLE_SPACE_AROUND_PIPES = TableFormatOptions.FORMAT_TABLE_SPACE_AROUND_PIPES;
final public static DataKey<Boolean> FORMAT_TABLE_ADJUST_COLUMN_WIDTH = TableFormatOptions.FORMAT_TABLE_ADJUST_COLUMN_WIDTH;
final public static DataKey<Boolean> FORMAT_TABLE_APPLY_COLUMN_ALIGNMENT = TableFormatOptions.FORMAT_TABLE_APPLY_COLUMN_ALIGNMENT;
final public static DataKey<Boolean> FORMAT_TABLE_FILL_MISSING_COLUMNS = TableFormatOptions.FORMAT_TABLE_FILL_MISSING_COLUMNS;
// QUERY: is this still needed???
final public static NullableDataKey<Integer> FORMAT_TABLE_FILL_MISSING_MIN_COLUMN = TableFormatOptions.FORMAT_TABLE_FILL_MISSING_MIN_COLUMN;
final public static DataKey<DiscretionaryText> FORMAT_TABLE_LEFT_ALIGN_MARKER = TableFormatOptions.FORMAT_TABLE_LEFT_ALIGN_MARKER;
final public static DataKey<Integer> FORMAT_TABLE_MIN_SEPARATOR_COLUMN_WIDTH = TableFormatOptions.FORMAT_TABLE_MIN_SEPARATOR_COLUMN_WIDTH;
final public static DataKey<Integer> FORMAT_TABLE_MIN_SEPARATOR_DASHES = TableFormatOptions.FORMAT_TABLE_MIN_SEPARATOR_DASHES;
final public static DataKey<CharWidthProvider> FORMAT_CHAR_WIDTH_PROVIDER = TableFormatOptions.FORMAT_CHAR_WIDTH_PROVIDER;
final public static DataKey<TableManipulator> FORMAT_TABLE_MANIPULATOR = TableFormatOptions.FORMAT_TABLE_MANIPULATOR;
final public static DataKey<TableCaptionHandling> FORMAT_TABLE_CAPTION = TableFormatOptions.FORMAT_TABLE_CAPTION;
final public static DataKey<DiscretionaryText> FORMAT_TABLE_CAPTION_SPACES = TableFormatOptions.FORMAT_TABLE_CAPTION_SPACES;
final public static DataKey<String> FORMAT_TABLE_INDENT_PREFIX = TableFormatOptions.FORMAT_TABLE_INDENT_PREFIX;
public static TablesExtension create() {
return new TablesExtension();
}
@Override
public void extend(Formatter.Builder formatterBuilder) {
formatterBuilder.nodeFormatterFactory(new TableNodeFormatter.Factory());
}
@Override
public void rendererOptions(@NotNull MutableDataHolder options) {
}
@Override
public void parserOptions(MutableDataHolder options) {
}
@Override
public void extend(Parser.Builder parserBuilder) {
parserBuilder.paragraphPreProcessorFactory(TableParagraphPreProcessor.Factory());
}
@Override
public void extend(@NotNull HtmlRenderer.Builder htmlRendererBuilder, @NotNull String rendererType) {<FILL_FUNCTION_BODY>}
}
|
if (htmlRendererBuilder.isRendererType("HTML")) {
htmlRendererBuilder.nodeRendererFactory(new TableNodeRenderer.Factory());
} else if (htmlRendererBuilder.isRendererType("JIRA")) {
htmlRendererBuilder.nodeRendererFactory(new TableJiraRenderer.Factory());
}
| 1,275
| 75
| 1,350
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-tables/src/main/java/com/vladsch/flexmark/ext/tables/internal/TableJiraRenderer.java
|
TableJiraRenderer
|
tailBlankLine
|
class TableJiraRenderer implements NodeRenderer {
public TableJiraRenderer(DataHolder options) {
//this.options = new TableParserOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeRenderingHandler<>(TableBlock.class, this::render),
new NodeRenderingHandler<>(TableHead.class, this::render),
new NodeRenderingHandler<>(TableSeparator.class, this::render),
new NodeRenderingHandler<>(TableBody.class, this::render),
new NodeRenderingHandler<>(TableRow.class, this::render),
new NodeRenderingHandler<>(TableCell.class, this::render)
));
}
private HtmlWriter tailBlankLine(Node node, HtmlWriter html) {
return tailBlankLine(node, 1, html);
}
public boolean isLastBlockQuoteChild(Node node) {
Node parent = node.getParent();
return parent instanceof BlockQuote && parent.getLastChild() == node;
}
public HtmlWriter tailBlankLine(Node node, int count, HtmlWriter html) {<FILL_FUNCTION_BODY>}
private void render(TableBlock node, NodeRendererContext context, HtmlWriter html) {
context.renderChildren(node);
tailBlankLine(node, html);
}
private void render(TableHead node, NodeRendererContext context, HtmlWriter html) {
context.renderChildren(node);
}
private void render(TableSeparator tableSeparator, NodeRendererContext context, HtmlWriter html) {
}
private void render(TableBody node, NodeRendererContext context, HtmlWriter html) {
context.renderChildren(node);
}
private void render(TableRow node, NodeRendererContext context, HtmlWriter html) {
if (node.getParent() instanceof TableHead) {
html.line().raw("||");
} else if (node.getParent() instanceof TableBody) {
html.line().raw("|");
}
context.renderChildren(node);
html.line();
}
private void render(TableCell node, NodeRendererContext context, HtmlWriter html) {
context.renderChildren(node);
if (node.getGrandParent() instanceof TableHead) {
html.raw("||");
} else if (node.getGrandParent() instanceof TableBody) {
html.raw("|");
}
}
private static String getAlignValue(TableCell.Alignment alignment) {
switch (alignment) {
case LEFT:
return "left";
case CENTER:
return "center";
case RIGHT:
return "right";
}
throw new IllegalStateException("Unknown alignment: " + alignment);
}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new TableJiraRenderer(options);
}
}
}
|
if (isLastBlockQuoteChild(node)) {
// Needed to not add block quote prefix to trailing blank lines
//if (getPushedPrefixCount() > 0) {
// flush(-1); // clear pending lines so pop prefix is not delayed, if PREFIX_AFTER_PENDING_EOL is enabled
// popPrefix();
// pushPrefix();
//}
CharSequence prefix = html.getPrefix();
html.popPrefix();
html.blankLine(count);
html.pushPrefix();
html.setPrefix(prefix, false);
} else {
html.blankLine(count);
}
return html;
| 777
| 168
| 945
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-tables/src/main/java/com/vladsch/flexmark/ext/tables/internal/TableNodeRenderer.java
|
TableNodeRenderer
|
getAlignValue
|
class TableNodeRenderer implements NodeRenderer {
final private TableParserOptions options;
public TableNodeRenderer(DataHolder options) {
this.options = new TableParserOptions(options);
}
@Override
public Set<NodeRenderingHandler<?>> getNodeRenderingHandlers() {
return new HashSet<>(Arrays.asList(
new NodeRenderingHandler<>(TableBlock.class, this::render),
new NodeRenderingHandler<>(TableHead.class, this::render),
new NodeRenderingHandler<>(TableSeparator.class, this::render),
new NodeRenderingHandler<>(TableBody.class, this::render),
new NodeRenderingHandler<>(TableRow.class, this::render),
new NodeRenderingHandler<>(TableCell.class, this::render),
new NodeRenderingHandler<>(TableCaption.class, this::render)
));
}
private void render(TableBlock node, NodeRendererContext context, HtmlWriter html) {
if (!options.className.isEmpty()) {
html.attr("class", options.className);
}
html.srcPosWithEOL(node.getChars()).withAttr().tagLineIndent("table", () -> context.renderChildren(node)).line();
}
private void render(TableHead node, NodeRendererContext context, HtmlWriter html) {
html.withAttr().withCondIndent().tagLine("thead", () -> context.renderChildren(node));
}
private void render(TableSeparator tableSeparator, NodeRendererContext context, HtmlWriter html) {
}
private void render(TableBody node, NodeRendererContext context, HtmlWriter html) {
html.withAttr().withCondIndent().tagLine("tbody", () -> context.renderChildren(node));
}
private void render(TableRow node, NodeRendererContext context, HtmlWriter html) {
html.srcPos(node.getChars().trimStart()).withAttr().tagLine("tr", () -> context.renderChildren(node));
}
private void render(TableCaption node, NodeRendererContext context, HtmlWriter html) {
html.srcPos(node.getChars().trimStart()).withAttr().tagLine("caption", () -> context.renderChildren(node));
}
private void render(TableCell node, NodeRendererContext context, HtmlWriter html) {
String tag = node.isHeader() ? "th" : "td";
if (node.getAlignment() != null) {
html.attr("align", getAlignValue(node.getAlignment()));
}
if (options.columnSpans && node.getSpan() > 1) {
html.attr("colspan", String.valueOf(node.getSpan()));
}
html.srcPos(node.getText()).withAttr().tag(tag);
context.renderChildren(node);
html.tag("/" + tag);
}
private static String getAlignValue(TableCell.Alignment alignment) {<FILL_FUNCTION_BODY>}
public static class Factory implements NodeRendererFactory {
@NotNull
@Override
public NodeRenderer apply(@NotNull DataHolder options) {
return new TableNodeRenderer(options);
}
}
}
|
switch (alignment) {
case LEFT:
return "left";
case CENTER:
return "center";
case RIGHT:
return "right";
}
throw new IllegalStateException("Unknown alignment: " + alignment);
| 808
| 66
| 874
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark-ext-toc/src/main/java/com/vladsch/flexmark/ext/toc/SimTocBlock.java
|
SimTocBlock
|
getSegments
|
class SimTocBlock extends TocBlockBase {
protected BasedSequence anchorMarker = BasedSequence.NULL;
protected BasedSequence openingTitleMarker = BasedSequence.NULL;
protected BasedSequence title = BasedSequence.NULL;
protected BasedSequence closingTitleMarker = BasedSequence.NULL;
@Override
public void getAstExtra(@NotNull StringBuilder out) {
super.getAstExtra(out);
segmentSpanChars(out, anchorMarker, "anchorMarker");
segmentSpanChars(out, openingTitleMarker, "openingTitleMarker");
segmentSpanChars(out, title, "title");
segmentSpanChars(out, closingTitleMarker, "closingTitleMarker");
}
@NotNull
@Override
public BasedSequence[] getSegments() {<FILL_FUNCTION_BODY>}
public SimTocBlock(BasedSequence chars) {
this(chars, null, null);
}
public SimTocBlock(BasedSequence chars, BasedSequence styleChars, BasedSequence titleChars) {
super(chars, styleChars, true);
int anchorPos = chars.indexOf('#', closingMarker.getEndOffset() - chars.getStartOffset());
if (anchorPos == -1) {
throw new IllegalStateException("Invalid TOC block sequence");
}
anchorMarker = chars.subSequence(anchorPos, anchorPos + 1);
if (titleChars != null) {
if (titleChars.length() < 2) {
throw new IllegalStateException("Invalid TOC block title sequence");
}
openingTitleMarker = titleChars.subSequence(0, 1);
title = titleChars.midSequence(1, -1);
closingTitleMarker = titleChars.endSequence(1);
}
}
public BasedSequence getAnchorMarker() {
return anchorMarker;
}
public BasedSequence getOpeningTitleMarker() {
return openingTitleMarker;
}
public BasedSequence getTitle() {
return title;
}
public BasedSequence getClosingTitleMarker() {
return closingTitleMarker;
}
}
|
BasedSequence[] nodeSegments = new BasedSequence[] { openingMarker, tocKeyword, style, closingMarker, anchorMarker, openingTitleMarker, title, closingTitleMarker };
if (lineSegments.size() == 0) return nodeSegments;
BasedSequence[] allSegments = new BasedSequence[lineSegments.size() + nodeSegments.length];
lineSegments.toArray(allSegments);
System.arraycopy(allSegments, 0, allSegments, nodeSegments.length, lineSegments.size());
return allSegments;
| 528
| 137
| 665
|
<methods>public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, boolean) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence) ,public void <init>(com.vladsch.flexmark.util.sequence.BasedSequence, com.vladsch.flexmark.util.sequence.BasedSequence, boolean) ,public void getAstExtra(@NotNull StringBuilder) ,public com.vladsch.flexmark.util.sequence.BasedSequence getClosingMarker() ,public com.vladsch.flexmark.util.sequence.BasedSequence getOpeningMarker() ,public @NotNull BasedSequence [] getSegments() ,public com.vladsch.flexmark.util.sequence.BasedSequence getStyle() ,public com.vladsch.flexmark.util.sequence.BasedSequence getTocKeyword() <variables>protected com.vladsch.flexmark.util.sequence.BasedSequence closingMarker,protected com.vladsch.flexmark.util.sequence.BasedSequence openingMarker,protected com.vladsch.flexmark.util.sequence.BasedSequence style,protected com.vladsch.flexmark.util.sequence.BasedSequence tocKeyword
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.