<?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-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 * @version    $Id: Abstract.php 20096 2010-01-06 02:05:09Z bkarwin $

 */

/** Zend_Controller_Dispatcher_Interface */

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

/**

 * @category   Zend

 * @package    Zend_Controller

 * @subpackage Dispatcher

 * @copyright  Copyright (c) 2005-2010 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;

    }

}