SPRING WEB FLOW CHANGELOG
=========================
http://www.springframework.org/webflow

Changes in version 2.0.3 (31.07.2008)
-------------------------------------
New Features
* Introduced view-state <binder> sub-element, allowing the model bindings to be configured explicitly per view (SWF-568). 
  This allows you to restrict the allowed field->model bindings.
  It also allows you to register a custom type Converter per field by referring to it by its identifier; e.g. "shortDate".
  In addition, you can set basic binding value constraints such as required=true.
  See the 'Views' section of the reference documentation for more information and the Spring Travel booking-mvc sample for an example.

* You can now use Spring's own DataBinder for form data binding; as an alternative to OGNL or Unified EL.
  This allows you to take advantage of the unique features of the DataBinder such as the ability to apply type conversion to elements of a generic collection.
  To do this, set the "useSpringBeanBinding" property to true on a custom MvcViewFactoryCreator instance.
  See the Config section of the reference documentation for how to install a custom ViewFactoryCreator.

* Added the ability to disable model validation per transition by setting validate="false".
  This allows enabling binding but disabling validation; useful when going back between pages.
  See the 'Views' section of the reference documentation for more information.

* Introduced new flavor of the Spring Travel referenced application built to run as a set of OSGi bundles
  on the SpringSource Application Platform in a PAR deployment unit.
  Access spring-webflow-samples/platform-spring-travel to review and build the sample.

* Now ensure that Spring Faces now outputs Javascript blocks that are valid for both HTML and XHTML content types (SWF-785).

Improvements
* Unified the "Formatter" and "Conversion" systems into a single "Conversion" type conversion system.
  This unified type conversion system is now used consistently throughout Web Flow, including for view data binding.
  Simplified the Converter API to make it easier to implement custom converters, including TwoWayConverters.
  See the example converters in org.springframework.binding.convert.converters package for example Converter implementations.
  To plug in your own custom converters, register a custom ConversionService.
  Custom converters will be usable immediately throughout the system, and can be aliased e.g. "shortDate".
  See the Config section of the reference documentation for how to install a custom ConversionService, and the booking-mvc sample for an example.

* Made several improvements to the documentation.  Added coverage of action-states and decision-states (SWF-721).
  Also added converage of the new view-state binder element.

* Added support for rendering .jspx views selected by a flow in a Spring MVC environment (SWF-793).

* Error responses returned as the result of handling an Ajax request are now displayed in an error popup dialog by default (SWF-783).

* Made the eventId request parameter configurable in a Spring MVC environment (SWF-731).

Bug Fixes
* Fixed a bug preventing binding of String[] array request parameters to collection properties in a Spring MVC environment (SWF-720).
  This bug effected use of <form:checkboxes> and <form:select> tags.
* Fixed a bug where classpath: resource loading prefix was not respected within a Flow ApplicationContext (SWF-743).
  This prevented loading of classpath-based resources defined in flow beans files imported using the <bean-import> tag.
* Fixed a bug where the Severity.FATAL severity was lost in the mapping of a JSF FacesMessage to a Spring Message (SWF-752).
  Added Severity.FATAL as a supported message severity.
* Fixed a bug where the "detail" part of a FacesMessage was lost in the mapping of a JSF FacesMessages to a Spring Message (SWF-751).
* Fixed a bug where transitioning back to the originating view-state within one request always triggered a redirect (SWF-808).
  Redirect+after+post is appropriate for non-Ajax requests, but was not appropriate for Ajax requests. 
* Fixed a bug where attempting to render a view from an end-state resulted in an exception (SWF-711).
* Fixed a bug where flows where not accessible inside unexpanded WAR archives (SWF-784).
* Fixed several browser compatibility bugs affecting IE 6 with Spring Javascript (SWF-764).

Changes in version 2.0.2 (06.06.2008)
-------------------------------------
New Features
* Allow flow-execution-repository max-execution-snapshots to be set to 0 to disable snapshotting (SWF-709).
  Use this to disable serialization-based execution state snapshotting.
  Note that browser back button use is not supported when this option is enabled. 

Improvements
* Added syntax highlighting to the reference manual.
* Documented the Default ExpressionParser configuration for Spring Faces (SWF-707).
* Documented transition actions and how to restrict transition execution by returning action error results (SWF-715).
* Documented how to link in parent flows in a test environment when using inheritance (SWF-694)
* Documented how to access Web Flow Nightly Builds from the SpringSource Bundle Repository (SWF-710).
* Simplified Spring Security Config across the booking samples (SWF-724).
* Now set Locale of UIViewRoot to the Spring MVC Request Locale for JSF-based Spring MVC Views (SWF-659).

Bug Fixes
* Fixed a bug preventing use of Faces commandLinks or commandButtons inside facet definitions (SWF-692).
* Fixed a bug where Spring.ElementDecoration did not properly copy styles from the decorated node (SWF-703).
* Fixed a bug where ajaxEnabled="false" did not work properly with the Faces commandLink (SWF-700).
* Fixed a bug the Spring Web MVC AjaxView was not properly sending Ajax redirect requests to Spring.js (SWF-682).
* Fixed a bug in Spring.js related to regexp matching of <script> tags in a HTML page (SWF-672).
* Fixed a bug in decoration of radio buttons and select boxes with use of ajaxEvent and selectOneRadio components (SWF-712).
* Fixed a bug where a modal popup window would not disappear after a flow external redirect (SWF-675).
* Fixed a bug where the Faces components were not rendering the 'propercase' attribute (SWF-736).
* Fixed a bug where the ResourceServlet allowed access to sensitive files (SWF-706).
* Fixed a bug preventing mapping of non-string request parameters such as MultiPart files.
* Fixed a bug where the clientTextValidator component doesn't respect a custom JSF Converter (SWF-690)
* Fixed several locale-related bugs in the Web Flow Test Suite (SWF-697).

Changes in version 2.0.1 (15.05.2008)
-------------------------------------
Improvements
* Added a Bundle-Name: entry to each project's manifest for improved OSGi compliance.
* Changed to use the ClassLoader of a flow's ApplicationContext when deserializing a FlowExecution, allowing for more a modular usage of SWF when running in a OSGi environment.
* Co-located FlowExecution creation and state restoration logic inside a FlowExecutionFactory, a design improvement eliminating the need for a separate FlowExecutionStateRestorer.
* Reduced the size a persistent flow execution by removing the need to store the id of the root flow definition with each FlowExecutionSnapshot.
* Simplified the Converter interface and implementation contract by allowing Converters to throw any Exception to report type conversion failures.
  The ConversionExecutor now cares for wrapping any exception in a ConversionExecutionException providing full context about the conversion attempt.
  This change will effect any custom Converter implementations extending from AbstractConverter.
  Please see the existing converters in the org.springframework.binding.converters package for examples of refined Converter implementations.
* Improved booking samples by removing the unnecessary dispatcher-servlet-config.xml file and favoring configuration driven by a single master Spring configuration file.
* Made RequestContext and ExternalContext thread locals named for supporting introspection
* Added a MockExternalContext.setCurrentUser(Principal) method allowing for control over Principal implementation.
* Resolved cyclical dependencies between the action and engine packages, the config and engine packages, and the engine.model.registry and engine.model.builder subpackages.
  
Bug Fixes
* Fixed a bug preventing the handling of NumberFormatExceptions when binding to number properties using the default NumberFormatter.
* Fixed a bug preventing the loading of externalized flow definition resources in a EAR environment, for example, in Web Logic.
* Fixed a bug requiring Spring Portlet MVC in the classpath even in a Servlet-based web application when running on a Portal server.
* Fixed a bug preventing generic use of javax.faces.model.DataModel as the target type of a List conversion.
* Fixed a bug effecting TransitionCriteria expressions that evaluate the currentEvent; for example ${currentEvent.id == 'submit'}.
  This bug fix required a change to how currentEvent attributes are accessed with EL: instead of accessing an event attribute directly like ${currentEvent.attr},
  access an attribute through the 'attributes' property like ${currentEvent.attributes.attr}.  The reference documentation was updated to reflect this change.
* Fixed a bug resulting in loss of JSF ExternalContext state during execution of the JSF Lifecycle.
  This bug was effecting integration of the Trindad component library, which requires a special Response object to be set for its Ajax support to work.
* Fixed a bug preventing resolution of flow-local messages for flows launched as subflows.
* Fixed a bug where field errors recorded using Errors.rejectValue were not being associated with the source field.
* Fixed a bug preventing binding of unselected checkbox fields in a Spring MVC View environment.
* Restored JDK 1.4 compatibility in two places: when catching and re-throwing an Exception thrown by a Spring MVC View, when writing out mock responses during testing.
    
Documentation
* Added documentation on Spring Faces integration with Rich Faces and Apache Trinidad JSF component libraries.
* Added documentation on FlowHandler and externalRedirect: redirect prefixes.
* Added documentation on accessing Web Flow artifacts from Maven Central.
* Clarified the conversation-scoped and view-state managed persistence context patterns will be considered for implementation in future Web Flow releases.
* Removed unnecessary note about special Spring MVC and JSF model binding semantics; the semantics should be equal between view technologies, even if the underlying technologies differ.
* Improved documentation on model validator conventions.

Changes in version 2.0.0 (29.04.2008)
-------------------------------------
New Features
* Formally introduced the Spring Javascript (spring-js) public API and quick reference.
  The Spring.js library provides a consistent API for decorating HTML DOM nodes with rich widgets such as a filtering select,
  calendar, validating text box, currency text box, etc.  The API builds on Dojo 1.1 as the underlying widget toolkit.

* Added support for Ajax views with Spring MVC and Tiles.  This enables the rendering of JSP fragments / partials in a plain Spring MVC environment.
  See the 'booking-mvc' reference application for an example.

* Enhanced the 'booking-mvc' sample to use the Spring.js API for applying Ajax and client-side validation behaviors.
  This puts the Spring MVC + Web Flow + JSP sample on par with the Spring MVC + Web Flow + JSF sample in terms of "rich web" behavior.
  Ajax partial rendering, popup dialogs, hover effects, as well as text, number, and date validation are all demonstrated.

* Added support for automatic partial rendering of error messages when validation errors occur.

* Added support for convention-based model validation in a JSF environment, consistent with the rules defined in the reference documentation.

* Added support for accessing flow message bundle resources, such as internationalized labels, using the 'resourceBundle' EL variable.
  For example: the expression #{resourceBundle.myLabel} would resolve 'myLabel' in your messages.properties file.

* Added support for accessing beans managed by the standard JSF managed-bean facility from a flow definition.
  This is particularly useful for using Web Flow in existing JSF applications.
  To enable, set the 'enable-managed-beans' attribute to true in your Faces flow-builder-services configuration.

* Added support for explicit redirect prefixes, respected when requesting external redirects from within a flow or by a FlowHandler.
  The supported prefixes are:
      servletRelative:/<path> - relative to the current servlet mapping
      contextRelative:/<path> - relative to the web application
      serverRelative:/<path> - relative to the server
      http://<url> or https://<url> - an absolute URL 
      No prefix - servlet-mapping relative e.g. '/hotels/index' would be servlet-mapping relative.

* Added instructions on how to obtain Web Flow release artifacts from the SpringSource Enterprise Bundle Repository using Maven or Ivy.
  See the readme.txt included in this distribution for instructions on how to do this.

Improvements
* Renamed Web Flow specific terms 'conversation' and 'continuation' to 'flow execution' and 'flow execution snapshot', respectively (SWF-651).
  With these terms, rather than saying "users participate in conversations and continuations are created to support backtracking",
  you would simply say "users participate in flow executions and snapshots of execution state are taken to support backtracking".
  This lexicon improvement resulted in a package rename of repository.continuation to repository.snapshot, as well as several repository class renames.
  The default encoded flow execution key format is now e<executionId>s<snapshotId> as a result.
  The webflow-config flow-execution-repository attributes are now 'max-executions' and 'max-snapshots' as a result.
  The term "Conversation" still has a place, e.g. conversationScope, but this is a concept specific to the base web MVC platform and external to Web Flow.

* Made the FlowExecutionSnapshotFactory of DefaultFlowExecutionRepository pluggable (SWF-530).

* Removed the 'type' attribute of the webflow-config flow-execution-repository element (SWF-651).
  This element should be used to customize configuration of the default repository implementation.
  To plug in custom implementations, use regular Spring beans.

* Introduced a FlowExecutionSnapshotGroup hook for customizing the algorithm used to manage the storage of flow execution snapshots (SWF-503).

* Moved the view-state 'history' attribute to the view <transition> element to allow setting history policies per transition (SWF-628).

* Improved the implementation of the Spring MVC integration for both Servlet MVC and Portlet MVC environments.
  These improvements consisted of:
  - Eliminating code duplication between FlowController and FlowHandlerAdapter. The FlowController now delegates to a FlowHandlerAdapter internally.

  - Removing the FlowController and FlowHandlerAdapter constructors that accepted a FlowExecutor argument in favor of a default constructor with a flowExecutor property.  
    This was done for simplicity reasons for their typical use as Spring beans.
    Please note this change requires a minor update to pre 2.0.0 Web Flow + MVC configurations.

  - Adding support for auto-detecting if Web Flow is running in a Servlet or Portlet MVC environment, and applying the appropriate environmental defaults.

  - Introducing a FlowViewResolver hook for customizing how Spring MVC views are resolved in a Web Flow environment when defining a custom MvcViewFactoryCreator.
    By default, view ids are resolved to flow-relative file resources.
    Pre-existing Spring MVC ViewResolvers can be used by setting the 'viewResolvers' property on the configured MvcViewFactoryCreator instance.

  - Improving the Portlet FlowHandler interface definition.  A Portlet FlowHandler can now return a error view to render when handling a flow exception.
    Also, the FlowHandler can respond to a flow outcome in an ActionRequest.  A typical response action is to change the Portlet mode; e.g. from EDIT to VIEW.

  - Introducing a FlowExecutionOutcome parameter object for conveniently handling a flow outcome such as 'bookingConfirmed' (SWF-634).
    This improvements effects the signature of the FlowHandler interface.

* Factored out AjaxHandler into the spring-js project as a strategy interface that can be used across controller / view environments.
  Also moved the SpringJavascript and RichFaces AjaxHandler implementations to this project.
  This change makes the spring-js.jar a required Web Flow dependency needed in conjunction with the Web Flow Spring MVC integration.

* SelectionTrackingActionListener nows work with any JSF component that iterates over a DataModel (SWF-646).

Bug Fixes
* Fixed several issues with the Web Flow 1 to 2 flow upgrader tool (SWF-643, SWF-644).
* Flash scope is now stored with the Conversation object, preventing snapshotting of flash values and providing equivalent semantics of flash in other frameworks (SWF-639).
* Fixed several JDK 1.4 compatibility issues (SWF-612, SWF-638).
* Fixed a bug preventing action execution attributes such as a FormAction 'validatorMethod' from being respected (SWF-626).
* Fixed a bug preventing data binding to nested bean properties (SWF-625).
* Fixed a bug preventing bind suppression with bind="false" when using OGNL.
* Fixed a parsing bug for the <exception-handler> XML flow definition element (SWF-613).
* ResourceServlet now restricts access to protected resources within the WEB-INF directory (SWF-604).
* Fixed several bugs in both the Hibernate and JPA persistence listeners preventing use of flow-managed persistence contexts with subflows (SWF-600).
* 'bind' attribute is now supported on global-transitions now, for global events where data binding should occur (SWF-597).
* Fixed a bug where a MessageContext is not preserving message order (SWF-596).
* Fixed a possible NPE when using Spring Faces command buttons (SWF-594).
* Resolved cyclical dependency between mvc.view and the mvc.servlet/mvc.portlet packages (SWF-580). 
  This resulted in the move of MvcViewFactoryCreator from the mvc.view package to a new mvc.builder package.
* Fixed a bug preventing non-validating Dojo widgets from working with Spring Javascript (SWF-606).
* Fixed a bug preventing proper Locale resolution for flow message bundles (SWF-622).
* Fixed a bug preventing HTML button form parsing of eventIds for view-state external redirect postbacks (SWF-632).
* Fixed a possible NPE when rendering a MVC View from a EndState (SWF-656).

Changes in version 2.0 RC1 (11.04.2008)
-------------------------------------
Major New Features
* Introduced a new Web Flow 2 reference guide, available in PDF and HTML format.
  The new guide is written in "quick reference" style with complete code examples.

* Added support for migrating from Web Flow 1 to 2.
  Included in this distribution is a WebFlowUpgrader tool capable of converting flows from the version 1 syntax to the version 2 syntax.
  See the reference guide for instructions on how to use this tool.

* Added support for flow definition inheritance.
  With this feature, A flow may extend one or more flows. A flow state can also extend another state.
  This feature is used to facilitate reuse between flows and states that share a common structure.

* Added Portlet support.  See the Portlet section of the reference guide and the booking-mvc-portlet and booking-faces-portlet sample applications for examples.

* Introduced the spring-js module called "Spring Javascript".
  This module provides a Javascript abstraction framework for applying client-side behaviors such as form validation and Ajax in a consistent manner.
  The default UI toolkit this framework builds upon is Dojo 1.
  Spring's JSF integration module called "Spring Faces" builds on spring-js to provide simple declarative JSF components for validation and Ajax.

* Added integration with the RichFaces JSF component library.  Rich Faces can be used with the Spring Faces component library or used standalone.

* Added a "jsf-booking" reference application that offers a comparsion between a traditional "JSF-centric" web application
  and a Spring web application that uses JSF as the UI component model.
  Compare jsf-booking with booking-faces to see the differences in the architectural approach and implementation.
  Particularly insightful for seasoned JSF developers interested in Spring.

* Introduced support for automatic model binding and validation with Spring MVC.
  This support provides a concise alternative to manual setupForm and bindAndValidate calls using FormAction.
  This support also allows registration of data input Formatters application wide,
  reducing the need to manually register PropertyEditors on a view-by-view basis in many cases.
  Support for suppressing data binding for a event such as a cancel button click is also provided.

* Introduced view scope.
  View scope is allocated when a view-state enters and destroyed when a view-state exits.
  The scope is particularly useful for updating a model over a series of Ajax requests.

* Added support for flow message bundles.
  Create a messages.properties file in your flow's working directory for the Locales you need to support and off you go.

* Introduced configurable view-state history polices.
  A view state can preserve its history to support backtracking, discard its history to prevent backtracking,
  and invalidate all previous history to disallow backtracking after a point of no return.
  See the new 'history' attribute on the view-state element.

* Refined the flow execution snapshotting process.
  These refinements capture view-state form values on postback to support restoring those values when backtracking.

* Simplified flow execution testing by allowing you to "jump" to any state to begin a test case.
  See the booking-mvc and booking-faces for examples of flow test cases.

Minor Improvements
* Added "before view rendering" and "after view rendering" FlowExecutionListener callbacks.
* Upgraded to Dojo 1.1 from 1.0.
* Attempts to lock a Conversation will now throw an Exception after a configurable timeout period (default is 30).
* Changed the faces-config schema to simply 'faces' in-line with Spring conventions.
* Added automatic registration of Spring 2 Flow scopes in the flow-local application context, removing the need for a custom enable-flow-scopes tag.
* Added a flow-registry 'parent' attribute, allowing registries to be linked together in a hierarchy.
* Made the JSF 1.2 RI the default JSF implementation used by the JSF samples.
* Updated the distribution structure to use the new "Spring Build" system.
* Made backport-util-concurrent the fallback concurrency framework in a Java 1.4 environment, instead of oswego-concurrent.
* Added a dynamic subflow resolution capability.
* Simplified the FlowHandler interface and added examples of implementing FlowHandlers to manage access to a flow in a custom manner.
* Upgraded the booking-mvc sample to show a mixing Spring MVC @Controllers with web flows, which is typical in a real-world application.
* Added ExternalContext.getLocale() to get the client locale from the flow in a portable manner.
* Added ExternalContext.getCurrentUser() to get the current user principal from the flow in a portable manner.
* Restored support for setting action execution attributes such as validatorMethod.  See the <attribute> sub-element of <evaluate>, <set>, and <render>.

Changes in version 2.0 M4 (06.03.2008)
-------------------------------------

General
* Stabilized the Web Flow 2 architectural model.  This includes Web Flow's role and relationship with Spring MVC, JSF, and Ajax,
  as well as the definition of new Web Flow 2 extension points.
  Notes:
  - Web Flow 2 will continue to play the role of a stateful controller framework complimenting stateless web controller implementations like @Controller.
  - In this role, Web Flow continues to plug into Spring MVC via Controller and HandlerAdapter hooks and treats Spring MVC
    as the base web MVC platform for request dispatch. 
  - Web Flow can now manage the JSF UI component lifecycle fully within its ViewState lifecycle.  This work resides in the Spring Faces project.
  - Spring MVC can also now execute the JSF rendering lifecycle directly, allowing rendering of JSF views by @Controllers as well.
    This work also resides in the Spring Faces project.
  - The SWF ViewFactory API is an extension point for other UI framework providers to integrate their view rendering and postback lifecycles
    into the Web Flow Execution Engine.  SWF 2 ships integration with Spring MVC and JSF, and we expect additional UI frameworks to integrate over time.
  - The SWF FlowExecutor API can be used to embed the Web Flow engine in any web controller environment. For example, Grails uses this API as does IceFaces.
  - Web Flow 2 defines a general model for handling asynchronous events from within a page and requesting partial rendering of page fragments after
    handling those events.  Spring Javascript Ajax integration ships with SWF 2.x, and hooks exist for other Ajax framework providers to plug in.

Major New Features
* Introduced a much simplified XML-based flow definition syntax.  See the "Spring Travel" reference applications (booking-faces and booking-mvc projects) for an
  illustration of the new syntax.  Use of the version 2 syntax can reduce the size of a version 1 flow definition by up to 50%.  This is achieved
  primarily by stronger Expression Language (EL) integration and simpler tags for action execution and data mapping.

* Added Spring Security integration.  Full support for securing flows, states, and transitions is provided.  A new "currentUser" EL variable
  provides easy-reference to the current Authenticated user from a flow definition or view template.

* Added full support for flow exception handling, including support for automatically restarting a flow that has ended or expired.

* Added support for view "event handlers", transitions that process Ajax events that should not change the current page.
  A new "render" element allows you to request fragment(s) of a page that should re-render after handling an Ajax event.
  This element is not tied to any particular Ajax framework.

* Added support for "view variables" (view scope or page scope).
  A view variable is allocated when its containing view-state enters and destroyed when that state exits.
  These variables provide a page context and are particularly useful for updating a model over a series of Ajax requests.

* Added support for @Autowired flow variables.  Flow and view variables can now have their dependencies @Autowired by Spring, enabling flow-scoped beans
  to hold references to Spring-managed beans such as @Services.  If a dependency is not serializable and therefore transient, those references will
  be re-wired for you automatically between requests.
  
* Added support for "popup" view-states.  Mark a view-state as popup=true and it will render in a popup dialog when Javascript is enabled.
  
* Introduced a Javascript abstraction framework called "Spring Javascript", currently providing Dojo and Ext based implementations.
  This abstraction framework provides the following:
  - A common interface for Ajax, regardless of which toolkit is being used under the covers
  - An unique aspect-oriented configuration API for decorating HTML DOM nodes with rich web behaviors, including client-side validation behaviors.

* Added a lightweight JSF component library that uses Spring Javascript underneath to employ progressive enhancement techniques,
  degrading nicely if Javascript is not available for use on the client.  See the Spring Travel example for an illustration;
  turn Javascript off and compare the application to when Javascript is turned on.

* Added support for registering "Flow Handlers", as an alternative or supplement to the traditional Spring MVC FlowController.
  A FlowHandler is a gatekeeper that brokers access to a single flow definition.
  Such handlers are useful when you need the to handle flow input mapping, flow outcomes, or flow exceptions in a custom manner.
  See the FlowHandlerAdapter and FlowHandler Javadoc API for more information.

Changes in version 2.0 M3 (20.12.2007)
-------------------------------------
Package org.springframework.webflow.faces
* Added built-in Ajax support for rendering partial page views in response to asynchronous Web Flow events.
  See the booking-jsf sample for an example.
* Added built-in support for progressive enhancement, including a library of JSF components that degrade nicely if Javascript
  is not available on the client.  See booking-jsf for an example of two such components: first, the Spring Faces command link which
  renders as a standard submit button if Javascript is not available, and second a popup window that displays a partial asynchronous response if
  Javascript is available (otherwise a full synchronous page navigation occurs).
* Polished overall JSF integration approach since M2, including applying refinements and performance optimizations
  to the UIViewRoot state saving strategy.
* Upgraded to Dojo 1.0 from 0.9.

Changes in version 2.0 M2 (30.10.2007)
-------------------------------------

General
* Spring Web Flow now cares for the entire web controller request/response lifecycle (including control over the view rendering process, too!)
* Spring Web Flow now provides first-class JSF and Spring MVC integration by driving their respective view rendering and
  restoration request lifecycles in the context of a web flow execution request.  This simplifies view technology integration
  for the developer, provides a cleaner and more powerful architectural model, and makes it possible to mix-and-match JSF and MVC-style views
  in the same application, if desired.  Support for Portlet MVC using this approach will be added in a future 2.x milestone.
* Please see the "booking-jsf" reference application for a complete example of a "standalone" webflow app using JSF as the view technology.
  Please see the "booking-mvc" reference application for a complete example of a "embedded" webflow app using Spring MVC as the view technology.
  Note it would be possible to introduce flows that render JSF-based views in this "embedded" mode, if desired.
* The default URL scheme for working with flows is now REST-based:
	http://host/<flowId>[?requestParameters] - to launch a new flow execution; for example http://host/booking
	http://host/<flowId>?execution=<flowExecutionKey> - to resume a paused flow execution; for example http://host/booking?execution=e1s1
  This scheme will be configurable in later 2.x milestones, primarily to ease migration to 2.0 from 1.0.
* Flow execution key assignment now happens before a view state is entered now, allowing a flow execution to send proper callback Url to a 
  external systems that will take over control of the conversation and return control at a later time.  An example would be a e-shopping site
  redirecting to paypal to complete a payment authorization.  This was difficult to do in SWF 1.0 and is now supported natively.

Package org.springframework.binding
* Simplified Expression and ExpressionParser abstraction, normalized parser contract to be consistent between parser implementations as far as possible.
  OGNL and the Unified EL are the two supported expression parser implementations.  OGNL is currently the default.  The Unified EL is recommended for
  a JSF environment.  See booking-jsf for an example of the Unified EL in use.  See booking-mvc for an example of OGNL in use.
  These changes will require tweaks in flow definitions being upgraded to 2.x that define implicit eval expressions without encasing them in explicit
  eval expression delimiters (#{} for EL, ${} for OGNL).  Now, such delimiters are required for eval expressions for clarity and consistency.
   
Package org.springframework.webflow.engine
* Added support for "flow relative resources".  Most notably, this allows views to be selected by a flow-relative file path, rather than requiring 
  a fully-qualified context path.  See booking-mvc and booking-jsf for an example.
* Removed support for inline flows entirely for 2.x. Use subflows instead.  Support for local flow registries for internal subflows is planned for
  a future 2.x milestone.
* Removed support for declaring flow variables whose source value is sourced from a Spring bean factory.  Use simply name/class notation instead.
  Support for dependency injection of flow variables is planned for a future 2.x milestone.

Package org.springframework.faces
* Made Dojo the default UI toolkit for the default 'faces' component namespace.  See booking-jsf for an example of using Spring Faces with the Dojo toolkit.
* Made Ext an alternate UI toolkit and introduced the alternate 'faces-ext' component namespace.
* Added support for serving web resources from .jar files using the general purpose 'resources' flow.  See booking-jsf or mvc for an example.

Package org.springframework.webflow.samples
* Introduced booking-mvc, the hotel booking reference application using Spring MVC-based views with Tiles for templating.
* Removed old SWF 1.x samples, with 2.x now focusing on a smaller set of more comprehensive reference applications.

Changes in version 2.0 M1 (21.08.2007)
-------------------------------------

Package org.springframework.binding
* Fixed serializability problems in ConversionException, EvaluationException and MethodInvocationException.
* Added targetCollection(String) method to MappingBuilder.
* ConversionExecutor now checks for assignment compatible types (SWF-337).
* Fixed bug in MapAccessor where accessing a map entry with a null value would result in an exception (SWF-343).

Package org.springframework.webflow.action
* Improved FormAction.setupForm() JavaDoc (SWF-325).

Package org.springframework.webflow.config
* FlowExecutorFactoryBean now has an 'inputMapper' property to conveniently configure the 'inputMapper'
  property of the created FlowExecutorImpl object.
* Added a new <enable-scopes/> bean definition to a new 2.0 revision of the spring-webflow-config schema to support
  Web Flow scoping of beans in Spring (SWF-163).

Package org.springframework.webflow.engine
* Made flash scope a property of the FlowExecution instead of the active FlowSession.  This allows flash messages to be saved across an redirect
  if the messages were put there by a subflow that ended, for example (SWF-221).

Package org.springframework.webflow.context.scope
* Added support for Web Flow scoping of Spring beans (SWF-163).

Package org.springframework.webflow.conversation
* Each SessionBindingConversationManager now uses a unique key to store it's conversation container
  in the session (SWF-304).

Package org.springframework.webflow.core
* Fixed DefaultExpressionParserFactory to not require OGNL on the classpath if another expression parser
  is configured (SWF-335).

Package org.springframework.webflow.definition.registry
* Added namespace awareness to the flow registry allowing flows with the same id to be placed in different namespaces
  and be referenced by a 'flow path' (SWF-363).

Package org.springframework.webflow.engine
* Added invoke(String, Action) method to AbstractFlowBuilder.
* Added initBuilder() hook method to AbstractFlowBuilder.
* Added name(String, Action) method to AbstractFlowBuilder for convenient creation of named actions.
* AnnotatedAction now has a convenience putAttribute(String, Object) method.
* Added annotate(Action) method to AbstractFlowBuilder.
* Added createLocalBeanFactory(Flow, Resource[]) and registerLocalBeans(Flow, ConfigurableBeanFactory) hook
  methods to XmlFlowBuilder to allow for control over the registration of beans needed locally by a flow definition.
  Useful for testing (SWF-307).
* Ensures that all exceptions (including RuntimeExceptions) are handled properly by the FlowExecution (SWF-333).
* Ensured the RequestContext attribute map can never be null (SWF-347).
* Renamed TransitionExecutingStateExceptionHandler to TransitionExecutingFlowExecutionExceptionHandler.
  This handler now exposes the handled flow execution exception under the key "flowExecutionException"
  instead of the key "stateException (SWF-281). 
  
Package org.springframework.webflow.execution
* Added a holder for the FlowExecutionContext of a request (SWF-163).
* Made the Event class non-final to allow for extension (SWF-330).
* Now allow multiple conversation containers per session in a manner that supports use in a cluster (SWF-378).

Package org.springframework.webflow.executor
* JSF integration code now manages flow execution locks properly in exceptional situations and when the
  RENDER RESPONSE phase is bypassed (SWF-302).
* Restored compatability with 1.0.1 allowing default navigation rules to be queried if no transition could
  be matched against the state of the current flow execution (SWF-303).
* JSF integration code now tears down ExternalContext thread local properly in exceptional situations and when
  the RENDER_RESPONSE phase is bypassed (SWF-305).
* JSF integration code now binds the current FlowExecutionContext to a thread local for use by the Spring scoping
  mechanism (SWF-163).
* JSF can now use a FlowSystemCleanupFilter to ensure that no matter what happens in JSF, the request context
  is cleaned up properly (SWF-306).

Package org.springframework.webflow.persistence
* Added support for Flow Managed Persistence Contexts with Hibernate and JPA (SWF-92).

Package org.springframework.webflow.test
* Added the ability to apply multiple listeners to a test case (SWF-334).
* Relaxed 'final' qualifier on AbstractXmlFlowExecutionTests#createFlowBuilder(FlowServiceLocator).
* Added registerLocalMockServices(Flow, ConfigurableBeanFactory) hook method to AbstractXmlFlowExecutionTests.
  Overriding this method is useful for customizing the builder's population of the bean factory local to the
  flow definition (SWF-307).
* Introduced MockAction for stubbing out action implementations when unit testing flow executions (SWF-317).

Package org.springframework.faces
* Introduced a "Spring Faces" component library, the new home of the Spring Web Flow + Java Server Faces (JSF) integration
  and additional JSF-based functionality such as client-side UI input validation components (SWF-388).

Package org.springframework.webflow.samples
* Added a "booking-jsf" reference application, a hotel booking system built on "Spring Faces" (which ties together JSF + Spring Web Flow + Spring).
  Also serves as a Seam comparison sample (SWF-366).

Package reference-manual
* Improved readability of reference manual in several sections (SWF-349).
* Added documentation on flow execution exception handling options (SWF-357).