Dispatcher::initializeModule() - Code Metrics - horros/agavi2 - Measure and Improve Code Quality continuously with Scrutinizer

Dispatcher::initializeModule() C
last analyzed 2017-05-30 13:20 UTC

↳ Parent: Dispatcher
Complexity

Conditions	8
Paths	39
Size

Total Lines	45
Code Lines	26
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	8
eloc	26
nc	39
nop	1
dl	0
loc	45
rs	5.3846
c	0
b	0
f	0
<?php

// +---------------------------------------------------------------------------+
// | This file is part of the Agavi package.                                   |
// | Copyright (c) 2005-2011 the Agavi Project.                                |
// | Based on the Mojavi3 MVC Framework, Copyright (c) 2003-2005 Sean Kerr.    |
// |                                                                           |
// | For the full copyright and license information, please view the LICENSE   |
// | file that was distributed with this source code. You can also view the    |
// | LICENSE file online at http://www.agavi.org/LICENSE.txt                   |
// |   vi: set noexpandtab:                                                    |
// |   Local Variables:                                                        |
// |   indent-tabs-mode: t                                                     |
// |   End:                                                                    |
// +---------------------------------------------------------------------------+

namespace Agavi\Dispatcher;

use Agavi\Controller\Controller;
use Agavi\Config\Config;
use Agavi\Config\ConfigCache;
use Agavi\Exception\AgaviException;
use Agavi\Exception\ClassNotFoundException;
use Agavi\Exception\FileNotFoundException;
use Agavi\Filter\FilterChain;
use Agavi\Filter\Filter;
use Agavi\Request\RequestDataHolder;
use Agavi\Response\Response;
use Agavi\Util\ParameterHolder;
use Agavi\Exception\DispatcherException;
use Agavi\Core\Context;
use Agavi\Exception\DisabledModuleException;
use Agavi\Util\Toolkit;
use Agavi\View\View;

/**
 * Dispatcher directs application flow.
 *
 * @package    agavi
 * @subpackage Dispatcher
 *
 * @author     Sean Kerr <[email protected]>
 * @author     David Zülke <[email protected]>
 * @copyright  Authors
 * @copyright  The Agavi Project
 *
 * @since      0.9.0
 *
 * @version    $Id$
 */
class Dispatcher extends ParameterHolder
{
    /**
     * @var        int The number of execution containers run so far.
     */
    protected $numExecutions = 0;
    
    /**
     * @var        Context An Context instance.
     */
    protected $context = null;
    
    /**
     * @var        Response The global response.
     */
    protected $response = null;
    
    /**
     * @var        FilterChain The global filter chain.
     */
    protected $filterChain = null;
    
    /**
     * @var        array An array of filter instances for reuse.
     */
    protected $filters = array(
        'global' => array(),
        'controller' => array(
            '*' => null
        ),
        'dispatch' => null,
        'execution' => null,
        'security' => null
    );
    
    /**
     * @var        string The default Output Type.
     */
    protected $defaultOutputType = null;
    
    /**
     * @var        array An array of registered Output Types.
     */
    protected $outputTypes = array();
    
    /**
     * @var        array Ref to the request data object from the request.
     */
    private $requestData = null;
    
    /**
     * Increment the execution counter.
     * Will throw an exception if the maximum amount of runs is exceeded.
     *
     * @throws     DispatcherException If too many execution runs were made.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function countExecution()
    {
        $maxExecutions = $this->getParameter('max_executions');
        
        if (++$this->numExecutions > $maxExecutions && $maxExecutions > 0) {
            throw new DispatcherException('Too many execution runs have been detected for this Context.');
        }
    }
    
    /**
     * Create and initialize new execution container instance.
     *
     * @param      string                 $moduleName    The name of the module.
     * @param      string                 $controllerName    The name of the controller.
     * @param      RequestDataHolder      $arguments     A RequestDataHolder with additional
     *                                    request arguments.
     * @param      string                 $outputType    Optional name of an initial output type
     *                                    to set.
     * @param      string                 $requestMethod Optional name of the request method to
     *                                    be used in this container.
     *
     * @return     ExecutionContainer A new execution container instance,
     *                                     fully initialized.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function createExecutionContainer($moduleName = null, $controllerName = null, RequestDataHolder $arguments = null, $outputType = null, $requestMethod = null)
    {
        // create a new execution container
        /** @var ExecutionContainer $container */
        $container = $this->context->createInstanceFor('execution_container');
        $container->setModuleName($moduleName);
        $container->setControllerName($controllerName);
        $container->setRequestData($this->requestData);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        if ($arguments !== null) {
            $container->setArguments($arguments);
        }
        $container->setOutputType($this->context->getDispatcher()->getOutputType($outputType));
        if ($requestMethod === null) {
            $requestMethod = $this->context->getRequest()->getMethod();
        }
        $container->setRequestMethod($requestMethod);
        return $container;
    }
    
    /**
     * Initialize a module and load its autoload, module config etc.
     *
     * @param      string $moduleName The name of the module to initialize.
     *
     * @author     Felix Gilcher <[email protected]>
     * @since      1.0.0
     */
    public function initializeModule($moduleName)
    {
        $lowerModuleName = strtolower($moduleName);
        
        if (null === Config::get('modules.' . $lowerModuleName . '.enabled')) {
            // set some defaults first
            Config::fromArray(array(
                'modules.' . $lowerModuleName . '.agavi.controller.path' => '%core.module_dir%/${moduleName}/controllers/${controllerName}Controller.class.php',
                'modules.' . $lowerModuleName . '.agavi.cache.path' => '%core.module_dir%/${moduleName}/cache/${controllerName}.xml',
                'modules.' . $lowerModuleName . '.agavi.template.directory' => '%core.module_dir%/${module}/templates',
                'modules.' . $lowerModuleName . '.agavi.validate.path' => '%core.module_dir%/${moduleName}/validate/${controllerName}.xml',
                'modules.' . $lowerModuleName . '.agavi.view.path' => '%core.module_dir%/${moduleName}/views/${viewName}View.class.php',
                'modules.' . $lowerModuleName . '.agavi.view.name' => '${controllerName}${viewName}',
            ));
            // include the module configuration
            // loaded only once due to the way load() (former import()) works
            if (is_readable(Config::get('core.module_dir') . '/' . $moduleName . '/config/module.xml')) {
                include_once(ConfigCache::checkConfig(Config::get('core.module_dir') . '/' . $moduleName . '/config/module.xml'));
            } else {
                Config::set('modules.' . $lowerModuleName . '.enabled', true);
            }
            
            $moduleAutoload = Config::get('core.module_dir') . '/' . $moduleName . '/config/autoload.xml';
            if (is_readable($moduleAutoload)) {
                ConfigCache::load($moduleAutoload);
            }
            
            if (Config::get('modules.' . $lowerModuleName . '.enabled')) {
                $moduleConfigHandlers = Config::get('core.module_dir') . '/' . $moduleName . '/config/config_handlers.xml';
                if (is_readable($moduleConfigHandlers)) {
                    ConfigCache::addConfigHandlersFile($moduleConfigHandlers);
                }
            }
        }
        
        if (!Config::get('modules.' . $lowerModuleName . '.enabled')) {
            throw new DisabledModuleException(sprintf('The module "%1$s" is disabled.', $moduleName));
        }
        
        // check for a module config.php
        $moduleConfig = Config::get('core.module_dir') . '/' . $moduleName . '/config.php';
        if (is_readable($moduleConfig)) {
            require_once($moduleConfig);
        }
    }
    
    /**
     * Dispatch a request
     *
     * @param      RequestDataHolder  $arguments An optional request data holder object
     *                                with additional request data.
     * @param      ExecutionContainer $container An optional execution container that,
     *                                if given, will be executed right away,
     *                                skipping routing execution.
     *
     * @return     Response The response produced during this dispatch call.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.9.0
     */
    public function dispatch(RequestDataHolder $arguments = null, ExecutionContainer $container = null)
    {
        try {
            $rq = $this->context->getRequest();
            $rd = $rq->getRequestData();
            
            if ($container === null) {
                // match routes and assign returned initial execution container
                $container = $this->context->getRouting()->execute();
            }
            
            if ($container instanceof ExecutionContainer) {
                // merge in any arguments given. they need to have precedence over what the routing found
                if ($arguments !== null) {
                    $rd->merge($arguments);
                }
                
                // next, we have to see if the routing did anything useful, i.e. whether or not it was enabled.
                $moduleName = $container->getModuleName();
                $controllerName = $container->getControllerName();
                if (!$moduleName) {
                    // no module has been specified; that means the routing did not run, as it would otherwise have the 404 controller's module name
                    
                    // lets see if our request data has values for module and controller
                    $ma = $rq->getParameter('module_accessor');
                    $aa = $rq->getParameter('controller_accessor');
                    if ($rd->hasParameter($ma) && $rd->hasParameter($aa)) {
                        // yup. grab those
                        $moduleName = $rd->getParameter($ma);
                        $controllerName = $rd->getParameter($aa);
                    } else {
                        // nope. then its time for the default controller
                        $moduleName = Config::get('controllers.default_module');
                        $controllerName = Config::get('controllers.default_controller');
                    }
                    
                    // so by now we hopefully have something reasonable for module and controller names - let's set them on the container
                    $container->setModuleName($moduleName);
                    $container->setControllerName($controllerName);
                }
                
                if (!Config::get('core.available', false)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $container = $container->createSystemControllerForwardContainer('unavailable');
                }
                
                // create a new filter chain
                /** @var FilterChain $filterChain */
                $filterChain = $this->getFilterChain();
                
                $this->loadFilters($filterChain, 'global');
                
                // register the dispatch filter
                $filterChain->register($this->filters['dispatch'], 'agavi_dispatch_filter');
                
                // go, go, go!
                $filterChain->execute($container);
                
                $response = $container->getResponse();
            } elseif ($container instanceof Response) {
                // the routing returned a response!
                $response = $container;
                // set $container to null so Exception::render() won't think it is a container if an exception happens later!
                $container = null;
            } else {
                throw new AgaviException('AgaviRouting::execute() returned neither ExecutionContainer nor Response object.');
            }
            $response->merge($this->response);
            
            if ($this->getParameter('send_response')) {
                $response->send();
            }
            
            return $response;
        } catch (\Exception $e) {
            AgaviException::render($e, $this->context, $container);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }
    }
    
    /**
     * Get the global response instance.
     *
     * @return     Response The global response.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function getGlobalResponse()
    {
        return $this->response;
    }
    
    
    /**
     * Indicates whether or not a module has a specific controller file.
     *
     * Please note that this is only a cursory check and does not
     * check whether the file actually contains the proper class
     *
     * @param      string $moduleName A module name.
     * @param      string $controllerName An controller name.
     *
     * @return     string|false  the path to the controller file if the controller file
     *                    exists and is readable, false in any other case
     *
     * @author     Felix Gilcher <[email protected]>
     * @since      1.0.0
     */
    public function checkControllerFile($moduleName, $controllerName)

    {
        $this->initializeModule($moduleName);


        $controllerName = Toolkit::canonicalName(Toolkit::stripNamespace($controllerName));
        $file = Toolkit::evaluateModuleDirective(
            $moduleName,
            'agavi.controller.path',
            array(
                'moduleName' => $moduleName,
                'controllerName' => $controllerName,
            )
        );
        
        if (is_readable($file) && substr($controllerName, 0, 1) !== '/') {
            return $file;
        }
        return false;
    }
    
    /**
     * Retrieve an Controller implementation instance.
     *
     * @param      string $moduleName A module name.
     * @param      string $controllerName An controller name.
     *
     * @return     Controller An Controller implementation instance
     *
     * @throws     FileNotFoundException|ClassNotFoundException if the controller could not be found.
     *
     * @author     Sean Kerr <[email protected]>
     * @author     Mike Vincent <[email protected]>
     * @author     David Zülke <[email protected]>
     * @since      0.9.0
     */
    public function createControllerInstance($moduleName, $controllerName)
    {
        $this->initializeModule($moduleName);
        

        $longControllerName = str_replace('/', '\\', Toolkit::canonicalName(Toolkit::stripNamespace($controllerName)));
        $ns = Config::get('app.namespace');

        if (strlen($ns) > 0) {
            $ns .= '\\Modules\\' . $moduleName . '\\Controllers\\';
        }
        $class = $ns . $longControllerName . 'Controller';
        if (!class_exists($class)) {
            if (false !== ($file = $this->checkControllerFile($moduleName, $controllerName))) {
                require($file);
            } else {
                throw new FileNotFoundException(sprintf('Could not find file for Controller "%s" in Module "%s".', $controllerName, $moduleName));
            }
            
            if (!class_exists($class, false)) {
                throw new ClassNotFoundException(sprintf('Failed to instantiate Controller "%s" in Module "%s" because file "%s" does not contain class "%s".', $controllerName, $moduleName, $file, $class));
            }
        }
        
        return new $class();
    }

    /**
     * Retrieve the current application context.
     *
     * @return     Context An Context instance.
     *
     * @author     Sean Kerr <[email protected]>
     * @since      0.9.0
     */
    final public function getContext()
    {
        return $this->context;
    }


    
    /**
     * Indicates whether or not a module has a specific view file.
     *
     * Please note that this is only a cursory check and does not
     * check whether the file actually contains the proper class
     *
     * @param      string $moduleName A module name.
     * @param      string $viewName A view name.
     *
     * @return     string|false  the path to the view file if the view file
     *                    exists and is readable, false in any other case
     *
     * @author     Felix Gilcher <[email protected]>
     * @since      1.0.0
     */
    public function checkViewFile($moduleName, $viewName)

    {
        $this->initializeModule($moduleName);
        
        $viewName = Toolkit::canonicalName(Toolkit::stripNamespace($viewName));
        $file = Toolkit::evaluateModuleDirective(
            $moduleName,
            'agavi.view.path',
            array(
                'moduleName' => $moduleName,
                'viewName' => $viewName,
            )
        );
        
        if (is_readable($file) && substr($viewName, 0, 1) !== '/') {
            return $file;
        }
        
        return false;
    }
    
    /**
     * Retrieve a View implementation instance.
     *
     * @param      string $moduleName A module name.
     * @param      string $viewName A view name.
     *
     * @return     View A View implementation instance,
     *
     * @throws     AgaviException if the view could not be found.
     *
     * @author     Sean Kerr <[email protected]>
     * @author     Mike Vincent <[email protected]>
     * @author     David Zülke <[email protected]>
     * @since      0.9.0
     */
    public function createViewInstance($moduleName, $viewName)
    {
        try {
            $this->initializeModule($moduleName);
        } catch (DisabledModuleException $e) {
            // views from disabled modules should be usable by definition
            // swallow
        }

        $longViewName = str_replace('/', '\\', Toolkit::canonicalName(Toolkit::stripNamespace($viewName)));
        $ns = Config::get('app.namespace');

        if (strlen($ns) > 0 && strrpos($ns, '\\') !== strlen($ns)) {
            $ns .= '\\Modules\\' . $moduleName . '\\Views\\';
        }
        $class = $ns . $longViewName . 'View';
        
        if (!class_exists($class)) {
            if (false !== ($file = $this->checkViewFile($moduleName, $viewName))) {
                require($file);
            } else {
                throw new FileNotFoundException(sprintf('Could not find file for View "%s" in Module "%s".', $viewName, $moduleName));
            }
            
            if (!class_exists($class, false)) {
                throw new ClassNotFoundException(sprintf('Failed to instantiate View "%s" in Module "%s" because file "%s" does not contain class "%s".', $viewName, $moduleName, $file, $class));
            }
        }
        
        return new $class();
    }

    /**
     * Constructor.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function __construct()
    {
        parent::__construct();
        $this->setParameters(array(
            'max_executions' => 20,
            'send_response' => true,
        ));
    }
    
    /**
     * Initialize this Dispatcher.
     *
     * @param      Context $context A Context instance.
     * @param      array   $parameters An array of initialization parameters.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.9.0
     */
    public function initialize(Context $context, array $parameters = array())
    {
        $this->context = $context;
        
        $this->setParameters($parameters);
        
        $this->response = $this->context->createInstanceFor('response');
        
        $cfg = Config::get('core.config_dir') . '/output_types.xml';
        require(ConfigCache::checkConfig($cfg, $this->context->getName()));
        
        if (Config::get('core.use_security', false)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->filters['security'] = $this->context->createInstanceFor('security_filter');
        }
        
        $this->filters['dispatch'] = $this->context->createInstanceFor('dispatch_filter');
        
        $this->filters['execution'] = $this->context->createInstanceFor('execution_filter');
    }
    
    /**
     * Get a filter.
     *
     * @param      string $which The name of the filter list section.
     *
     * @return     Filter A filter instance, or null.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function getFilter($which)
    {
        return (isset($this->filters[$which]) ? $this->filters[$which] : null);
    }
    
    /**
     * Get the global filter chain.
     *
     * @return     FilterChain The global filter chain.
     *
     * @author     David Zülke <[email protected]>
     * @since      1.1.0
     */
    public function getFilterChain()

    {
        if ($this->filterChain === null) {
            $this->filterChain = $this->context->createInstanceFor('filter_chain');
            $this->filterChain->setType(FilterChain::TYPE_GLOBAL);
        }
        
        return $this->filterChain;
    }
    
    /**
     * Load filters.
     *
     * @param      FilterChain $filterChain A FilterChain instance.
     * @param      string      $which "global" or "controller".
     * @param      string      $module A module name, or "*" for the generic config.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function loadFilters(FilterChain $filterChain, $which = 'global', $module = null)
    {
        if ($module === null) {
            $module = '*';
        }
        
        if (($which != 'global' && !isset($this->filters[$which][$module])) || $which == 'global' && $this->filters[$which] == null) {
            if ($which == 'global') {
                $this->filters[$which] = array();
                $filters =& $this->filters[$which];
            } else {

                $this->filters[$which][$module] = array();
                $filters =& $this->filters[$which][$module];
            }
            $config = ($module == '*' ? Config::get('core.config_dir') : Config::get('core.module_dir') . '/' . $module . '/config') . '/' . $which . '_filters.xml';
            if (is_readable($config)) {
                require(ConfigCache::checkConfig($config, $this->context->getName()));
            }
        } else {

            if ($which == 'global') {
                $filters =& $this->filters[$which];
            } else {
                $filters =& $this->filters[$which][$module];
            }
        }
        
        foreach ($filters as $name => $filter) {
            $filterChain->register($filter, $name);
        }
    }

    /**
     * Indicates whether or not a module has a specific model.
     *
     * @param      string $moduleName A module name.
     * @param      string $modelName A model name.
     *
     * @return     bool true, if the model exists, otherwise false.
     *
     * @author     Sean Kerr <[email protected]>
     * @since      0.9.0
     */
    public function modelExists($moduleName, $modelName)
    {
        $modelName = Toolkit::canonicalName($modelName);
        $file = Config::get('core.module_dir') . '/' . $moduleName . '/models/' . $modelName .  'Model.class.php';
        return is_readable($file);
    }

    /**
     * Indicates whether or not a module exists.
     *
     * @param      string $moduleName A module name.
     *
     * @return     bool true, if the module exists, otherwise false.
     *
     * @author     Sean Kerr <[email protected]>
     * @since      0.9.0
     */
    public function moduleExists($moduleName)
    {
        $file = Config::get('core.module_dir') . '/' . $moduleName . '/config/module.xml';
        return is_readable($file);
    }

    /**
     * Do any necessary startup work after initialization.
     *
     * This method is not called directly after initialize().
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function startup()
    {
        // grab a pointer to the request data
        $this->requestData = $this->context->getRequest()->getRequestData();

    }

    /**
     * Execute the shutdown procedure for this Dispatcher.
     *
     * @author     Sean Kerr <[email protected]>
     * @since      0.9.0
     */
    public function shutdown()
    {
    }

    /**
     * Indicates whether or not a module has a specific controller.
     *
     * @param      string $moduleName A module name.
     * @param      string $controllerName A view name.
     *
     * @return     bool true, if the controller exists, otherwise false.
     *
     * @author     David Zülke <[email protected]>
     * @since      1.0.1
     */
    public function controllerExists($moduleName, $controllerName)
    {
        return $this->checkControllerFile($moduleName, $controllerName) !== false;
    }

    /**
     * Indicates whether or not a module has a specific view.
     *
     * @param      string $moduleName A module name.
     * @param      string $viewName A view name.
     *
     * @return     bool true, if the view exists, otherwise false.
     *
     * @author     Sean Kerr <[email protected]>
     * @since      0.9.0
     */
    public function viewExists($moduleName, $viewName)
    {
        return $this->checkViewFile($moduleName, $viewName) !== false;
    }
    
    /**
     * Retrieve an Output Type object
     *
     * @param      string $name The optional output type name.
     *
     * @return     OutputType An Output Type object.
     *
     * @author     David Zülke <[email protected]>
     * @since      0.11.0
     */
    public function getOutputType($name = null)

    {
        if ($name === null) {
            $name = $this->defaultOutputType;
        }
        if (isset($this->outputTypes[$name])) {
            return $this->outputTypes[$name];
        } else {
            throw new AgaviException('Output Type "' . $name . '" has not been configured.');
        }
    }
}

horros / agavi2

Dispatcher::initializeModule() C last analyzed 2017-05-30 13:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Dispatcher::initializeModule() C
last analyzed 2017-05-30 13:20 UTC
