From a56d124c9177d9f424b7390180659e5b01a4791e Mon Sep 17 00:00:00 2001 From: Brett Ryan Date: Mon, 15 Jun 2015 09:49:29 +1000 Subject: [PATCH 1/5] Added git ignore/attributes. --- .gitattributes | 30 ++++++++++++++++++++++++++++++ .gitignore | 25 +++++++++++++++++++++++++ 2 files changed, 55 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..4eebd49bc --- /dev/null +++ b/.gitattributes @@ -0,0 +1,30 @@ +# Handle line endings automatically for files detected as text +# and leave all files detected as binary untouched. +* text=auto + +# +# The above will handle all files NOT found below +# +# These files are text and should be normalized (Convert crlf => lf) +*.css text +*.df text +*.java text +*.js text +*.json text +*.jsp text +*.properties text +*.sql text +*.svg text +*.tld text +*.txt text +*.xml text + +# These files are binary and should be left untouched +# (binary is a macro for -text -diff) +*.dll binary +*.gif binary +*.ico binary +*.jar binary +*.png binary +*.so binary + diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..0163e1860 --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +/target/ +/tiles-api/target/ +/tiles-core/target/ +/tiles-template/target/ +/tiles-servlet/target/ +/tiles-jsp/target/ +/tiles-freemarker/target/ +/tiles-velocity/target/ +/tiles-el/target/ +/tiles-ognl/target/ +/tiles-mvel/target/ +/tiles-compat/target/ +/tiles-extras/target/ +/tiles-test-pom/tiles-test-db/target/ +/tiles-test-pom/tiles-test-alt/target/ +/tiles-test-pom/target/ +/tiles-test-pom/tiles-test-common/target/ +/tiles-test-pom/tiles-test/target/ +/assembly/target/ +*~ +*.bak +*.swp +*.log +.DS_Store +pom.xml.versionsBackup From 0312ece161c23aa4b75ab647d8966b68943ce971 Mon Sep 17 00:00:00 2001 From: Brett Ryan Date: Mon, 15 Jun 2015 09:50:00 +1000 Subject: [PATCH 2/5] Added support for simple object expression evaluation. Object type attributes such as the implementation may now implement o.a.t.awareness.ExpressionAware which will be provided the opertunitiy for #evaluateExpressions(AttributeEvaluator,Request) to be called. It is up to the implementation to handle evaluation using the supplied evaluator. --- .../apache/tiles/beans/SimpleMenuItem.java | 41 +++++++++++++- .../tiles/awareness/ExpressionAware.java | 47 ++++++++++++++++ .../evaluator/AbstractAttributeEvaluator.java | 22 ++++++++ .../tiles/el/ELAttributeEvaluatorTest.java | 56 +++++++++++++++++++ .../ognl/OGNLAttributeEvaluatorTest.java | 56 +++++++++++++++++++ 5 files changed, 221 insertions(+), 1 deletion(-) create mode 100644 tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java diff --git a/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java b/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java index 757f3a1c3..f7f1c134b 100644 --- a/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java +++ b/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java @@ -21,6 +21,11 @@ package org.apache.tiles.beans; import java.io.Serializable; +import org.apache.tiles.awareness.ExpressionAware; +import org.apache.tiles.evaluator.AttributeEvaluator; +import org.apache.tiles.request.Request; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * A MenuItem implementation. @@ -28,7 +33,9 @@ * * @version $Rev$ $Date$ */ -public class SimpleMenuItem implements MenuItem, Serializable { +public class SimpleMenuItem implements MenuItem, Serializable, ExpressionAware { + + private static final Logger log = LoggerFactory.getLogger(SimpleMenuItem.class); /** * The value of the item, i.e. what is really visible to the user. @@ -154,4 +161,36 @@ public String toString() { return buff.toString(); } + /** + * Evaluates all values for expressions replacing their contents with the + * result of the evaluation. + * + * In the event of a {@link ClassCastException} the original value is used. + * + * @param eval + * Evaluator instance used to evaluate expressions. + * @param request + * Request object to evaluate expressions with. + */ + @Override + public void evaluateExpressions(AttributeEvaluator eval, Request request) { + value = safeEval(eval, request, value); + link = safeEval(eval, request, link); + icon = safeEval(eval, request, icon); + tooltip = safeEval(eval, request, tooltip); + } + + private String safeEval(AttributeEvaluator eval, Request request, String val) { + if (val == null || val.length() == 0) { + return val; + } + try { + Object res = eval.evaluate(val, request); + return res == null ? null : res.toString(); + } catch (Exception ex) { + log.warn("Could not evaluate expressions for SimpleMenuItem: {}", ex.getMessage(), ex); + } + return val; + } + } diff --git a/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java b/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java new file mode 100644 index 000000000..106896ae6 --- /dev/null +++ b/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java @@ -0,0 +1,47 @@ +/* + * ExpressionAware.java Jun 12 2015, 07:42 + * + * Copyright 2015 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.tiles.awareness; + +import org.apache.tiles.evaluator.AttributeEvaluator; +import org.apache.tiles.request.Request; + + +/** + * Provides the ability for extended attributes a mechanism for evaluating + * expressions. + * + * Objects will have {@link #evaluateExpressions(AttributeEvaluator, Request) evaluateExpressions} + * called which leaves the evaluation up to the object in question. + * + * @author Brett Ryan + * @since 3.4.1 + */ +public interface ExpressionAware { + + /** + * Evaluate supported expressions on object. + * + * @param eval + * Evaluator instance used to evaluate expressions. + * @param request + * Request object to evaluate expressions with. + */ + void evaluateExpressions(AttributeEvaluator eval, Request request); + +} diff --git a/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java b/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java index 82542a690..2436b39af 100644 --- a/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java +++ b/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java @@ -22,7 +22,10 @@ import org.apache.tiles.Attribute; import org.apache.tiles.Expression; +import org.apache.tiles.awareness.ExpressionAware; 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,6 +36,8 @@ */ public abstract class AbstractAttributeEvaluator implements AttributeEvaluator { + private static final Logger log = LoggerFactory.getLogger(AbstractAttributeEvaluator.class); + /** {@inheritDoc} */ public Object evaluate(Attribute attribute, Request request) { if (attribute == null) { @@ -41,12 +46,29 @@ public Object evaluate(Attribute attribute, Request request) { Object retValue = attribute.getValue(); + log.debug("Evaluating expression: [attribute={},retValue={}]", attribute, retValue); if (retValue == null) { Expression expression = attribute.getExpressionObject(); if (expression != null) { retValue = evaluate(attribute.getExpressionObject() .getExpression(), request); } + } else if (retValue instanceof Iterable) { + log.debug("Instance is list, evaluating for expression awareness."); + Iterable list = (Iterable)retValue; + for (Object n : list) { + log.debug("list instance {} ({})", n, n.getClass()); + if (n instanceof Attribute) { + log.debug("list instance is an attribute"); + evaluate((Attribute) n, request); + } else if (n instanceof ExpressionAware) { + log.debug("List instance is expression-aware"); + ((ExpressionAware) n).evaluateExpressions(this, request); + } + } + } else if (retValue instanceof ExpressionAware) { + log.debug("Instance is expression-aware"); + ((ExpressionAware) retValue).evaluateExpressions(this, request); } return retValue; diff --git a/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java b/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java index 82a47451e..bcf470c0b 100644 --- a/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java +++ b/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java @@ -20,8 +20,10 @@ */ package org.apache.tiles.el; +import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; +import java.util.List; import java.util.Map; import javax.el.ArrayELResolver; @@ -37,6 +39,8 @@ import org.apache.el.ExpressionFactoryImpl; import org.apache.tiles.Attribute; import org.apache.tiles.Expression; +import org.apache.tiles.awareness.ExpressionAware; +import org.apache.tiles.evaluator.AttributeEvaluator; import org.apache.tiles.request.ApplicationContext; import org.apache.tiles.request.Request; import org.easymock.EasyMock; @@ -171,6 +175,58 @@ public void testEvaluateString() { .evaluate(expression, request)); } + public void testEvaluateExpressionAware() { + List list = new ArrayList(); + list.add(new Attribute(new Explosion("${requestScope.object1}"))); + list.add(new Attribute(new Explosion("${sessionScope.object2}"))); + list.add(new Attribute(new Explosion("${applicationScope.object3}"))); + list.add(new Attribute(new Explosion("${object1}"))); + list.add(new Attribute(new Explosion("${object2}"))); + list.add(new Attribute(new Explosion("${object3}"))); + list.add(new Attribute(new Explosion("${paulaBean.paula}"))); + list.add(new Attribute(new Explosion("String literal"))); + Attribute attribute = new Attribute(list); + + evaluator.evaluate(attribute, request); + + int i = 0; + assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "Brillant", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "String literal", ((Explosion)list.get(i++).getValue()).getValue()); + } + + private static final class Explosion implements ExpressionAware { + + private final String expression; + private transient Object value; + + public Explosion(String expression) { + this.expression = expression; + this.value = expression; + } + + public Object getValue() { + return value; + } + + @Override + public void evaluateExpressions(AttributeEvaluator eval, Request request) { + this.value = safeEval(eval, request, expression); + } + + private Object safeEval(AttributeEvaluator eval, Request request, String val) { + if (val == null || val.length() == 0) { + return val; + } + return eval.evaluate(val, request); + } + } + /** * This is The Brillant Paula Bean (sic) just like it was posted to: * http://thedailywtf.com/Articles/The_Brillant_Paula_Bean.aspx diff --git a/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java b/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java index 520b9c482..71ed32d62 100644 --- a/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java +++ b/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java @@ -20,12 +20,14 @@ */ package org.apache.tiles.ognl; +import java.util.ArrayList; import java.util.Arrays; import static org.easymock.EasyMock.*; import static org.easymock.classextension.EasyMock.*; import static org.junit.Assert.*; import java.util.HashMap; +import java.util.List; import java.util.Map; import ognl.OgnlException; @@ -34,6 +36,8 @@ import org.apache.tiles.Attribute; import org.apache.tiles.Expression; +import org.apache.tiles.awareness.ExpressionAware; +import org.apache.tiles.evaluator.AttributeEvaluator; import org.apache.tiles.evaluator.EvaluationException; import org.apache.tiles.request.ApplicationContext; import org.apache.tiles.request.Request; @@ -185,6 +189,58 @@ public void testEvaluateString() { .evaluate(expression, request)); } + public void testEvaluateExpressionAware() { + List list = new ArrayList(); + list.add(new Attribute(new Explosion("${requestScope.object1}"))); + list.add(new Attribute(new Explosion("${sessionScope.object2}"))); + list.add(new Attribute(new Explosion("${applicationScope.object3}"))); + list.add(new Attribute(new Explosion("${object1}"))); + list.add(new Attribute(new Explosion("${object2}"))); + list.add(new Attribute(new Explosion("${object3}"))); + list.add(new Attribute(new Explosion("${paulaBean.paula}"))); + list.add(new Attribute(new Explosion("String literal"))); + Attribute attribute = new Attribute(list); + + evaluator.evaluate(attribute, request); + + int i = 0; + assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "Brillant", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "String literal", ((Explosion)list.get(i++).getValue()).getValue()); + } + + private static final class Explosion implements ExpressionAware { + + private final String expression; + private transient Object value; + + public Explosion(String expression) { + this.expression = expression; + this.value = expression; + } + + public Object getValue() { + return value; + } + + @Override + public void evaluateExpressions(AttributeEvaluator eval, Request request) { + this.value = safeEval(eval, request, expression); + } + + private Object safeEval(AttributeEvaluator eval, Request request, String val) { + if (val == null || val.length() == 0) { + return val; + } + return eval.evaluate(val, request); + } + } + /** * Tests {@link OGNLAttributeEvaluator#evaluate(String, Request)}. */ From 70b0288d22f80a90bbda618072936b6668f5333d Mon Sep 17 00:00:00 2001 From: Brett Ryan Date: Mon, 15 Jun 2015 14:33:08 +1000 Subject: [PATCH 3/5] Corrected trailing comma in toString. --- .../apache/tiles/beans/SimpleMenuItem.java | 19 ++++++++++++++----- .../tiles/beans/SimpleMenuItemTest.java | 2 +- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java b/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java index f7f1c134b..d495a78dd 100644 --- a/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java +++ b/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java @@ -139,22 +139,31 @@ public String getTooltip() { /** {@inheritDoc} */ @Override public String toString() { - StringBuffer buff = new StringBuffer("SimpleMenuItem["); + StringBuilder buff = new StringBuilder("SimpleMenuItem["); if (getValue() != null) { - buff.append("value=").append(getValue()).append(", "); + buff.append("value=").append(getValue()); } if (getLink() != null) { - buff.append("link=").append(getLink()).append(", "); + if (buff.length() > 0) { + buff.append(", "); + } + buff.append("link=").append(getLink()); } if (getTooltip() != null) { - buff.append("tooltip=").append(getTooltip()).append(", "); + if (buff.length() > 0) { + buff.append(", "); + } + buff.append("tooltip=").append(getTooltip()); } if (getIcon() != null) { - buff.append("icon=").append(getIcon()).append(", "); + if (buff.length() > 0) { + buff.append(", "); + } + buff.append("icon=").append(getIcon()); } buff.append("]"); diff --git a/tiles-compat/src/test/java/org/apache/tiles/beans/SimpleMenuItemTest.java b/tiles-compat/src/test/java/org/apache/tiles/beans/SimpleMenuItemTest.java index fd4b6c525..c3d6ce680 100644 --- a/tiles-compat/src/test/java/org/apache/tiles/beans/SimpleMenuItemTest.java +++ b/tiles-compat/src/test/java/org/apache/tiles/beans/SimpleMenuItemTest.java @@ -91,7 +91,7 @@ public void testToString() { item.setTooltip("tooltip"); item.setValue("value"); assertEquals( - "SimpleMenuItem[value=value, link=link, tooltip=tooltip, icon=icon, ]", + "SimpleMenuItem[value=value, link=link, tooltip=tooltip, icon=icon]", item.toString()); } From 38611303f98b52758f35de068efe9473689a4993 Mon Sep 17 00:00:00 2001 From: Brett Ryan Date: Mon, 15 Jun 2015 14:34:28 +1000 Subject: [PATCH 4/5] Corrected evaluation to not overwrite the model. I mistakenly thought the object instances were per request. It was necessary to change this to return values instead of updating themselves. --- .../apache/tiles/beans/SimpleMenuItem.java | 18 +++++-- .../tiles/awareness/ExpressionAware.java | 5 +- .../evaluator/AbstractAttributeEvaluator.java | 30 ++++++----- .../tiles/el/ELAttributeEvaluatorTest.java | 49 +++++++++++------- .../ognl/OGNLAttributeEvaluatorTest.java | 50 ++++++++++++------- 5 files changed, 95 insertions(+), 57 deletions(-) diff --git a/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java b/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java index d495a78dd..8c0fdfa9e 100644 --- a/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java +++ b/tiles-compat/src/main/java/org/apache/tiles/beans/SimpleMenuItem.java @@ -64,6 +64,14 @@ public SimpleMenuItem() { super(); } + public SimpleMenuItem(String value, String link, String icon, String tooltip) { + super(); + this.value = value; + this.link = link; + this.icon = icon; + this.tooltip = tooltip; + } + /** * Sets the value of the item, i.e. what is really visible to the user. * @@ -182,11 +190,11 @@ public String toString() { * Request object to evaluate expressions with. */ @Override - public void evaluateExpressions(AttributeEvaluator eval, Request request) { - value = safeEval(eval, request, value); - link = safeEval(eval, request, link); - icon = safeEval(eval, request, icon); - tooltip = safeEval(eval, request, tooltip); + public Object evaluateExpressions(AttributeEvaluator eval, Request request) { + return new SimpleMenuItem(safeEval(eval, request, value), + safeEval(eval, request, link), + safeEval(eval, request, icon), + safeEval(eval, request, tooltip)); } private String safeEval(AttributeEvaluator eval, Request request, String val) { diff --git a/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java b/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java index 106896ae6..8280b09c1 100644 --- a/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java +++ b/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java @@ -37,11 +37,14 @@ public interface ExpressionAware { /** * Evaluate supported expressions on object. * + * Implementors may return any type for view rendering. + * * @param eval * Evaluator instance used to evaluate expressions. * @param request * Request object to evaluate expressions with. + * @return Model instance with attributes evaluated. */ - void evaluateExpressions(AttributeEvaluator eval, Request request); + Object evaluateExpressions(AttributeEvaluator eval, Request request); } diff --git a/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java b/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java index 2436b39af..20dc26d99 100644 --- a/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java +++ b/tiles-core/src/main/java/org/apache/tiles/evaluator/AbstractAttributeEvaluator.java @@ -20,6 +20,8 @@ */ 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.awareness.ExpressionAware; @@ -39,6 +41,7 @@ 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"); @@ -46,29 +49,30 @@ public Object evaluate(Attribute attribute, Request request) { Object retValue = attribute.getValue(); - log.debug("Evaluating expression: [attribute={},retValue={}]", attribute, retValue); 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 Iterable) { - log.debug("Instance is list, evaluating for expression awareness."); - Iterable list = (Iterable)retValue; + } else if (retValue instanceof List) { + log.debug("Evaluating iterable for expressions: [attribute={},retValue={}]", attribute, retValue); + List list = (List)retValue; + List newList = new ArrayList(list.size()); for (Object n : list) { - log.debug("list instance {} ({})", n, n.getClass()); if (n instanceof Attribute) { - log.debug("list instance is an attribute"); - evaluate((Attribute) n, request); - } else if (n instanceof ExpressionAware) { - log.debug("List instance is expression-aware"); - ((ExpressionAware) n).evaluateExpressions(this, request); + Attribute m = (Attribute) n; + if (m.getValue() instanceof ExpressionAware) { + log.debug("Evaluating expression-aware value: [object={}]", n); + m = new Attribute(m); + m.setValue(((ExpressionAware)m.getValue()).evaluateExpressions(this, request)); + } + n = m; } + newList.add(n); } - } else if (retValue instanceof ExpressionAware) { - log.debug("Instance is expression-aware"); - ((ExpressionAware) retValue).evaluateExpressions(this, request); + retValue = newList; } return retValue; diff --git a/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java b/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java index bcf470c0b..fae0c7a85 100644 --- a/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java +++ b/tiles-el/src/test/java/org/apache/tiles/el/ELAttributeEvaluatorTest.java @@ -45,6 +45,9 @@ import org.apache.tiles.request.Request; import org.easymock.EasyMock; +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.junit.Assert.assertThat; + /** * Tests {@link ELAttributeEvaluator}. * @@ -187,27 +190,28 @@ public void testEvaluateExpressionAware() { list.add(new Attribute(new Explosion("String literal"))); Attribute attribute = new Attribute(list); - evaluator.evaluate(attribute, request); + Object res = evaluator.evaluate(attribute, request); + + assertThat("Evaluated instance is not a List.", res, instanceOf(List.class)); + List nlist = (List)res; int i = 0; - assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", "Brillant", ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", "String literal", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "value", ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "value", ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "Brillant", ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "String literal", ((Explosion)nlist.get(i++).getValue()).getValue()); } private static final class Explosion implements ExpressionAware { - private final String expression; - private transient Object value; + private final Object value; - public Explosion(String expression) { - this.expression = expression; - this.value = expression; + public Explosion(Object value) { + this.value = value; } public Object getValue() { @@ -215,15 +219,22 @@ public Object getValue() { } @Override - public void evaluateExpressions(AttributeEvaluator eval, Request request) { - this.value = safeEval(eval, request, expression); + public Object evaluateExpressions(AttributeEvaluator eval, Request request) { + return new Explosion(safeEval(eval, request, value)); } - private Object safeEval(AttributeEvaluator eval, Request request, String val) { - if (val == null || val.length() == 0) { + private Object safeEval(AttributeEvaluator eval, Request request, Object val) { + if (val == null) { return val; } - return eval.evaluate(val, request); + if (val instanceof String) { + String n = (String) val; + if (n.length() == 0) { + return n; + } + return eval.evaluate(n, request); + } + return val; } } diff --git a/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java b/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java index 71ed32d62..e25ac6b7f 100644 --- a/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java +++ b/tiles-ognl/src/test/java/org/apache/tiles/ognl/OGNLAttributeEvaluatorTest.java @@ -22,6 +22,7 @@ import java.util.ArrayList; import java.util.Arrays; + import static org.easymock.EasyMock.*; import static org.easymock.classextension.EasyMock.*; import static org.junit.Assert.*; @@ -45,6 +46,9 @@ import org.junit.Before; import org.junit.Test; +import static junit.framework.Assert.assertEquals; +import static org.hamcrest.CoreMatchers.instanceOf; + /** * Tests {@link OGNLAttributeEvaluator}. * @@ -201,27 +205,28 @@ public void testEvaluateExpressionAware() { list.add(new Attribute(new Explosion("String literal"))); Attribute attribute = new Attribute(list); - evaluator.evaluate(attribute, request); + Object res = evaluator.evaluate(attribute, request); + assertThat("Evaluated instance is not a List.", res, instanceOf(List.class)); + + List nlist = (List)res; int i = 0; - assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", "value", ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Integer(1), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", new Float(2.0), ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", "Brillant", ((Explosion)list.get(i++).getValue()).getValue()); - assertEquals("The value is not correct", "String literal", ((Explosion)list.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "value", ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "value", ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Integer(1), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", new Float(2.0), ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "Brillant", ((Explosion)nlist.get(i++).getValue()).getValue()); + assertEquals("The value is not correct", "String literal", ((Explosion)nlist.get(i++).getValue()).getValue()); } private static final class Explosion implements ExpressionAware { - private final String expression; - private transient Object value; + private final Object value; - public Explosion(String expression) { - this.expression = expression; - this.value = expression; + public Explosion(Object value) { + this.value = value; } public Object getValue() { @@ -229,15 +234,22 @@ public Object getValue() { } @Override - public void evaluateExpressions(AttributeEvaluator eval, Request request) { - this.value = safeEval(eval, request, expression); + public Object evaluateExpressions(AttributeEvaluator eval, Request request) { + return new Explosion(safeEval(eval, request, value)); } - private Object safeEval(AttributeEvaluator eval, Request request, String val) { - if (val == null || val.length() == 0) { + private Object safeEval(AttributeEvaluator eval, Request request, Object val) { + if (val == null) { return val; } - return eval.evaluate(val, request); + if (val instanceof String) { + String n = (String) val; + if (n.length() == 0) { + return n; + } + return eval.evaluate(n, request); + } + return val; } } From ea4e190753478d3e1ff8082fd8ca5d2fb08ff64e Mon Sep 17 00:00:00 2001 From: Brett Ryan Date: Mon, 15 Jun 2015 14:42:04 +1000 Subject: [PATCH 5/5] Corrected @since doctag. --- .../main/java/org/apache/tiles/awareness/ExpressionAware.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java b/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java index 8280b09c1..781bc32d6 100644 --- a/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java +++ b/tiles-core/src/main/java/org/apache/tiles/awareness/ExpressionAware.java @@ -30,7 +30,7 @@ * called which leaves the evaluation up to the object in question. * * @author Brett Ryan - * @since 3.4.1 + * @since 3.0.6 */ public interface ExpressionAware {