# Migrating from Previous Versions

The API of the MVC components has changed over time. If you started using Zend Framework in an early version, follow the guidelines below to migrate your scripts to use the new architecture.

## Migrating from 1.7.x to 1.8.0 or newer

### Standard Route Changes

As translated segments were introduced into the new standard route, the '@' character is now a special character in the beginning of a route segment. To be able to use it in a static segment, you must escape it by prefixing it with second '@' character. The same rule now applies for the ':' character.

## Migrating from 1.6.x to 1.7.0 or newer

### Dispatcher Interface Changes

Users brought to our attention the fact that `Zend_Controller_Action_Helper_ViewRenderer` were using a method of the dispatcher abstract class that was not in the dispatcher interface. We have now added the following method to ensure that custom dispatchers will continue to work with the shipped implementations:

- `formatModuleName()`: should be used to take a raw controller name, such as one that would be packaged inside a request object, and reformat it to a proper class name that a class extending `Zend_Controller_Action` would use

## Migrating from 1.5.x to 1.6.0 or Newer

### Dispatcher Interface Changes

Users brought to our attention the fact that `Zend_Controller_Front` and `Zend_Controller_Router_Route_Module` were each using methods of the dispatcher that were not in the dispatcher interface. We have now added the following three methods to ensure that custom dispatchers will continue to work with the shipped implementations:

- `getDefaultModule()`: should return the name of the default module.

- `getDefaultControllerName()`: should return the name of the default controller.

- `getDefaultAction()`: should return the name of the default action.

## Migrating from 1.0.x to 1.5.0 or Newer

Though most basic functionality remains the same, and all documented functionality remains the same, there is one particular undocumented "feature" that has changed.

When writing URLs, the documented way to write camelCased action names is to use a word separator; these are '.' or '-' by default, but may be configured in the dispatcher. The dispatcher internally lowercases the action name, and uses these word separators to re-assemble the action method using camelCasing. However, because PHP functions are not case sensitive, you could still write URLs using camelCasing, and the dispatcher would resolve these to the same location. For example, 'camel-cased' would become 'camelCasedAction' by the dispatcher, whereas 'camelCased' would become 'camelcasedAction'; however, due to the case insensitivity of PHP, both will execute the same method.

This causes issues with the ViewRenderer when resolving view scripts. The canonical, documented way is that all word separators are converted to dashes, and the words lowercased. This creates a semantic tie between the actions and view scripts, and the normalization ensures that the scripts can be found. However, if the action 'camelCased' is called and actually resolves, the word separator is no longer present, and the ViewRenderer attempts to resolve to a different location -- `camelcased.phtml` instead of `camel-cased.phtml`.

Some developers relied on this "feature", which was never intended. Several changes in the 1.5.0 tree, however, made it so that the ViewRenderer no longer resolves these paths; the semantic tie is now enforced. First among these, the dispatcher now enforces case sensitivity in action names. What this means is that referring to your actions on the url using camelCasing will no longer resolve to the same method as using word separators (i.e., 'camel-casing'). This leads to the ViewRenderer now only honoring the word-separated actions when resolving view scripts.

If you find that you were relying on this "feature", you have several options:

- Best option: rename your view scripts. Pros: forward compatibility. Cons: if you have many view scripts that relied on the former, unintended behavior, you will have a lot of renaming to do.

- Second best option: The ViewRenderer now delegates view script resolution to `Zend_Filter_Inflector`; you can modify the rules of the inflector to no longer separate the words of an action with a dash:

      $viewRenderer =
          Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
      $inflector = $viewRenderer->getInflector();
      $inflector->setFilterRule(':action', array(
          new Zend_Filter_PregReplace(
              '#[^a-z0-9' . preg_quote(DIRECTORY_SEPARATOR, '#') . ']+#i',
              ''
          ),
          'StringToLower'
      ));

  The above code will modify the inflector to no longer separate the words with dash; you may also want to remove the 'StringToLower' filter if you do want the actual view script names camelCased as well.

  If renaming your view scripts would be too tedious or time consuming, this is your best option until you can find the time to do so.

- Least desirable option: You can force the dispatcher to dispatch camelCased action names with a new front controller flag, useCaseSensitiveActions:

      $front->setParam('useCaseSensitiveActions', true);

  This will allow you to use camelCasing on the url and still have it resolve to the same action as when you use word separators. However, this will mean that the original issues will cascade on through; you will likely need to use the second option above in addition to this for things to work at all reliably.

  Note, also, that usage of this flag will raise a notice that this usage is deprecated.

## Migrating from 0.9.3 to 1.0.0RC1 or Newer

The principal changes introduced in 1.0.0RC1 are the introduction of and default enabling of the ErrorHandler plugin and the ViewRenderer action helper. Please read the documentation to each thoroughly to see how they work and what effect they may have on your applications.

The `ErrorHandler` plugin runs during `postDispatch()` checking for exceptions, and forwarding to a specified error handler controller. You should include such a controller in your application. You may disable it by setting the front controller parameter noErrorHandler:

    $front->setParam('noErrorHandler', true);

The `ViewRenderer` action helper automates view injection into action controllers as well as autorendering of view scripts based on the current action. The primary issue you may encounter is if you have actions that do not render view scripts and neither forward or redirect, as the `ViewRenderer` will attempt to render a view script based on the action name.

There are several strategies you can take to update your code. In the short term, you can globally disable the `ViewRenderer` in your front controller bootstrap prior to dispatching:

    // Assuming $front is an instance of Zend_Controller_Front
    $front->setParam('noViewRenderer', true);

However, this is not a good long term strategy, as it means most likely you'll be writing more code.

When you're ready to start using the `ViewRenderer` functionality, there are several things to look for in your controller code. First, look at your action methods (the methods ending in 'Action'), and determine what each is doing. If none of the following is happening, you'll need to make changes:

- Calls to `$this->render();`

- Calls to `$this->_forward();`

- Calls to `$this->_redirect();`

- Calls to the `Redirector` action helper

The easiest change is to disable auto-rendering for that method:

    $this->_helper->viewRenderer->setNoRender();

If you find that none of your action methods are rendering, forwarding, or redirecting, you will likely want to put the above line in your `preDispatch()` or `init()` methods:

    public function preDispatch()
    {
        // disable view script autorendering
        $this->_helper->viewRenderer->setNoRender()
        // .. do other things...
    }

If you are calling `render()`, and you're using the Conventional Modular directory structure, you'll want to change your code to make use of autorendering:

- If you're rendering multiple view scripts in a single action, you don't need to change a thing.

- If you're simply calling `render()` with no arguments, you can remove such lines.

- If you're calling `render()` with arguments, and not doing any processing afterwards or rendering multiple view scripts, you can change these calls to read `$this->_helper->viewRenderer();`.

If you're not using the conventional modular directory structure, there are a variety of methods for setting the view base path and script path specifications so that you can make use of the `ViewRenderer`. Please read the ViewRenderer documentation for information on these methods.

If you're using a view object from the registry, or customizing your view object, or using a different view implementation, you'll want to inject the `ViewRenderer` with this object. This can be done easily at any time.

- Prior to dispatching a front controller instance:

      // Assuming $view has already been defined
      $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view);
      Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);

- Any time during the bootstrap process:

      $viewRenderer =
          Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
      $viewRenderer->setView($view);

There are many ways to modify the `ViewRenderer`, including setting a different view script to render, specifying replacements for all replaceable elements of a view script path (including the suffix), choosing a response named segment to utilize, and more. If you aren't using the conventional modular directory structure, you can even associate different path specifications with the `ViewRenderer`.

We encourage you to adapt your code to use the `ErrorHandler` and `ViewRenderer` as they are now core functionality.

## Migrating from 0.9.2 to 0.9.3 or Newer

0.9.3 introduces action helpers. As part of this change, the following methods have been removed as they are now encapsulated in the redirector action helper:

- `setRedirectCode()`; use `Zend_Controller_Action_Helper_Redirector::setCode()`.

- `setRedirectPrependBase()`; use `Zend_Controller_Action_Helper_Redirector::setPrependBase()`.

- `setRedirectExit()`; use `Zend_Controller_Action_Helper_Redirector::setExit()`.

Read the action helpers documentation for more information on how to retrieve and manipulate helper objects, and the redirector helper documentation for more information on setting redirect options (as well as alternate methods for redirecting).

## Migrating from 0.6.0 to 0.8.0 or Newer

Per previous changes, the most basic usage of the MVC components remains the same:

    Zend_Controller_Front::run('/path/to/controllers');

However, the directory structure underwent an overhaul, several components were removed, and several others either renamed or added. Changes include:

- `Zend_Controller_Router` was removed in favor of the rewrite router.

- `Zend_Controller_RewriteRouter` was renamed to `Zend_Controller_Router_Rewrite`, and promoted to the standard router shipped with the framework; `Zend_Controller_Front` will use it by default if no other router is supplied.

- A new route class for use with the rewrite router was introduced, `Zend_Controller_Router_Route_Module`; it covers the default route used by the MVC, and has support for controller modules.

- `Zend_Controller_Router_StaticRoute` was renamed to `Zend_Controller_Router_Route_Static`.

- `Zend_Controller_Dispatcher` was renamed `Zend_Controller_Dispatcher_Standard`.

- `Zend_Controller_Action::_forward()`'s arguments have changed. The signature is now:

      final protected function _forward($action,
                                        $controller = null,
                                        $module = null,
                                        array $params = null);

  `$action` is always required; if no controller is specified, an action in the current controller is assumed. `$module` is always ignored unless `$controller` is specified. Finally, any `$params` provided will be appended to the request object. If you do not require the controller or module, but still need to pass parameters, simply specify `NULL` for those values.

## Migrating from 0.2.0 or before to 0.6.0

The most basic usage of the MVC components has not changed; you can still do each of the following:

    Zend_Controller_Front::run('/path/to/controllers');

    /* -- create a router -- */
    $router = new Zend_Controller_RewriteRouter();
    $router->addRoute('user',
                      'user/:username',
                      array('controller' => 'user', 'action' => 'info')
    );

    /* -- set it in a controller -- */
    $ctrl = Zend_Controller_Front::getInstance();
    $ctrl->setRouter($router);

    /* -- set controller directory and dispatch -- */
    $ctrl->setControllerDirectory('/path/to/controllers');
    $ctrl->dispatch();

We encourage use of the Response object to aggregate content and headers. This will allow for more flexible output format switching (for instance, JSON or XML instead of XHTML) in your applications. By default, `dispatch()` will render the response, sending both headers and rendering any content. You may also have the front controller return the response using `returnResponse()`, and then render the response using your own logic. A future version of the front controller may enforce use of the response object via output buffering.

There are many additional features that extend the existing API, and these are noted in the documentation.

The main changes you will need to be aware of will be found when subclassing the various components. Key amongst these are:

- `Zend_Controller_Front::dispatch()` by default traps exceptions in the response object, and does not render them, in order to prevent sensitive system information from being rendered. You can override this in several ways:

  - Set `throwExceptions()` in the front controller:

        $front->throwExceptions(true);

  - Set `renderExceptions()` in the response object:

        $response->renderExceptions(true);
        $front->setResponse($response);
        $front->dispatch();

        // or:
        $front->returnResponse(true);
        $response = $front->dispatch();
        $response->renderExceptions(true);
        echo $response;

- `Zend_Controller_Dispatcher_Interface::dispatch()` now accepts and returns a The Request Object instead of a dispatcher token.

- `Zend_Controller_Router_Interface::route()` now accepts and returns a The Request Object instead of a dispatcher token.

- `Zend_Controller_Action` changes include:

  - The constructor now accepts exactly three arguments, `Zend_Controller_Request_Abstract` `$request`, `Zend_Controller_Response_Abstract` `$response`, and Array `$params` (optional). `Zend_Controller_Action::__construct()` uses these to set the request, response, and invokeArgs properties of the object, and if overriding the constructor, you should do so as well. Better yet, use the `init()` method to do any instance configuration, as this method is called as the final action of the constructor.

  - `run()` is no longer defined as final, but is also no longer used by the front controller; its sole purpose is for using the class as a page controller. It now takes two optional arguments, a `Zend_Controller_Request_Abstract` `$request` and a `Zend_Controller_Response_Abstract` `$response`.

  - `indexAction()` no longer needs to be defined, but is encouraged as the default action. This allows using the RewriteRouter and action controllers to specify different default action methods.

  - `__call()` should be overridden to handle any undefined actions automatically.

  - `_redirect()` now takes an optional second argument, the HTTP code to return with the redirect, and an optional third argument, `$prependBase`, that can indicate that the base URL registered with the request object should be prepended to the url specified.

  - The `$_action` property is no longer set. This property was a `Zend_Controller_Dispatcher_Token`, which no longer exists in the current incarnation. The sole purpose of the token was to provide information about the requested controller, action, and URL parameters. This information is now available in the request object, and can be accessed as follows:

        // Retrieve the requested controller name
        // Access used to be via: $this->_action->getControllerName().
        // The example below uses getRequest(), though you may also directly
        // access the $_request property; using getRequest() is recommended as
        // a parent class may override access to the request object.
        $controller = $this->getRequest()->getControllerName();

        // Retrieve the requested action name
        // Access used to be via: $this->_action->getActionName().
        $action = $this->getRequest()->getActionName();

        // Retrieve the request parameters
        // This hasn't changed; the _getParams() and _getParam() methods simply
        // proxy to the request object now.
        $params = $this->_getParams();
        // request 'foo' parameter, using 'default' as default value if not found
        $foo = $this->_getParam('foo', 'default');

  - `noRouteAction()` has been removed. The appropriate way to handle non-existent action methods should you wish to route them to a default action is using `__call()`:

        public function __call($method, $args)
        {
            // If an unmatched 'Action' method was requested, pass on to the
            // default action method:
            if ('Action' == substr($method, -6)) {
                return $this->defaultAction();
            }

            throw new Zend_Controller_Exception('Invalid method called');
        }

- `Zend_Controller_RewriteRouter::setRewriteBase()` has been removed. Use `Zend_Controller_Front::setBaseUrl()` instead (or `Zend_Controller_Request_Http::setBaseUrl()`, if using that request class).

- `Zend_Controller_Plugin_Interface` was replaced by `Zend_Controller_Plugin_Abstract`. All methods now accept and return a The Request Object instead of a dispatcher token.