%line	%branch
org.apache.commons.jexl.ExpressionFactory	92%	92%

1		/*
2		* Copyright 2002,2004 The Apache Software Foundation.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.apache.commons.jexl;
17
18		import java.io.StringReader;
19
20		import org.apache.commons.jexl.parser.ASTExpressionExpression;
21		import org.apache.commons.jexl.parser.ASTReferenceExpression;
22		import org.apache.commons.jexl.parser.Parser;
23		import org.apache.commons.jexl.parser.SimpleNode;
24		import org.apache.commons.logging.Log;
25		import org.apache.commons.logging.LogFactory;
26
27		/**
28		* <p>
29		* Creates Expression objects. To create a JEXL Expression object, pass
30		* valid JEXL syntax to the static createExpression() method:
31		* </p>
32		*
33		* <pre>
34		* String jexl = "array[1]";
35		* Expression expression = ExpressionFactory.createExpression( jexl );
36		* </pre>
37		*
38		* <p>
39		* When an {@link Expression} object is created, the JEXL syntax is
40		* parsed and verified. If the supplied expression is neither an
41		* expression not a reference, an exception is thrown from createException().
42		* </p>
43		* @author <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
44		* @version $Id: ExpressionFactory.java,v 1.7 2004/08/23 13:50:00 dion Exp $
45		*/
46	2	public class ExpressionFactory
47		{
48		/**
49		* The Log to which all ExpressionFactory messages will be logged.
50		*/
51	50	protected static Log log =
52	2	LogFactory.getLog("org.apache.commons.jexl.ExpressionFactory");
53
54		/**
55		* The singleton ExpressionFactory also holds a single instance of {@link Parser}.
56		* When parsing expressions, ExpressionFactory synchronizes on Parser.
57		*/
58	30	protected static Parser parser = new Parser(class="keyword">new StringReader(";")); //$NON-NLS-1$
59
60		/**
61		* ExpressionFactory is a single and this is the private
62		* status instance fufilling that pattern.
63		*/
64	30	protected static ExpressionFactory ef = new ExpressionFactory();
65
66		/**
67		* Private constructor, the single instance is always obtained
68		* with a call to getInstance().
69		*/
70	30	private ExpressionFactory(){}
71
72		/**
73		* Returns the single instance of ExpressionFactory.
74		* @return the instance of ExpressionFactory.
75		*/
76		protected static ExpressionFactory getInstance()
77		{
78	2748	return ef;
79		}
80
81		/**
82		* Creates an Expression from a String containing valid
83		* JEXL syntax. This method parses the expression which
84		* must contain either a reference or an expression.
85		* @param expression A String containing valid JEXL syntax
86		* @return An Expression object which can be evaluated with a JexlContext
87		* @throws Exception An exception can be thrown if there is a problem parsing
88		* his expression, or if the expression is neither an
89		* expression or a reference.
90		*/
91		public static Expression createExpression(String expression)
92		throws Exception
93		{
94	2748	return getInstance().createNewExpression(expression);
95		}
96
97
98		/**
99		* Creates a new Expression based on the expression string.
100		*
101		* @param expression valid Jexl expression
102		* @return Expression
103		* @throws Exception for a variety of reasons - mostly malformed
104		* Jexl expression
105		*/
106		protected Expression createNewExpression(String expression)
107		throws Exception {
108
109	2748	String expr = cleanExpression(expression);
110
111		// Parse the Expression
112		SimpleNode tree;
113	2935	synchronized(parser)
114		{
115	2748	log.debug( "Parsing expression: " + expr );
116	2748	tree = parser.parse(new StringReader(expr));
117	2546	}
118
119		// Must be a simple reference or expression, otherwise
120		// throw an exception.
121	2733	SimpleNode node = (SimpleNode) tree.jjtGetChild(0);
122
123	2733	if( (node instanceof ASTReferenceExpression) ||
124	128	(node instanceof ASTExpressionExpression) )
125		{
126	2733	node = (SimpleNode) node.jjtGetChild(0);
127	2733	Expression e = new ExpressionImpl(expression, node);
128
129	2733	return e;
130		}
131		else
132		{
133	0	log.error( "Invalid Expression, node of type: " + node.getClass().getName() );
134	0	throw new Exception("Invalid Expression: neither Reference nor Expression");
135		}
136		}
137
138		/**
139		* Trims the expression and adds a semi-colon if missing.
140		* @param expression to clean
141		* @return trimmed expression ending in a semi-colon
142		*/
143		private String cleanExpression(String expression) {
144	2748	String expr = expression.trim();
145	2748	if (!expr.endsWith(";"))
146		{
147	2748	expr += ";";
148		}
149	2748	return expr;
150		}
151		}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.