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.