@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { if (!parser.isMoveNext(SymbolType.Whitespace)) return Symbol.nothing; return new Maybe<>(current.add(parser.parseToEnds(0, SymbolProvider.pathRuleProvider, new SymbolType[]{SymbolType.Newline}))); } }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { String state = ""; Symbol next = parser.moveNext(1); if (next.getContent().equals(">")) { state = CLOSED; next = parser.moveNext(1); } else if (next.getContent().equals("<")) { state = INVISIBLE; next = parser.moveNext(1); } if (!next.isType(SymbolType.Whitespace)) return Symbol.nothing; Symbol titleText = parser.parseToIgnoreFirst(SymbolType.Newline); if (parser.atEnd()) return Symbol.nothing; Symbol bodyText = parser.parseTo(SymbolType.CloseCollapsible); if (parser.atEnd()) return Symbol.nothing; // Remove trailing newline so we do not introduce excessive whitespace in the page. if (parser.peek().isType(SymbolType.Newline)) { parser.moveNext(1); } return new Maybe<>(current .putProperty(STATE, state) .add(titleText) .add(bodyText)); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol tag = parser.parseToIgnoreFirst(SymbolType.CloseBracket); if (!parser.isMoveNext(SymbolType.OpenBracket)) return Symbol.nothing; Symbol link = parser.parseToIgnoreFirstWithSymbols(SymbolType.CloseBracket, SymbolProvider.aliasLinkProvider); if (!parser.isMoveNext(SymbolType.CloseBracket)) return Symbol.nothing; return new Maybe<>(current.add(tag).add(link)); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol next = parser.moveNext(1); if (!next.isType(SymbolType.Whitespace)) return Symbol.nothing; next = parser.moveNext(1); String option = ""; 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); while (parser.peek().isType(SymbolType.Text) || parser.peek().isType(WikiWord.symbolType)) { Symbol remainderOfPageName = parser.moveNext(1); includedPageName += remainderOfPageName.getContent(); SourcePage sourcePage = parser.getPage().getNamedPage(); 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") ? parser.getPage() : parser.getPage().copyForNamedPage(includedPage.getValue()); current.add("").add(Parser.make( included, includedPage.getValue().getContent()) .parse());
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { if (!parser.isMoveNext(SymbolType.Whitespace)) return Symbol.nothing; Maybe<String> name = parser.parseToAsString(SymbolType.Whitespace); if (name.isNothing()) return Symbol.nothing; String variableName = name.getValue(); if (!ScanString.isVariableName(variableName)) return Symbol.nothing; Symbol next = parser.moveNext(1); Maybe<String> valueString = (next.isType(SymbolType.Text)) ? copyVariableValue(parser, next) : parseVariableValue(parser, next); if (valueString.isNothing()) return Symbol.nothing; String variableValue = valueString.getValue(); parser.getPage().putVariable(variableName, variableValue); return new Maybe<>(current.add(variableName).add(variableValue)); }
@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) { Symbol table = parser.getCurrent(); table.putProperty("class", "plain_text_table"); parser.moveNext(1); if (parser.atEnd()) return Symbol.nothing; Symbol cellSeparator = parser.getCurrent(); if (!cellSeparator.isType(SymbolType.Newline) && !cellSeparator.isType(SymbolType.Whitespace)) { SymbolType plainTextCellSeparator = new SymbolType("PlainTextCellSeparator"); {SymbolType.Newline, SymbolType.ClosePlainTextTable, Evaluator.symbolType, Literal.symbolType, Variable.symbolType, plainTextCellSeparator}); terminators = new SymbolType[] {plainTextCellSeparator, SymbolType.Newline, SymbolType.ClosePlainTextTable}; parser.moveNext(1); if (parser.atEnd()) return Symbol.nothing; if (parser.getCurrent().isType(SymbolType.Whitespace)) { table.putProperty("hideFirst", ""); Symbol line = parser.parseToWithSymbols(terminators, plainTextTableTypes, 0); if (parser.atEnd()) return Symbol.nothing; if (parser.getCurrent().isType(SymbolType.ClosePlainTextTable)) return new Maybe<>(table); if (row == null) { row = new Symbol(SymbolType.SymbolList); if (parser.getCurrent().isType(SymbolType.Newline)) row = null;
public List<Symbol> moveNext(SymbolType[] symbolTypes) { ArrayList<Symbol> tokens = new ArrayList<>(); for (SymbolType type: symbolTypes) { Symbol current = moveNext(1); if (!current.isType(type)) return new ArrayList<>(); tokens.add(current); } return tokens; }
private Maybe<Symbol> populateList(Parser parser, Symbol list) { Symbol nextSymbol = list; while (isList(nextSymbol)) { if (indent(nextSymbol) < indent(list)) break; if (nextSymbol != list) parser.moveNext(1); if (indent(nextSymbol) > indent(list)) { Maybe<Symbol> subList = populateList(parser, nextSymbol); if (subList.isNothing()) return Symbol.nothing; list.lastChild().add(subList.getValue()); } else { Symbol body = makeListBody(parser); if (parser.atEnd()) return Symbol.nothing; list.add(body); } nextSymbol = parser.peek(); } return new Maybe<>(list); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { List<Symbol> lookAhead = parser.peek(new SymbolType[] {SymbolType.Whitespace, SymbolType.DateFormatOption}); if (!lookAhead.isEmpty()) { String option = lookAhead.get(1).getContent(); if (isDateFormatOption(option)) { current.putProperty(Today.Format, option); parser.moveNext(2); } } else { lookAhead = parser.peek(new SymbolType[] {SymbolType.Whitespace, SymbolType.OpenParenthesis}); if (!lookAhead.isEmpty()) { parser.moveNext(2); Maybe<String> format = parser.parseToAsString(SymbolType.CloseParenthesis); if (format.isNothing()) return Symbol.nothing; current.putProperty(Format, format.getValue()); } } lookAhead = parser.peek(new SymbolType[] {SymbolType.Whitespace, SymbolType.Delta}); if (!lookAhead.isEmpty()) { String increment = lookAhead.get(1).getContent(); current.putProperty(Increment, increment); parser.moveNext(2); } return new Maybe<>(current); }
public Maybe<String> parseToAsString(SymbolType terminator) { int start = scanner.getOffset(); scanner.markStart(); parseTo(terminator); if (!atEnd() && !getCurrent().isType(terminator)) return Maybe.noString; return scanner.stringFromStart(start); }
@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); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Maybe<String> name = parser.parseToAsString(SymbolType.CloseBrace); if (name.isNothing() || name.getValue().isEmpty()) return Symbol.nothing; String variableName = name.getValue(); if (!ScanString.isVariableName(variableName)) return Symbol.nothing; current.add(variableName); Maybe<String> variableValue = parser.getVariableSource().findVariable(variableName); if (variableValue.isNothing()) { current.add(new Symbol(SymbolType.Meta).add("undefined variable: " + variableName)); } else { Symbol variableValueSymbol = parser.parseWithParent(variableValue.getValue(), null); current.add(variableValueSymbol); } return new Maybe<>(current); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { String content = current.getContent(); if (content.charAt(0) == '-') current.putProperty("hideFirst", ""); boolean endOfTable = false; while (!endOfTable) { Symbol row = new Symbol(tableRow); row.setStartOffset(parser.getOffset()); current.add(row); while (true) { int offset = parser.getOffset(); Symbol cell = parseCell(parser, content); if (parser.getOffset() == offset) { endOfTable = true; break; } if (parser.atEnd()) return Symbol.nothing; if (containsNewLine(cell)) return Symbol.nothing; row.add(cell); if (endsRow(parser.getCurrent())) break; } row.setEndOffset(parser.getOffset()); if (!startsRow(parser.getCurrent())) break; } return new Maybe<>(current); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { String literal = parser.parseLiteral(Newline); if (!parser.atEnd()) literal += "\n"; return new Maybe<>(current.add(literal)); }
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { List<Symbol> lookAhead = parser.peek(new SymbolType[] {SymbolType.Whitespace, SymbolType.Text}); if (!lookAhead.isEmpty()) { String option = lookAhead.get(1).getContent(); if (option.equals(editableOption)) { current.putProperty(editableOption, ""); parser.moveNext(2); } } return new Maybe<>(current); }
parser.moveNext(1); if (!parser.getCurrent().isType(SymbolType.Whitespace)) return Symbol.nothing; parser.moveNext(1); while (parser.getCurrent().isType(SymbolType.Text) && parser.getCurrent().getContent().startsWith("-")) { String option = parser.getCurrent().getContent(); parser.moveNext(1); if (!parser.getCurrent().isType(SymbolType.Whitespace)) return Symbol.nothing; parser.moveNext(1); if (!parser.getCurrent().isType(SymbolType.Text)) return Symbol.nothing; String value = parser.getCurrent().getContent(); parser.moveNext(1); if (!parser.getCurrent().isType(SymbolType.Whitespace)) return Symbol.nothing; parser.moveNext(1); options.put(option, value); if (parser.getCurrent().isType(Link.symbolType)) { Maybe<Symbol> link = Link.symbolType.getWikiRule().parse(parser.getCurrent(), parser); if (link.isNothing()) return Symbol.nothing; addOptions(link.getValue(), options); return makeImageLink(current, link.getValue(), imageProperty); else if (parser.getCurrent().isType(SymbolType.Text)) { Symbol list = new Symbol(SymbolType.SymbolList).add(parser.getCurrent()); Symbol link = new Symbol(Link.symbolType).add(list); addOptions(link, options);
@Override public Maybe<Symbol> parse(Symbol current, Parser parser) { Symbol targetList = parser.parseToEnds(-1, SymbolProvider.linkTargetProvider, new SymbolType[] {SymbolType.Newline, SymbolType.Whitespace}); return new Maybe<>(current.add(targetList)); } @Override