8398c9048d
code was modified slightly, so the code differs from the original downloadable 1.9.5 version
440 lines
12 KiB
PHP
440 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Controller
|
|
* @subpackage Dispatcher
|
|
* @copyright Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id: Abstract.php 16541 2009-07-07 06:59:03Z bkarwin $
|
|
*/
|
|
|
|
/** Zend_Controller_Dispatcher_Interface */
|
|
require_once 'Zend/Controller/Dispatcher/Interface.php';
|
|
|
|
/**
|
|
* @category Zend
|
|
* @package Zend_Controller
|
|
* @subpackage Dispatcher
|
|
* @copyright Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
abstract class Zend_Controller_Dispatcher_Abstract implements Zend_Controller_Dispatcher_Interface
|
|
{
|
|
/**
|
|
* Default action
|
|
* @var string
|
|
*/
|
|
protected $_defaultAction = 'index';
|
|
|
|
/**
|
|
* Default controller
|
|
* @var string
|
|
*/
|
|
protected $_defaultController = 'index';
|
|
|
|
/**
|
|
* Default module
|
|
* @var string
|
|
*/
|
|
protected $_defaultModule = 'default';
|
|
|
|
/**
|
|
* Front Controller instance
|
|
* @var Zend_Controller_Front
|
|
*/
|
|
protected $_frontController;
|
|
|
|
/**
|
|
* Array of invocation parameters to use when instantiating action
|
|
* controllers
|
|
* @var array
|
|
*/
|
|
protected $_invokeParams = array();
|
|
|
|
/**
|
|
* Path delimiter character
|
|
* @var string
|
|
*/
|
|
protected $_pathDelimiter = '_';
|
|
|
|
/**
|
|
* Response object to pass to action controllers, if any
|
|
* @var Zend_Controller_Response_Abstract|null
|
|
*/
|
|
protected $_response = null;
|
|
|
|
/**
|
|
* Word delimiter characters
|
|
* @var array
|
|
*/
|
|
protected $_wordDelimiter = array('-', '.');
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @return void
|
|
*/
|
|
public function __construct(array $params = array())
|
|
{
|
|
$this->setParams($params);
|
|
}
|
|
|
|
/**
|
|
* Formats a string into a controller name. This is used to take a raw
|
|
* controller name, such as one stored inside a Zend_Controller_Request_Abstract
|
|
* 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)
|
|
{
|
|
return ucfirst($this->_formatName($unformatted)) . 'Controller';
|
|
}
|
|
|
|
/**
|
|
* Formats a string into an action name. This is used to take a raw
|
|
* action name, such as one that would be stored inside a Zend_Controller_Request_Abstract
|
|
* 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, true);
|
|
return strtolower(substr($formatted, 0, 1)) . substr($formatted, 1) . 'Action';
|
|
}
|
|
|
|
/**
|
|
* Verify delimiter
|
|
*
|
|
* Verify a delimiter to use in controllers or actions. May be a single
|
|
* string or an array of strings.
|
|
*
|
|
* @param string|array $spec
|
|
* @return array
|
|
* @throws Zend_Controller_Dispatcher_Exception with invalid delimiters
|
|
*/
|
|
public function _verifyDelimiter($spec)
|
|
{
|
|
if (is_string($spec)) {
|
|
return (array) $spec;
|
|
} elseif (is_array($spec)) {
|
|
$allStrings = true;
|
|
foreach ($spec as $delim) {
|
|
if (!is_string($delim)) {
|
|
$allStrings = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!$allStrings) {
|
|
require_once 'Zend/Controller/Dispatcher/Exception.php';
|
|
throw new Zend_Controller_Dispatcher_Exception('Word delimiter array must contain only strings');
|
|
}
|
|
|
|
return $spec;
|
|
}
|
|
|
|
require_once 'Zend/Controller/Dispatcher/Exception.php';
|
|
throw new Zend_Controller_Dispatcher_Exception('Invalid word delimiter');
|
|
}
|
|
|
|
/**
|
|
* Retrieve the word delimiter character(s) used in
|
|
* controller or action names
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getWordDelimiter()
|
|
{
|
|
return $this->_wordDelimiter;
|
|
}
|
|
|
|
/**
|
|
* Set word delimiter
|
|
*
|
|
* Set the word delimiter to use in controllers and actions. May be a
|
|
* single string or an array of strings.
|
|
*
|
|
* @param string|array $spec
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setWordDelimiter($spec)
|
|
{
|
|
$spec = $this->_verifyDelimiter($spec);
|
|
$this->_wordDelimiter = $spec;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the path delimiter character(s) used in
|
|
* controller names
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getPathDelimiter()
|
|
{
|
|
return $this->_pathDelimiter;
|
|
}
|
|
|
|
/**
|
|
* Set path delimiter
|
|
*
|
|
* Set the path delimiter to use in controllers. May be a single string or
|
|
* an array of strings.
|
|
*
|
|
* @param string $spec
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setPathDelimiter($spec)
|
|
{
|
|
if (!is_string($spec)) {
|
|
require_once 'Zend/Controller/Dispatcher/Exception.php';
|
|
throw new Zend_Controller_Dispatcher_Exception('Invalid path delimiter');
|
|
}
|
|
$this->_pathDelimiter = $spec;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Formats a string from a URI into a PHP-friendly name.
|
|
*
|
|
* By default, replaces words separated by the word separator character(s)
|
|
* with camelCaps. If $isAction is false, it also preserves replaces words
|
|
* separated by the path separation character with an underscore, making
|
|
* the following word Title cased. All non-alphanumeric characters are
|
|
* removed.
|
|
*
|
|
* @param string $unformatted
|
|
* @param boolean $isAction Defaults to false
|
|
* @return string
|
|
*/
|
|
protected function _formatName($unformatted, $isAction = false)
|
|
{
|
|
// preserve directories
|
|
if (!$isAction) {
|
|
$segments = explode($this->getPathDelimiter(), $unformatted);
|
|
} else {
|
|
$segments = (array) $unformatted;
|
|
}
|
|
|
|
foreach ($segments as $key => $segment) {
|
|
$segment = str_replace($this->getWordDelimiter(), ' ', strtolower($segment));
|
|
$segment = preg_replace('/[^a-z0-9 ]/', '', $segment);
|
|
$segments[$key] = str_replace(' ', '', ucwords($segment));
|
|
}
|
|
|
|
return implode('_', $segments);
|
|
}
|
|
|
|
/**
|
|
* Retrieve front controller instance
|
|
*
|
|
* @return Zend_Controller_Front
|
|
*/
|
|
public function getFrontController()
|
|
{
|
|
if (null === $this->_frontController) {
|
|
require_once 'Zend/Controller/Front.php';
|
|
$this->_frontController = Zend_Controller_Front::getInstance();
|
|
}
|
|
|
|
return $this->_frontController;
|
|
}
|
|
|
|
/**
|
|
* Set front controller instance
|
|
*
|
|
* @param Zend_Controller_Front $controller
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setFrontController(Zend_Controller_Front $controller)
|
|
{
|
|
$this->_frontController = $controller;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Add or modify a parameter to use when instantiating an action controller
|
|
*
|
|
* @param string $name
|
|
* @param mixed $value
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setParam($name, $value)
|
|
{
|
|
$name = (string) $name;
|
|
$this->_invokeParams[$name] = $value;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set parameters to pass to action controller constructors
|
|
*
|
|
* @param array $params
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setParams(array $params)
|
|
{
|
|
$this->_invokeParams = array_merge($this->_invokeParams, $params);
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve a single parameter from the controller parameter stack
|
|
*
|
|
* @param string $name
|
|
* @return mixed
|
|
*/
|
|
public function getParam($name)
|
|
{
|
|
if(isset($this->_invokeParams[$name])) {
|
|
return $this->_invokeParams[$name];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Retrieve action controller instantiation parameters
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getParams()
|
|
{
|
|
return $this->_invokeParams;
|
|
}
|
|
|
|
/**
|
|
* Clear the controller parameter stack
|
|
*
|
|
* By default, clears all parameters. If a parameter name is given, clears
|
|
* only that parameter; if an array of parameter names is provided, clears
|
|
* each.
|
|
*
|
|
* @param null|string|array single key or array of keys for params to clear
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function clearParams($name = null)
|
|
{
|
|
if (null === $name) {
|
|
$this->_invokeParams = array();
|
|
} elseif (is_string($name) && isset($this->_invokeParams[$name])) {
|
|
unset($this->_invokeParams[$name]);
|
|
} elseif (is_array($name)) {
|
|
foreach ($name as $key) {
|
|
if (is_string($key) && isset($this->_invokeParams[$key])) {
|
|
unset($this->_invokeParams[$key]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set response object to pass to action controllers
|
|
*
|
|
* @param Zend_Controller_Response_Abstract|null $response
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setResponse(Zend_Controller_Response_Abstract $response = null)
|
|
{
|
|
$this->_response = $response;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Return the registered response object
|
|
*
|
|
* @return Zend_Controller_Response_Abstract|null
|
|
*/
|
|
public function getResponse()
|
|
{
|
|
return $this->_response;
|
|
}
|
|
|
|
/**
|
|
* Set the default controller (minus any formatting)
|
|
*
|
|
* @param string $controller
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setDefaultControllerName($controller)
|
|
{
|
|
$this->_defaultController = (string) $controller;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the default controller name (minus formatting)
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getDefaultControllerName()
|
|
{
|
|
return $this->_defaultController;
|
|
}
|
|
|
|
/**
|
|
* Set the default action (minus any formatting)
|
|
*
|
|
* @param string $action
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setDefaultAction($action)
|
|
{
|
|
$this->_defaultAction = (string) $action;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the default action name (minus formatting)
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getDefaultAction()
|
|
{
|
|
return $this->_defaultAction;
|
|
}
|
|
|
|
/**
|
|
* Set the default module
|
|
*
|
|
* @param string $module
|
|
* @return Zend_Controller_Dispatcher_Abstract
|
|
*/
|
|
public function setDefaultModule($module)
|
|
{
|
|
$this->_defaultModule = (string) $module;
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the default module
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getDefaultModule()
|
|
{
|
|
return $this->_defaultModule;
|
|
}
|
|
}
|