private boolean isValid(String updatedFormula) { try { FormulaParser.parse(updatedFormula); return true; } catch (Exception e) { return false; } } }
public Multimap<Integer, FilterConfig> parseFilter(Optional<String> filterString) { if(filterString.isPresent()) { return parseFilter(FormulaParser.parse(filterString.get())); } else { return EMPTY; } }
@JsonSetter public void setFilter(String filterExpression) { if(filterExpression == null) { this.filter = null; } else { this.filter = FormulaParser.parse(filterExpression); } }
private List<FormulaNode> parsePermission(String filter) { FormulaNode formulaNode = FormulaParser.parse(filter); return Formulas.findBinaryTree(formulaNode, AndFunction.INSTANCE); }
private static FormulaNode parseFilter(String filter) { if(Strings.isNullOrEmpty(filter)) { return new ConstantNode(true); } try { return FormulaParser.parse(filter); } catch (FormulaException e) { // Failed to parse filter, falling back to denied access return new ConstantNode(false); } }
public static FormulaNode parse(String expression) { if(Strings.isNullOrEmpty(expression)) { return new ConstantNode((String)null); } FormulaLexer lexer = new FormulaLexer(expression); FormulaParser parser = new FormulaParser(lexer); return parser.parse(); } }
public CalculatedField(FormField field) { this.field = field; CalculatedFieldType type = (CalculatedFieldType) field.getType(); try { expr = FormulaParser.parse(type.getExpression()); } catch(FormulaException e) { LOGGER.log(Level.WARNING, "Expression failed to parse: " + type.getExpression(), e); expr = null; errorValue = new ErrorValue(e); } }
@JsonSetter public ColumnModel setFormula(String formula) { try { this.formula = FormulaParser.parse(formula); } catch (FormulaSyntaxException e) { throw new ColumnModelException("Invalid column expression '" + formula + "': " + e.getMessage(), e); } return this; }
@Test public void decomposition() { assertThat(Formulas.findBinaryTree(parse("A && B"), AND), contains(A, B)); assertThat(Formulas.findBinaryTree(parse("A && B && C"), AND), contains(A, B, C)); assertThat(Formulas.findBinaryTree(parse("A && (B && C)"), AND), contains(A, B, C)); assertThat(Formulas.findBinaryTree(parse("(A && ((B && (C))))"), AND), contains(A, B, C)); }
@Test public void stringContains() { ColumnFilterParser parser = new ColumnFilterParser(asList(A)); Multimap<Integer, FilterConfig> map = parser.parseFilter(parse("ISNUMBER(SEARCH('foo', A))")); Matcher<FilterConfig> equality = Matchers.allOf( hasProperty("type", equalTo("string")), hasProperty("comparison", equalTo("contains")), hasProperty("value", equalTo("foo"))); assertThat(map.get(0), contains(equality)); }
@Test public void dateComparison() { ColumnFilterParser parser = new ColumnFilterParser(asList(A)); Multimap<Integer, FilterConfig> map = parser.parseFilter(parse("A == DATE(2017, 1, 1)")); Matcher<FilterConfig> equality = Matchers.allOf( hasProperty("type", equalTo("date")), hasProperty("comparison", equalTo("on")), hasProperty("value", equalTo("" + new LocalDate(2017, 1, 1).atMidnightInMyTimezone().getTime()))); assertThat(map.get(0), contains(equality)); }
@Test public void twoFields() { ColumnFilterParser parser = new ColumnFilterParser(asList(A, B)); Multimap<Integer, FilterConfig> map = parser.parseFilter(parse("A > 50 && B == 30")); assertThat(map.get(0), contains(numericFilter("gt", 50))); assertThat(map.get(1), contains(numericFilter("eq", 30))); }
@Test public void range() { ColumnFilterParser parser = new ColumnFilterParser(asList(A)); Multimap<Integer, FilterConfig> map = parser.parseFilter(parse("A > 50 && A < 100")); assertThat(map.get(0), containsInAnyOrder( numericFilter("gt", 50), numericFilter("lt", 100))); }
@Test public void roundTrip() { FilterConfig config = new FilterConfigBean(); config.setType("numeric"); config.setComparison("eq"); config.setValue("1"); FormulaNode columnExpr = parse("IF(A && B, A * 42 / 3, CEIL(B / 99))"); String filterFormula = toFormula(columnExpr, config).asExpression(); ColumnFilterParser parser = new ColumnFilterParser(asList(A, columnExpr)); Multimap<Integer, FilterConfig> map = parser.parseFilter(parse(filterFormula)); assertThat(map.get(1), contains(numericFilter("eq", 1))); }
private void evaluate(String exprString, double expectedValue) { FormulaLexer lexer = new FormulaLexer(exprString); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); FieldValue value = expr.evaluate(EmptyEvalContext.INSTANCE); if(Double.isNaN(expectedValue)) { assertTrue(exprString + " is NaN", Double.isNaN(Casting.toQuantity(value).getValue())); } else { assertThat(exprString, Casting.toQuantity(value).getValue(), closeTo(expectedValue, 0)); } }
private FormulaValidator validate(String formula) { Survey surveyForm = catalog.getSurvey(); FormulaValidator validator = new FormulaValidator(catalog.getFormTree(surveyForm.getFormId())); validator.validate(FormulaParser.parse(formula)); for (FormulaError error : validator.getErrors()) { System.out.println("Error at " + error.getSourceRange() + ": " + error.getMessage()); } return validator; }
@Test public void symbolSourceConstants() { FunctionCallNode call = (FunctionCallNode) FormulaParser.parse("1+3.456"); assertThat(call.getSourceRange(), equalTo(new SourceRange(new SourcePos(0, 0), new SourcePos(0, 7)))); }
private void eval(String relevanceExpression, boolean expectedValue, TypedFormRecord instance) { FormulaLexer lexer = new FormulaLexer(relevanceExpression); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); Assert.assertEquals(relevanceExpression, expectedValue, Casting.toBoolean(expr.evaluate(new FormEvalContext(formClass, instance)))); }
private void eval(String relevanceExpression, boolean expectedValue, TypedFormRecord instance) { FormulaLexer lexer = new FormulaLexer(relevanceExpression); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); Assert.assertEquals(relevanceExpression, expectedValue, Casting.toBoolean(expr.evaluate(new FormEvalContext(formClass, instance)))); }
@Test public void symbolSourceRefs() { FunctionCallNode call = (FunctionCallNode) FormulaParser.parse("[A] + [B]"); assertThat(call.getSourceRange(), equalTo(new SourceRange(new SourcePos(0, 0), new SourcePos(0, 9)))); assertThat(call.getArgument(1).getSourceRange(), equalTo(new SourceRange(new SourcePos(0, 6), new SourcePos(0, 9)))); }