/** * Creates a new processor instance with the given {@link org.pegdown.Extensions}, parsing timeout and plugins. * * @param options the flags of the extensions to enable as a bitmask * @param maxParsingTimeInMillis the parsing timeout * @param plugins the plugins to use */ public PegDownProcessor(int options, long maxParsingTimeInMillis, PegDownPlugins plugins) { this(Parboiled.createParser(Parser.class, options, maxParsingTimeInMillis, Parser.DefaultParseRunnerProvider, plugins)); }
/** * Add a plugin parser. This should either implement {@link InlinePluginParser} or {@link BlockPluginParser}, * or both. The parser will be enhanced by parboiled before its rules are extracted and registered here. * * @param pluginParser the plugin parser class. * @param arguments the arguments to pass to the constructor of that class. */ public Builder withPlugin(Class<? extends BaseParser<Object>> pluginParser, Object... arguments) { // First, check that the parser implements one of the parser interfaces if (!(InlinePluginParser.class.isAssignableFrom(pluginParser) || BlockPluginParser.class.isAssignableFrom(pluginParser))) { throw new IllegalArgumentException("Parser plugin must implement a parser plugin interface to be useful"); } BaseParser<Object> parser = Parboiled.createParser(pluginParser, arguments); if (parser instanceof InlinePluginParser) { withInlinePluginRules(((InlinePluginParser) parser).inlinePluginRules()); } if (parser instanceof BlockPluginParser) { withBlockPluginRules(((BlockPluginParser) parser).blockPluginRules()); } return this; }
public static void main(String... args) { Parser templateParser = Parboiled.createParser(Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(templateParser.Unit()).run(input2); ImmutableList<Object> copy = ImmutableList.copyOf(result.valueStack.iterator()); if (!copy.isEmpty()) { Unit unit = (Unit) copy.get(0); Unit balance = Balancing.balance(unit); System.out.println(balance); } if (result.hasErrors()) { System.err.println(ErrorUtils.printParseErrors(result.parseErrors)); } // System.out.println(ParseTreeUtils.printNodeTree(result)); } }
public MapExpressionParser(ParserContext context) { super(MapExpressionParser.class, context); createParser(MapParser.class, context); createParser(StringOrIdentifierParser.class, context); }
public AnyTestExpressionParser(ParserContext context, List<Class<? extends TestExpressionParser>> testExpressionParsers) { super(AnyTestExpressionParser.class, context); this.testExpressionParsers = testExpressionParsers; createParser(NotParser.class, context); }
public FunctionExpressionParser(ParserContext context) { super(FunctionExpressionParser.class, context); createParser(ArgumentsParser.class, context); createParser(FunctionNameParser.class, context); }
public ParserGroup(Source source) { this.source = source; basics = Parboiled.createParser(BasicsParser.class, this); literals = Parboiled.createParser(LiteralsParser.class, this); types = Parboiled.createParser(TypesParser.class, this); expressions = Parboiled.createParser(ExpressionsParser.class, this); statements = Parboiled.createParser(StatementsParser.class, this); structures = Parboiled.createParser(StructuresParser.class, this); } }
OpelEngine(MethodExecutionFilter methodExecutionFilter, ImplicitConversion implicitConversion, EvalContext embeddedEvalContext) { this.embeddedEvalContext = embeddedEvalContext; this.implicitConversion = implicitConversion; parser = ThreadLocal.withInitial(() -> Parboiled.createParser(OpelParser.class, methodExecutionFilter, this.implicitConversion)); }
public Optional<MDNReport> parse(String mdnReport) { Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.dispositionNotificationContent()).run(mdnReport); if (result.matched) { return Optional.of((MDNReport)result.resultValue); } return Optional.empty(); }
private void buildModel() { this.proxyValues = new HashMap<>(); this.parser = Parboiled.createParser(ValueExpressionParser.class, proxyValues); this.parseRunner = new ReportingParseRunner<>(parser.value()); if (values != null) { createProxies(); parseValues(); } }
@Override public void parseQueryParameters(String nativeQuery, Recognizer journaler) { QueryParser parser = Parboiled.createParser( QueryParser.class, journaler ); new RecoveringParseRunner<Recognizer>( parser.Query() ).run( nativeQuery ); } }
public String markdownToHtml(String markdown, String concordionNamespacePrefix) { Parser parser = Parboiled.createParser(Parser.class, Extensions.TABLES | Extensions.STRIKETHROUGH | pegdownExtensions, 5000L, Parser.DefaultParseRunnerProvider); PegDownProcessor processor = new PegDownProcessor(); RootNode root = parser.parse(processor.prepareSource(markdown.toCharArray())); ToHtmlSerializer serializer = new ConcordionHtmlSerializer(concordionNamespacePrefix, namespaces); return serializer.toHtml(root); } }
@Test public void originalMessageIdShouldParse() { String originalMessageId = "Original-Message-ID: <original@message.id>"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.originalMessageIdField()).run(originalMessageId); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(OriginalMessageId.class); assertThat((OriginalMessageId)result.resultValue).isEqualTo(new OriginalMessageId("<original@message.id>")); }
@Test public void errorFieldShouldParse() { String error = "Error: Message1"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.errorField()).run(error); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(Error.class); assertThat((Error)result.resultValue).isEqualTo(new Error(Text.fromRawText("Message1"))); }
@Test public void reportingUserAgentShouldParseWithoutProduct() { String minimal = "Reporting-UA: UA_name"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.reportingUaField()).run(minimal); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(ReportingUserAgent.class); assertThat((ReportingUserAgent)result.resultValue).isEqualTo(ReportingUserAgent.builder().userAgentName("UA_name").build()); }
@Test public void extensionFieldShouldParse() { String extension = "X-OPENPAAS-IP: 177.177.177.77"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.extentionField()).run(extension); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(ExtensionField.class); assertThat((ExtensionField)result.resultValue).isEqualTo(ExtensionField.builder().fieldName("X-OPENPAAS-IP").rawValue(" 177.177.177.77").build()); } }
@Test public void reportingUserAgentShouldParseWithProduct() { String minimal = "Reporting-UA: UA_name; UA_product"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.reportingUaField()).run(minimal); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(ReportingUserAgent.class); assertThat((ReportingUserAgent)result.resultValue).isEqualTo(ReportingUserAgent.builder().userAgentName("UA_name").userAgentProduct("UA_product").build()); }
@Test public void finalRecipientFieldShouldParse() { String finalRecipient = "Final-Recipient: rfc822; final_recipient"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.finalRecipientField()).run(finalRecipient); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(FinalRecipient.class); assertThat((FinalRecipient)result.resultValue).isEqualTo(FinalRecipient.builder().addressType(new AddressType("rfc822")).finalRecipient(Text.fromRawText("final_recipient")).build()); }
@Test public void mdnGatewayFieldShouldParse() { String gateway = "MDN-Gateway: smtp; apache.org"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.mdnGatewayField()).run(gateway); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(Gateway.class); assertThat((Gateway)result.resultValue).isEqualTo(Gateway.builder().nameType(new AddressType("smtp")).name(Text.fromRawText("apache.org")).build()); }
@Test public void originalRecipientFieldShouldParse() { String originalRecipient = "Original-Recipient: rfc822; originalRecipient"; Parser parser = Parboiled.createParser(MDNReportParser.Parser.class); ParsingResult<Object> result = new ReportingParseRunner<>(parser.originalRecipientField()).run(originalRecipient); assertThat(result.matched).isTrue(); assertThat(result.resultValue).isInstanceOf(OriginalRecipient.class); assertThat((OriginalRecipient)result.resultValue).isEqualTo(OriginalRecipient.builder().addressType(new AddressType("rfc822")).originalRecipient(Text.fromRawText("originalRecipient")).build()); }