
                            Apache Commons JEXL
                                Version 3.2
                               Release Notes


INTRODUCTION:
=============

JEXL is a library intended to facilitate the implementation of dynamic and scripting features in
applications and frameworks written in Java.

JEXL implements an Expression Language based on some extensions to the JSTL Expression Language supporting most of the
constructs seen in shell-script or ECMAScript.

Its goal is to expose scripting features usable by technical operatives or consultants working with enterprise platforms.


  https://commons.apache.org/jexl/


========================================================================================================================
Release 3.2
========================================================================================================================

Version 3.2 is a minor release.

Compatibility with previous releases
====================================
Version 3.2 is binary compatible with 3.1. However, JEXL now requires Java 8.

Unfortunately, it is not strictly source compatible. This release does break source compatibility by adding methods to existing
interfaces and an abstract method to an abstract class. However, since these interfaces and class are not expected to be implemented
or derived by code external to the JEXL project, this compatibility break should remain unnoticeable.
It is nevertheless possible and we are sorry if it causes problems to any of you.

What's new in 3.2:
==================
* Lexical scoping for local variables and parameters allowing at parse and/or runtime to reduce scripting errors and bugs and align with
  known development languages best practice (C, Java, ...).
* Interpolated strings in identifiers, as in x.`${prefix}_${suffix}` that in many cases would be equivalent to
  x[prefix + '_' + suffix] or x[`${prefix}_${suffix}`].
* Safe-navigation mode and operator '?.' allowing lenient handling of non-existent or null properties so that an expression
  like 'x?.y?.z' would behave as 'x.y.z' in nominal execution and return null instead of throwing an exception in error
  cases. The safe() option on the builder enables the behavior making '.' and '[...]' behave as '?.'.
* A set of syntactic restrictions can be applied to scripts ranging from not allowing side-effects to not allowing
  loops enabling fine control over what end-users may be able to enter as expressions/scripts.

New Features in 3.2:
====================
* JEXL-344:      Don't fill stack trace for JexlExpression#Return (to improve performance)
* JEXL-334:      Remove offensive terminology from code and API
* JEXL-333:      Allow declaration of namespace within script
* JEXL-317:      Support script cancellation through less invasive API
* JEXL-307:      Variable redeclaration option
* JEXL-295:      Add unary plus operator
* JEXL-292:      Allow specifying custom Permissions class for Uberspect to be used later by Introspector
* JEXL-288:      Annotation can not be specified for a standalone statement
* JEXL-275:      Allow safe navigation as option
* JEXL-274:      Handle soft and hard stack overflow
* JEXL-273:      Add do...while(...) loops
* JEXL-264:      Allow space, quote & double-quote in identifiers
* JEXL-260:      Automatically inject JexlContext in constructor call when possible
* JEXL-253:      Permissions by super type in JexlSandbox
* JEXL-252:      Allow for interpolated strings to be used in property access operators
* JEXL-250:      Safe navigation operator (?.)
* JEXL-249:      Java 1.8 as minimum supported version
* JEXL-248:      Allow range subexpression as an array property assignment identifier
* JEXL-243:      Allow restricting available features in Script/Expressions
* JEXL-238:      Restrict getLiteralClass to a Number for NumberLiterals
* JEXL-237:      Ability to restrict usage of certain names when declaring local variables
* JEXL-236:      Support CharSequence in size(), empty() and contains() operators
* JEXL-234:      Extend application of operators startsWith and endsWith from String to CharSequence types
* JEXL-226:      Add ?? operator support
* JEXL-224:      The ability to overload call() operator in customized JexlArithmetic implementation
* JEXL-212:      Restrict usage of assignment statements in JexlExpression
* JEXL-175:      java.util.regex.Pattern creation operator (regex literals)

Bugs Fixed in 3.2:
==================
* JEXL-336:      Escape some control characters
* JEXL-331:      Please document \uXXXX escape sequence
* JEXL-330:      JexlException.Parsing.getMessage() throws exception when parse error is in long expression
* JEXL-328:      JXLT template scripts evaluation do not process pragmas
* JEXL-327:      map[null] does not work in assignment context
* JEXL-326:      Link to "JavaCC" on syntax reference page is broken
* JEXL-325:      Potential race-condition in NumberParser.toString()
* JEXL-324:      JexlEngine.createExpression("new()").getParsedText() throws NPE
* JEXL-323:      Ant-style variables can throw exception when evaluated for their value
* JEXL-322:      JXLT String literals cannot contain curly brace
* JEXL-321:      Empty do-while loop is broken
* JEXL-320:      "mvn test" fails with COMPILATION ERROR in SynchronizedArithmetic.java on Java 11
* JEXL-319:      Apache project documentation gives instructions in subversion
* JEXL-318:      Annotation processing may fail in lexical mode
* JEXL-315:      JxltEngine literal string strings ending in \ $ or # throw JxltEngine$Exception
* JEXL-314:      Comparison NULL values of variables NAME1.NAME2
* JEXL-312:      @NoJexl fails to disallow method call
* JEXL-311:      Jxlt template scripts fail using verbatim expressions embedded in lambdas
* JEXL-309:      Line numbers are not correct when template report errors
* JEXL-306:      Ternary operator ? protects also its branches from resolution errors
* JEXL-305:      Script debugger produces incorrect syntax
* JEXL-304:      Error parsing overview.limit.var
* JEXL-303:      Block syntax is broken
* JEXL-302:      JexlScript.getVariables returns strange values for array access
* JEXL-301:      Array access operator does not fail on null object in non-strict arithmetic mode
* JEXL-300:      Ant-ish variables should not use safe-access operator syntax
* JEXL-299:      Improve message error when method could not be found
* JEXL-298:      Unable to call 'empty' and 'size' member methods with parameters
* JEXL-296:      Real literal in scientific format is not parsed without suffix
* JEXL-291:      Using sandbox prevents array-syntax lookup by number in Map
* JEXL-290:      Safe navigation fails on chained method calls
* JEXL-289:      Passing undeclared function parameter can overwrite a local function variable
* JEXL-287:      Wrong resolution of local variables
* JEXL-286:      For statement without a body should update its variable
* JEXL-285:      For statement variable may seem unaffected by iteration
* JEXL-282:      Pragmas with antish names are broken
* JEXL-281:      MethodExecutor incorrectly tests for empty parameters list
* JEXL-280:      break/continue statements outside of the loop
* JEXL-279:      Null variables property access do not throw exceptions
* JEXL-278:      Ambiguous exceptions should point to actual statement ambiguity
* JEXL-272:      Dereferencing null property not reported on method call
* JEXL-271:      Hoisted variable is lost when currying lambda
* JEXL-270:      Wrong Script$Curried creation when script.curry() method is called inside script
* JEXL-261:      JexlEngine.setClassLoader(...) should reload namespaces that are classes
* JEXL-257:      Function throwing IllegalArgumentException may be called twice
* JEXL-246:      Intermittent ambiguous method invocation when processing assignOverload
* JEXL-245:      Engine in strict mode fails to fail on unsolvable variables or properties
* JEXL-244:      Webapp classloader memory leaks
* JEXL-241:      NPE when script containing string interpolation executed in multiple threads
* JEXL-240:      Unable to invoke a call operator using antish style variable resolution
* JEXL-231:      Syntax for accessing List elements is not mentioned in docs
* JEXL-230:      List literal is not mentioned in docs
* JEXL-227:      JexlScriptEngineFactory.getEngineVersion() should return actual version
* JEXL-225:      Incorrect invoking methods with ObjectContext

There are no other changes.


========================================================================================================================
Release 3.1
========================================================================================================================

Version 3.1 is a minor release.

Compatibility with previous releases
====================================
Version 3.1 is binary compatible with 3.0.

However it is not source compatible, this release does break source compatibility by adding methods to existing
interfaces; these interfaces are however not expected to be implemented by code external to the JEXL project.
This compatibility break should remain hypothetical. It is nevertheless possible and we are sorry if it causes problems
to any of you.
If you encounter this issue, besides continuing using JEXL 3.0, your code likely delegates method calls to JEXL3 objects
and you shall be able to continue doing so with these new methods.

The three interfaces and methods are:

1 - 'isCancellable()' in interface org.apache.commons.jexl3.JexlEngine$Options
2 - 'callable(JexlContext)' in interface org.apache.commons.jexl3.JexlExpression
3 - 'getPragmas()' in interface org.apache.commons.jexl3.JxltEngine$Template

What's new in 3.1:
==================
* Annotations syntax (@annotation) and processing capabilities.
  Annotations in JEXL are 'meta-statements'; they allow to wrap the execution of the JEXL statement in a user provided
  caller; a typical example would be: ""@synchronized(x) x.someMethod();". Annotations may be declared with zero or more
  parameters. Annotation processing is implemented by providing a JexlContext.AnnotationProcessor; its processAnnotation
  method will call the annotated statement encapsulated in a Callable. Annotation arguments are evaluated and passed
  as arguments to processAnnotation.
* Better support for script execution options, error handling and cancelling.
* All operators can be overloaded.

New Features in 3.1:
====================
* JEXL-222:     The ability to declare indexed property getter/setter in customized JexlArithmetic implementation
* JEXL-219:     Blacklist by default in sandbox
* JEXL-216:     Improve parsing concurrency in multithreaded environment
* JEXL-211:     Add callable method to JexlExpression interface
* JEXL-201:     Allow Interpreter to use live values from JexlEngine.Option interface implemented by JexlContext
* JEXL-198:     JxltEngine Template does not expose pragmas
* JEXL-197:     Add annotations
* JEXL-194:     Allow synchronization on iterableValue in foreach statement

Bugs Fixed in 3.1:
==================
* JEXL-221:     Sporadic undefined property error caused by NPE at MapGetExecutor.tryInvoke()
* JEXL-217:     Interpreter.getAttribute() raises exception in non-strict mode when cached property resolver is used
* JEXL-215:     JexlEngine.createInfo() is redundantly called when debug and caching is enabled leading to sub-optimal performance
* JEXL-214:     Redundant call of fillInStackTrace() in JexlEngine.createInfo() ?
* JEXL-213:     rename JexlBuilder.loader(Charset arg) to JexlBuilder.charset(Charset arg)
* JEXL-210:     The way to cancel script execution with an error
* JEXL-209:     Unsolvable function/method '<?>.<null>(...)'
* JEXL-208:     Documentation typos/inconsistencies
* JEXL-207:     Inconsistent error handling
* JEXL-206:     testCallableCancel() test hangs sporadically
* JEXL-205:     testCancelForever() is not terminated properly as 'Fixed'
* JEXL-204:     Script is not interrupted by a method call throwing Exception
* JEXL-203:     JexlArithmetic.options() diverts Interpreter to use default implementation of JexlArithmetic instead of custom one
* JEXL-202:     Detect invalid assignment operator usage with non-assignable l-value during script parsing
* JEXL-196:     Script execution hangs while calling method with one argument without parameter
* JEXL-195:     Support for AtomicBoolean in logical expressions
* JEXL-193:     InterruptedException is swallowed in function call in silent and non-strict mode
* JEXL-192:     Invalid return type when expected result is null
* JEXL-191:     Jexl3 unsolvable property exception when using enum
* JEXL-190:     local function within context is not resolved if function resolver class without namespace is specified
* JEXL-189:     Possible bug in Interpreter.isCancelled()
* JEXL-188:     Possible bug in JexlArithmetic.isFloatingPointNumber()
* JEXL-187:     Jexl Syntax doc does not mention 'continue' and 'break' operators
* JEXL-186:     Performance regression in arithmetic operations compared to JEXL 2.1


========================================================================================================================
Release 3.0
========================================================================================================================

Version 3.0 is a major release changing the public JEXL API.

Due to binary and source incompatibilities and the scope of modifications, JEXL has moved to the
org.apache.commons.jexl3 package.
However, this is a drop-in replacement through JSR-223 and casual code usage should find easy equivalence between
jexl-2.x and 3.x (besides the package name).
Also note that JEXL 3.0 now requires Java 6.


What's new in 3.0:
==================
* A redesigned API that properly segregates the "public" part and the "internal" parts of JEXL.
* A real difference between Expression and Script (scripts accept statements: for, while, etc).
* The ability to create JEXL functions in script, closure/variables hoisting/currying included.
* A set of assignment operators (+=, *= , ...).
* A set of String matching operators (^= startsWith, $= endsWith) and their negative counterparts (!^, !$)
* A range operator (x .. y) to ease writing loops (for(var x : 1 .. 10) ... )
* A literal set syntax to ease creating sets: { 1, 2...}

New features in 3.0:
====================
* JEXL-178:     'Unsolvable property' message to provide details about underlying exception
* JEXL-177:     Unified expressions to be used in String literals in JEXL scripts
* JEXL-176:     Synonym operator name 'in' for operator =~ // Remove 'foreach...in' syntax
* JEXL-174:     Overloadable property access operators
* JEXL-173:     Duck-typed java closures
* JEXL-170:     Implement assignment operators
* JEXL-164:     public getters for high/low properties for IntegerRange and LongRange
* JEXL-152:     Extend Range literal to support Long values
* JEXL-149:     Set Construction as per EL 3.0 spec
* JEXL-133:     String matching Operator short-hand inspired by CSS3
* JEXL-128:     ObjectContext<> should implement NamespaceResolver
* JEXL-127:     Allow the creation of functions
* JEXL-123:     Redesign API for stability
* JEXL-122:     Move JEXL from org.apache.comms.jexl2 to org.apache.commons.jexl3
* JEXL-136:     Script calls within scripts may fail with number arguments
* JEXL-135:     Using map as script parameter or local variable
* JEXL-134:     Issue with evaluation of concat of variables : \r + \n gives 0
* JEXL-131:     UnifiedJexl parsing may fail with NPE
* JEXL-130:     Ternary Conditional fails for Object values
* JEXL-126:     Decimal numbers literals should be 'double' by default (instead of 'float')


Bugs Fixed in 3.0:
==================
* JEXL-184:     dot-ed identifiers parsing failure
* JEXL-180:     Documentation - suggests using float for financials
* JEXL-171:     Map access operator does not work if key name clashes with map property name
* JEXL-169:     A string is wrongly identified as FloatingPointNumber
* JEXL-168:     Dedicated operator for String concatenation
* JEXL-79:      Add support for growable arrays (ArrayLists)
* JEXL-167:     Possible loss of value when converting BigDecimal to BigInteger
* JEXL-166:     Incorrect operator symbol for bitwise complement in jexlArithmetic
* JEXL-163:     empty(new ("java.lang.Long", 4294967296)) returns true
* JEXL-162:     empty() function throws an exception : unsupported type
* JEXL-160:     typo in package.html
* JEXL-158:     Handle locale decimal separators correctly
* JEXL-157:     Replace File.pathSeparator with File.separator
* JEXL-146:     Performance problem in Interpreter.unknownVariable mechanism
* JEXL-145:     Sandbox calling wrong check (classname vs class)
* JEXL-144:     Empty array property setting fails
* JEXL-142:     Map expression issue with empty key
* JEXL-141:     Suffix for Big Decimal and Big Integer Literal is incorrectly mentioned in Java docs
* JEXL-137:     Invalid script variable list for nested array/map access

Detail of all changes in changes.xml.


========================================================================================================================
Release 2.1.1
========================================================================================================================

Version 2.1.1 is a micro release to fix a regression detected in 2.1:

* JEXL-124:     Array parameters to methods don't work anymore (JEXL 2.1.1)

There are no other changes.


========================================================================================================================
Release 2.1
========================================================================================================================

Version 2.1 is a minor release adding new features and fixing known issues detected in 2.0.

Compatibility with previous releases
====================================
Version 2.1 is binary compatible with 2.0.1.

However it is not source compatible.
New methods have been added to the org.apache.commons.jexl2.Script and org.apache.commons.jexl2.JexlInfo interfaces.
Any source code that implements these interfaces will need to be updated.

What's new in 2.1:
==================
* A more thorough arithmetic (JexlArithmetic) that allows fine control over decimals (scale and precision), a
  new syntax for numeric literals (OGNL inspired Big and Huge notations) and a better type handling keeping the most
  appropriate representation in casual operations.
* The introduction of script variables and parameters that reduce context dependencies and methods; this allows to
  perform checks after script creation (light static checking hints). Plus the ability to call script from scripts.
* A sandoxing feature to restrict and rename what JEXL can access from the environment allowing tighter control over security.
* Extensions to UnifiedJEXL that allow the creation of templates.

New features in 2.1:
====================
* JEXL-114:     Allow scripts to create local variables // Add return keyword
* JEXL-113:     Add functions to extract which variables, parameters and local variables are used to evaluate a script
* JEXL-118:     Provide an IN operator
* JEXL-115:     Add support for asynchronous script execution and cancellation
* JEXL-116:     Add control over classes, methods, constructors and properties allowed in scripts
* JEXL-120:     Add simple template features
* JEXL-119:     Allow indexed properties container resolution in expressions
* JEXL-106:     When divide two BigDecimal values in an expression it results in java.lang.ArithmeticException
* JEXL-102:     Add "jexl2" as a supported name

Bugs Fixed in 2.1:
==================
* JEXL-83:      Make JexlArithmetic immutable (and threadsafe)
* JEXL-24:      Support Long for integer literal instead of Integers
* JEXL-107:     literals and parenthesized expressions can not be used as references
* JEXL-108:     parsing error if i define a empty literal array/map
* JEXL-101:     Vararg methods where the first argument is no vararg can not be called with only the fixed parameters given
* JEXL-105:     Array literals are considered constant even when they are not
* JEXL-104:     NPE in JexlArithmetic when an Array-Expression containing a null is used.
* JEXL-112:     Cannot parse Integer.MIN_VALUE
* JEXL-111:     expression execute error

Bugs fixed in 2.0.1:
====================

* JEXL-100:     Array access expressions fail when evaluated twice and cache is enabled
* JEXL-99:      Documentation of Thread Safety / Invalid code examples on homepage
* JEXL-98:      Quote escaping cannot be escaped


2.0
==================

Bugs fixed in 2.0:
==================

* JEXL-90:	JEXL parser allows invalid expressions, e.g. "a=1 b=2 3"
* JEXL-88:	MethodKey.java - name clash getMostSpecific() with Java 1.5.0
* JEXL-87:	Inconsistent behavior of arithmetical operations
* JEXL-81:	Introspector does not use ListGetExecutor for List
* JEXL-80:	Lenient mode should not throw exception when {g,s}etting an undefined property
* JEXL-78:	Ternary operator throws Exception when JexlEngine in strict mode
* JEXL-76:	Remove unnecessary class VisitorAdapter
* JEXL-71:	Parsing errors?
* JEXL-67:	Potential NPE in util.introspection.MethodKey
* JEXL-66:	testDottedNames expects map enumeration order
* JEXL-64:	Inconsistent behavior of dotted names
* JEXL-62:	NPE in Interpreter
* JEXL-59:	ClassMap holds a reference to class
* JEXL-56:	Logging wrongly uses java.util.logging
* JEXL-50:	Div operator does not do integer division
* JEXL-49:	Block statements aren't parsed
* JEXL-48:	NPE during expression evaluation
* JEXL-45:	Unhandled division by zero
* JEXL-42:	NullPointerException evaluating an expression
* JEXL-40:	JEXL fails to find abstract public methods in the base class if overridden by non-public derived types
* JEXL-32:	BigDecimal values are treated as Long values which results in loss of precision
* JEXL-30:	ASTAddNode does not add BigDecimal objects correctly
* JEXL-27:	Cannot assign a value to the property of an object, such as object.prop = value.
* JEXL-26:	ASTArrayAccess messes up on fallback to JexlContext
* JEXL-19:	Ternary conditional not supported
* JEXL-3 :	Static method resolution and changes to context

Other issues fixed (Improvements/New Features):
===============================================

* JEXL-95:	Enhance JSR-223 implementation
* JEXL-94:	Allow stateful namespaces (ns:function)
* JEXL-93:	Add public fields as targets of set/get property
* JEXL-92:	JexlContext API should be more flexible
* JEXL-89:	Drop main() and suite() methods from Test cases
* JEXL-85:	2.0 grammar finishing touches & debugger update
* JEXL-82:	Change foreach syntax
* JEXL-77:	Rename last Velocity originated classes
* JEXL-72:	Remove deprecated classes and methods entirely
* JEXL-70:	Add main class to allow scripts etc to be tested
* JEXL-63:	JSR-223 support
* JEXL-61:	Usage of strong references on Method/Constructor & WeakHashMap usage
* JEXL-60:	Refactor o.a.c.jexl.util and o.a.c.jexl.util.introspection
* JEXL-58:	UnifiedJEXL
* JEXL-57:	Change pom.xml to make it Netbeans Maven2 plugin friendly
* JEXL-55:	JEXL 2.0 redux, attempting to restart the effort to release 2.0
* JEXL-54:	Light performance enhancements
* JEXL-47:	Allow single-line comments with //
* JEXL-43:	Website overview does not mention method calls and new 2.0 features
* JEXL-41:	Allow nested ${} evaluation
* JEXL-35:	Final API requirements
* JEXL-34:	Remove pre and post resolution of variables via the JexlExprResolver classes.
* JEXL-33:	Remove unnecessary throws Exception from various classes
* JEXL-29:	Support non-object-level functions/methods, as size and empty function
* JEXL-25:	Call method with varargs
* JEXL-24:	Support Long for integer literal instead of Integers
* JEXL-21:	operator overloading / hooks on operator processing
* JEXL-16:	allowing quote escaping
* JEXL-15:	Needs definable functions
* JEXL-11:	Don't make null convertible into anything
* JEXL-10:	Make possible checking for unresolved variables

Other Changes:
==============

o Add @since 2.0 tags to code so we can track API additions via Javadoc

Upgrading from JEXL 1.x
=======================

JEXL now requires Java 1.5 or later.

Version 2.0 resides in the org.apache.commons.jexl2 package; part of the version 1.x API is reimplemented as an
add-on source library in the jexl-compat directory; since it can not fully reimplement the original public 1.x, it may
only be used to ease transition in strictly controlled deployments.

The following classes are implemented through the jexl-compat source library:
  * ExpressionFactory
  * ScriptFactory
  * Expression
  * Script
  * JexlContext
  * JexlHelper

Migration notes
===============

When migrating from jexl 1.x to jexl 2.0, the following hints may be helpfull.

The following classes no longer exist:
  * ExpressionFactory, ScriptFactory: create a JexlEngine and use createExpression() or createScript()
  instead.

The following classes have been renamed and replaced:

  * VelMethod <=> JexlMethod
  * VelPropertyGet <=> JexlPropertyGet
  * VelPropertySet <=> JexlPropertySet

The following methods have been removed:

  * Info.getTemplateName() - use Info.getName() instead
  * Expression.addPostResolver() / Expression.addPreResolver() - set ant-like variables in JexlContext, implement
    a specific JexlContext or derive JexlcontextInterpreter/JexlEngine instead

Behavior changes
================

* Public fields are considered when using JexlPropertyGet / JexlPropertySet: JEXL 1.x behavior can be reimplemented
by subclassing UberspectImpl.

*Division (/ operator) behavior change: division between integers no longer casts its operands to double; integer division
    allways results in a integer. The 1.x behavior can be reimplemented by subclassing JexlArithmetic.

New Features:
=============

Assignment expression: a = b (and a.b.c = d)
   * Assigns a variable (ant-like variable or bean-property)

Ternary operator expression: a ? b : c  (and a ?: c)
   * The usual inline conditional shortcut and its 'Elvis' form (a ?: b evaluates as a ? a : b)

Constructor call expression: new('my.class.name', arguments...)
   * Creates a new instance of a class using the most appropriate constructor according
     to the actual arguments

Function namespace: ns:func(arguments...)
   * A function namespace allows the use of class or instance methods in function calls

UnifiedJEXL
   * Adds ${...} and #{...} JSP/EL syntax support on top of the JexlEngine

JSR-223 support
   * Implement JSR-223 Scripting Engine for JEXL script (need BSF-3.0 on Java < 6)

Error and exception handling
   * Configuring the leniency and verbosity of the JEXL engine allows user control over the
     error handling policy