/**
* recurses through the Test subdir and includes classes in each test group subdir,
* then builds an array of classnames for the tests that will be run
*
*/
public function loadTests($test_path = NULL)
{
$this->resetStats();
if ($test_path === NULL) {
// this seems hackey. is it? dunno.
$test_path = dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . 'Security' . DIRECTORY_SEPARATOR . 'Test';
}
$test_root = dir($test_path);
while (false !== ($entry = $test_root->read())) {
if (is_dir($test_root->path . DIRECTORY_SEPARATOR . $entry) && !preg_match('|^\\.(.*)$|', $entry)) {
$test_dirs[] = $entry;
}
}
// include_once all files in each test dir
foreach ($test_dirs as $test_dir) {
$this_dir = dir($test_root->path . DIRECTORY_SEPARATOR . $test_dir);
while (false !== ($entry = $this_dir->read())) {
if (!is_dir($this_dir->path . DIRECTORY_SEPARATOR . $entry) && preg_match('/[A-Za-z]+\\.php/i', $entry)) {
$className = "Zend_Environment_Security_Test_" . $test_dir . "_" . basename($entry, '.php');
Zend::loadClass($className);
$classNames[] = $className;
}
}
}
$this->_tests_to_run = $classNames;
}
public function addAdvancedRoute($name, $map, $params = array(), $reqs = array())
{
if (!class_exists('Custom_Controller_Router_AdvancedRoute')) {
Zend::loadClass('Custom_Controller_Router_AdvancedRoute');
}
$this->_routes[$name] = new Custom_Controller_Router_AdvancedRoute($map, $params, $reqs);
}
public static function autoload($class)
{
try {
Zend::loadClass($class);
} catch (Zend_Exception $e) {
return false;
}
return true;
}
/**
* Tests that the security filter catches directory injections.
*/
public function testLoadClassIllegalFilename()
{
try {
Zend::loadClass('/path/to/danger');
} catch (Zend_Exception $e) {
$this->assertRegExp('/security(.*)filename/i', $e->getMessage());
return;
}
$this->assertFail('Zend_Exception was expected but never thrown.');
}
public function getDriver()
{
// @todo: when the Mysqli adapter moves out of the incubator,
// the following trick to allow it to be loaded should be removed.
$incubator = dirname(dirname(dirname(dirname(dirname(__FILE__))))) . DIRECTORY_SEPARATOR . 'incubator' . DIRECTORY_SEPARATOR . 'library';
Zend::loadClass('Zend_Db_Adapter_Mysqli', $incubator);
// @todo: also load any auxiliary classes if necessary, e.g.:
// Zend_Db_Adapter_Mysqli_Exception
// Zend_Db_Statement_Mysqli
// Zend_Db_Statement_Mysqli_Exception
return 'Mysqli';
}
public static function autoload($class)
{
try {
if (self::$withLoader) {
Zend_Loader::loadClass($class);
} else {
Zend::loadClass($class);
}
} catch (Zend_Exception $e) {
return false;
}
return true;
}
public static function autoload($class)
{
try {
if (class_exists('Zend_Version')) {
Zend_Loader::loadClass($class);
} else {
Zend::loadClass($class);
}
} catch (Zend_Exception $e) {
return false;
}
return true;
}
public function setUp()
{
if (!class_exists('Zend_Log') || !class_exists('Zend_Log_Adapter_Null')) {
Zend::loadClass('Zend_Log');
Zend::loadClass('Zend_Log_Adapter_Null');
}
if (!Zend_Log::hasLogger('LOG')) {
Zend_Log::registerLogger(new Zend_Log_Adapter_Null(), 'LOG');
}
$this->_instance->setDirectives(array('logging' => true));
$this->_instance->save('bar : data to cache', 'bar', array('tag3', 'tag4'));
$this->_instance->save('bar2 : data to cache', 'bar2', array('tag3', 'tag1'));
$this->_instance->save('bar3 : data to cache', 'bar3', array('tag2', 'tag3'));
}
/**
* The Primitus View plugin is a procedural function which implements the logic of
* the template-level {render} function. It is responsible for either calling the
* requested controller's render() method to get the template, or simply processing
* the template in the views/ directory if the controller didn't exist.
*
* You can set template-level variables in the module being rendered by simply setting
* them in the smarty {render} function. i.e.
*
* {render module="blog" action="view" entry=$entry}
*
* will expose the {$entry} template variable to the blog::view template in /blog/view.tpl
*
* @category Primitus
* @package Primitus
* @subpackage View
* @copyright Copyright (c) 2006 John Coggeshall
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
function Primitus_View_Plugin_Render($params, &$smarty)
{
if (!isset($params['module'])) {
throw new Primitus_View_Exception("No module name was provided to render");
}
$module = $params['module'];
if (strtolower(substr($module, strlen($module) - 10)) != "controller") {
$module .= "Controller";
}
$action = isset($params['action']) ? $params['action'] : "indexAction";
$dispatcher = Primitus::registry('Dispatcher');
$controllerFile = $dispatcher->formatControllerFile($module);
if (file_exists($controllerFile)) {
// Load the Class
Zend::loadClass($module, $dispatcher->getControllerDirectory());
$controller = new $module();
if ($controller instanceof Primitus_Controller_Action_Base) {
unset($params['module']);
unset($params['action']);
if (!empty($params)) {
$view = Primitus_View::getInstance($module);
foreach ($params as $key => $value) {
$view->assign($key, $value);
}
}
return $controller->render($action);
} else {
throw new Primitus_View_Exception("Bad Request");
}
} else {
$view = Primitus_View::getInstance($module);
unset($params['module']);
unset($params['action']);
if (!empty($params)) {
$view = Primitus_View::getInstance($module);
foreach ($params as $key => $value) {
$view->assign($key, $value);
}
}
return $view->render($action);
}
}
/**
* load class
* @param string $className : the class to load
* @throws Exception
*/
function __autoload($className)
{
if (class_exists('Zend', false)) {
if (is_int(strrpos($className, '_Interface'))) {
Zend::loadClass($className);
} else {
Zend::loadInterface($className);
}
} else {
if (!defined('__CLASS_PATH__')) {
define('__CLASS_PATH__', realpath(dirname(__FILE__)));
}
$file = __CLASS_PATH__ . '/' . str_replace('_', '/', $className) . '.php';
if (!file_exists($file)) {
throw new Exception('Cannot load class file ' . $className);
} else {
require_once $file;
}
}
}
/**
* @param array $modules
* @param array $config
* @throws Zend_Environment_Exception
* @return void
*/
public function __construct($modules, $config = array())
{
if (is_array($config)) {
if (isset($config['cache'])) {
$this->_cache = $config['cache'];
}
}
if (isset($this->_cache)) {
if ($data = $this->_cache->load($this->_cachePrefix . 'module')) {
$this->_data = unserialize($data);
return;
}
}
if ($modules === null) {
$modules = array();
$registry = new Zend_Environment_ModuleRegistry();
foreach ($registry as $file) {
$class = rtrim($file->getFilename(), '.php');
$module = "Zend_Environment_Module_{$class}";
Zend::loadClass($module);
try {
$modules[] = new $module(strtolower($class));
} catch (Zend_Environment_Exception $e) {
}
}
} elseif (!is_array($modules)) {
$modules = array($modules);
}
foreach ($modules as $instance) {
if (!$instance instanceof Zend_Environment_Module_Interface) {
throw new Zend_Environment_Exception("Module does not implement Zend_Environment_Module_Interface");
}
$this->_data[$instance->getId()] = $instance;
}
$this->_cache('module', serialize($this->_data));
}
/**
* If $performDispatch is FALSE, this method will check if a controller
* file exists. This still doesn't necessarily mean that it can be dispatched
* in the stricted sense, as file may not contain the controller class or the
* controller may reject the action.
*
* If $performDispatch is TRUE, then this method will actually
* instantiate the controller and call its action. Calling the action
* is done by passing a Zend_Controller_Dispatcher_Token to the controller's constructor.
*
* @param Zend_Controller_Dispatcher_Token $action
* @param boolean $performDispatch
* @return boolean|Zend_Controller_Dispatcher_Token
*/
protected function _dispatch(Zend_Controller_Dispatcher_Token $action, $performDispatch)
{
if ($this->_directory === null) {
throw new Zend_Controller_Dispatcher_Exception('Controller directory never set. Use setControllerDirectory() first.');
}
$className = $this->formatControllerName($action->getControllerName());
/**
* If $performDispatch is FALSE, only determine if the controller file
* can be accessed.
*/
if (!$performDispatch) {
return Zend::isReadable($this->_directory . DIRECTORY_SEPARATOR . $className . '.php');
}
Zend::loadClass($className, $this->_directory);
$controller = new $className();
if (!$controller instanceof Zend_Controller_Action) {
throw new Zend_Controller_Dispatcher_Exception("Controller \"{$className}\" is not an instance of Zend_Controller_Action.");
}
/**
* Dispatch
*
* Call the action of the Zend_Controller_Action. It will return either null or a
* new Zend_Controller_Dispatcher_Token object. If a Zend_Controller_Dispatcher_Token object is returned, this will be returned
* back to ZFrontController, which will call $this again to forward to
* another action.
*/
$nextAction = $controller->run($this, $action);
// Destroy the page controller instance
$controller = null;
// Return either null (finished) or a Zend_Controller_Dispatcher_Token object (forward to another action).
return $nextAction;
}
/**
* Removes the Role from the registry
*
* The $role parameter can either be a Role or a Role identifier.
*
* @param Zend_Acl_Role_Interface|string $role
* @throws Zend_Acl_Role_Registry_Exception
* @return Zend_Acl_Role_Registry Provides a fluent interface
*/
public function remove($role)
{
Zend::loadClass('Zend_Acl_Role_Registry_Exception');
try {
$roleId = $this->get($role)->getRoleId();
} catch (Zend_Acl_Role_Registry_Exception $e) {
throw $e;
}
foreach ($this->_roles[$roleId]['children'] as $childId => $child) {
unset($this->_roles[$childId]['parents'][$roleId]);
}
foreach ($this->_roles[$roleId]['parents'] as $parentId => $parent) {
unset($this->_roles[$parentId]['children'][$roleId]);
}
unset($this->_roles[$roleId]);
return $this;
}
public function testTableInsert()
{
Zend::loadClass('Zend_Db_Table_ZfTestTable');
$table = $this->getIdentifier(self::TABLE_NAME);
$id = $this->getIdentifier('id');
$tab1 = new Zend_Db_Table_ZfTestTable(array('db' => $this->_db, 'name' => $table, 'primary' => $id));
$nextId = $this->_db->fetchOne("SELECT nextval('" . self::SEQUENCE_NAME . "')");
$row = array('id' => $nextId, 'title' => 'News Item 3', 'subtitle' => 'Sub title 3', 'body' => 'This is body 1', 'date_created' => '2006-05-03 13:13:13');
$insertResult = $tab1->insert($row);
$last_insert_id = $this->_db->lastInsertId($table);
$this->assertEquals($insertResult, (string) $last_insert_id);
$this->assertEquals(3, (string) $last_insert_id);
}
/**
* Dispatch an HTTP request to a controller/action.
*
* @param Zend_Controller_Request_Abstract|null $request
* @param Zend_Controller_Response_Abstract|null $response
* @return Zend_Controller_Response_Abstract
*/
public function dispatch(Zend_Controller_Request_Abstract $request = null, Zend_Controller_Response_Abstract $response = null)
{
/**
* Instantiate default request object (HTTP version) if none provided
*/
if (null === $request && null === ($request = $this->getRequest())) {
Zend::loadClass('Zend_Controller_Request_Http');
$request = new Zend_Controller_Request_Http();
}
/**
* Instantiate default response object (HTTP version) if none provided
*/
if (null === $response && null === ($response = $this->getResponse())) {
Zend::loadClass('Zend_Controller_Response_Http');
$response = new Zend_Controller_Response_Http();
}
/**
* Register request and response objects with plugin broker
*/
$this->_plugins->setRequest($request)->setResponse($response);
// Begin dispatch
try {
/**
* Route request to controller/action, if a router is provided
*/
if (null !== ($router = $this->getRouter())) {
/**
* Notify plugins of router startup
*/
$this->_plugins->routeStartup($request);
$router->setParams($this->getParams());
$router->route($request);
/**
* Notify plugins of router completion
*/
$this->_plugins->routeShutdown($request);
}
/**
* Notify plugins of dispatch loop startup
*/
$this->_plugins->dispatchLoopStartup($request);
$dispatcher = $this->getDispatcher();
$dispatcher->setParams($this->getParams());
/**
* Attempt to dispatch the controller/action. If the $request
* indicates that it needs to be dispatched, move to the next
* action in the request.
*/
do {
$request->setDispatched(true);
/**
* Notify plugins of dispatch startup
*/
$this->_plugins->preDispatch($request);
/**
* Skip requested action if preDispatch() has reset it
*/
if (!$request->isDispatched()) {
continue;
}
/**
* Dispatch request
*/
$dispatcher->dispatch($request, $response);
/**
* Notify plugins of dispatch completion
*/
$this->_plugins->postDispatch($request);
} while (!$request->isDispatched());
/**
* Notify plugins of dispatch loop completion
*/
$this->_plugins->dispatchLoopShutdown();
} catch (Exception $e) {
$response->setException($e);
}
return $response;
}
/**
* Factory for Zend_Db_Adapter classes.
*
* Additional keys are processed as key-value pairs for the adapter config array.
*
* @param string $adapterName Name of the adapter to return:
* 'pdo_mysql' -> Zend_Db_Adapter_Pdo_Mysql
*
* @param array $config An array of adapter configuration keys.
*
* @return Zend_Db_Adapter_Abstract
*/
public static function factory($adapterName, $config = array())
{
if (!is_string($adapterName) or !strlen($adapterName)) {
throw new Zend_Db_Exception('Adapter name must be specified in a string');
}
if (!is_array($config)) {
throw new Zend_Db_Exception('Configuration must be an array');
}
$adapterName = strtolower($adapterName);
// normalize input
$adapterName = 'Zend_Db_Adapter_' . str_replace(' ', '_', ucwords(str_replace('_', ' ', $adapterName)));
Zend::loadClass($adapterName);
return new $adapterName($config);
}
/**
* load needed classes
*/
function loadClasses()
{
$classname = array('mbox' => 'Zend_Mail_Storage_Mbox', 'mbox-folder' => 'Zend_Mail_Storage_Folder_Mbox', 'maildir' => 'Zend_Mail_Storage_Maildir', 'maildir-folder' => 'Zend_Mail_Storage_Folder_Maildir', 'pop3' => 'Zend_Mail_Storage_Pop3', 'imap' => 'Zend_Mail_Storage_Imap');
if (isset($classname[$this->type])) {
Zend::loadClass($classname[$this->type]);
}
}
/**
* Dispatcher class loader
*
* Allows loading prefixed classes from a specific directory; used when
* modules are utilized.
*
* @param string $class
* @param string $dir
* @return false|string Returns false if unable to load class, class name
* of class loaded otherwise
*/
public function loadClass($class, $dir)
{
if (class_exists($class, false)) {
return $class;
}
$path = str_replace('_', DIRECTORY_SEPARATOR, $class);
if (strstr($path, DIRECTORY_SEPARATOR)) {
$file = substr($path, strrpos($path, DIRECTORY_SEPARATOR));
$spec = $dir . DIRECTORY_SEPARATOR . $file . '.php';
if (is_readable($spec)) {
include_once $spec;
if (!class_exists($class)) {
while (strstr($class, '_')) {
$class = substr($class, strpos($class, '_'));
if (class_exists($class)) {
return $class;
}
}
return false;
}
return $class;
}
} else {
Zend::loadClass($class, $dir);
return $class;
}
return false;
}
<?php
/**
* This example shows how to get the language for all
* languages written in native letters
*
* So en = english de = deutsch da = dánsk and so on
*/
require_once 'Zend.php';
Zend::loadClass('Zend_Locale');
$locale = new Zend_Locale();
$list = $locale->getLanguageList();
unset($list['no']);
foreach ($list as $language => $content) {
$lang = new Zend_Locale($language);
print "\n<br>[" . $language . "] " . $lang->getLanguageDisplay($language);
}
/**
* Return the current set of options and parameters seen in Json format.
*
* @throws Zend_Console_Getopt_Exception
* @return string
*/
public function toJson()
{
if (!$this->_parsed) {
$this->parse();
}
$j = array();
foreach ($this->_options as $flag => $value) {
$j['options'][] = array('option' => array('flag' => $flag, 'parameter' => $value));
}
Zend::loadClass('Zend_Json');
$json = Zend_Json::encode($j);
return $json;
}
/**
* If called without parameter getLibrary() returns the current library,
* otherwise the library of the stated version.
*
* @access public
* @static
* @param integer $version
* @return Zend_Locale_UTF8_Interface
* @throws Zend_Locale_UTF8_Exception
*/
public static function &getLibrary($version = self::CURRENT)
{
$_version = self::PHP5;
switch ($version) {
case self::AUTO:
$_version = self::_determineVersion();
break;
case self::CURRENT:
$_version = self::$_current;
break;
case self::PHP5:
case self::PHP6:
self::$_version = $version;
break;
default:
throw new Zend_Locale_UTF8_Exception('Version is not supported by Zend_Locale_UTF8.');
}
/**
* @todo implement PHP6
*/
if (!isset(self::$_libraries[$_version])) {
switch ($_version) {
case self::PHP6:
Zend::loadClass('Zend_Locale_UTF8_PHP6');
self::$_libraries[$_version] = new Zend_Locale_UTF8_PHP6();
break;
case self::PHP5:
default:
Zend::loadClass('Zend_Locale_UTF8_PHP5');
self::$_libraries[$_version] = new Zend_Locale_UTF8_PHP5();
}
}
return self::$_libraries[$_version];
}
/**
* Zend_Measure_Area provides an locale aware class for
* conversion and formatting of area values
*
* Zend_Measure $input can be a locale based input string
* or a value. $locale can be used to define that the
* input is made in a different language than the actual one.
*
* @param $value mixed - Value as string, integer, real or float
* @param $type type - OPTIONAL a Zend_Measure_Area Type
* @param $locale locale - OPTIONAL a Zend_Locale Type
* @throws Zend_Measure_Exception
*/
public function __construct($value, $type, $locale = false)
{
if ($locale === null) {
$locale = $this->_Locale;
}
if (!($locale = Zend_Locale::isLocale($locale, true))) {
throw new Zend_Measure_Exception("language ({$locale}) is a unknown language");
}
if ($type === null) {
$type = self::STANDARD;
}
if (strpos($type, '::') !== false) {
$type = substr($type, 0, strpos($type, '::'));
$sublib = substr($type, strpos($type, '::') + 2);
}
if (!array_key_exists($type, self::$_UNIT)) {
throw new Zend_Measure_Exception("type ({$type}) is unknown");
}
if (empty($sublib)) {
$sublib = current(self::$_UNIT[$type]);
}
$library = 'Zend_Measure_' . key(self::$_UNIT[$type]);
Zend::loadClass($library);
$this->_Measurement = new $library($value, $sublib, $locale);
}
function __autoload($class)
{
Zend::loadClass($class);
}
/**
* _processValidator() - internal function that is called in the existence of VALID metadata
*
* @return void
*/
protected static function _processValidators()
{
foreach ($_SESSION['__ZF']['VALID'] as $validator_name => $valid_data) {
Zend::loadClass($validator_name);
$validator = new $validator_name();
if ($validator->validate() === false) {
throw new Zend_Session_Exception("This session is not valid according to {$validator_name}.");
}
}
return;
}
<?php
/**
* @package Zend_Measure
* @subpackage UnitTests
*/
/**
* Zend_Measure
*/
require_once 'Zend.php';
Zend::loadClass('Zend_Measure');
Zend::loadClass('Zend_Measure_Temperature');
/**
* PHPUnit test case
*/
require_once 'PHPUnit/Framework/TestCase.php';
/**
* @package Zend_Measure
* @subpackage UnitTests
*/
class Zend_MeasureTest extends PHPUnit_Framework_TestCase
{
/**
* test for Angle initialisation
* expected instance
*/
public function testMeasureInit()
{
$value = new Zend_Measure('100', Zend_Measure::TEMPERATURE, 'de');
$this->assertTrue($value instanceof Zend_Measure, 'Zend_Measure Object not returned');
}
public static function loadBehavior($behaviorClassName, $targetElement)
{
Zend::loadClass($behaviorClassName, self::$BEHAVIOR_FACTORY_DIRS);
$newObject = new $behaviorClassName($targetElement);
if (!$newObject instanceof ZFormElementBehavior) {
throw new ZFormElementException("{$behaviorClassName} is not an " . 'instance of ZFormElementBehavior');
}
return $newObject;
}
/**
* Set response class/object
*
* Set the response object. The response is a container for action
* responses and headers. Usage is optional.
*
* If a class name is provided, instantiates a response object.
*
* @param string|Zend_Controller_Response_Abstract $response
* @throws Zend_Controller_Exception if invalid response class
* @return Zend_Controller_Front
*/
public function setResponse($response)
{
if (is_string($response)) {
Zend::loadClass($response);
$response = new $response();
}
if (!$response instanceof Zend_Controller_Response_Abstract) {
throw new Zend_Controller_Exception('Invalid response class');
}
$this->_response = $response;
return $this;
}
/**
* If $performDispatch is FALSE, this method will check if a controller
* file exists. This still doesn't necessarily mean that it can be dispatched
* in the stricted sense, as file may not contain the controller class or the
* controller may reject the action.
*
* If $performDispatch is TRUE, then this method will actually
* instantiate the controller and call its action. Calling the action
* is done by passing a Zend_Controller_Dispatcher_Token to the controller's constructor.
*
* @param Zend_Controller_Request_Abstract $request
* @param boolean $performDispatch
* @return void
*/
protected function _dispatch(Zend_Controller_Request_Abstract $request, $performDispatch = true)
{
/**
* Controller directory check
*/
if ($this->_directory === null) {
throw new Zend_Controller_Dispatcher_Exception('Controller directory never set. Use setControllerDirectory() first');
}
/**
* Get controller name
*
* Try request first; if not found, try pulling from request parameter;
* if still not found, fallback to default
*/
$controllerName = $request->getControllerName();
if (empty($controllerName)) {
$controllerName = $this->getDefaultController();
}
$className = $this->formatControllerName($controllerName);
/**
* Determine if controller is dispatchable
*/
$dispatchable = Zend::isReadable($this->_directory . DIRECTORY_SEPARATOR . $className . '.php');
/**
* If $performDispatch is FALSE, only determine if the controller file
* can be accessed.
*/
if (!$performDispatch) {
return $dispatchable;
}
/**
* If not dispatchable, get the default controller; if this is already
* the default controller, throw an exception
*/
if (!$dispatchable) {
if ($controllerName == $this->getDefaultController()) {
throw new Zend_Controller_Dispatcher_Exception('Default controller class not defined');
}
$className = $this->formatControllerName($this->getDefaultController());
}
/**
* Load the controller class file
*/
Zend::loadClass($className, $this->_directory);
/**
* Perform reflection on the class and verify it's a controller
*/
$reflection = new ReflectionClass($className);
if (!$reflection->isSubclassOf(new ReflectionClass('Zend_Controller_Action'))) {
throw new Zend_Controller_Dispatcher_Exception("Controller \"{$className}\" is not an instance of Zend_Controller_Action");
}
/**
* Get any instance arguments and instantiate a controller object
*/
$argv = $this->getParams();
/**
* Prepend response object to arguments
*/
array_unshift($argv, $this->getResponse());
/**
* Prepend request object to arguments
*/
array_unshift($argv, $request);
/**
* Instantiate controller with arguments
*/
$controller = $reflection->newInstanceArgs($argv);
/**
* Determine the action name
*
* First attempt to retrieve from request; then from request params
* using action key; default to default action
*/
$action = $request->getActionName();
if (empty($action)) {
$action = $this->getDefaultAction();
}
$action = $this->formatActionName($action);
$invokeArgs = array();
/**
* If method does not exist, default to __call()
*/
if (!$reflection->hasMethod($action)) {
$invokeArgs = array($action, array());
$action = '__call';
}
$method = $reflection->getMethod($action);
/**
* Dispatch the method call
*/
$request->setDispatched(true);
$controller->preDispatch();
if ($request->isDispatched()) {
// preDispatch() didn't change the action, so we can continue
$method->invokeArgs($controller, $invokeArgs);
$controller->postDispatch();
}
// Destroy the page controller instance and reflection objects
$controller = null;
$reflection = null;
$method = null;
}
/**
* Dispatch to a controller/action
*
* @param Zend_Controller_Request_Abstract $request
* @param Zend_Controller_Response_Abstract $response
* @return boolean
*/
public function dispatch(Zend_Controller_Request_Abstract $request, Zend_Controller_Response_Abstract $response)
{
$this->setResponse($response);
/**
* Get controller directories
*/
$directories = $this->getControllerDirectory();
/**
* Get controller class
*/
$className = $this->_getController($request);
/**
* If no class name returned, report exceptional behaviour
*/
if (!$className) {
throw new Zend_Controller_Dispatcher_Exception('"' . $request->getControllerName() . '" controller does not exist');
}
/**
* Load the controller class file
*
* Attempts to load the controller class file from {@link getControllerDirectory()}.
*/
Zend::loadClass($className, $this->getControllerDirectory());
/**
* Instantiate controller with request, response, and invocation
* arguments; throw exception if it's not an action controller
*/
$controller = new $className($request, $this->getResponse(), $this->getParams());
if (!$controller instanceof Zend_Controller_Action) {
throw new Zend_Controller_Dispatcher_Exception("Controller '{$className}' is not an instance of Zend_Controller_Action");
}
/**
* Retrieve the action name
*/
$action = $this->_getAction($request);
/**
* If method does not exist, default to __call()
*/
$doCall = !method_exists($controller, $action);
/**
* Dispatch the method call
*/
$request->setDispatched(true);
$controller->preDispatch();
if ($request->isDispatched()) {
// preDispatch() didn't change the action, so we can continue
if ($doCall) {
$controller->__call($action, array());
} else {
$controller->{$action}();
}
$controller->postDispatch();
}
// Destroy the page controller instance and reflection objects
$controller = null;
}
/**
* Factory for Zend_Db_Adapter classes.
*
* Additional keys are processed as key-value pairs for the adapter config array.
*
* @param string $adapterName Name of the adapter to return:
* 'pdo_mysql' -> Zend_Db_Adapter_Pdo_Mysql
*
* @param array $config An array of adapter configuration keys.
*
* @return Zend_Db_Adapter_Abstract
*/
public static function factory($adapterName, $config = array())
{
if (!is_string($adapterName) or !strlen($adapterName)) {
throw new Zend_Db_Exception('Adapter name must be specified in a string');
}
if (!is_array($config)) {
throw new Zend_Db_Exception('Configuration must be an array');
}
if (substr($adapterName, 0, 3) == 'pdo') {
$adapterName = 'Zend_Db_Adapter_Pdo_' . substr($adapterName, 3);
} else {
$adapterName = 'Zend_Db_Adapter_' . str_replace(' ', '_', ucwords(str_replace('_', ' ', $adapterName)));
}
Zend::loadClass($adapterName);
return new $adapterName($config);
}
