Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.jelly.expression.CompositeExpression |
69% |
90% |

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.jelly.expression;
17 |  |
18 |  |
     import java.util.ArrayList;
19 |  |
     import java.util.Collections;
20 |  |
     import java.util.Iterator;
21 |  |
     import java.util.List;
22 |  |
23 |  |
     import org.apache.commons.collections.iterators.SingletonIterator;
24 |  |
25 |  |
     import org.apache.commons.jelly.JellyContext;
26 |  |
     import org.apache.commons.jelly.JellyException;
27 |  |
28 |  |
     /**
29 |  |
      * <p><code>CompositeExpression</code> is a Composite expression made up of several
30 |  |
      * Expression objects which are concatenated into a single String.</p>
31 |  |
      *
32 |  |
      * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
33 |  |
      * @version $Revision: 155420 $
34 |  |
      */
35 |  |
     public class CompositeExpression extends ExpressionSupport {
36 |  |
37 |  |
         /** The expressions */
38 |  |
         private List expressions;
39 |  |
40 | 533 |
         public CompositeExpression() {
41 | 533 |
             this.expressions = new ArrayList();
42 | 533 |
         }
43 |  |
44 | 0 |
         public CompositeExpression(List expressions) {
45 | 0 |
             this.expressions = expressions;
46 | 0 |
         }
47 |  |
48 |  |
         public String toString() {
49 | 0 |
             return super.toString() + "[expressions=" + expressions +"]";
50 |  |
         }
51 |  |
52 |  |
         /**
53 |  |
          * Parses the given String to be either a ConstantExpresssion, an Expression denoted as
54 |  |
          * "${foo}" or some String with embedded expresssions such as "abc${something}def${else}xyz"
55 |  |
          * which results in a CompositeExpression being returned.
56 |  |
          *
57 |  |
          * @param text is the String to parse into expressions
58 |  |
          * @param factory is the Factory of Expression objects used to create expresssions for the contents
59 |  |
          *  of the String "foo" inside expressions such as "${foo}"
60 |  |
          *
61 |  |
          * @return the Expresssion for the given String.
62 |  |
          * @throws JellyException if the text is invalid (such as missing '}' character).
63 |  |
          * @throws JellyException if there was some problem creating the underlying Expression object
64 |  |
          *  from the ExpressionFactory
65 |  |
          */
66 |  |
         public static Expression parse(String text, ExpressionFactory factory) throws JellyException {
67 |  |
68 | 53950 |
             int len = text.length();
69 |  |
70 | 53950 |
             int startIndex = text.indexOf( "${" );
71 |  |
72 | 53950 |
             if ( startIndex < 0) {
73 | 46410 |
                 return new ConstantExpression(text);
74 |  |
             }
75 |  |
76 | 7540 |
             int endIndex = text.indexOf( "}", startIndex+2 );
77 |  |
78 | 7540 |
             if ( endIndex < 0 ) {
79 | 0 |
                 throw new JellyException( "Missing '}' character at the end of expression: " + text );
80 |  |
             }
81 | 7540 |
             if ( startIndex == 0 && endIndex == len - 1 ) {
82 | 7007 |
                 return factory.createExpression(text.substring(2, endIndex));
83 |  |
             }
84 |  |
85 | 533 |
             CompositeExpression answer = new CompositeExpression();
86 |  |
87 | 533 |
             int cur = 0;
88 | 533 |
             char c = 0;
89 |  |
90 | 533 |
             StringBuffer chars = new StringBuffer();
91 | 533 |
             StringBuffer expr  = new StringBuffer();
92 |  |
93 |  |
           MAIN:
94 | 11232 |
             while ( cur < len ) {
95 | 10699 |
                 c = text.charAt( cur );
96 |  |
97 | 10699 |
                 switch ( c ) {
98 |  |
                     case('$'):
99 | 988 |
                         if ( cur+1<len ) {
100 | 988 |
                             ++cur;
101 | 988 |
                             c = text.charAt( cur );
102 |  |
103 | 988 |
                             switch ( c ) {
104 |  |
                                 case('$'):
105 | 0 |
                                     chars.append( c );
106 | 0 |
                                     break;
107 |  |
                                 case('{'):
108 | 988 |
                                     if ( chars.length() > 0 ) {
109 | 507 |
                                         answer.addTextExpression( chars.toString() );
110 | 507 |
                                         chars.delete(0, chars.length() );
111 |  |
                                     }
112 |  |
113 | 988 |
                                     if (cur+1<len) {
114 | 988 |
                                         ++cur;
115 |  |
116 | 10881 |
                                         while (cur<len) {
117 | 10881 |
                                             c = text.charAt(cur);
118 | 10881 |
                                             switch ( c ) {
119 |  |
                                                 case('"'):
120 | 13 |
                                                   expr.append( c );
121 | 13 |
                                                   ++cur;
122 |  |
123 |  |
                                                   DOUBLE_QUOTE:
124 | 91 |
                                                     while(cur<len) {
125 | 91 |
                                                         c = text.charAt(cur);
126 |  |
127 | 91 |
                                                         switch ( c ) {
128 |  |
                                                             case('\\'):
129 | 0 |
                                                                 ++cur;
130 | 0 |
                                                                 expr.append(c);
131 | 0 |
                                                                 break;
132 |  |
                                                             case('"'):
133 | 13 |
                                                                 ++cur;
134 | 13 |
                                                                 expr.append(c);
135 | 13 |
                                                                 break DOUBLE_QUOTE;
136 |  |
                                                             default:
137 | 78 |
                                                                 ++cur;
138 | 78 |
                                                                 expr.append(c);
139 |  |
                                                         } // switch
140 | 78 |
                                                     } // while
141 |  |
                                                     break;
142 |  |
                                                 case('\''):
143 | 0 |
                                                     expr.append( c );
144 | 0 |
                                                     ++cur;
145 |  |
146 |  |
                                                   SINGLE_QUOTE:
147 | 0 |
                                                     while(cur<len) {
148 | 0 |
                                                         c = text.charAt(cur);
149 |  |
150 | 0 |
                                                         switch ( c ) {
151 |  |
                                                             case('\\'):
152 | 0 |
                                                                 ++cur;
153 | 0 |
                                                                 expr.append(c);
154 | 0 |
                                                                 break;
155 |  |
                                                             case('\''):
156 | 0 |
                                                                 ++cur;
157 | 0 |
                                                                 expr.append(c);
158 | 0 |
                                                                 break SINGLE_QUOTE;
159 |  |
                                                             default:
160 | 0 |
                                                                 ++cur;
161 | 0 |
                                                                 expr.append(c);
162 |  |
                                                         } // switch
163 | 0 |
                                                     } // while
164 |  |
                                                     break;
165 |  |
                                                 case('}'):
166 | 988 |
                                                     answer.addExpression(factory.createExpression(expr.toString()));
167 | 988 |
                                                     expr.delete(0, expr.length());
168 | 988 |
                                                     ++cur;
169 | 988 |
                                                     continue MAIN;
170 |  |
                                                 default:
171 | 9880 |
                                                     expr.append( c );
172 | 9880 |
                                                     ++cur;
173 |  |
                                             }
174 | 9880 |
                                         }
175 |  |
                                     }
176 |  |
                                     break;
177 |  |
                                 default:
178 | 0 |
                                     chars.append(c);
179 |  |
                             }
180 | 0 |
                         }
181 |  |
                         else
182 |  |
                         {
183 | 0 |
                             chars.append(c);
184 |  |
                         }
185 | 0 |
                         break;
186 |  |
                     default:
187 | 9711 |
                         chars.append( c );
188 |  |
                 }
189 | 9711 |
                 ++cur;
190 | 9711 |
             }
191 |  |
192 | 533 |
             if ( chars.length() > 0 )
193 |  |
             {
194 | 286 |
                 answer.addTextExpression( chars.toString() );
195 |  |
             }
196 |  |
197 | 533 |
             return answer;
198 |  |
         }
199 |  |
200 |  |
         // Properties
201 |  |
         //-------------------------------------------------------------------------
202 |  |
203 |  |
         /**
204 |  |
          * @return the Expression objects that make up this
205 |  |
          * composite expression
206 |  |
          */
207 |  |
         public List getExpressions() {
208 | 208 |
             return expressions;
209 |  |
         }
210 |  |
211 |  |
         /**
212 |  |
          * Sets the Expression objects that make up this
213 |  |
          * composite expression
214 |  |
          */
215 |  |
         public void setExpressions(List expressions) {
216 | 0 |
             this.expressions = expressions;
217 | 0 |
         }
218 |  |
219 |  |
         /**
220 |  |
          * Adds a new expression to the end of the expression list
221 |  |
          */
222 |  |
         public void addExpression(Expression expression) {
223 | 1781 |
             expressions.add(expression);
224 | 1781 |
         }
225 |  |
226 |  |
         /**
227 |  |
          * A helper method to add a new constant text expression
228 |  |
          */
229 |  |
         public void addTextExpression(String text) {
230 | 793 |
             addExpression(new ConstantExpression(text));
231 | 793 |
         }
232 |  |
233 |  |
         // Expression interface
234 |  |
         //-------------------------------------------------------------------------
235 |  |
236 |  |
         public String getExpressionText() {
237 | 91 |
             StringBuffer buffer = new StringBuffer();
238 | 91 |
             for (Iterator iter = expressions.iterator(); iter.hasNext(); ) {
239 | 273 |
                 Expression expression = (Expression) iter.next();
240 | 273 |
                 buffer.append( expression.getExpressionText() );
241 | 273 |
             }
242 | 91 |
             return buffer.toString();
243 |  |
         }
244 |  |
245 |  |
246 |  |
         // inherit javadoc from interface
247 |  |
         public Object evaluate(JellyContext context) {
248 | 1456 |
             return evaluateAsString(context);
249 |  |
         }
250 |  |
251 |  |
         // inherit javadoc from interface
252 |  |
         public String evaluateAsString(JellyContext context) {
253 | 1456 |
             StringBuffer buffer = new StringBuffer();
254 | 1456 |
             for (Iterator iter = expressions.iterator(); iter.hasNext(); ) {
255 | 3003 |
                 Expression expression = (Expression) iter.next();
256 | 3003 |
                 String value = expression.evaluateAsString(context);
257 | 3003 |
                 if ( value != null ) {
258 | 2977 |
                     buffer.append( value );
259 |  |
                 }
260 | 3003 |
             }
261 | 1456 |
             return buffer.toString();
262 |  |
263 |  |
         }
264 |  |
265 |  |
         // inherit javadoc from interface
266 |  |
         public Iterator evaluateAsIterator(JellyContext context) {
267 | 0 |
             String value = evaluateAsString(context);
268 | 0 |
             if ( value == null ) {
269 | 0 |
                 return Collections.EMPTY_LIST.iterator();
270 |  |
             }
271 |  |
             else {
272 | 0 |
                 return new SingletonIterator( value );
273 |  |
             }
274 |  |
         }
275 |  |
     }

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