@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol body = parser.parseToEnd(SymbolType.Newline); for (Symbol option: body.getChildren()) { if (option.isType(SymbolType.Whitespace)) continue; if (!option.getContent().startsWith("-")) return Symbol.nothing; current.add(option); } current.evaluateVariables( new String[] {HELP_TOC, HELP_INSTEAD_OF_TITLE_TOC, REGRACE_TOC, PROPERTY_TOC, FILTER_TOC, MORE_SUFFIX_TOC, PROPERTY_CHARACTERS}, parser.getVariableSource()); return new Maybe<>(current); } @Override
@Override public boolean visit(Symbol node) { if (node.isType(See.symbolType)) { if (node.childAt(0).isType(Alias.symbolType)) { xrefPages.add(node.childAt(0).lastChild().childAt(0).getContent()); } else { xrefPages.add(node.childAt(0).getContent()); } } return true; }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol body = parser.parseToIgnoreFirst(current.getType()); if (body.getChildren().isEmpty()) return Symbol.nothing; if (!parser.getCurrent().isType(current.getType())) return Symbol.nothing; return new Maybe<>(current.add(body)); } }
private boolean containsNewLine(Symbol cell) { for (Symbol child : cell.getChildren()) { if (child.isType(SymbolType.Newline)) return true; } return false; }
@Override public boolean visit(Symbol node) { if (node.isType(Literal.symbolType)) { node.setContent(literalDelimiter + node.getContent() + literalDelimiter); } return true; }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol next = parser.moveNext(1); if (!next.isType(SymbolType.Whitespace)) return Symbol.nothing; if ((next.isType(SymbolType.Text) && next.getContent().startsWith("-")) || next.isType(SymbolType.DateFormatOption)) { option = next.getContent() + (next.isType(SymbolType.DateFormatOption) ? parser.moveNext(1).getContent() : ""); next = parser.moveNext(1); if (!next.isType(SymbolType.Whitespace)) return Symbol.nothing; next = parser.moveNext(1); current.add(option); if (!next.isType(SymbolType.Text) && !next.isType(WikiWord.symbolType)) return Symbol.nothing; String includedPageName = next.getContent(); while (parser.peek().isType(SymbolType.Text) || parser.peek().isType(WikiWord.symbolType)) { Symbol remainderOfPageName = parser.moveNext(1); includedPageName += remainderOfPageName.getContent(); current.add(new Symbol(new WikiWord(sourcePage), includedPageName)); } else { current.add(includedPageName); current.add("").add(new Symbol(SymbolType.Style, "error").add(includedPage.because())); current.add("").add(Parser.make( parser.getPage(),helpText).parse()); } else { current.childAt(1).putProperty(WikiWord.WITH_EDIT, "true"); ParsingPage included = option.equals("-setup") || option.equals("-teardown")
@Override public String toTarget(Translator translator, Symbol symbol) { if (symbol.childAt(0).childAt(0).isType(WikiWord.symbolType)) return translator.translate(symbol.childAt(0)); String linkBody = translator.translate(symbol.childAt(0)); String linkReferenceString = HtmlUtil.unescapeHTML(translator.translate(symbol.childAt(1))); ParsingPage parsingPage = ((HtmlTranslator)translator).getParsingPage(); Symbol linkReference = Parser.make(parsingPage, linkReferenceString).parseToIgnoreFirst(Comment.symbolType); if (linkReference.childAt(0).isType(WikiWord.symbolType) || (linkReference.getChildren().size() == 1 && PathParser.isWikiPath(linkReference.childAt(0).getContent()))) { return new WikiWordBuilder(translator.getPage(), linkReference.childAt(0).getContent(), linkBody) .buildLink(translator.translate(linkReference.childrenAfter(0)), linkBody); } HtmlTag alias = new HtmlTag("a", linkBody); if (linkReference.childAt(0).isType(Link.symbolType)) { alias.addAttribute("href", linkReferenceString.startsWith("http://files/") ? linkReferenceString.substring(7) : linkReferenceString); } else { alias.addAttribute("href", translator.translate(linkReference)); } return alias.htmlInline(); } }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol next = parser.moveNext(1); if (!next.isType(SymbolType.Whitespace)) return Symbol.nothing; String level = current.getContent().substring(1,2); if (ScanString.isDigits(level)) current.putProperty(Level, level); current.add(parser.parseToEnd(SymbolType.Newline)); if (parser.peek().isType(SymbolType.Newline) && !parser.endsOn(SymbolType.Newline)) parser.moveNext(1); return new Maybe<>(current); } }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { while (true) { Symbol row = new Symbol(SymbolType.SymbolList); current.add(row); for (int i = 0; i < 2; i++) { Symbol cell = parser.parseToIgnoreFirst(terminators); if (parser.atEnd() || cell.getChildren().isEmpty()) return Symbol.nothing; row.add(cell); } if (parser.getCurrent().isType(SymbolType.CloseBrace)) break; } return new Maybe<>(current); }
private List<String> getClasspathElements(Symbol symbol) { String pomFile = symbol.childAt(0).getContent(); String scope = MavenClasspathExtractor.DEFAULT_SCOPE; if (pomFile.contains("@")) { String[] s = pomFile.split("@"); pomFile = s[0]; scope = s[1]; } return mavenClasspathExtractor.extractClasspathEntries(new File(pomFile), scope); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { String content = current.getContent(); char beginner = content.charAt(content.length() - 1); Symbol body = parser.parseToIgnoreFirst(closeType(beginner)); if (parser.atEnd()) return Symbol.nothing; return new Maybe<>(new Symbol(SymbolType.Style, content.substring(7, content.length() - 1)).add(body)); }
public String translate(Symbol symbol) { if (getTranslation(symbol.getType()) != null) { return getTranslation(symbol.getType()).toTarget(this, symbol); } else { StringBuilder result = new StringBuilder(symbol.getContent()); for (Symbol child: symbol.getChildren()) { result.append(translate(child)); } return result.toString(); } }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol next = parser.moveNext(1); if (next.isType(WikiWord.symbolType)) { return new Maybe<>(current.add(next)); } if (next.isType(Alias.symbolType)) { Maybe<Symbol> alias = next.getType().getWikiRule().parse(next, parser); if (!alias.isNothing()) return new Maybe<>(current.add(alias.getValue())); } return Symbol.nothing; } }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { List<Symbol> tokens = parser.moveNext(new SymbolType[] {SymbolType.Whitespace, SymbolType.Text}); if (tokens.isEmpty()) return Symbol.nothing; String anchor = tokens.get(1).getContent(); if (!ScanString.isWord(anchor)) return Symbol.nothing; current.add(tokens.get(1)); return new Maybe<>(current); } }
@Override public boolean visit(Symbol node) { if (node.isType(WikiWord.symbolType)) { new WikiWordReference(currentPage(), node.getContent()).wikiWordRenamePageIfReferenced(node, subjectPage, newName); } else if (node.isType(Alias.symbolType)) { String aliasReference = node.childAt(1).childAt(0).getContent(); if (PathParser.isWikiPath(aliasReference)) { new WikiWordReference(currentPage(), aliasReference).wikiWordRenamePageIfReferenced(node.childAt(1).childAt(0), subjectPage, newName); } } return true; }
/** * * @param parser parser * @param scanner scanner * @return a possible value if parser should stop. */ public Maybe<Symbol> parseSymbol(Parser parser, Scanner scanner) { while (true) { Scanner backup = new Scanner(scanner); scanner.moveNextIgnoreFirst(this); if (scanner.isEnd()) return Maybe.nothingBecause("scanner is at end of buffer"); Symbol currentToken = scanner.getCurrent(); int startOffset = currentToken.getStartOffset(); if (endsOn(currentToken.getType()) || parser.parentOwns(currentToken.getType(), this)) { scanner.copy(backup); return Maybe.nothingBecause("At termination symbol or parent owns symbol"); } if (terminatesOn(currentToken.getType())) return Maybe.nothingBecause("At termination symbol"); Rule currentRule = currentToken.getType().getWikiRule(); Maybe<Symbol> parsedSymbol = currentRule.parse(currentToken, parser); if (parsedSymbol.isNothing()) { ignoreFirst(currentToken.getType()); scanner.copy(backup); } else { parsedSymbol.getValue().setStartOffset(startOffset).setEndOffset(scanner.getOffset()); clearIgnoresFirst(); return parsedSymbol; } } }
@Override public String toTarget(Translator translator, Symbol symbol) { return translator.translate(symbol.childAt(1)); } }
private boolean hasOption(String option, String variableName) { for (Symbol child: contents.getChildren()) { if (child.getContent().equals(option)) return true; } return !variableName.isEmpty() && contents.getVariable(variableName, "").equals("true"); }
public Symbol parse(Parser parser, Scanner scanner) { Symbol result = new Symbol(SymbolType.SymbolList); result.setStartOffset(scanner.getOffset()); while (true) { Maybe<Symbol> parsedSymbol = parseSymbol(parser, scanner); if (parsedSymbol.isNothing()) { break; } else { result.add(parsedSymbol.getValue()); } } result.setEndOffset(scanner.getOffset()); return result; }