Please go to the new MVC Changes page

This proposal is no longer being worked on. Instead direct your attention to the official proposal from Zend:

http://framework.zend.com/wiki/x/kxM

Zend Framework: Changes to Zend MVC Component Proposal

Proposed Component Name	Changes to Zend MVC
Developer Notes	http://framework.zend.com/wiki/display/ZFDEV/Changes to Zend MVC
Proposers	Michael Sheakoski Christopher Thompson
Revision	1.1 - 1 August 2006: Updated from community comments. (wiki revision: 40)

introduction of a Request object which acts a common layer of communication between the bootstrap, Router, FrontController, and ActionController. It is designed in a way to pull data from any source and provide it via a common interface to the MVC components. Currently in this proposal the Zend_Http_Request object provides input from PATH_INFO, GET, and POST data.
removal of the DispatchToken. Its functionality is now contained in the Request object.
removal of Router-dependant code from the FrontController::dispatch() method. The router is now an optional component that is handled in the bootstrap or in a convenience method such as ::run()
removal of URL-related functions from the Router. This is now handled by the Request object.
added support for ActionControllers in subdirectories

2. References

3. Component Requirements, Constraints, and Acceptance Criteria

Zend_Http_Request

4. Dependencies on Other Framework Components

5. Theory of Operation

6. Milestones / Tasks

7. Class Index

Zend_Request_Interface is a common generic interface that the Router, FrontController, Dispatcher, and ActionController use to to talk to each other. It is designed to interface with any type of input source.
Zend_Http_Request builds on top of the Zend_Request_Interface. It contains functions to pull any data from the browser and provide it to the MVC components.
Some features include:
- determines important variables on any platform with or without mod_rewrite such as REQUEST_URI and PATH_INFO
- getParam() automatically falls back to GET/POST variables if a Router is not used or user-defined vars are not set
- aliases allow you to call your controllers and actions something other than 'controller' and 'action'. This allows for a central location to configure these settings.
- aliases can be used for more flexible URLs. For example:
  $request->setAlias('controller' => 'c'); $request->setAlias('action' => 'a'); would work with the URL: http://mysite.com/index.php?c=news&a=view
Zend_Cli_Request (not created yet) is meant to pull any input from the command-line (args) or keyboard (stdin) and provide it to the MVC components through the Zend_Controller_Request_Interface. This is an example of how the proposed MVC changes allow for much more flexibility by not limiting them to HTTP-specific functionality.
Zend_Router_Rewrite (evolution of the RewriteRouter, for mapping PATH_INFO to a controller/action)
Zend_Router_RewriteLite (evolution of the original ZF Router, handles simple routes such as http://mysite.com/ and http://mysite.com/ctrl/act/p1/one/p2/two/pN/N) sites in need of a fast, lean and mean solution would use this as opposed to the more full-featured PathRouter
Zend_Router_CliParam (not created yet) would allow you to map command-line parameters or keyboard input to an action/controller. For example, automatic processing of parameters in the GNU "--paramname=value" format, "-f filename", "/C zend", etc...

8. Use Cases

This is perhaps how an intermediate / advanced user would use it:

// Create a Request object
$request = new Zend_Http_Request();
// Map the controller/action to c/a for shorter URLs if not using a Router
// $request->setAlias('controller', 'c');
// $request->setAlias('action',     'a');

// Create a Router and route the Request
$router = new Zend_Router_Rewrite();
$router->route($request);

// Create a View object and pass any needed vars to it
$view = new Zend_View();
$view->request = $request;
// The URL Helper needs a Request and Router to generate URLs
// Pass the Router and Request as parameters to the Zend_View_Helper_Url constructor
$view->passToHelperConstructor('url', $request, $router);

// Create a "fake" Database object just as an example to pass to an Action
$db = 'new Zend_Db()';

// Create a FrontController and pass specified vars to the Action(s)
$controller = new Zend_Controller_Front();
// Pass the DB and View objects to ALL Actions
$controller->passToActionConstructor('*', array('db' => $db, 'view' => $view));
$controller->dispatch($request);

And this would be the beginner approach:

$controller = new Zend_Controller_Front();
$controller->run();

// Psuedo code:
public function run()
{
    Create a Zend_Http_Request object

    If PATH_INFO is not an empty string {
        Create a new Zend_Router_RewriteLite object
        Route the Request object
    }

    // If no controller/action was found in PATH_INFO, GET, or
    // POST then the default values in the Dispatcher are used

    $this->dispatch(Request);
}

9. Class Skeletons

Download the working prototype here: [Zend_Db_Adapter_Odbtp_Mssql^mvc_working_prototype.zip]

<?php

interface Zend_Controller_Request_Interface
{
    public function setParam($key, $value);
    public function getParam($key);

    public function getParams();
    public function setParams(array $params);
}

This code is shared with the Zend_Http_Request proposal http://framework.zend.com/wiki/x/Ng8

<?php

/** Zend_Http_Request_Interface */
require_once 'Zend/Http/Request/Interface.php';

/** Zend_Controller_Request_Interface */
require_once 'Zend/Controller/Request/Interface.php';

class Zend_Http_Request implements Zend_Http_Request_Interface, Zend_Controller_Request_Interface
{
    protected $_requestUri;
    protected $_baseUrl;
    protected $_basePath;
    protected $_pathInfo;
    protected $_params  = array();
    protected $_aliases = array();

    /**
     * Access values contained in the superglobals as public members
     * Order of precedence: 1. GET, 2. POST, 3. COOKIE, 4. SERVER, 5. ENV
     *
     * http://msdn.microsoft.com/en-us/library/system.web.httprequest.item.aspx
     *
     * @param string $key
     * @return mixed
     */
    public function __get($key)
    {
        if (isset($_GET[$key])) {
            return $_GET[$key];
        } elseif (isset($_POST[$key])) {
            return $_POST[$key];
        } elseif (isset($_COOKIE[$key])) {
            return $_COOKIE[$key];
        } elseif (isset($_SERVER[$key])) {
            switch ($key) {
                case 'REQUEST_URI' : return $this->getRequestUri();
                case 'PATH_INFO'   : return $this->getPathInfo();
                default            : return $_SERVER[$key];
            }
        } elseif (isset($_ENV[$key])) {
            return $_ENV[$key];
        }

        return null;
    }

    public function getQuery($key)
    {
        return (isset($_GET[$key])) ? $_GET[$key] : null;
    }

    public function getPost($key)
    {
        return (isset($_POST[$key])) ? $_POST[$key] : null;
    }

    public function getCookie($key)
    {
        return (isset($_COOKIE[$key])) ? $_COOKIE[$key] : null;
    }

    public function getServer($key)
    {
        return (isset($_SERVER[$key])) ? $_SERVER[$key] : null;
    }

    public function getEnv($key)
    {
        return (isset($_ENV[$key])) ? $_ENV[$key] : null;
    }

    public function setRequestUri($requestUri = null)
    {
        if ($requestUri === null) {
            if (isset($_SERVER['REQUEST_URI'])) {
                $requestUri = $_SERVER['REQUEST_URI'];
            } elseif (isset($_SERVER['HTTP_X_REWRITE_URL'])) {
                $requestUri = $_SERVER['HTTP_X_REWRITE_URL'];
            } else {
                return false;
            }
        }

        $this->_requestUri = $requestUri;
    }

    /**
     * Returns the REQUEST_URI taking into account
     * platform differences between Apache and IIS
     *
     * @return string
     */
    public function getRequestUri()
    {
        if ($this->_requestUri === null) {
            $this->setRequestUri();
        }

        return $this->_requestUri;
    }

    public function setBaseUrl($baseUrl = null)
    {
        if ($baseUrl === null) {
            $filename = basename($_SERVER['SCRIPT_FILENAME']);

            if (basename($_SERVER['SCRIPT_NAME']) === $filename) {
                $baseUrl = $_SERVER['SCRIPT_NAME'];
            } elseif (basename($_SERVER['PHP_SELF']) === $filename) {
                $baseUrl = $_SERVER['PHP_SELF'];
            } elseif (isset($_SERVER['ORIG_SCRIPT_NAME']) && basename($_SERVER['ORIG_SCRIPT_NAME']) === $filename) {
                $baseUrl = $_SERVER['ORIG_SCRIPT_NAME']; // 1and1 shared hosting compatibility
            } else {
                return false;
            }

            if (($requestUri = $this->getRequestUri()) === null) {
                return false;
            }

            // If using mod_rewrite or ISAPI_Rewrite strip the script filename out of baseUrl
            // $pos !== 0 makes sure it is not matching a value from PATH_INFO or QueryString
            if (($pos = strpos($requestUri, $baseUrl)) === false || $pos !== 0) {
                $baseUrl = dirname($baseUrl);
            }
        }

        $this->_baseUrl = rtrim($baseUrl, '/');
    }

    /**
     * Everything in REQUEST_URI before PATH_INFO
     * <form action="<?=$baseUrl?>/news/submit" method="POST"/>
     *
     * @return string
     */
    public function getBaseUrl()
    {
        if ($this->_baseUrl === null) {
            $this->setBaseUrl();
        }

        return $this->_baseUrl;
    }

    public function setBasePath($basePath = null)
    {
        if ($basePath === null) {
            $filename = basename($_SERVER['SCRIPT_FILENAME']);

            if (($baseUrl = $this->getBaseUrl()) === null) {
                return false;
            }

            if (basename($baseUrl) === $filename) {
                $basePath = dirname($baseUrl);
            } else {
                $basePath = $baseUrl;
            }
        }

        $this->_basePath = rtrim($basePath, '/');
    }

    /**
     * Everything in REQUEST_URI before PATH_INFO not including the filename
     * <img src="<?=$basePath?>/images/zend.png"/>
     *
     * @return string
     */
    public function getBasePath()
    {
        if ($this->_basePath === null) {
            $this->setBasePath();
        }

        return $this->_basePath;
    }

    public function setPathInfo($pathInfo = null)
    {
        if ($pathInfo === null) {
            if (($baseUrl = $this->getBaseUrl()) === null) {
                return false;
            }

            if (($requestUri = $this->getRequestUri()) === null) {
                return false;
            }

            // Remove the query string from REQUEST_URI
            if ($pos = strpos($requestUri, '?')) {
                $requestUri = substr($requestUri, 0, $pos);
            }

            if (($pathInfo = substr($requestUri, strlen($baseUrl))) === false) {
                // If substr() returns false then PATH_INFO is set to an empty string
                $pathInfo = '';
            }
        }

        $this->_pathInfo = $pathInfo;
    }

    /**
     * Returns everything between the BaseUrl and QueryString.
     * This value is calculated instead of reading PATH_INFO
     * directly from $_SERVER due to cross-platform differences.
     *
     * @return string
     */
    public function getPathInfo()
    {
        if ($this->_pathInfo === null) {
            $this->setPathInfo();
        }

        return $this->_pathInfo;
    }

    public function setParam($key, $value)
    {
        $keyName = (($alias = $this->getAlias($key)) !== null) ? $alias : $key;
        $this->_params[$keyName] = $value;
    }

    public function getParam($key)
    {
        $keyName = (($alias = $this->getAlias($key)) !== null) ? $alias : $key;

        if (isset($this->_params[$keyName])) {
            return $this->_params[$keyName];
        } elseif ((isset($_GET[$keyName]))) {
            return $_GET[$keyName];
        } elseif ((isset($_POST[$keyName]))) {
            return $_POST[$keyName];
        }

        return null;
    }

    public function getParams()
    {
        return $this->_params + $_GET + $_POST;
    }

    public function setParams(array $params)
    {
        foreach ($params as $key => $value) {
            $this->setParam($key, $value);
        }
    }

    public function setAlias($name, $target)
    {
        $this->_aliases[$name] = $target;
    }

    public function getAlias($name)
    {
        if (isset($this->_aliases[$name])) {
            return $this->_aliases[$name];
        }

        return null;
    }

    public function getAliases()
    {
        return $this->_aliases;
    }
}

<?php

/** Zend_Router_Rewrite_Route */
require_once 'Zend/Router/Rewrite/Route.php';

class Zend_Router_Rewrite
{
    protected $_routes = array();
    protected $_currentRoute;

    public function addRoute($name, Zend_Router_Rewrite_Route_Interface $route)
    {
        $this->_routes[$name] = $route;
    }

    public function getRoute($name)
    {
        if (!isset($this->_routes[$name])) {
            throw new Exception("Route $name is not defined");
        }

        return $this->_routes[$name];
    }

    public function addRoutes($routes)
    {
        foreach ($routes as $name => $route) {
            $this->addRoute($name, $route);
        }
    }

    public function getCurrentRoute()
    {
        if (!isset($this->_currentRoute))
            throw new Exception("Current route is not defined");
        return $this->_currentRoute;
    }

    public function addDefaultRoutes()
    {
        // Add default route (for root url - '/')
        $this->addRoute('default', new Zend_Router_Rewrite_Route('', array('controller' => 'index', 'action' => 'index')));

        // Route for Router v1 compatibility
        $this->addRoute('compat', new Zend_Router_Rewrite_Route(':controller/:action/*', array('action' => 'index')));
    }

    public function route(Zend_Http_Request $request)
    {
        if (($path = $request->getPathInfo()) === null) {
            throw new Exception('PathInfo not set in ' . get_class($request));
        }

        $path = trim($path, '/');

        // If no routes are set use the default routes
        if (count($this->_routes) === 0) {
            $this->addDefaultRoutes();
        }

        // Find the matching route
        foreach (array_reverse($this->_routes) as $route) {
            if ($match = $route->match($path)) {
                $params = $match;
                $this->_currentRoute = $route;
                break;
            }
        }

        if ($match !== false) {
            $request->setParams($params);
        }
    }
}

<?php

class Zend_Controller_Front
{
    /**
     * Instance of Zend_Controller_Dispatcher_Interface
     * @var Zend_Controller_Dispatcher_Interface
     */
    private $_dispatcher;


    /**
     * Instance of Zend_Controller_Plugin_Broker
     * @var Zend_Controller_Plugin_Broker
     */
    private $_plugins;


	/**
	 * Constructor
	 * Instantiate the plugin broker.
	 */
	public function __construct()
	{
	    $this->_plugins = new Zend_Controller_Plugin_Broker();
	}


    /**
	 * Set the dispatcher object.
	 *
	 * @param Zend_Controller_Dispatcher_Interface $dispatcher
	 */
	public function setDispatcher(Zend_Controller_Dispatcher_Interface $dispatcher)
	{
	    $this->_dispatcher = $dispatcher;
	}


	/**
	 * Return the dispatcher object.
	 *
	 * @return Zend_Controller_Dispatcher_Inteface
	 */
	public function getDispatcher()
	{
	    // Instantiate the default dispatcher if one was not set.
        if (!$this->_dispatcher instanceof Zend_Controller_Dispatcher_Interface) {
            require_once 'Zend/Controller/Dispatcher.php';
            $this->_dispatcher = new Zend_Controller_Dispatcher();
        }

        return $this->_dispatcher;
	}


	/**
	 * Register a plugin.
	 *
	 * @param Zend_Controller_Plugin_Interface $plugin
	 * @return Zend_Controller_Front
	 */
	public function registerPlugin(Zend_Controller_Plugin_Interface $plugin)
	{
	    $this->_plugins->registerPlugin($plugin);
	    return $this;
	}


	/**
	 * Unregister a plugin.
	 *
	 * @return Zend_Controller_Front
	 */
    public function unregisterPlugin(Zend_Controller_Plugin_Interface $plugin)
    {
        $this->_plugins->unregisterPlugin($plugin);
        return $this;
    }


	/**
	 * Passthrough to Zend_Controller_Dispatcher::setControllerDirectory()
	 *
	 * @param string $directory
	 */
	public function setControllerDirectory($directory)
	{
        $dispatcher = $this->getDispatcher();

        if (!method_exists($dispatcher, __FUNCTION__)) {
            throw new Exception(get_class($dispatcher) . ' does not support the ' . __FUNCTION__ . '() method.');
        }

        $dispatcher->{__FUNCTION__}($directory);
	}


    /**
     * Passthrough to Zend_Controller_Dispatcher::passToActionConstructor()
     * Interface for passing args to an ActionController constructor
     * from an external source.
     *
     * @param string $actionController
     * @param mixed $arg
     */
    public function passToActionConstructor($actionController, $arg)
    {
        $dispatcher = $this->getDispatcher();

        if (!method_exists($dispatcher, __FUNCTION__)) {
            throw new Exception(get_class($dispatcher) . ' does not support the ' . __FUNCTION__ . '() method.');
        }

        $args = func_get_args();
        call_user_func_array(array($dispatcher, __FUNCTION__), $args);
    }


    /**
     * Dispatch a Request to a controller/action.
     *
     * @param Zend_Controller_Request_Interface $request
     */
    public function dispatch(Zend_Controller_Request_Interface $request)
    {
        $dispatcher = $this->getDispatcher();

        // Use the default Controller if not specified in the Request
        if ($request->getParam('controller') === null) {
            $request->setParam('controller', $dispatcher->getDefaultController());
        }

        // Use the default Action if not specified in the Request
        if ($request->getParam('action') === null) {
            $request->setParam('action', $dispatcher->getDefaultAction());
        }

        // notify plugins that the dispatch loop is starting up
        $request = $this->_plugins->dispatchLoopStartup($request);

        /**
         * Attempt to dispatch to the controller/action.  On return, either NULL will be given
         * to indicate completion or Zend_Controller_Request_Interface will be given to indicate a forward
         * to another controller/action must be performed.
         */
        while ($request instanceof Zend_Controller_Request_Interface) {
            // notify plugins that a dispatch is about to occur
            $request = $this->_plugins->preDispatch($request);

            // perform the dispatch
            $request = $dispatcher->dispatch($request);

            // notify plugins that the dispatch has finished
            $request = $this->_plugins->postDispatch($request);
        }

        // notify plugins that the dispatch loop is shutting down
        $this->_plugins->dispatchLoopShutdown();
    }
}

<?php

/** Zend_Controller_Dispatcher_Interface */
require_once 'Zend/Controller/Dispatcher/Interface.php';

class Zend_Controller_Dispatcher implements Zend_Controller_Dispatcher_Interface
{
    protected $_defaultController = 'index';
    protected $_defaultAction     = 'noRoute';
    protected $_controllerSuffix  = 'Controller';
    protected $_actionSuffix      = 'Action';
    protected $_controllerDir     = 'controllers';
    protected $_controllerSubdir;
    protected $_actionConstructor;


    public function setDefaultController($controllerName)
    {
    	$this->_defaultController = $controllerName;
    }


    public function getDefaultController()
    {
    	return $this->_defaultController;
    }


    public function setDefaultAction($actionName)
    {
    	$this->_defaultAction = $actionName;
    }


    public function getDefaultAction()
    {
    	return $this->_defaultAction;
    }


    public function setControllerSuffix($suffix)
    {
    	$this->_controllerSuffix = $suffix;
    }


    public function setActionSuffix($actionName)
    {
    	$this->_actionSuffix = $suffix;
    }


    /**
     * Sets the directory where the Zend_Controller_Action class files are stored.
     *
     * @param string $dir
     */
    public function setControllerDirectory($dir)
    {
        if (!is_dir($dir) or !is_readable($dir)) {
            throw new Exception("Directory \"$dir\" not found or not readable.");
        }

        $this->_controllerDir = rtrim($dir, '/\\');
    }


    /**
     * Interface for passing args to an ActionController constructor
     * from an external source.
     *
     * @param string $actionController
     * @param mixed $arg
     */
    public function passToActionConstructor($actionController, $arg)
    {
        if (!is_string($actionController)) {
            throw new Exception('First argument "$actionController" must be a string.');
        }

        $this->_actionConstructor[$actionController] = array_slice(func_get_args(), 1);
    }


    /**
     * Formats a string into a controller name.  This is used to take a raw controller name, such as
     * one that would be packaged inside a Zend_Controller_Request_Interface object, and reformat it to a proper
     * class name that a class extending Zend_Controller_Action would use.
     *
     * @param string $unformatted
     * @return string
     */
    public function formatControllerName($unformatted)
    {
        if (($pos = strrpos($unformatted, '_')) !== false) {
            $subdir = substr($unformatted, 0, $pos);
            $subdir = str_replace('_', ' ', strtolower($subdir));
            $this->_controllerSubdir = str_replace(' ', DIRECTORY_SEPARATOR, ucwords($subdir));
            return ucfirst($this->_formatName(substr($unformatted, $pos)));
        } elseif (strpos($unformatted, DIRECTORY_SEPARATOR) !== false) {
            $this->_controllerSubdir = dirname($unformatted);
            return ucfirst($this->_formatName(basename($unformatted)));
        } else {
            return ucfirst($this->_formatName($unformatted));
        }
    }


    /**
     * Formats a string into an action name.  This is used to take a raw action name, such as one
     * that would be packaged inside a Zend_Controller_Request_Interface object, and reformat into a proper
     * method name that would be found inside a class extending Zend_Controller_Action.
     *
     * @param string $unformatted
     * @return string
     */
    public function formatActionName($unformatted)
    {
        $formatted = $this->_formatName($unformatted);
        return strtolower(substr($formatted, 0, 1)) . substr($formatted, 1);
    }


    /**
     * Formats a string from a URI into a PHP-friendly name.  Replaces words
     * separated by "-", "_", or "." with camelCaps and removes any characters
     * that are not alphanumeric.
     *
     * @param string $unformatted
     * @return string
     */
    protected function _formatName($unformatted)
    {
        $unformatted = str_replace(array('-', '_', '.'), ' ', strtolower($unformatted));
        $unformatted = preg_replace('[Zend_Db_Adapter_Odbtp_Mssql^a-z0-9 ]', '', $unformatted);
        return str_replace(' ', '', ucwords($unformatted));
    }


    /**
     * Dispatch a request to a controller/action.
     *
     * @param Zend_Controller_Request_Interface $request
     */
    public function dispatch(Zend_Controller_Request_Interface $request)
    {
        // Format the ActionController name and class
        $controllerName  = $this->formatControllerName($request->getParam('controller'));
        $controllerClass = $controllerName . $this->_controllerSuffix;

        Zend::loadClass($controllerClass, $this->_controllerDir . DIRECTORY_SEPARATOR . $this->_controllerSubdir);

        // Create an ActionController instance and pass any user-defined args to the Constructor
        if (isset($this->_actionConstructor[$controllerName])) {
            $args = $this->_actionConstructor[$controllerName];
            array_unshift($args, $request);
            $controller = call_user_func_array(array(new ReflectionClass($controllerClass), 'newInstance'), $args);
        } elseif (isset($this->_actionConstructor['*'])) {
            $args = $this->_actionConstructor['*'];
            array_unshift($args, $request);
            $controller = call_user_func_array(array(new ReflectionClass($controllerClass), 'newInstance'), $args);
        } else {
            $controller = new $controllerClass($request);
        }

        // Make sure we are working with an instance of Zend_Controller_Action
        if (!$controller instanceof Zend_Controller_Action) {
            throw new Exception("Controller \"$controllerClass\" is not an instance of Zend_Controller_Action.");
        }

        // Format the ActionController method
        $actionMethod = $this->formatActionName($request->getParam('action')) . $this->_actionSuffix;

        // Prerun
        if (method_exists($controller, 'preRun')) {
            $controller->preRun();
            $nextAction = $controller->_getNextAction();
            if ($nextAction instanceof Zend_Controller_Request_Interface) {
                return $nextAction;
            }
        }

        // perform the dispatch
        if (!method_exists($controller, $actionMethod)) {
            $controller->__call($actionMethod, array());
        } else {
            $controller->{$actionMethod}();
        }

        // Postrun
        if (method_exists($controller, 'postRun')) {
            $controller->postRun();
            $nextAction = $controller->_getNextAction();
            if ($nextAction instanceof Zend_Controller_Request_Interface) {
                return $nextAction;
            }
        }

        /**
         * If _forward() was called within the action, _getNextAction() will return a modified
         * Zend_Controller_Request_Interface object that is to be dispatched.  Otherwise it will return NULL
         * and no further requests will be processed.
         */
        return $controller->_getNextAction();
    }
}

<?php

abstract class Zend_Controller_Action
{
    /** @var Zend_Controller_Request_Interface */
    protected $_request;

    /**
     * If _forward() is called, $_nextAction will contain a modified Zend_Controller_Request_Interface object
     * which is sent back to the Dispatcher and queued to be dispatched.
     *
     * @var Zend_Controller_Request_Interface
     */
    protected $_nextAction;


    /**
     * Constructor
     *
     * @param Zend_Controller_Request_Interface $request
     */
    public function __construct(Zend_Controller_Request_Interface $request)
    {
        $this->_request = $request;
    }


    /**
     * Proxy for undefined methods.  Default behavior is to throw an exception on undefined methods,
     * however this function can be overridden to implement magic (dynamic) actions.
     *
     * @param string $methodName
     * @param array $args
     */
    public function __call($methodName, $args)
    {
        if (empty($methodName)) {
            $msg = 'No action specified and no default action has been defined in __call() for ' . get_class($this);
        } else {
            $msg = get_class($this) . '::' . $methodName . '() does not exist and was not trapped in __call()';
        }

        throw new Exception($msg);
    }


    /**
     * Any controller extending Zend_Controller_Action must provide a noRouteAction()
     * method.  The noRouteAction() method is the default action for the controller
     * when no action is specified.
     *
     * This only handles a controller which has been called with no action specified.
     *
     * For handling nonexistant actions in controllers, the controller class must
     * provide a __call() method or an exception will be thrown.
     */
    abstract public function noRouteAction();


    public function _getNextAction()
    {
        return $this->_nextAction;
    }


    /**
     * Gets a parameter that was passed to this controller.  If the
     * parameter does not exist, NULL will be returned.
     *
     * @param string $key
     * @return mixed
     */
    protected function _getParam($key)
    {
        return $this->_request->getParam($key);
    }


    /**
     * Return all parameters that were passed to the controller
     * as an associative array.
     *
     * @return array
     */
    protected function _getParams()
    {
        return $this->_request->getParams();
    }


    /**
     * Forward to another controller/action.
     *
     * It is important to supply the unformatted names, i.e. "article"
     * rather than "ArticleController".  The FrontController will do the
     * appropriate formatting when the Zend_Controller_Request item is received.
     *
     * @param string $controllerName
     * @param string $actionName
     * @param array $params
     */
    protected function _forward($controllerName, $actionName, array $params = array())
    {
        $this->_nextAction = $this->_request;

        $this->_nextAction->setParam('controller', $controllerName);
        $this->_nextAction->setParam('action',     $actionName);
        $this->_nextAction->setParams($params);
    }


    /**
     * Redirect to another URL
     *
     * @param string $url
     */
    protected function _redirect($url)
    {
        if (headers_sent()) {
            throw new Exception('Cannot redirect because headers have already been sent.');
        }

        // prevent header injections
        $url = str_replace(array("\n", "\r"), '', $url);

        // redirect
        header("Location: $url");
        exit;
    }
}

Page Operations

Browse Space

Changes to Zend MVC - Michael Sheakoski and Christopher Thompson

Labels