+ * The first time the Introspector sees a class it creates a class method map + * for the class in question. Basically the class method map is a Hastable where + * Method objects are keyed by a concatenation of the method name and the names +@@ -324,4 +324,4 @@ public class IntrospectorBase { + return classMap; + } + } +-} +\ No newline at end of file ++} +diff -up commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java.javadoc commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java +--- commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java.javadoc 2011-12-19 06:15:01.000000000 -0700 ++++ commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java 2015-04-15 19:05:24.055352589 -0600 +@@ -40,7 +40,7 @@ import java.util.Arrays; + *
+ * A key can be constructed either from arguments (array of objects) or from parameters + * (array of class). +- * Roughly 3x faster than string key to access the map & uses less memory. ++ * Roughly 3x faster than string key to access the map & uses less memory. + */ + public final class MethodKey { + /** The hash code. */ +diff -up commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java.javadoc commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java +--- commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java.javadoc 2011-12-19 06:15:01.000000000 -0700 ++++ commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java 2015-04-15 19:05:24.055352589 -0600 +@@ -28,11 +28,11 @@ import org.apache.commons.logging.Log; + + /** + * Default introspection services. +- *Finding methods as well as property getters & setters.
++ *Finding methods as well as property getters & setters.
+ * @since 1.0 + */ + public class Introspector { +- /** The logger to use for all warnings & errors. */ ++ /** The logger to use for all warnings & errors. */ + protected final Log rlog; + /** The soft reference to the introspector currently in use. */ + private volatile SoftReference+ * A whitelist explicitly allows methods/properties for a class; ++ *
+ *+ * A blacklist explicitly forbids methods/properties for a class; ++ *
+ *+ * Permissions are composed of three lists, read, write, execute, each being "white" or "black": ++ *
+ *+ * All arithmetic operators (+, - , *, /, %) follow the same rules regarding their arguments. ++ *
+ *+ * Creates and evaluates Expression and Script objects. +- * Determines the behavior of Expressions & Scripts during their evaluation with respect to: ++ * Determines the behavior of Expressions & Scripts during their evaluation with respect to: ++ *
+ *The setSilent and setLenient methods allow to fine-tune an engine instance behavior
+ * according to various error control needs. The lenient/strict flag tells the engine when and if null as operand is
+ * considered an error, the silent/verbose flag tells the engine what to do with the error
+@@ -68,7 +68,7 @@ import org.apache.commons.jexl2.parser.A
+ *
0 & null should be indicators of "default" values so that even in an case of error, ++ *
0 & null should be indicators of "default" values so that even in an case of error, + * something meaningfull can still be inferred; may be convenient for configurations. + *
+ *The finest error control grain is obtained; it is the closest to Java code - +- * still augmented by "script" capabilities regarding automated conversions & type matching. ++ * still augmented by "script" capabilities regarding automated conversions & type matching. + *
+ *
+- * Supports the following:
+- * File Extensions: ".jexl", ".jexl2"
++ * Supports the following:
++ * Language short names: "JEXL", "Jexl", "jexl", "JEXL2", "Jexl2", "jexl2"
++ * File Extensions: ".jexl", ".jexl2"
+ * "jexl2" etc. were added for engineVersion="2.0".
+ *
+diff -up commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java.javadoc commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java +--- commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java.javadoc 2011-12-19 06:15:00.000000000 -0700 ++++ commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java 2015-04-15 19:33:18.303497441 -0600 +@@ -95,6 +95,7 @@ public class JexlScriptEngine extends Ab + * Those properties are allways bound to the default engine scope context. + *
+ * The following properties are defined: ++ *
+ *+ * An expression can mix immediate, deferred and nested sub-expressions as well as string constants; ++ *
+ *"...${jexl-expr}...""...#{jexl-expr}...""...#{...${jexl-expr0}...}...""...${jexl-expr0}... #{jexl-expr1}..."+- * Deferred & immediate expression carry different intentions: ++ * Deferred & immediate expression carry different intentions: ++ *
+ *
+ * For instance: "Hello ${name}, now is #{time}" is a composite "deferred" expression since one
+ * of its subexpressions is deferred. Furthermore, this (composite) expression intent is
+@@ -62,14 +62,14 @@ import org.apache.commons.jexl2.parser.S
+ *
+ * The API reflects this feature in 2 methods, prepare and evaluate. The prepare method + * will evaluate the immediate subexpression and return an expression that contains only +- * the deferred subexpressions (& constants), a prepared expression. Such a prepared expression ++ * the deferred subexpressions (& constants), a prepared expression. Such a prepared expression + * is suitable for a later phase evaluation that may occur with a different JexlContext. + * Note that it is valid to call evaluate without prepare in which case the same JexlContext + * is used for the 2 evaluation phases. + *
+ *+ * In the most common use-case where deferred expressions are to be kept around as properties of objects, +- * one should parse & prepare an expression before storing it and evaluate it each time ++ * one should parse & prepare an expression before storing it and evaluate it each time + * the property storing it is accessed. + *
+ *+@@ -339,7 +339,7 @@ public final class UnifiedJEXL { + *
+ * In effect, this binds the result of the immediate sub-expressions evaluation in the + * context, allowing to differ evaluation of the remaining (deferred) expression within another context. +- * This only has an effect to nested & composite expressions that contain differed & immediate sub-expressions. ++ * This only has an effect to nested & composite expressions that contain differed & immediate sub-expressions. + *
+ *+ * If the underlying JEXL engine is silent, errors will be logged through its logger as warning. +@@ -409,7 +409,7 @@ public final class UnifiedJEXL { + * Prepares a sub-expression for interpretation. + * @param interpreter a JEXL interpreter + * @return a prepared expression +- * @throws JexlException (only for nested & composite) ++ * @throws JexlException (only for nested & composite) + */ + protected Expression prepare(Interpreter interpreter) { + return this; +@@ -419,7 +419,7 @@ public final class UnifiedJEXL { + * Intreprets a sub-expression. + * @param interpreter a JEXL interpreter + * @return the result of interpretation +- * @throws JexlException (only for nested & composite) ++ * @throws JexlException (only for nested & composite) + */ + protected abstract Object evaluate(Interpreter interpreter); + } +@@ -734,7 +734,7 @@ public final class UnifiedJEXL { + } + + /** Creates a a {@link UnifiedJEXL.Expression} from an expression string. +- * Uses & fills up the expression cache if any. ++ * Uses & fills up the expression cache if any. + *
+ * If the underlying JEXL engine is silent, errors will be logged through its logger as warnings. + *
+@@ -1010,20 +1010,23 @@ public final class UnifiedJEXL { + * evaluation and their output gathered through a writer. + * It is thus possible to use looping or conditional construct "around" expressions generating output. + * +- * For instance: +- *