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

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 runs in a "standalone" mode as well as an "embedded" mode.  "Standalone" mode introduces a Spring Web Servlet that
  delegates directly to the Spring Web Flow Engine.  "embedded" mode allows Spring Web Flow to be used within another Servlet, such as the 
  Spring MVC DispatcherServlet.
* 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 Struts using this integration approach will be added in a future 2.x milestone.
  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 recommended URL scheme for working with flows is now REST-based:
	http://host/<flowId>[/requestPath][?requestParameters][#fragment] - to launch a new flow execution; for example http://host/booking
	http://host/executions/<flowId>/<flowExecutionKey> - to resume a paused flow execution; for example http://host/executions/booking
  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).

Changes in version 1.0.3 (19.04.2007)
-------------------------------------

Package org.springframework.webflow.executor
* PortletFlowController now correctly handles flow redirection parameters (SWF-236).
* SWF-JSF: FlowExecution refresh no longer causes a new flow execution key to be generated (SWF-291).
* SWF-JSF: Restored capability to launch a new flow within an ongoing flow using a UICommand (SWF-290).

Changes in version 1.0.2 (10.04.2007)
-------------------------------------

Package org.springframework.binding
* GenericConversionService.getConversionExecutor() now uses isAssignableFrom to detect situations where no
  conversion is necessary (SWF-264).
* Fixed possbile NullPointerException in MethodKey.parameterTypesString() (SWF-265).
* OgnlExpression now unwraps the ognl.OgnlException to make the real exception available to the caller (SWF-255).
* OgnlExpressionParser now supports OGNL collection construction syntax (SWF-274).
* AbstractExpressionParser now has a doParseSettableExpression() template method.
* MethodInvoker now unwraps an InvocationTargetException to make the target exception directly available as
  the cause of a MethodInvocationException.
  
Package org.springframework.webflow.action
* FormAction methods doBind() and createBinder() now declare "throws Exception".
* FormAction now consistently uses the getters to get property values (SWF-251).
* FormAction now allows usage of a validator when the formObjectClass is null.
* ResultObjectBasedEventFactory now uses java.lang.Enum.name() to get the name of a Java 5 enum (SWF-250).

Package org.springframework.webflow.config
* Fixed bug in WebFlowConfigNamespaceHandler that caused the type attribute of the repository tag not to be
  read properly and throw an exception (SWF-239).
* Added Spring tooling funtionality to the BeanDefinitionParser to allow tools such as SpringIDE to properly
  interact with it (SWF-254).
* Added getFlowExecutor() method to FlowExecutorFactoryBean.

Package org.springframework.webflow.context
* The ThreadLocal in ExternalContextHolder is now final (SWF-262).

Package org.springframework.webflow.conversation
* The SessionBindingConversationManager now re-binds the ConversationContainer in the session every time a
  contained conversation is unlocked (SWF-244).

Package org.springframework.webflow.engine
* FlowExecutionImpl.handleException() now also tries to handle FlowExecutionExceptions that occur during
  exception handling (SWF-261).
* The XmlFlowBuilder now also supports OGNL expressions in the "to" attribute of a transition when using the
  "on-exception" attribute (SWF-269).
* The XmlFlowBuilder now consistently uses "fromStringTo(Class.class)" to resolve types (SWF-268).
* Added AbstractFlowBuilderFlowRegistryFactoryBean for easy setup of a flow registry containing flows built
  using AbstractFlowBuilders.
* Added DefaultFlowServiceLocator(String, BeanFactory) convenience constructor to the DefaultFlowServiceLocator.
* Added BeanFactoryFlowVariable(String, BeanFactory, ScopeType) convenience constructor to the
  BeanFactoryFlowVariable.
* Added settableExpression() method to AbstractFlowBuilder.
* Added new exposeException() hook method to TransitionExecutingStateExceptionHandler (SWF-280).

Package org.springframework.webflow.execution
* Added FlowExecutionListener.sessionCreated(RequestContext, FlowSession) callback, useful for setting flow
  attributes before the flow starts (SWF-223).
* ClientContinuationFlowExecutionRepository now uses 'URL-safe Base64 encoding' (SWF-270).
* AbstractConversationFlowExecutionRepository.parseFlowExecutionKey() now throws an
  BadlyFormattedFlowExecutionKeyException when asked to parse an empty flow execution key (SWF-277).

Package org.springframework.webflow.executor
* Added ease of configuration for those using SWF in a JSF environment, consistent with the other environments
  Spring Web Flow supports.
  This includes support for using the <flow:executor> webflow-config element in a JSF environment, which allows JSF
  users to benefit from defaults such as a continuation-based flow execution repository and 'alwaysRedirectOnPause'
  for full back-button-support out of the box.  See sellitem-jsf for an example.
* Added DelegatingFlowVariableResolver for resolving flow variables in any of the support scopes: "flash" (like view
  scope), "flow" (local flow scope) and "conversation" (global conversation scope). Previously only "flowScope" was
  accessible to view developers.
  In addition, this resolver does not require a variable prefix, meaning variables can be resolved like
  {#someBean.someProperty} which is what JSF developers are familiar with.  In this case a search of
  flash/flow/conversation is performed in that order with a fallback to the next variable resolver in the chain
  when no match is found.
* Added new FlowExecutionVariableResolver and FlowExecutionPropertyResolver for resolving flow execution variables
  with an explicit "flowExecution" prefix.  This is an alternative to using DelegatingFlowVariableResolver. 
* Support for embedding the flowExecutionKey (identifying the state of an active flow instance) in the UIViewRoot
  as a component.
  This means view developers no longer have to track the ${flowExecutionKey} themselves and remember to post it back
  to the server. So the bottom line is JSF views in a SWF environment now look like standard JSF views (there is no
  difference at all), which makes SWF more natural and easier to adopt by the JSF community.  Special thanks to
  Jeremy Grelle for submitting this work (SWF-283).
* Added resource URL encoding to redirects in a JSF environment (SWF-256).
* JSF flow execution lifecycle now respects flow execution locking contract (SWF-229, SWF-276).
* Fixed bug in FlowPhaseListener that resulted in a NPE on a flow that started and ended in the same request (SWF-273).
* Introduced ResponseInstructionHandler convenience class and refactored FlowController, PortletFlowController,
  FlowAction and FlowPhaseListener to use it.
* Added FlowIdMappingArgumentHandlerWrapper (SWF-204).

Package org.springframework.webflow.test
* Added constructor taking test name argument to AbstractFlowExecutionTests, AbstractExternalizedFlowExecutionTests
  and AbstractXmlFlowExecutionTests.
* Added getFlashAttribute and getRequiredFlashAttribute methods to AbstractFlowExecutionTests.

Package org.springframework.webflow.samples
* Made all samples Spring IDE 2.0 projects for use with the Spring Web Flow Graphical Editor and XML Flow Definition
  Editor out of the box.
  To use these features, import the sample projects into Eclipse 3.2.2 with WTP 1.5.3 and Spring IDE 2.0 M3 or
  greater installed. Get Spring IDE 2.0 at http://springide.org.
* Featured alternate versions of "ItemList" and "Sellitem" flows more prominently.
* Enhanced the JSF-based version of SellItem to take advantage of the latest simplifications in Spring Web Flow's
  JSF support. Please see this sample along with the practical section in the reference manual for illustrations
  of how to use Spring Web Flow in a JSF environment effectively.
* Greatly enhanced sample walkthrough documentation in 'practical' section of reference manual (special thanks to
  Rossen Stoyanchev who contributed this).

Changes in version 1.0.1 (08.01.2007)
-------------------------------------

General
* In Ivy, JUnit is no longer a default dependency. There is now a new 'testing' configuration that
  includes JUnit as a dependency (SWF-213).

Package org.springframework.webflow.action
* FormAction methods getFormObject and getFormErrors are no longer final (SWF-222).
* When FormAction detects that the existing Errors instance is invalid, it will now copy over
  existing field and object errors to the newly created Errors instance (SWF-219).

Package org.springframework.webflow.config
* Added get/setMaxConversations and get/setMaxContinuations methods to FlowExecutorFactoryBean. Also
  added corresponding configuration abilities to the config schema (SWF-210).
* Fixed bug in FlowExecutorFactoryBean where the ClientContinuationFlowExecutionRepository was being
  configured with the SessionBindingConversationManager by default (SWF-216).
* The conversationManager argument of the createExecutionRepository hook method in the
  FlowExecutorFactoryBean is now possibly null. Review your implementation if you were overriding
  this method!
* Fixed JDK 1.3 compatibility issue in FlowSystemDefaults (SWF-227).

Package org.springframework.webflow.context
* ExternalContextHolder now uses a ThreadLocal instead of an InheritableThreadLocal (SWF-206).

Package org.springframework.webflow.conversation
* The default value of the maxConversations property of the SessionBindingConversationManager is
  now 5. It used to be -1 (unlimited).
* Added getConversationIdGenerator and getMaxConversations methods to SessionBindingConversationManager.
* Reduced log level from INFO to DEBUG.

Package org.springframework.webflow.definition
* Added debug logging to FlowDefinitionRegistryImpl.
* FlowDefinitionResource now has a public static helper method named conventionalFlowId that implements
  conventions based flow id calculation logic.

Package org.springframework.webflow.engine
* The methods getMatchingCriteria, getExecutionCriteria, getTargetStateResolver, and canExecute
  of the Transition class have been made public (SWF-209).
* Added debug logging to FlowAssembler, RefreshableFlowDefinitionHolder and FlowExecutionImplFactory.
* The "alwaysRedirectOnPause" flow execution attribute value can now also be a String.
* Added toString implementations to XmlFlowBuilder and AbstractFlowBuilder.
* Added support for the "name" attribute to the <set> and <evaluate-action> elements in the flow XML.
* Fixed bug in method isFlowElement of XmlFlowBuilder to make it namespace-aware (SWF-226).
* TransitionExecutingStateExceptionHandler now does full logging of the exceptions that it handles.
* Fixed bug in BaseFlowServiceLocator where it was not allowing user to override the default web flow
  converters (SWF-220).
* Added setFlowAttributes method to XmlFlowRegistryFactoryBean to make it easier to configure
  externally defined flow definition attributes (SWF-200).
* Added setXmlFlowRegistrar method to XmlFlowRegistryFactoryBean.

Package org.springframework.webflow.execution.factory
* The getHolder method on ConditionalFlowExecutionListenerLoader is now private. It has a package
  private return type, so there is no use in it being protected.

Package org.springframework.webflow.execution.repository
* Fixed a bug in FlowExecutionContinuationGroup. It was not correctly handling an update of a
  continuation (SWF-211).
* The default value for the maxContinuations property of the ContinuationFlowExecutionRepository
  is now 30. It used to be -1 (unlimited).
* Method getConversationManager of AbstractConversationFlowExecutionRepository is now public.
* Added debug logging to the FlowExecutionRepository implementations.

Package org.springframework.webflow.executor
* Added debug logging to FlowExecutorImpl.

Package org.springframework.webflow.samples
* Made sample projects Eclipse Dynamic Web Projects for easy deployment from Eclipse.

Changes in version 1.0 (25.10.2006)
-----------------------------------

Package org.springframework.webflow.action
* Fixed bug in FormAction where the binder was not properly initialized in all cases (SWF-193).

Package org.springframework.webflow.definition.registry
* Added createFlowDefinitionRegistry hook method to AbstractFlowDefinitionRegistryFactoryBean.

Package org.springframework.webflow.engine
* Removed END_STATE_VIEW_FLAG_PARAMETER from TextToViewSelector. As a result, the endingViewSelector
  method of AbstractFlowBuilder was also removed.
* Removed newDefaultFlowServiceLocator method from AbstractFlowBuildingFlowRegistryFactoryBean. 
* Fixed bug in RefreshableFlowDefinitionHolder. It was not correctly reloading flows when resources
  changed.
* Added "input-attribute" and "output-attribute" convenience elements to "input-mapper" and 
  "output-mapper" elements, respectively.
* Renamed DefaultFlowAttributeMapper to ConfigurableFlowAttributeMapper for clarity and to avoid confusion.
* Restored TargetStateResolver to support dynamic transitions.

Package org.springframework.webflow.executor
* FlowExecutorImpl now updates the flow execution in the flow execution repository after a refresh,
  without generating a new key. This ensures that side effects of render actions live beyond the
  current request.
* Refactored FlowExecutorArgumentExtractor into an interface and introduced FlowExecutorArgumentExposer
  and FlowExecutorArgumentHandler. What the FlowExecutorArgumentExtractor used to be is now
  RequestParameterFlowExecutorArgumentHandler. RequestPathFlowExecutorArgumentExtractor was renamed
  to RequestPathFlowExecutorArgumentHandler.
  The flow controllers (FlowController, FlowAction, PortletFlowController and FlowPhaseListener) now
  use a FlowExecutorArgumentHandler instead of just a FlowExecutorArgumentExtractor. The corresponding
  "argumentExtractor" properties of the flow controllers were renamed to "argumentHandler".
* Fixed bug in FlowPhaseListener where flow execution was being saved twice on redirects out of the 
  control of the JSF lifecycle due to obeying response complete lifecycle semantics incorrectly (SWF 181).
  
Package org.springframework.webflow.test
* Introduced createExternalContext hook method in AbstractFlowExecutionTests.

Changes in version 1.0 RC4 (04.10.2006)
---------------------------------------

General
* Restructured codebase into distinct layers and subsystems upon in-depth SonarJ analysis of architecture.
  Notable restructuring:
  - Extracted stable "Flow Definition" API to webflow.definition package from root webflow package
  - Extracted stable "Flow Definition Registry" subsystem to webflow.definition.registry.
  - Extracted stable "Flow Execution" API to webflow.execution package from root webflow package.
  - Extracted stable "External Context" subsystem to webflow.context from root webflow package.
  - Extracted "Flow Execution Engine" implementation to webflow.engine package from root webflow package,
    decoupling stable Flow Definition, Flow Definition Registry, Flow Execution, Flow Execution Repository,
    and Flow Executor subsystems from the more volatile engine implementation.
  - Moved webflow.builder subsystem into the webflow.engine implementation package.
  - Extracted the XML-based Flow Builder into webflow.builder.xml sub package.
  - Extracted generic data structures into webflow.core.collection from root webflow package.
  - Extracted generic "Conversation Manager" subsystem into webflow.conversation from execution.repository.
  - Factored out test support code into "engine" and "execution" subpackages, for unit testing 
    flow artifacts and system testing flow executions respectively.
  Restructuring effort successfully reduced project average component dependency from 48 to 27 (45%), 
  largely by isolating and encapsulating the complexity of the Spring Web Flow engine implementation.
  See reference documentation and JavaDoc overview for layer and subsystem descriptions.
  See root spring-webflow project directory for SonarJ architecture document - "webflow-architecture.xml"
* Refined and polished method throws exception signatures in various places.
* JavaDoc enhancements all over the source code.
* Significant reference documentation updates.

Package org.springframework.webflow.action
* Added EvaluateAction for evaluating Expression objects against the RequestContext as part of Action execution.
* Added SetAction for setting attribute values in a configured scope on Action execution.
* Added note about the "final" nature of FormAction's action methods.  In general, do not override action methods,
  instead have your flow call multiple methods in a chain or have your action method delegate to an explict overridable hook.
* Added support for reinstalling custom property editors on FormAction.setupForm if necessary; for 
  example, because the errors collection was serialized and transient editors were lost.
* Factored out generic ResultEventFactory and ResultEventFactorySelector helpers.
* Collapsed default RC3 FormAction.createFormObject behavior into "loadFormObject" for simplictly and 
  renamed "loadFormObject" to simply "createFormObject" for consistency.  This leaves a single hook
  -- createFormObject -- to customize how the form object instance is created/retrieved.
* Extracted FormAction.registerPropertyEditors(PropertyEditorRegistry) hook, now called by initBinder
  on bind and initFormErrors on setupForm.
* Renamed MethodResultSpecification to ActionResultExposer indicating its more general applicability.
* Removed GuardedAction as it was not being used.
* Removed automatic adaption of a Spring-managed prototype bean to a flow-scoped bean.  Overloaded usage
  of prototype semantics was confusing particular in a Spring 2.0 environment with the notion of custom
  bean scopes.  If you need flow-scoped beans, use flow variables (see 'var' element).  You can call
  methods on a flow-scoped bean using an evaluate action (see 'evaluate-action' element and Numberguess
  sample application).
* Removed experimental and now unused bean action related classes BeanFactoryBeanInvokingAction,
  BeanStatePersister, and related Memento persister classes.  Flow variables with evaluate actions
  provide a better solution.  In the future we may provide support for restoring transient variable
  references on flow execution restoration.
      
Package org.springframework.webflow.config
* Introduced new Spring 2.0 webflow-config XML namespace, significantly simplifying user configuration 
  of the flow execution engine.  See spring-webflow-config.xsd and sample applications for more information.
* Introduced Spring 1.2 compatible FlowExecutorFactoryBean for easing configuration of the flow
  execution engine.  See itemlist sample for an example of how to use.
* Introduced FlowSystemDefaults encapsulating system-wide default settings.  These defaults include:
  - repositoryType = 'continuation'
  - alwaysRedirectOnPause = 'true'
  Defaults may be overridden on a flow executor basis.  The defaults themselves are also configurable.
  
Package org.springframework.webflow.core
* Factored out "AttributeMap" interface and renamed default implementation to "LocalAttributeMap".
* Factored out "ParameterMap" interface and renamed default implementation to "LocalParameterMap".
* Factored out "MutableAttributeMap" interface from "AttributeMap" for modifiable maps.
* Added AttributeMapBindingListener abstraction for listening to bind and unbind events in supported attribute maps 
  such as the external context session map.  

Package org.springframework.webflow.context
* Added support for accessing a PortletRequest.USER_INFO map as context.getUserInfoMap().
* Added support for MultipartActionRequest parameters for fileupload support in a Portlet environment.
* Introduced ExternalContextHolder for setting a thread-bound ExternalContext.  Used by FlowExecutionRepository 
  implementations that need to access external state such as the sessionMap.
* Promoted the "globalSessionMap" property to the normalized ExternalContext interface.
* Factored out generic Map decorators to spring-binding collection package.

Package org.springframework.webflow.conversation
* Renamed ConversationService to ConversationManager.
* Added SessionBindingConversationManager for storing conversations in the session map.
* Fixed bug where an IllegalMonitorException could occur on implicit conversation unlock on 'end'.

Package org.springframework.webflow.definition
* Introduced stable FlowDefinition abstractions, useful for reasoning on flow definition metadata 
  to support tooling and other runtime introspection.
* Relocated FlowLocator and related exception types from execution to registry subpackage.
* Renamed FlowLocator to FlowDefinitionLocator for consistency.
* Renamed FlowRegistry to FlowDefinitionRegistry for consistency.
* Renamed FlowRegistrar to FlowDefinitionRegistrar for consistency.
* Renamed ExternalizedFlowDefinition to FlowDefinitionResource for clarity.
* Reworked FlowDefinitionRegistrar interface, simplifying and decoupling it from the concept of a FlowServiceLocator.
* Removed FlowDefinitionRegistryFactoryBean as it was not used.

Package org.springframework.webflow.engine
* Introduced full support for XML schema, see builder/xml/spring-webflow.xsd
* Removed support for XML DTD, removing spring-webflow.dtd.
* Significantly enhanced in-line XML element and attribute documentation for benefit of .xsd users.
* Reworked support for "bean invoking actions".  Introduced new <bean action/> tag.
* Added support for <evaluate-action/> elements for evaluating arbitrary flow expressions as an action using OGNL.
* Added support for <set/> elements for setting attributes in a scope type as an action.
* Added support for 'required' mappings.  A required mapping will report an error if its source expression evaluates to a null value.
* Added 'renderActionList' property to ViewState, for executing behavior before a view selection is rendered. 
* Added support for <render-actions> within a <view-state/> element, for executing behavior
  when the view state makes a renderable view selection.
* Added the ability to invoke a list of actions before executing an exception handling transition.
* Added several AbstractFlowBuilder.addViewState convenience operations.
* BaseFlowBuilder now resets its internal flow reference on a call to dispose.
* FlowAssembler.assembleFlow now returns the constructed flow for clarity. This also clarifies the API in that it is no longer
  required to call getFlow on a FlowBuilder that has already been disposed by the FlowAssembler.
* Replaced STATE_TYPE_CONTEXT_PARAMETER parameter used by the TextToViewSelector by END_STATE_VIEW_FLAG_PARAMETER which just
  has a boolean value (a flag). This makes the contract a bit clearer. As a result, the VIEW_STATE_TYPE and END_STATE_TYPE
  constants in TextToViewSelector were also dropped.
* Moved ImmutableFlowAttributeMapper to builder and made package-private.  Not a general support class.
* Reworked FlowExecution transient state restoration behavior, now using
  a dedicated FlowExecutionImplStateRestorer.
* Added support for EndState transitions on exception, typically thrown as party of an entry action.
  Transition.execute now accepts the base State type now, no longer requiring a TransitionableState reference.
* Made execution state restorer strategy always apply, updated execution impl types to keep transient 
  and serialized references in sync for VM clustering purposes.
* Extracted DocumentLoader strategy interface from XmlFlowBuilder to isolate dependency on DOM/SAX
  DocumentBuilder factory logic.
* Fixed bug where flow execution restoration would fail when the active flow was an in-line flow
  of a subflow.
* TransitionExecutingStateExceptionHandler now exposes exceptions in flash scope now so they live through
  a view redirect and any subsequent refreshes.
       
Package org.springframework.webflow.execution
* Added support for "flow execution attributes" for setting system parameters that can affect flow execution.
* Added new "flash" scope type for storing attributes for the duration of a request plus a redirect
  and any subsequent view refreshes.  More specifically, flash is cleared when the next user event
  is signaled.
* Added support for listening to "exceptionThrown" events in a FlowExecution - see FlowExecutionListener.
* Decoupled the central RequestContext interface from the flow execution engine implementation.
* Renamed the "flow" property of FlowExecutionContext to "definition" for consistency.
* Renamed the "flow" property of FlowSession to "definition" for consistency.
* Renamed FlowRedirect to FlowDefinitionRedirect for clarity.
* Made all modifiable execution data maps "MutableAttributeMap" references: this includes 
  "request scope", "flow scope", and "conversation scope".  Umodifiable maps are simply plain
  "AttributeMap" references: this includes request context attributes, flow execution system
  attributes, and flow definition attributes.
* Introduced FlowExecutionFactory for encapsulating the construction of a FlowExecution from a FlowDefinition.
* Moved generic FlowExcutionFactory support code into "factory" subpackage.
* Fixed inconsistency in continuation id parsing within ClientContinuationFlowExecutionRepository.
* Removed FlowExecutionRepositoryFactory abstraction, simplifying overall use of the
  FlowExecutionRepository subsystem.
* Improved support for customization of FlowExecutionContinuation creation via the FlowExecutionContinuationFactory.
* Event id-based transition matching expressions are now case sensitive.
  
Package org.springframework.webflow.executor
* Decoupled executor subsystem from the flow execution engine implementation and assumptions about engine defaults.
* Removed 'alwaysRedirectOnPause' property in favor of dedicated 'alwaysRedirectOnPause' flow execution attribute.
* Changed RequestPathFlowExecutorArgumentExtractor to append keyDelimiter property as path element instead of
  request parameter for flow execution URLs.
* Renamed FlowExecutor.signalEvent to FlowExecutor.resume for clarity and revised order of parameters accordingly.

Package org.springframework.webflow.samples
* Updated sample applications to take advantage of new features including:
  - New spring-webflow-config Spring 2.0 XML Schema
  - "Render actions" (Shipping rate)
  - "Always redirect on pause" (Sellitem, Itemlist)
  - "Bean actions" (Phonebook, Sellitem)
  - "Flow variables" and "Evaluate actions" (Numberguess)
  - "Flash scope" and "Set" actions (Fileupload)
  Please review samples to see these features in action!
  
Package org.springframework.webflow.test
* Changed AbstractXmlFlowExecutionTests 'getFlowDefinition' hook to 'getFlowDefinitionResource' returning
  a FlowDefinitionResource.  See phonebook and sellitem src/test trees for an example.
* Added several convenience flow definition resource factory methods.
* Removed startFlow variants in AbstractFlowExecutionTests that accept a flow execution listener, call
  setFlowExecutionListener(...) instead.
* Added convenient registerMockServices hook to AbstractExternalizedFlowExecutionTests.
    
Changes in version 1.0 RC3 (23.6.2006)
--------------------------------------

Package org.springframework.webflow
* Renamed TransitionSet.transitionMatches to "hasMatchingTransition".
* A flow variable can now be annotated with arbitrary properties to influence behaviour.
* Factored out shared behavior of TransitionSet and StateExceptionHandlerSet into CollectionUtils.
* Renamed FlowExecutionControlContext to RequestControlContext to avoid confusion with the FlowExecutionContext
  and highlight the relationship with the RequestContext.
* Renamed FlowArtifactException to FlowArtifactLookupException and relocated to builder package.
* Renamed StateException to FlowExecutionException.  Revised semantics to ensure it is serializable.
* Renamed StateExceptionHandler to FlowExecutionExceptionHandler.
* Renamed StateExceptionHandlerSet to FlowExecutionHandlerSet.
* Removed FlowExecutionStatistics, merging its only useful method (isActive) into the FlowExecutionContext interface
* Removed unnecessary Event argument from Flow.onEvent and TransitionableState.onEvent.
* Removed CannotExecuteTransitionException, as its use reflected an illegal state.
* Removed NoSuchFlowStateException, as its use reflected an illegal argument.
* Made all exceptions honor serializable contract, removing dependencies on internal transient arguments such as Flow, State, and Transition 
  in favor of serializable artifact identifiers such as the flowId and stateId.
  
Package org.springframework.webflow.action
* Renamed FormAction.VALIDATOR_METHOD_PROPERTY to VALIDATOR_METHOD_ATTRIBUTE for consistency with other
  context attributes.
* Removed FormAction.validateUsingValidatorMethod property. If you don't want validation, don't call bindAndValidate()
  or validate() but just bind().  Updated samples accordingly.
* Removed AbstractAction.setEventFactorySupport(). In the unlikely case that you want to use an custom subclass of
  EventFactorySupport, just override AbstractAction.getEventFactorySupport().
* Removed FormActionMethods since it served little purpose and was very closely linked to the way FormAction
  implemented form handling.
* Renamed ResultSpecification to MethodResultSpecification for clarity. The property AbstractBeanInvokingAction.resultSpecification
  was also renamed accordingly.

Package org.springframework.webflow.builder
* Reapplied 1.0 rc2 fix for inline flow parsing, which was lost in SourceForge CVS issues occurring between 7/5/06 and 15/5/06

Package org.springframework.webflow.execution
* Renamed ConversationService.begin to "beginConversation".
* Removed implicit unlock call in LocalConversationService.removeFlowExecution
* Fixed a bug where ConversationEntry.lock field was serializable--it should be transient.
* Made ConversationServiceException extend NestedRuntimeException, since it is a distinct subsystem root exception.
* Added FlowExecutionRestorationFailureException.
* Added BadlyFormattedFlowExecutionKeyException.
* NoSuchConversationException now triggers a NoSuchFlowExecution exception.
* InvalidContinuationIdException, ContinuationNotFoundException, and ContinuationUnmarshalException 
  now trigger a FlowExecutionRestorationException.

Package org.springframework.webflow.executor
* Refined PortletFlowController to no longer set flowExecutionKey render parameter when an execution terminates.
* Removed the temporary workaround accounting for differences between SWF view names and JSF view ids.  Now 
  by default it is expected that the SWF view name match the JSF view id exactly.  A custom ViewIdMapper can be
  configured to configure a specific mapping strategy.
* Renamed ViewIdResolver to ViewIdMapper.
  
Package org.springframework.webflow.executor.support
* Removed the appendFlowInputAttributesToRequestPath flag in RequestPathFlowExecutorArgumentExtractor since it didn't offer
  a ready-to-use system--you would need to do custom coding to make it work completely.

Package org.springframework.webflow.registry
* Made NoSuchFlowDefinitionException a standalone exception of the flow registry subsystem.

Package org.springframework.webflow.samples
* Simplified 'flowLauncher' to take advantage of latest attribute mapping features.
* Simplified 'fileUpload' to take advantage of convenient MultipartFile parameter access support.
* Refined 'birthdate', 'sellitem', and 'sellitem-jsf' to use simpler "bind" methods instead of 'bindAndValidate' with a 'validateUsingValidatorMethod=true' flag.
* Refined sellitem-jsf to demonstrate default view name behavior within a JSF environment--that is, 
  where view-state 'view' names should match JSF view ids exactly.
  
Package org.springframework.webflow.support
* Fixed bug in FlowRedirectSelector where a NPE was thrown on null redirect expression.
* Removed RedirectType. Classes using it now have a simple boolean redirect flag.

Changes in version 1.0 RC2 (09.6.2006)
--------------------------------------

Overall
* Moved project source control (with history preserved) to sourceforge subversion (SVN) repository at:
      https://svn.sourceforge.net/svnroot/springframework/spring-projects/trunk
* Updated projects structure to maven2 standard (e.g. src/main/java, src/test/java).
* Spring-projects JAR repository structure now follows maven2 standard.

Package org.springframework.webflow
* Removed 'requiredType' not null check on AttributeMap accessor methods; if no requiredType is specified
  the type assert is simply not performed.
* Fixed bug in Flow.end where outputMapper source and target arguments were backwards.
* Removed unused constructors in AttributeMap.
* Added CollectionUtils.singleEntryMap for easily populating a UnmodifiableAttributeMap with a single attribute.
* AttributeMap, UnmodifiableAttributeMap, and ParameterMap implement equals and hashCode now.

Package org.springframework.webflow.action
* Moved MultiAction.METHOD_ATTRIBUTE constant to AnnotatedAction.METHOD_ATTRIBUTE.
* Made FormAction.formObjectScope default ScopeType.FLOW instead of ScopeType.REQUEST.
* Improved FormAction debug logging.
* Removed FormAction.bindOnSetupForm flag for simplicity--if you need to perform a bind operation before
  entering a view state simply invoke the 'bind' action method from your flow definition.
* Removed FormAction.validateOnBinding flag for simplicity--if you need to dynamically calculate if 
  validation should occur after binding on 'bindAndValidate' override validationEnabled(RequestContext).
* Removed 'exposeFormObject' action method from FormAction; use 'setupForm' instead.
 
Package org.springframework.webflow.builder
* Fixed bug related to inline-flow parsing where inline flow artifacts were not assembled properly.
* Added not null asserts to setters allowing overriding of required flow builder services.
* Improved DTD documentation describing input-mapper and output-mapper element usage.
* Relaxed 'isMultiAction' assert in XmlFlowBuilder to simply 'isAction', allowing provision of the 'method'
  annotated action attribute with any target Action implementation, not just MultiActions.
* Removed 'isMultiAction' tester on FlowServiceLocator as it is no longer needed by the builders.
* Renamed 'resultName' and 'resultScope' <action/> element attributes to 'result-name' and 
  'result-scope', respectively, for consistency with other attribute and element names.
* Removed support for special "conversationRedirect:" 'view' prefix.

Package org.springframework.webflow.context
* Enhanced PortletExternalContext to provide access to the "globalSessionMap" for accessing attributes in 
  the session's APPLICATION_SCOPE.
  
Package org.springframework.webflow.execution
* Fixed bug in FlowExecutionImpl toString, where a NPE could be thrown if toString was called during 
  a FlowExecution.start (after becoming active but before having the current state set).
* Added various not null asserts to setters allowing overriding of required flow execution repository services.
* Changed ContinuationFlowExecutionRepositoryCreator's default 'maxContinuations' property to 0, setting 
  no upper bound on the number of continuations that can exist per conversation by default.
* Renamed EmptyFlowExecutionListenerLoader to StaticFlowExecutionListenerLoader and improved to accept
  a static listener array for convenient listener loading without conditionals.
* Reworked FlowExecutionRepository interface to encapsulate the flow execution key generation strategy
  as well as the additional (and optional) concept of a conversation.
* Factored out conversation code into a portable conversation management subsystem, see repository.conversation.
  This generic abstraction is usable outside of SWF and may be promoted to a top-level project in the future.
* Renamed SimpleFlowExecutionRepository to DefaultFlowExecutionRepository.
* Removed 'CannotContinueConversationException' from root repository package.  Now the
  'NoSuchFlowExecutionException' is thrown consistently by the repository implementations 
  for both invalid conversation and continuation identifiers with the 'cause' property
  noting exactly what happened.
* Moved FlowExecutionRepositoryCreator to the support package and made implementations private
  inner classes of their containing factories, reflecting the role as a helper.
  
Package org.springframework.webflow.executor
* Simplified FlowExecutor interface, exposing simple types to clients and encapsulating dependencies 
  on internal types (as a good facade should).
* Removed all support for conversation "refresh" and redirect, decoupling the optional concept of 
  a conversation from that of a flow execution.  To achieve the 1.0 EA and 1.0 RC1 equivalent semantics 
  of a "conversation redirect" use a flow execution redirects with FlowExecutionRepository that uses
  the same FlowExecutionKey for the duration of the FlowExecution.
* Refined support for context-relative external redirects; now by default external URLs that begin with 
  a leading '/' are treated as context-relative.  The FlowExecutorArgumentExtractor.redirectContextRelative
  property allows for overriding this default.
* Fixed bug in RequestPathFlowExecutorArgumentExtractor.createFlowUrl where flow redirect input 
  was not being appended to the redirect URL correctly.
* Fixed bug where JSFPhaseListener was resetting the UIViewRoot even if the view did not change as 
  part of a resubmission.
* Added support for populating the FlowExecution inputMap from ExternalContext attributes during a launch operation.
  This allows for a flow to be passed input from clients that start it, and subsequently
  map the input into its local scope using a input-mapper.
* Portlet flow controller now refreshes a flow execution on render request if necessary to support browser refresh.
* Portlet flow controller can now perform external redirects using ActionResponse.sendRedirect(url).

Package org.springframework.webflow.registry
* Improved ExternalizedFlowRegistrar, extracting a factory method for creating an ExternalizedFlowDefinition
  from a valid Resource location, and a template method for calculating if the location is actually a flow resource.
* Fixed a bug in AbstractFlowRegistryFactoryBean where a NPE would occur when configuring custom DefaultFlowServiceLocator services.
* Generally improved pluggability of core FlowBuilder services with the AbstractFlowRegistryFactoryBean,
  including the FlowArtifactFactory, BeanInvokingActionFactory, ExpressionParser, and parent ConversionService implementations.

Package org.springframework.webflow.support
* Improved TransitionExecutingStateExceptionHandler to consider exception superclasses in handler match.
* Improved TransitionExecutingStateExceptionHandler to expose "rootCauseException" as request scoped attribute
* Added TransitionExecutingStateExceptionHandler debug level logging.
* Changed "handledStateException" attribute to simply "stateException".
* Fixed bug in DefaultExpressionParserFactory where Ognl would be loaded before explict classpath check.
* Removed ConversationRedirect.

Package org.springframework.webflow.test
* Added flowExecution not null asserts to signalEvent and refresh AbstractFlowExecutionTests operations.
* Removed AbstractFlowExecutionTests.conversationRedirect method.
  
Changes in version 1.0 RC1 (03.5.2006)
--------------------------------------

Package org.springframework.webflow
* Added explict Flow variable support to this package; see Flow.addVariable and Flow.start
* Fixed a bug in ParameterMap related to multi-valued parameter access
* ParameterMap.get now returns the first element for a multi-valued parameter instead of throwing an exception
* Refined the semantics of flow input attribute mapping.  All input attributes passed into a flow 
  by a caller must now be explictly mapped by the flow.  To achieve this each Flow can be configured
  with an inputMapper; see Flow.setInputMapper and Flow.start.
* Removed the 'action' property of the DecisionState.  Use an ActionState if the purpose of the 
  state is to execute an Action and respond to its result.  Consider using a custom ResultEventFactory 
  to customize how the result event is created for bean invoking actions.

Package org.springframework.webflow.action
* Removed FlowVariableCreatingAction, superceded by variable support added to core package.
* Extracted ResultObjectBasedEventFactory and SuccessEventFactory implementations of the ResultEventFactory interface.
* Introduced MementoBeanStatePersister for saving and restoring action bean state from a flow-scoped managed memento.

Package org.springframework.webflow.builder
* Added a 'bean' attribute to the 'var' element, for delegating to a Spring bean factory for flow variable creation.
* Made the 'bean' and 'class' attributes optional of the 'var' element; by default the 'name' attribute will be treated as the name 
  of a prototype bean in the BeanFactory to use to create the flow variable value.
* Added 'input-mapper' and 'output-mapper' elements to the 'flow' element, for mapping input and output attributes respectively.
* Changed the 'attribute-mapper' element of the 'subflow-state' element to be consistent with the new
  'input-mapper' and 'output-mapper' elements, for mapping input and output attributes to and from a subflow, respectively.
* Changed the 'output-attribute' element of the 'end-state' element to be consistent with the new
  'output-mapper' elements, for output attributes specific to a flow outcome.
* Added an 'on-exception' attribute to the 'transition' element, for executing a state transition as part of
  state or flow exception handler logic.  This supercedes use of the 'class' and 'to' attributes of the 
  'exception-handler' element.
* Streamlined the 'exception-handler' attribute to support attaching custom exception handler implementations only.
  Favor use of <transition on-exception="..." to="..."/> for attaching transition executing state exception handlers.
* Added special detection for "stateful actions"; beans marked singleton=false (non-singleton prototypes) are treated
  as stateful actions, with their instances managed directly in flow scope by default.  Beans implementing MementoOriginator
  are treated as stateful actions responsible for creating mementos that house their state managed in flow scope.
* Added special detection for action "result event factories"; bean methods that return a scalar 'value object' are 
  configured with a ResultObjectBasedEventFactory, otherwise a SuccessEventFactory is used.
* Added back the state type context attribute to TextToViewSelector, to aid in creating the correct ViewSelector 
  implementation based on the state type (ViewState or EndState) in use.
* Changed the 'on' attribute of the 'transition' element to be optional.
* Enhanced the 'to' attribute of the 'transition' element ${expression} capable; the resolved string expression(s) are 
  treated as the target state of the transition.
* Enhanced the 'view' attribute of the 'view-state' and 'end-state' elements to be fully ${expression} capable; previously 
  expressions could only be defined for redirect parameters.
* Renamed the FlowArtifactFactory interface as it existed in 1.0 EA to FlowServiceLocator.  Factored out two new
  "services" from the original interface: FlowArtifactFactory, for encapsulating the construction of core flow elements
  like State and Transition, and BeanInvokingActionFactory, for encapsulating the construction of an Action that invokes 
  a method on a bean when executed.
* Refined the FlowBuilder interface, adding builder methods for each type of major Flow construct.
* Reworked AbstractFlowBuilder and XmlFlowBuilder to bring them in-line with the FlowServiceLocator and FlowBuilder refinements.
* XmlFlowBuilder now respects deployment within a WebApplicationContext now, supporting access to the 
  ServletContext from within beans deployed in flow-local contexts.

Package org.springframework.webflow.context
* Changed the String-keyed map attribute iteration construct from 'Enumeration' to 'Iterator'.

Package org.springframework.webflow.execution
* Simplified the ConditionalFlowExecutionListenerLoader configuration interface.
* Refined the FlowExecutionListener interface, improving the sessionStarting and eventSignaled method signatures.
* Fixed a bug in ContinuationFlowExecutionRepository related to conversation scope restoration (which could cause a NPE).
* Fixed a bug in FlowExecutionImpl related to nested exception handling.
* Added an 'input' Attribute argument to the FlowExecution.start operation, for passing input into a starting
  flow execution in a consistent manner.
* Added support "refreshing" a paused flow execution, an idempotent operation used to support flow execution redirects.
* Introduced an EventId value object for describing an external event that has been signaled.
* Streamlined FlowExecutionRepository interface to remove experimental 'getCurrentViewSelection' and 
  'setCurrentViewSelection' methods.

Package org.springframework.webflow.executor
* Added 'appendFlowInputAttributesToRequestPath' property to RequestPathFlowExecutorArgumentExtractor to control
  if flow redirect input is appended to the URL request path or by use of named query parameters.
* Added "redirectOnPause" attribute to FlowExecutorImpl to allow global enforcement of flow execution redirects for paused flows.
* FlowExecutorArgumentExtractor now throws typed argument extraction exceptions to report illegal arguments provided by clients.
* Changed JSF "resume flow" behavior to no longer require an eventId; if no eventId is provided in a request the current view will be refreshed.
* Changed JSF "launch" flow behavior to no longer require a nav handler outcome; if the _flowId parameter 
  is provided in the request the FlowPhaseListener will launch the new flow execution on RESTORE_VIEW instead.
* Fixed a situation where a NullPointerException could occur within JSF's FlowPhaseListener.
* Added support for conversation redirects, external redirects, and flow redirects within a JSF environment.
* Misc polishing

Package org.springframework.webflow.registry
* Fixed a race condition within RefreshableFlowHolder pertaining to flow assembly.
* Added 'builderValidating' and 'entityResolver' properties of XmlFlowRegistryFactoryBean configuration interface.
* Reworked to bring registry subsystem in-line with changes in builder system.  All "flow services" may be 
  configured by Spring now by setting properties of a FlowRegistryFactoryBean.
* Added setters to AbstractFlowRegistryFactoryBean for configuring common flow builder services.
* Misc polishing

Package org.springframework.webflow.support
* Added two concrete FlowVariable types, SimpleFlowVariable and BeanFactoryFlowVariable.
* Added FlowExecutionRedirect, for redirecting to a "current" ApplicationView of a FlowExecution.
  This facilitates post+redirect+get semantics with unique resource URLs for refreshing each
  flow execution continuation (allowing back and refresh button use without page caching).
* Factored out a RedirectType enumeration, as there are now two redirect options: FlowExecutionRedirect and
  ConversationRedirect.
* Added ImmutableFlowAttributeMapper.

Package org.springframework.webflow.test
* Misc polishing

Package org.springframework.webflow.samples
* Made all samples Spring IDE projects.
* Made the number guess "games" fully stateful, 100% decoupling game logic from SWF APIs.

Changes in version 1.0 Early Access (02.3.2006)
-----------------------------------------------

Overall
* The proposal to the community for Spring Web Flow 1.0; the next release will be 1.0 RC1 
  after a fixed user evaluation period
* Introduced the reference manual in HTML and PDF form, see "docs" directory.
* Added unit tests, with total test coverage above 70%.
* Added extensive JavaDoc enhancements.

Package org.springframework.webflow
* Added support for custom start, signal event, end, and handleException behavior to the Flow class.
* Added state exception handling support at the State level.  States may now be configured with a set of
  one or more StateExceptionHandler objects for responding to exceptions that occur within the state of a flow execution.
* Added state exception handling support at the Flow level.  Flows may now be configured with a set of
  one or more StateExeceptionHandler objects, for responding to exceptions that occur within a state but are not handled by that state.
* Added support for "global transitions" at the Flow level.  Flows may now be configured with a set 
  of one or more Transition objects that are inherited by all states of the Flow.
* Added Transition TargetStateResolver strategy, allowing for dynamic target state calculation.
* Added the ExternalContext facade for providing a normalized interface about external clients who have called into
  the Spring Web Flow system.
* Added ParameterMap and AttributeMap map decorators, for strongly-typed Map access support.
* Renamed ViewDescriptor and ViewDescriptorCreator to ViewSelection and ViewSelector, respectively, for clarity and consistency with lexicon.
  Also made ViewSelection immutable, as a value object created by a selector.
* Introduced a ViewSelection hierarchy for each of the supported response types: ApplicationView (forward), 
  ConversationRedirect, FlowRedirect, ExternalRedirect, and NullView, respectively.
* Renamed AnnotatedObject properties and Event parameters to "attributes", respectively, for consistency.

Package org.springframework.webflow.action
* Added support for invoking strongly typed methods on arbitrary beans (POJOs) as a SWF Action.
  SWF is now capable of invoking an abitrary java.lang.Object method
  like 'search(SearchCriteria critera)', when using a "bean invoking action" as an
  alternative to implementing the 'execute(RequestContext context)'  Action interface or
  extending MultiAction.  SWF is also capable of exposing return values on those bean methods
  in request or flow scope, as well as responding to method exceptions.
  See the Phonebook sample app for an example.
* Added BeanFactoryBeanInvokingAction, an action that can invoke any instance method on any bean managed by the Spring bean factory.
* Added LocalBeanInvokingAction, an action that can invoke any instance method on any bean.
* Added "CompositeEvent" support for composite actions that may generate multiple action result events.
* Added "validateUsingValidatorMethod" property to FormAction, useful for supporting piecemeal validation as part of a wizard flow.
* Added ActionUtils utility class, useful when implementing actions.
* Added a convenience constructor to the Event class that takes a single parameter name/value. Mainly for use in unit tests.
* Added a convenience constructor to the FormAction class that takes the formObjectClass name.
* Added logic in FormAction to automatically calculate a camelcase formObjectName from the formObjectClass if the name is not set.
* Added StatefulActionProxy, an action that delegates to a stateful action managed in flow scope.
* Added convenience methods for retrieving action execution properties to the AbstractAction class.
* Improved "validatorMethod" handling in FormAction: if no formObjectClass is specified, the invoked validator method
  should have a signature matching "public void ${validatorMethod}(Object obj, Errors errors)". When you do specify a
  formObjectClass, everything works like before, e.g. the signature will be
  "public void ${validatorMethod}(${formObjectClass} obj, Errors errors)".
* Removed DelegatingAction in favor of StatefulActionProxy and bean invoking actions.

Package org.springframework.webflow.builder
* Added support for "global-transitions", transitions attached at the flow level and inherited by all states.
* Added support for "inline-flows", local flow definitions fully nested within another flow definition.
* Added support for locally flow scoped artifacts, importable as bean definitions using the "import" element.
* Added support for action "resultName" and "resultScope" properties, for exposing POJO method return values
  as attributes in a flow execution scope automatically.  See 'action' element in XML DTD.
* Added support for automatic creation of flow variables during flow startup, see 'var' element in XML DTD.
* Added "redirect" attribute to view-state for requesting conversational redirects that permit browser refresh.
* Added support for mapping subflow output attributes into parent flow collections.  See 'output' element in XML DTD.
* Added AbstractFlowBuilder addDecisionState(...) methods for completeness.
* Introduced the FlowArtifactFactory, for accessing externally managed flow artifacts during the flow building process.
* Changed AbstractFlowBuilder addSubflowState(...) methods to return the added SubflowState, consistent with other add methods.
* Reworked FlowBuilder, externalizing flow id assignment from the builder itself (assignment is now a responsibility of the director).
* Renamed the "config" package to "builder" for clarity.
* Removed flow artifact creation and autowiring support in favor of artifact lookup by id (which is more compelling now with flow-definition scoped artifact support).

Package org.springframework.webflow.context
* Introduced webflow.context package for housing common ExternalContext implementations.
* Introduced ExternalContext implementations for HTTP Servlet and JSR 168 Portlet environments.
  This adds support for accessing request, session, and application variables from within SWF 
  in a consistent manner (regardless of the environment in which SWF is called).

Package org.springframework.webflow.execution
* Added paused, resumed, and sessionEnding FlowExecutionListener callbacks.
* Added UidGenerator strategy, providing a plugin point for generating unique keys.
* Introduced FlowExecutionRepository subsystem, for tracking ongoing conversations between browsers and 
  the Spring Web Flow system.  This subsystem obsoletes both the FlowExecutionStorage and TransactionSynchronizer
  infrastructure, as it provides the capabilities of both in a single system.
* Added support for continuation-based repositories (aka 'continuation servers'),
  including a built-in capability to limit the max number of continuations allowed per conversation
  as well as automatically invalidate all continuations associated with a conversation that has ended
  ("conversation invalidation after completion").  Explicit support for conversation and continuation
  expiry, as well as metadata-driven continuation invalidation strategies is under consideration.
* Added support for tracking and accessing the "current view selection" of a conversation accessible under 
  a bookmarkable conversation URL.
* Added for conversation locking, allowing exclusive access to a conversation contended for my multiple 
  concurrent threads.
* Reworked the flow execution package, decoupling the Event abstraction from the notion of an ExternalContext.
* Reworked the FlowExecution interface, making central start and signalEvent operations more explicit.  It is also now 
  impossible for external actors to signal an event in another state other than the current state.
  Also removed the "rehydrate" method from the public interface, as it's an implementation detail to 
  internal actors that create and restore flow executions.
* Removed FlowExecutionStorage infrastructure, replaced by an enhanced FlowExecutionRepository subsystem.
* Removed TransactionSynchronizer abstraction, which has been obsoleted since such a capability is being built
  into the FlowExecutionRepository implementations directly.
* Removed support for invoking flows in arbitrary states other than the current state for security reasons.
  Support for a single, externally referenceable navigation state per flow is under consideration.
* Removed ExpiredFlowCleanupFilter, as a more powerful expiry capability built into the
  FlowExecutionRepository subsystem is under consideration.

Package org.springframework.webflow.executor
* Introduced the webflow.executor package, the highest-layer subsystem of SWF for driving the execution of flows.
* Renamed FlowExecutionManager to FlowExecutor; FlowExecutor is now a central facade interface
  defining the SWF system boundary for typical clients.  FlowExecutorImpl is the default implementation; FlowLocator is now a required dependency.
* Added ResponseInstruction, for allowing strongly-typed access to a flow execution context when preparing 
  a response to issue.
* Added the FlowExecutorArgumentExtractor helper for extracting arguments needed by FlowExecutor implementations
  such as the flowId, flowExecutionKey, and eventId.
* Renamed all instances of "flowExecutionId" with "flowExecutionKey", for consistency with the FlowExecutionKey class.
  Note: this change affects the views of existing SWF applications, requiring a rename of the 
  _flowExcutionId input parameter to _flowExcutionKey.
* Added RequestPathFlowExecutorParameterExtractor, for extracting parameters from the request URL. 
  This faciliates flows being launched in REST-style, for example http://localhost/springair/reservations/booking.
* Introduced JSF flow executor integration, see the "jsf" package.
* Reinstated the Spring Portlet MVC flow executor integration, see the "mvc" package and "phonebook-portlet" sample.
  Note: the portlet MVC support requires Spring 2.0.
  
Package org.springframework.webflow.registry
* Added the FlowRegistry subsystem in webflow.registry, for registering groups of refreshable Flow definitions.
  With this addition, XML flow definitions may now be refreshed from their registries at runtime by using a
  JMX client like Sun's jConsole that ships standard with JDK 1.5.
* Added a refreshable FlowRegistryImpl, for managing a reloadable registry of flow definitions, 
  typically populated by an XmlFlowRegistrar or custom FlowRegistrar.  See XmlFlowRegistryFactoryBean
  as a convenient mechanism for populating a FlowRegistry using a standard Spring bean definition.
* Added RefreshableFlowHolder, capable of automatically detecting changes on externalized flow 
  definitions and refreshing those definitions without requiring a container restart.
  
Package org.springframework.webflow.test
* Improved FlowExecution test support with AbstractFlowExecutionTests.
* Decoupled flow execution test infrastructure from a first class dependency on spring-mock and
  AbstractTransactionalDataSourceSpringContextTests; this allows for testing flow executions and 
  their associated artifacts in isolation without a dependency on the container, and also makes it
  easier to test a flow execution with a mock service-layer.  See Phonebook and Sellitem src/test 
  tree for an example.
* Added convenient AbstractXmlFlowExecutionTests, for easy testing of xml-based flow definitions.
* Small improvements in MockRequestContext to make it easier to use.

Package org.springframework.webflow.samples
* Changed numberguess sample application to use the new StatefulActionProxy.
* Added sellitem-jsf sample.
* Added phonebook-portlet sample.
* Added shippingrate sample, showing Spring Web Flow together with Ajax technology.

Changes in version PR5 (28.7.2005)
----------------------------------

* Renamed the static helpers in the ServletEvent class to match with their instance counterparts: e.g. getHttpServletRequest()
  was renamed to getRequest().
* Renamed the addSubFlowState(...) methods in AbstractFlowBuilder to addSubflowState(...) to be consistent with the class name.
* Reorganized packages to remove all cyclic dependencies. Most of the changes were in packages not typically used by end users
  of the system. As a result the impact on existing applications should be limited. Changes to look out for are:
  FlowConversionService is now in package org.springframework.webflow.convert, ExpiredFlowCleanupFilter is now in package
  org.springframework.webflow.execution.servlet and FlowExecutionListenerAdapter moved to the package
  org.springframework.webflow.execution.
* Fixed JDK 1.3 compatability issues.
* Fixed several bugs reported in JIRA.
* Several improvements in FlowAction (the SWF-Struts integration).
* Fixed Struts 1.1 compatability issues.
* Minor changes in the SWF DTD: the "property" element is now always the first sub element of its containing parent element.
* Added several unit tests, e.g. for FormAction.
* Drastically improved FormAction. This also involved some minor refactorings in the FormObjectAccessor.
* Improved AttributeMapperAction.
* Improved JavaDoc.
* Miscellaneous code cleanup, especially in spring-binding.

Changes in version PR4 (17.7.2005)
----------------------------------

* Top level package rename from org.springframework.web.flow to org.springframework.webflow.
* Changes to make this SWF compatible with Spring 1.2.2 and later.
* Moved to a new build system based on Ant and Ivy.
* Temporarily dropped Portlet support untill it is included in Spring 1.3.
* Added state entry and exit actions.
* Added some additional callbacks to the FlowExecutionListener: loaded(), saved() and removed().
* Greatly enhanced expression language support.
* Enhanced attribute mapper type conversion support.
* Added SessionTransactionSynchronizer.
* Added several convenience actions: CompositeAction, DelegatingAction and GuardedAction.
* Introduced basic JMX monitoring capabilities, to be improved in future releases.
* Better and simpler Struts integration. Check the "BirthDate" sample for an example.
* Refactored FormObjectAccessor so that the getters return null instead of throwing an exception when the form object or Errors
  instance cannot be found.
* Refactored FlowExecutionListenerList to no longer depend on the closure support in the sandbox. As a result, the
  iteratorTemplate() method was removed.
* Fixed NullPointerException in Flow.getTransitionableState(String).
* The FlowExecutionManager now allows you to register FlowExecutionListener s for executions of particular flows. This makes it
  easy to have a single manager managing all the flow executions in your app and still have listeners that apply to just a
  specific flow. To make this possible, the FlowExecutionListenerCriteria were introduced.
* The TransitionableState now has a reenter() method that will be called when the state is re-entered. This allows you to have
  different behaviour when the state is first entered, or re-entered.
* Fixed problem with 'form states': view states that use a setup action and a bindAndValidate when transitioning out of the state.
  The validation errors generated by the bindAndValidate were being overwritten by the setupForm action when the view state
  re-entered.
* Removed hardwired dependency on LinkedHashSet, for use with JDK 1.3.
* The ongoing flow execution is now exposed to the view as a FlowExecutionContext instance with name flowExecutionContext in the
  model. Existing apps should change the use of flowExecution in their views to flowExecutionContext from now on.
* Miscellaneous code cleanup and JavaDoc enhancements.

Changes in version PR3 (22.5.2005)
----------------------------------

* Renamed EventParameterMapperAction to AttributeMapperAction.
* Dynamic (pluggable) view selection and model population capability for view states.
* View state setup actions.
* View forward and redirect expressions.
* Subflow attribute mapping expressions.
* Support for primitive/complex property types (besides string) using new type conversion infrastructure.
* Enhanced flow execution listener lifecycle methods resumed, paused.
* Pluggable expression evaluation capability.
* Pluggability for all core definition objects: Flow, State, Transition, action, ...
* Pluggability of transaction synchronizer interface for custom application-transaction demarcation.
* A lot of general refining and polishing – package structure should be stable now.
* Flow attribute mapping is now possible from a XML definition using the new "input", and "output" mapping elements within the
  "attribute-mapper" element (see the spring-webflow.dtd).
* FlowController now provides a setFlow(Flow) method for convenience.
* Renamed XmlFlowBuilder.resource to "location" for consistency.
* Introduced convenient XmlFlowFactoryBean.
* Introduced flow properties.
* Introduced state properties.
* Introduced transition properties.
* The last transition to execute is now available for access via the RequestContext, allowing states and/or actions to reason on
  transition properties.
* Renamed AbstractAction.doExecuteAction to AbstractAction.doExecute for consistency and conciseness.
* Fixed bug where an incoming transaction token was searched for in the last event on the request context. The search now always
  uses the originating event of the request context.
* Added support for transition actions. These actions can also be used as transition execution criteria.
* Made Struts FlowExecutionStorage strategy pluggable.
* Refactored ActionStateAction into AnnotatedAction. This has several advantages: it completely decouples Action from ActionState
  and avoids error prone lookup of action properties by the action itself.
* Fixed bug in ExternalEvent.searchForParameter().
* Simplified sample app package structure, collapsing unnecessary packages.
* Added some extra mapping configuration methods to ParameterizableFlowAttributeMapper.
* Added some convenience constructors to EventParameterMapperAction.
* Fixed bug in Struts integration where Errors instance was not exposed via BindingActionForm adapter correctly.
* Birthdate sample now is fully Struts-based, using Struts html form taglibs in the JSPs.
* Added StrutsEvent, for easy access to a Struts ActionForm and ActionMapping from Web Flow action code.
* Added Flow Launcher sample application illustrating different ways of launching flows with input parameters.
* Fixed bug where flowExecution.start(event) was mapping all starting event parameters into flow scope.
* Added getFormObject() and getFormErrors() methods that search both request and flow scope to FormObjectAccessor class.
* Reworked FormObjectAccessor to alias form object and error instances under well-defined names.
* Added getOrCreateAttribute method to Scope class.
* Added assertAttributePresent method to Scope class.
* Added Number Guess sample application, with two number guess games demonstrating flow-scoped history.
* The FormAction now uses the WebDataBinder (introduced in Spring 1.2 RC2) to properly support HTML checkboxes.
* Fixed bug in FlowController and PortletFlowController where the flowLocator property of the default flow execution manager was
  not getting initialized.
* Improved build scripts for sample applications.
* Fixed bug in PortletFlowController. As a result it now requires a Portlet session, which it will create if none exists.
* Miscellaneous code cleanup and JavaDoc enhancements.

Changes in version PR2 (11.4.2005)
----------------------------------

* Added sample flow execution tests to PhoneBook sample app.
* ViewDescriptor is now an AttributeSource.
* Added Sell Item sample application, demonstrating a wizard using continuations to preserve use of back/refresh browser buttons.
  This sample application also demonstrates the use of OGNL based transitional criteria.
* Introduced TransitionCriteriaCreator, used by a FlowBuilder to create a transition criteria object based on an encoded string
  representation. Two TransitionCriteriaCreator implementations are provided out-of-the-box:
	* SimpleTransitionCriteriaCreator, the default, that does exact eventId matching or "*" wildcard matching (like in SWF
	  preview 1).
	* OgnlTransitionCriteriaCreator, that parses an OGNL expression expressing a condition to be evaluated in the request context
	  (e.g. ${lastEvent.id=='success' and flowScope.sale.shipping}).
* Improved Phonebook sample deployment configuration, for easily reusing configuration between test and production environments.
* Introduced MockFlowExecutionListener to support writing unit tests.
* Added Portlet support. This also led to some minor refactoring, e.g. the abstract class ExternalEvent was introduced.
* Improved package dependencies in sandbox classes shipped in webflow-support.jar - mainly package moves from 'util' to 'core'.
* Reimplemented MultiAction using new utility class: DispatchMethodInvoker.
* Added containsProperty() method to ActionStateAction.
* Birthdate sample now demonstrates Spring Web Flow Struts integration.
* Added some convenience methods to AbstractAction: getProperty(), containsProperty(), getActionStateAction() and getActionState().
* The FlowController no longer requires a pre-existing HTTP session by forcing the "requiresSession" property to true. HTTP
  session access is now done via the HttpSessionFlowExecutionStorage, which provides a "createSession" property (which defaults to
  true, instructing the creation of a new session if no existing session is found). If you're not using an HTTP session backed
  flow execution storage, there is of course no need for an HTTP session at all.
* Introduced convenience XML attribute for action-state: method="foo"
* Renamed the ActionStateAction executeMethodName property to just method for simplicity.
* Renamed FormAction.bindOnNewForm to bindOnSetupForm for consistency. Also renamed FormAction.suppressValidation to
  FormAction.validationEnabled to use positive logic.
* Added FormAction.validate(RequestContext, Object, Errors) hook for easy customization of validation logic.
* Added an ActionStateAction validatorMethod property, to specify a specific validation method to be invoked on the configured
  Validator used by the FormAction. This allows piecemeal validation to support wizard pages, for example. The validation method
  must be of the form public void <method>(Object formObject, Errors errors).
* Reworked flow execution management (via FlowExecutionManager) and introduced pluggable flow execution storage strategies (via
  FlowExecutionStorage). This introduces many exciting features and possibilities:
	* Integration with Portlets and other frameworks is very trivial now, no need to implement a custom manager.
* You now have the option to store flow execution state in any backing data store, e.g. the HttpSession (the default), a database,
  serialized files, ...
	* You may now store execution state client side if you want - no HTTP session required.
	* You can select to use a continuations based storage strategy, basically turning Spring Web Flow into a continuation driven
	  system. On top of that, you can choose between client side or server side continuation storage. The continuation storage
	  strategies also support GZIP compression.
* Renamed TransitionableState.getRequiredTransition() to TransitionableState.transitionFor().
* Removed TransitionableState.executeTransition() in favor of TransitionableState.transitionFor(context).execute(context).
* Removed hardwired dependency on LinkedHashSet, for use with JDK 1.3.
* Added dispose() method to FlowBuilder to release any resources held by the builder.
* Removed unused methods from AbstractFlowBuilder: attributeMapperId() and eventId().
* Default "cacheSeconds" for FlowController is now 0 (no caching).
* Miscellaneous code cleanup and JavaDoc enhancements.

Changes in version PR1 (30.3.2005)
----------------------------------

* First public preview release.