Coverage report

  %line %branch
org.apache.commons.jexl.util.introspection.UberspectImpl
20% 
72% 

 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   
 
 17   
 package org.apache.commons.jexl.util.introspection;
 18   
 
 19   
 import org.apache.commons.jexl.util.ArrayIterator;
 20   
 import org.apache.commons.jexl.util.EnumerationIterator;
 21   
 import org.apache.commons.jexl.util.AbstractExecutor;
 22   
 import org.apache.commons.jexl.util.GetExecutor;
 23   
 import org.apache.commons.jexl.util.BooleanPropertyExecutor;
 24   
 import org.apache.commons.jexl.util.PropertyExecutor;
 25   
 import org.apache.commons.logging.Log;
 26   
 
 27   
 import java.lang.reflect.Method;
 28   
 import java.lang.reflect.InvocationTargetException;
 29   
 import java.util.Iterator;
 30   
 import java.util.Collection;
 31   
 import java.util.Map;
 32   
 import java.util.Enumeration;
 33   
 import java.util.ArrayList;
 34   
 
 35   
 /**
 36   
  *  Implementation of Uberspect to provide the default introspective
 37   
  *  functionality of Velocity
 38   
  *
 39   
  * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
 40   
  * @version $Id: UberspectImpl.java,v 1.6 2004/08/19 17:15:59 dion Exp $
 41   
  */
 42  30 
 public class UberspectImpl implements Uberspect, UberspectLoggable
 43   
 {
 44   
     /**
 45   
      *  Our runtime logger.
 46   
      */
 47   
     private Log rlog;
 48   
 
 49   
     /**
 50   
      *  the default Velocity introspector
 51   
      */
 52   
     private static Introspector introspector;
 53   
 
 54   
     /**
 55   
      *  init - does nothing - we need to have setRuntimeLogger
 56   
      *  called before getting our introspector, as the default
 57   
      *  vel introspector depends upon it.
 58   
      */
 59   
     public void init()
 60   
         throws Exception
 61   
     {
 62  0 
     }
 63   
 
 64   
     /**
 65   
      *  Sets the runtime logger - this must be called before anything
 66   
      *  else besides init() as to get the logger.  Makes the pull
 67   
      *  model appealing...
 68   
      */
 69   
     public void setRuntimeLogger(Log runtimeLogger)
 70   
     {
 71  30 
         rlog = runtimeLogger;
 72  30 
         introspector = new Introspector(rlog);
 73  30 
     }
 74   
 
 75   
     /**
 76   
      *  To support iteratives - #foreach()
 77   
      */
 78   
     public Iterator getIterator(Object obj, Info i)
 79   
             throws Exception
 80   
     {
 81  0 
         if (obj.getClass().isArray())
 82   
         {
 83  0 
             return new ArrayIterator(obj);
 84   
         }
 85  0 
         else if (obj instanceof Collection)
 86   
         {
 87  0 
             return ((Collection) obj).iterator();
 88   
         }
 89  0 
         else if (obj instanceof Map)
 90   
         {
 91  0 
             return ((Map) obj).values().iterator();
 92   
         }
 93  0 
         else if (obj instanceof Iterator)
 94   
         {
 95  0 
             rlog.warn ("Warning! The iterative "
 96   
                           + " is an Iterator in the #foreach() loop at ["
 97   
                           + i.getLine() + "," + i.getColumn() + "]"
 98   
                           + " in template " + i.getTemplateName()
 99   
                           + ". Because it's not resetable,"
 100   
                           + " if used in more than once, this may lead to"
 101   
                           + " unexpected results.");
 102   
 
 103  0 
             return ((Iterator) obj);
 104   
         }
 105  0 
         else if (obj instanceof Enumeration)
 106   
         {
 107  0 
             rlog.warn ("Warning! The iterative "
 108   
                           + " is an Enumeration in the #foreach() loop at ["
 109   
                           + i.getLine() + "," + i.getColumn() + "]"
 110   
                           + " in template " + i.getTemplateName()
 111   
                           + ". Because it's not resetable,"
 112   
                           + " if used in more than once, this may lead to"
 113   
                           + " unexpected results.");
 114   
 
 115  0 
             return new EnumerationIterator((Enumeration) obj);
 116   
         }
 117   
 
 118   
         /*  we have no clue what this is  */
 119  0 
         rlog.warn ("Could not determine type of iterator in "
 120   
                       +  "#foreach loop "
 121   
                       + " at [" + i.getLine() + "," + i.getColumn() + "]"
 122   
                       + " in template " + i.getTemplateName() );
 123   
 
 124  0 
         return null;
 125   
     }
 126   
 
 127   
     /**
 128   
      *  Method
 129   
      */
 130   
     public VelMethod getMethod(Object obj, String methodName, Object[] args, Info i)
 131   
             throws Exception
 132   
     {
 133  501 
         if (obj == null)
 134  0 
             return null;
 135   
 
 136  501 
         Method m = introspector.getMethod(obj.getClass(), methodName, args);
 137   
 
 138  501 
         return (m != null) ? new VelMethodImpl(m) : class="keyword">null;
 139   
     }
 140   
 
 141   
     /**
 142   
      * Property  getter
 143   
      */
 144   
     public VelPropertyGet getPropertyGet(Object obj, String identifier, Info i)
 145   
             throws Exception
 146   
     {
 147   
         AbstractExecutor executor;
 148   
 
 149  300 
         Class claz = obj.getClass();
 150   
 
 151   
         /*
 152   
          *  first try for a getFoo() type of property
 153   
          *  (also getfoo() )
 154   
          */
 155   
 
 156  300 
         executor = new PropertyExecutor(rlog,introspector, claz, identifier);
 157   
 
 158   
         /*
 159   
          *  look for boolean isFoo()
 160   
          */
 161   
 
 162  300 
         if( executor.isAlive() == false)
 163   
         {
 164  30 
             executor = new BooleanPropertyExecutor(rlog, introspector, claz, identifier);
 165   
         }
 166   
 
 167   
         /*
 168   
          *  if that didn't work, look for get("foo")
 169   
          */
 170   
 
 171  300 
         if (executor.isAlive() == false)
 172   
         {
 173  0 
             executor = new GetExecutor(rlog, introspector, claz, identifier);
 174   
         }
 175   
 
 176  300 
         return (executor != null) ? new VelGetterImpl(executor) : class="keyword">null;
 177   
     }
 178   
 
 179   
     /**
 180   
      * Property setter
 181   
      */
 182   
     public VelPropertySet getPropertySet(Object obj, String identifier, Object arg, Info i)
 183   
             throws Exception
 184   
     {
 185  0 
         Class claz = obj.getClass();
 186   
 
 187  0 
         VelMethod vm = null;
 188   
         try
 189   
         {
 190   
             /*
 191   
              *  first, we introspect for the set<identifier> setter method
 192   
              */
 193   
 
 194  0 
             Object[] params = {arg};
 195   
 
 196   
             try
 197   
             {
 198  0 
                 vm = getMethod(obj, "set" + identifier, params, i);
 199   
 
 200  0 
                 if (vm == null)
 201   
                 {
 202  0 
                    throw new NoSuchMethodException();
 203   
                 }
 204  0 
             }
 205   
             catch(NoSuchMethodException nsme2)
 206   
             {
 207  0 
                 StringBuffer sb = new StringBuffer("set");
 208  0 
                 sb.append(identifier);
 209   
 
 210  0 
                 if (Character.isLowerCase( sb.charAt(3)))
 211   
                 {
 212  0 
                     sb.setCharAt(3, Character.toUpperCase(sb.charAt(3)));
 213   
                 }
 214   
                 else
 215   
                 {
 216  0 
                     sb.setCharAt(3, Character.toLowerCase(sb.charAt(3)));
 217   
                 }
 218   
 
 219  0 
                 vm = getMethod(obj, sb.toString(), params, i);
 220   
 
 221  0 
                 if (vm == null)
 222   
                 {
 223  0 
                    throw new NoSuchMethodException();
 224   
                 }
 225   
             }
 226  0 
         }
 227   
         catch (NoSuchMethodException nsme)
 228   
         {
 229   
             /*
 230   
              *  right now, we only support the Map interface
 231   
              */
 232   
 
 233  0 
             if (Map.class.isAssignableFrom(claz))
 234   
             {
 235  0 
                 Object[] params = {new Object(), class="keyword">new Object()};
 236   
 
 237  0 
                 vm = getMethod(obj, "put", params, i);
 238   
 
 239  0 
                 if (vm!=null)
 240  0 
                     return new VelSetterImpl(vm, identifier);
 241   
             }
 242   
        }
 243   
 
 244  0 
        return (vm!=null) ?  new VelSetterImpl(vm) : class="keyword">null;
 245   
     }
 246   
 
 247   
     /**
 248   
      *  Implementation of VelMethod
 249   
      */
 250   
     public class VelMethodImpl implements VelMethod
 251   
     {
 252   
         Method method = null;
 253   
 
 254   
         public VelMethodImpl(Method m)
 255   
         {
 256   
             method = m;
 257   
         }
 258   
 
 259   
         private VelMethodImpl()
 260   
         {
 261   
         }
 262   
 
 263   
         public Object invoke(Object o, Object[] params)
 264   
             throws Exception
 265   
         {
 266   
             try
 267   
             {
 268   
                 return method.invoke(o, params);
 269   
             }
 270   
             catch( InvocationTargetException e )
 271   
             {
 272   
                 final Throwable t = e.getTargetException();
 273   
 
 274   
                 if( t instanceof Exception )
 275   
                 {
 276   
                     throw (Exception)t;
 277   
                 }
 278   
                 else if (t instanceof Error)
 279   
                 {
 280   
                     throw (Error)t;
 281   
                 }
 282   
                 else
 283   
                 {
 284   
                     throw e;
 285   
                 }
 286   
             }
 287   
         }
 288   
 
 289   
         public boolean isCacheable()
 290   
         {
 291   
             return true;
 292   
         }
 293   
 
 294   
         public String getMethodName()
 295   
         {
 296   
             return method.getName();
 297   
         }
 298   
 
 299   
         public Class getReturnType()
 300   
         {
 301   
             return method.getReturnType();
 302   
         }
 303   
     }
 304   
 
 305   
     public class VelGetterImpl implements VelPropertyGet
 306   
     {
 307   
         AbstractExecutor ae = null;
 308   
 
 309   
         public VelGetterImpl(AbstractExecutor exec)
 310   
         {
 311   
             ae = exec;
 312   
         }
 313   
 
 314   
         private VelGetterImpl()
 315   
         {
 316   
         }
 317   
 
 318   
         public Object invoke(Object o)
 319   
             throws Exception
 320   
         {
 321   
             return ae.execute(o);
 322   
         }
 323   
 
 324   
         public boolean isCacheable()
 325   
         {
 326   
             return true;
 327   
         }
 328   
 
 329   
         public String getMethodName()
 330   
         {
 331   
             return ae.getMethod().getName();
 332   
         }
 333   
 
 334   
     }
 335   
 
 336  8 
     public class VelSetterImpl implements VelPropertySet
 337   
     {
 338   
         VelMethod vm = null;
 339   
         String putKey = null;
 340   
 
 341   
         public VelSetterImpl(VelMethod velmethod)
 342   
         {
 343   
             this.vm = velmethod;
 344   
         }
 345   
 
 346   
         public VelSetterImpl(VelMethod velmethod, String key)
 347   
         {
 348   
             this.vm = velmethod;
 349   
             putKey = key;
 350   
         }
 351   
 
 352   
         private VelSetterImpl()
 353   
         {
 354   
         }
 355   
 
 356   
         public Object invoke(Object o, Object value)
 357   
             throws Exception
 358   
         {
 359   
             ArrayList al = new ArrayList();
 360   
 
 361   
             if (putKey != null)
 362   
             {
 363   
                 al.add(putKey);
 364   
                 al.add(value);
 365   
             }
 366   
             else
 367   
             {
 368   
                 al.add(value);
 369   
             }
 370   
 
 371   
             return vm.invoke(o,al.toArray());
 372   
         }
 373   
 
 374   
         public boolean isCacheable()
 375   
         {
 376   
             return true;
 377   
         }
 378   
 
 379   
         public String getMethodName()
 380   
         {
 381   
             return vm.getMethodName();
 382   
         }
 383   
 
 384   
     }
 385   
 }

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