import org.pegdown.ast.SuperNode; //导入依赖的package包/类
public static String summary(final Node node) {
    final List<String> tokens = new ArrayList<>();
    tokens.add(typeCode(node));
    if (node instanceof TextNode) {
        tokens.add("'" + ((TextNode)node).getText() + "'");
    }
    if (node instanceof SuperNode) {
        final List<Node> children = ((SuperNode)node).getChildren();
        if (!children.isEmpty()) {
            for (Node n : children) {
                tokens.add(summary(n));
            }
        } else {
            tokens.add("()");
        }
    }
    return "(" + StringUtils.join(tokens, " ") + ")";
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
public void visit(final RefImageNode rin) {

    final ArrayList<String> alt = new ArrayList<String>();
    boolean found = findByClass(rin, TextNode.class, new FindPredicate<TextNode>() {

        @Override
        public boolean f(TextNode node, Node parent, int index) {
            alt.add(node.getText());
            return true;
        }
    });

    if (!found) {
        throw new IllegalStateException("The alt name should be mandatory in Markdown for images. ");
    }

    final SuperNode referenceKey = rin.referenceKey;
    final String ref = getRefString(rin, referenceKey);
    String url = ref;
    String title = null;
    ReferenceNode referenceNode = referenceNodes.get(ref);
    if (referenceNode != null) {
        if (isNotBlank(referenceNode.getUrl())) {
            url = referenceNode.getUrl();
        }
        title = referenceNode.getTitle();
    }

    String titlePart = isNotBlank(title) ? format("|title=\"%s\"", title) : "";
    _buffer.append( format( "!%s|alt=\"%s\"%s!", url, alt.get(0), titlePart));
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
protected void printTag(SuperNode node, String tag) {
   	String pre = "";
   	String post = "";
   	switch (tag.toLowerCase()) {
   	case "b":
   	case "strong":
   		pre = post = "*";
   		break;
   	case "i":
   	case "em":
   		pre = post = "_";
   		break;
   	case "p":
   		post = "\n\n";
   		break;
   	case "br":
   		post = "\n";
   		break;
   	case "code":
   		pre = post = "`";
   		break;
   	case "pre":
   		pre = post = "```\n";
   		break;
   	case "blockquote":
   		pre = "> ";
   		break;
   	default:
   		// unsupported transform type
   		log.warn("Slack does not offer a markup substitute for tag {}", tag);
   		pre = String.format("<%s>", tag);
   		post = String.format("</%s>", tag);
   	}

       printer.print(pre);
       visitChildren(node);
       printer.print(post);
   }
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
private void loadTitle() {
    rootNode.accept(new CollectTextVisitor() {
        @Override
        public void visit(HeaderNode node) {
            printer = new Printer();
            visit((SuperNode) node);
            title = printer.getString();
            printer = null;
            exit = true;
        }
    });
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
public void collectChildrensText(SuperNode node, AnchorNodeInfo nodeInfo) {
    for (Node child : node.getChildren()) {
        // accumulate all the text
        if (child instanceof TextNode) {
            nodeInfo.text.append(((TextNode) child).getText());
            if (nodeInfo.startIndex == 0) {
                nodeInfo.startIndex = child.getStartIndex();
            }
            nodeInfo.endIndex = child.getEndIndex();
        } else if (child instanceof SuperNode) {
            collectChildrensText((SuperNode) child, nodeInfo);
        }
    }
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
public static Visitor dump() {
    final AtomicReference<Visitor> selfRef = new AtomicReference<Visitor>();

    Visitor visitor = (Visitor) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Visitor.class}, new InvocationHandler() {
        int indent;

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Visitors.invoke::" + indent() + method.getName() + ":: " + Arrays.toString(args));
            Object o = args[0];
            if (o instanceof SuperNode) {
                indent++;
                visitChildren((SuperNode) o);
                indent--;
            }
            return null;
        }

        private String indent() {
            StringBuilder b = new StringBuilder();
            for (int i = 0; i < indent; i++)
                b.append("  ");
            return b.toString();
        }

        protected void visitChildren(SuperNode node) {
            for (Node child : node.getChildren()) {
                child.accept(selfRef.get());
            }

        }
    });
    selfRef.set(visitor);
    return visitor;
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
public void visit(final SuperNode node) {
    visitChildren(node);
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
protected void visitChildren(final SuperNode node) {
    for (Node child : node.getChildren()) {
        child.accept(this);
    }
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
protected void printIndentedTag(SuperNode node, String tag) {
       printTag(node, tag);
   }
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void usecase__ancestor_sibling_and_of_type() throws Exception {
    String mkd = loadResource("image-04-ref.md").trim();

    PegDownPlugins plugins = PegDownPlugins
            .builder()
            .withPlugin(AttributesPlugin.class)
            .build();
    PegDownProcessor processor = new PegDownProcessor(Extensions.ALL, plugins);
    RootNode rootNode = processor.parseMarkdown(mkd.toCharArray());

    TreeNavigation nav;
    nav = new TreeNavigation();
    nav.push(rootNode);
    nav.pushChild(3);
    nav.pushChild();
    nav.pushChild();
    assertThat(nav.peek()).isInstanceOf(RefImageNode.class);

    //
    //
    Optional<TreeNavigation> result1 =
            ancestor(RefImageNode.class, SuperNode.class, ParaNode.class)
                    .query(nav);
    assertThat(result1.isPresent()).isTrue();
    assertThat(result1.get().peek()).isInstanceOf(ParaNode.class);

    //
    //
    Optional<TreeNavigation> result2 =
            ancestor(RefImageNode.class, SuperNode.class, ParaNode.class)
                    .then(siblingBefore())
                    .query(nav);
    assertThat(result2.isPresent()).isTrue();
    assertThat(result2.get().peek()).isInstanceOf(AttributesNode.class);

    //
    //
    Optional<TreeNavigation> result3 =
            firstAncestorOfType(ParaNode.class)
                    .then(siblingBefore())
                    .query(nav);
    assertThat(result3.isPresent()).isTrue();
    assertThat(result3.get().peek()).isInstanceOf(AttributesNode.class);

    //System.out.println("TreeNavigationTest.usecase" + dumpAST(rootNode));
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
public void visit(SuperNode clarkNode) {
        visitChildren(clarkNode);

}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
protected void visitChildren(SuperNode node) {
        for (Node child : node.getChildren()) {
                child.accept(this);
        }
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
public void visit(@NotNull SuperNode node) {
    visitChildren(node);
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
void visitChildren(@NotNull SuperNode node) {
    for (Node child : node.getChildren()) {
        child.accept(this);
    }
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override public void visit(SuperNode node) {
  //To change body of implemented methods use File | Settings | File Templates.
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
@Override
public void visit(SuperNode superNode) {
  handleNodeGroup(superNode, "markdroid_text");
}
 

import org.pegdown.ast.SuperNode; //导入依赖的package包/类
protected void visitChildren(SuperNode node) {
  for (Node child : node.getChildren()) {
    child.accept(this);
  }
}