/** * Returns true when the argument is null or is equal to {@link ExpectationResult#INCORRECT}. * * @param obj object to compare * @return true when the argument is null or is equal to {@link ExpectationResult#INCORRECT} */ public static boolean nullOrUnexpected(Object obj) { return obj == null || ExpectationResult.INCORRECT.equals(obj); }
public static <T> BetweenParser<T> between(ExpectantParser start, Parser<T> parser, ExpectantParser end) { return new BetweenParser<T>(start, parser, end); }
public static ExpectantParser expect(String expectation) { return new ExpectantParser(expectation); }
@Test public void testBetweenParser() throws ParseException { assertEquals("abcdef", new BetweenParser<String>(new ExpectantParser("{"), Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.prefix(Parsers.whitespace(), new ExpectantParser("}"))) .parse(new StringParserState("{ abcdef }"))); }
@Override public SetType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("set").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureType itemType = Parsers.liberalBetween("<", TypeParser.INSTANCE, ">").parse(input); ConjureMetrics.incrementCounter(SetType.class); return SetType.of(itemType); } }
@Override public Boolean parse(ParserState input) throws ParseException { String val = new RawStringParser().parse(input); return !Parsers.nullOrEmpty(val) && (val.equalsIgnoreCase("true") || val.equalsIgnoreCase("yes") || val.equalsIgnoreCase("1")); }
@Override public MapType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("map").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } Parser<KeyValue<ConjureType, ConjureType>> kv = Parsers.liberalBetween( "<", new KeyValueParser<>( Parsers.whitespace(TypeParser.INSTANCE), Parsers.whitespace(Parsers.expect(",")), Parsers.whitespace(TypeParser.INSTANCE)), ">"); KeyValue<ConjureType, ConjureType> types = kv.parse(input); ConjureMetrics.incrementCounter(MapType.class); return MapType.of(types.getKey(), types.getValue()); } }
@Test public void testDispatchingParser() throws ParseException { Map<String, Parser<String>> map = new HashMap<String, Parser<String>>(); map.put("dir1", new RawStringParser()); map.put("dir2", new QuotedStringParser()); assertEquals("def", new DispatchingParser<String>(map, Parsers.whitespace()) .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))); assertEquals("def", new DispatchingParser<String>(map, Parsers.whitespace()) .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))); }
@Test public void testExpectantParser() { assertEquals(ExpectationResult.CORRECT, new ExpectantParser("abcdef").parse(new StringParserState("abcdef"))); assertEquals(ExpectationResult.INCORRECT, new ExpectantParser("abcdef").parse(new StringParserState("abcde"))); assertEquals(ExpectationResult.INCORRECT, new ExpectantParser("abcdef").parse(new StringParserState("abcdeg"))); }
@Test public void testListParser() throws ParseException { List<String> list = new ArrayList<>(); list.add("abc"); list.add("def"); assertEquals(list, new ListParser<>(new QuotedStringParser(), Parsers.whitespace()) .parse(new StringParserState("\"abc\" \"def\""))); }
public DispatchingParser(Map<String, Parser<T>> parsers, Parser<?> whitespaceParser) { this(parsers, new RawStringParser(), whitespaceParser); }
@Override public T parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect(type).parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureMetrics.incrementCounter(metric); return instance; }
@Test public void testQuotedStringParser() throws ParseException { assertEquals("Test 123", new QuotedStringParser(false).parse(new StringParserState("\"Test 123\""))); assertEquals("Test \"123", new QuotedStringParser(false).parse(new StringParserState("\"Test \\\"123\""))); assertEquals("Test 123", new QuotedStringParser(false).parse(new StringParserState("\"Test \n\n123\""))); assertEquals("Test \n\n123", new QuotedStringParser(true).parse(new StringParserState("\"Test \n\n123\""))); }
@Override public String parse(ParserState input) { StringBuilder sb = new StringBuilder(); int curr = input.curr(); // not at end of the file and character is explicitly allowed while (curr != -1 && condition.isAllowed((char) curr)) { sb.append((char) curr); curr = input.next(); } return sb.length() > 0 ? sb.toString() : null; }
@Override public OptionalType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("optional").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureType itemType = Parsers.liberalBetween("<", TypeParser.INSTANCE, ">").parse(input); ConjureMetrics.incrementCounter(OptionalType.class); return OptionalType.of(itemType); } }
@Test public void testRawStringParser() { assertEquals("a:b123", new RawStringParser().parse(new StringParserState("a:b123"))); assertNull(new RawStringParser().parse(new StringParserState(" a:b123"))); assertEquals("ab123", new RawStringParser().parse(new StringParserState("ab123 "))); assertEquals("ab123", new RawStringParser().parse(new StringParserState("ab123\n"))); }
public static <T> BetweenParser<T> between(String start, Parser<T> parser, String end) { return new BetweenParser<T>(expect(start), parser, expect(end)); }
public DefaultingDispatchingParser(Map<String, Parser<T>> parsers, Parser<?> whitespaceParser) { this(parsers, new RawStringParser(), whitespaceParser); }
@Override public ListType parse(ParserState input) throws ParseException { ExpectationResult result = Parsers.expect("list").parse(input); if (Parsers.nullOrUnexpected(result)) { return null; } ConjureType itemType = Parsers.liberalBetween("<", TypeParser.INSTANCE, ">").parse(input); ConjureMetrics.incrementCounter(ListType.class); return ListType.of(itemType); } }
public static <T> BetweenParser<T> liberalBetween(String start, Parser<T> parser, String end) { return new BetweenParser<T>(whitespace(expect(start)), whitespace(parser), whitespace(expect(end))); }