com.revolsys.util.JexlUtil.java Source code

Introduction

Here is the source code for com.revolsys.util.JexlUtil.java

Source

/*
 * Copyright 2004-2005 Revolution Systems Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.revolsys.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.jexl.Expression;
import org.apache.commons.jexl.ExpressionFactory;
import org.apache.commons.jexl.JexlContext;
import org.apache.log4j.Logger;

/**
 * The JexlUtil is a utility class for processing strings that contain patterns
 * from the Jakarta Commons Jexl library.
 *
 * @author Paul Austin
 */
public final class JexlUtil {
    /** The default expression pattern matching expressions in the form ${el}. */
    public static final String DEFAULT_EXPRESSION_PATTERN = "\\$\\{([^\\}]+)\\}";

    private static final Logger LOG = Logger.getLogger(JexlUtil.class);

    /**
     * Add the text to the Jexl expression, wrapping the text in a '' string.
     *
     * @param jexlExpression The expression to add the test to.
     * @param text The text to add.
     */
    private static void addText(final StringBuilder jexlExpression, final String text) {
        jexlExpression.append("'").append(text.replaceAll("'", "' + \"'\" + '")).append("'");
    }

    public static Object evaluateExpression(final JexlContext context, final Expression expression) {
        try {
            return expression.evaluate(context);
        } catch (final Exception e) {
            LOG.error("Unable to evaluate expression '" + expression.getExpression() + "': " + e.getMessage(), e);
            return null;
        }
    }

    /**
     * Convert expressions into valid JexlExpressions, if the string does not
     * contain any expressions in the form ${el} then null will be returned and
     * the caller can use the raw string.
     *
     * @param expression The string containing expressions.
     * @return The expression object for the string expression.
     * @throws Exception If there was an error creating the expression.
     */
    public static Expression newExpression(final String expression) throws Exception {
        return newExpression(expression, DEFAULT_EXPRESSION_PATTERN);
    }

    /**
     * <p>
     * Convert expressions into valid JexlExpressions, if the string does not
     * contain any expressions that match the expressionPattern then null will be
     * returned and the caller can use the raw string.
     * </p>
     * <p>
     * The expressionPattern can be used to define an alternate pattern than the
     * {@link #DEFAULT_EXPRESSION_PATTERN} that defines expressions in the form
     * ${el}. The pattern is defined as a Java Regular expression. The contents of
     * the expression part of the pattern must be enclosed in () to define the
     * group. The characters outside the first group will be removed from the
     * string and the expression portion will be added to the expression.
     * </p>
     *
     * @param expression The string containing expressions.
     * @param expressionPattern The regular expression pattern used to identify
     *          expressions in the string. The first group in the expression will
     *          be used as the expression.
     * @return The expression object for the string expression.
     * @throws Exception If there was an error creating the expression.
     */
    public static Expression newExpression(final String expression, final String expressionPattern)
            throws Exception {
        final String newExpression = expression.replaceAll("\n", "");
        // Wrap the entires expression in '' and replace the expressions in the
        // form "${expr)" to ' + expr + '
        final Pattern compiledPattern = Pattern.compile(expressionPattern);
        final Matcher matcher = compiledPattern.matcher(newExpression);
        int lastEnd = 0;
        if (matcher.find()) {
            final StringBuilder jexlExpression = new StringBuilder();
            do {
                final int startIndex = matcher.start();
                if (startIndex != lastEnd) {
                    final String text = newExpression.substring(lastEnd, startIndex);
                    addText(jexlExpression, text);
                    jexlExpression.append(" + ");
                }
                final String matchedExpression = matcher.group(1);
                jexlExpression.append(matchedExpression).append(" + ");
                lastEnd = matcher.end();
            } while (matcher.find());
            addText(jexlExpression, newExpression.substring(lastEnd));

            // Remove any empty strings from the expression to improve
            // performance
            String expr = jexlExpression.toString();
            expr = expr.replaceAll(" \\+ '' \\+ ", " + ");
            expr = expr.replaceAll("^'' \\+ ", "");
            expr = expr.replaceAll("\\+ ''$", "");
            return ExpressionFactory.createExpression(expr);
        } else {
            return null;
        }
    }

    /**
     * Construct a new JexlUtil.
     */
    private JexlUtil() {
    }

}