Skip to content

Commit

Permalink
Simplify changelog
Browse files Browse the repository at this point in the history
  • Loading branch information
@markt-asf
markt-asf committed Feb 28, 2020
1 parent 62d688b commit aef474a
Showing 1 changed file with 3 additions and 253 deletions.
256 changes: 3 additions & 253 deletions spec/src/main/asciidoc/ELSpec.adoc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2929,257 +2929,7 @@ empty.
This appendix lists the
changes in the EL specification. This appendix is non-normative.

=== Changes between 4.0 and 3.0 Final Release
=== Changes between 4.0 and JSR 341

* Update specification document for move to Jakarta EE.

* Convert from `javax.\*` to `jakarta.*`.



=== Changes between 3.0 Final Release and Proposed Final Draft

* Added link:ELSpec.html#a173[Invoking method expressions].

* Added link:ELSpec.html#a1355[count].



=== Changes between 3.0 Proposed Final Draft and 3.0 EDR

* Complete rewrite of Chapter 2, to align with
Java SE 8 libraries.

* Replace `+` and `cat` with `+=` as the String concatenation operator.

* Removed `T(...)` syntax as a type specifier.



=== New in 3.0 EDR

* Removed API from the specification document,
since they are included in the javadocs.

* Added link:ELSpec.html#a1063[
Operations on Collection Objects].

* Added
link:ELSpec.html#a265[String
Concatenation Operator - A += B].

* Added link:ELSpec.html#a337[Assignment Operator - A = B].

* Added link:ELSpec.html#a350[Semicolon Operator - A ; B].

* Added link:ELSpec.html#a398[Lambda Expressions].

* Added link:ELSpec.html#a421[Static
Field and Method Reference].

* Added `T` and `cat` to link:ELSpec.html#a380[Reserved Words].

* Modified link:ELSpec.html#a356[Operator Precedence].

* Modified coercion rule from nulls to non-primitive types.

* Many changes to the javadoc API.



=== Incompatibilities between EL 3.0 and EL 2.2

EL 3.0 introduces many new features, and
although we take care to keep it backward compatible, there are a few
areas that cannot be made backward compatible, either because the new
features requires it, or because the feature in EL 2.2 is a bug that
needs to be fixed. An implementation can provide an option to revert to
the 2.2 behavior, if desired.

* The default coercion for ``null``s to non-primitive
types (except `String`) returns ``null``s. For instance, a `null` coerced
to `Boolean` now returns a `null`, while a `null` coerced to `boolean`
returns `false`.



=== Changes between Maintenance 1 and Maintenance Release 2

* The main change in this release is the addition
of method invocations with parameters in the EL, such as
`#{trader.buy(“JAVA”)}`.

* Added one method in `javax.el.ELResolver`: +
`Object invoke(ELContext context, Object base,
Object method, Class<?>[] paramTypes, Object[] params)`.

* Added one method in `javax.el.BeanELResolver`: +
`Object invoke(ELContext context, Object base,
Object method, Class<?>[] paramTypes, Object[] params)`.

* Added one method in `javax.el.CompositeELResolver`: +
`Object invoke(ELContext context, Object base,
Object method, Class<?>[] paramTypes, Object[] params)`.

* Section 1.1.1. Added to the first paragraph: +
Simlarly, `.` operator can also be used to invoke
methods, when the method name is known, but the `[]` operator can be used
to invoke methods dynamically

* Section 1.2.1. Change the last part of the last
paragraph from: +
Upon evaluation, the EL API verifies that the
method conforms to the expected signature provided at parse time. There
is therefore no coercion performed. +
to: +
Upon evaluation, if the expected signature is
provided at parse time, the EL API verifies that the method conforms to
the expected signature, and there is therefore no coercion performed. If
the expected signature is not provided at parse time, then at
evaluation, the method is identified with the information of the
parameters in the expression and the parameters are coerced to the
respective formal types.

* Section 1.6

** Added syntax for method invocation with
parameters.

** The steps for evaluation of the expression was
modified to handle the method invocations with parameters.

* Section 1.19 +
Production of ValueSuffix includes the optional
parameters.



=== Changes between 1.0 Final Release and Maintenance Release 1

Added two methods in `javax.el.ExpressionFactory`:

* `newInstance()`

* `newInstance(Properties)`



=== Changes between Final Release and Proposed Final Draft 2

* Added support for enumerated data types.

* Coercions and comparisons were updated to include enumerated type types.


=== Changes between Public Review and Proposed Final Draft

* New constructor for derived exception classes +
Exception classes that extend
`ELException(PropertyNotFoundException, PropertyNotWritableException, MethodNotFoundException)`
did not have a constructor with both
`message` and `rootCause` as arguments (as it exists in
`ELException`). The constructor has been added to these classes.

* `javax.el.ELContext` API changes

** removed the `ELContext` constructor +
`protected ELContext(javax.el.ELResolver resolver)`

** added the following abstract method in `ELContext` +
`public abstract javax.el.ELResolver getELResolver();`

* Section 1.8.1 - A {<,>,<=,>=,lt,gt,le,ge} B +
If the first condition `(A==B)` is `false`, simply
fall through to the next step (do not return `false`).

* `javax.el.ResourceBundleELResolver` +
New `ELResolver` class added to support easy
access to localized messages.

* Generics +
Since JSP 2.1 requires J2SE 5.0, we’ve modified
the APIs that can take advantage of generics. These include:
`ExpressionFactory:createValueExpression()`,
`ExpressionFactory:createMethodExpression()`,
`ExpressionFactory:coerceToType()`, `ELResolver:getType()`,
`ELResolver:getCommonPropertyType()`, `MethodInfo:MethodInfo()`,
`MethodInfo.getReturnType()`, `MethodInfo:getParamTypes()`



=== Changes between Early Draft Release and Public Review

* New concept: EL Variables +
The EL now supports the concept of EL Variables
to properly support code structures such as <c:forEach> where a nested
action accesses a deferred expression that includes a reference to an
iteration variable. +
At a few locations in the spec, the term
"variable" has been replaced with "model object" to avoid confusion
between model objects and the newly introduced EL variables. +
Added new section “Variables” after section
1.15 to introduce the concept of EL Variables. +
Resulting API changes are:

** `The javax.el` package description describes
the motivation behind EL variables.

** `ElContext` has two additional methods to
provide access to `FunctionMapper` and `VariableMapper` .

** `ExpressionFactory` creation methods now take
an `ELContext` parameter. `FunctionMapper` has been removed as a
parameter to these methods.

** Added new class `VariableMapper`


* EL in a nutshell (section 1.1.1)+
Added a paragraph commenting on the flexibility
of the EL, thanks to its pluggable API for the resolution of model
objects, functions, and variables.

* `javax.el.ELException`

** `ElException` now extends `RuntimeException`
instead of `Exception` .

** Method `getRootCause()` has been removed in
favor of `Throwable.getCause().`

* `javax.el.ExpressionFactory`

** Creation methods now use `ELContext` instead
of `FunctionMapper` (see EL Variables above).

** Added method `coerceToType()`.

* `javax.el.MethodExpression`

** `invoke()` must unwrap an
`InvocationTargetExceptions` before re-throwing as an `ELException` .

* Section 1.6 - Operators `[]` and `.` +
`PropertyNotFoundException` is now thrown
instead of `NullPointerException` when this is the last property being
resolved and we’re dealing with an lvalue that is null.

* Section 1.13 - Operator Precedence +
Clarified the fact that qualified functions
with a namespace prefix have precedence over the operators.

* Faces Action Attribute and MethodExpression +
In Faces, the `action` attribute accepts both a
String literal or a `MethodExpression` . When migrating to JSF 1.2, if
the attribute's type is set as `MethodExpression`, an error would be
reported if a String literal is specified because a String literal
cannot evaluate to a valid `javax.el.MethodExpression`. +
To solve this issue, the specification of
MethodExpression has been expanded to also support String
literal-expressions. Changes have been made to:

** Section 1.2.2

** `ExpressionFactory.createMethodExpression()`

** `javax.el.MethodExpression:invoke()`
* The API has moved from the `javax.el` package to the `jakarta.el`
package.

0 comments on commit aef474a

Please sign in to comment.