Added support for list attributes to have expressions.

- This will certainly need review as the current implementation breaks current behavior with relation to attributes from list attributes being exposed to the view, while simple attributes are not.
- This implementation maps everything to the objects represented type where possible, though due to current requirements elements must remain to be an attribute wrapping the value.
- Attribute#getExpression is evaluated and set against a cloned version of Attribute#setValue.

Author: brettryan

tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java

@@ -18,11 +18,18 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+
 package org.apache.tiles.evaluator;
 
+import java.util.ArrayList;
+import java.util.List;
 import org.apache.tiles.Attribute;
 import org.apache.tiles.Expression;
+import org.apache.tiles.ListAttribute;
 import org.apache.tiles.request.Request;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 
 /**
  * Abstract class to link a correct evaluation of an attribute, by evaluating
@@ -33,7 +40,10 @@
  */
 public abstract class AbstractAttributeEvaluator implements AttributeEvaluator {
 
+    private static final Logger log = LoggerFactory.getLogger(AbstractAttributeEvaluator.class);
+
     /** {@inheritDoc} */
+    @Override
     public Object evaluate(Attribute attribute, Request request) {
         if (attribute == null) {
             throw new IllegalArgumentException("The attribute cannot be null");
@@ -44,11 +54,49 @@ public Object evaluate(Attribute attribute, Request request) {
         if (retValue == null) {
             Expression expression = attribute.getExpressionObject();
             if (expression != null) {
+                log.debug("Evaluating expression: [attribute={},expression={}]", attribute, expression);
                 retValue = evaluate(attribute.getExpressionObject()
                         .getExpression(), request);
             }
+        } else if (retValue instanceof List) {
+            log.debug("Evaluating list for expressions: {}", retValue);
+            retValue = evaluateList((List) retValue, request);
         }
 
+        log.debug("Returning result: {}", retValue);
         return retValue;
     }
+
+    private List evaluateList(List src, Request request) {
+        List res = new ArrayList();
+        for (Object val : src) {
+            if (val instanceof ListAttribute) {
+                log.debug("Evaluating list entry (ListAttribute): {}", val);
+                res.add(evaluateList(((ListAttribute) val).getValue(), request));
+            } else if (val instanceof Attribute) {
+                log.debug("Evaluating list entry (Attribute): {}", val);
+                Attribute att = (Attribute) val;
+                if (att.getValue() != null) {
+                    res.add(att.getValue() instanceof List
+                            ? evaluateList((List) att.getValue(), request)
+                            : att);
+                } else {
+                    Expression expression = att.getExpressionObject();
+                    if (expression != null) {
+                        log.debug("Evaluating list entry expression: {}", expression);
+                        att = att.clone();
+                        att.setValue(evaluate(expression.getExpression(), request));
+                        res.add(att);
+                    } else {
+                        res.add(att);
+                    }
+                }
+            } else {
+                log.debug("Evaluating list entry ({}): {}", val.getClass(), val);
+                res.add(val);
+            }
+        }
+        return res;
+    }
+
 }