Veto\App

Complexity

Total Complexity

13

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	37	4
A	registerParameters()	0	6	2
B	registerServices()	0	21	5
A	handle()	0	21	2

<?php
/**
 * Veto.
 * PHP Microframework.
 *
 * @author Damien Walsh <me@damow.net>
 * @copyright Damien Walsh 2013-2014
 * @version 0.1
 * @package veto
 */
namespace Veto;

use Veto\Configuration\Hive;
use Veto\DependencyInjection\AbstractContainerAccessor;
use Veto\DependencyInjection\Container;
use Veto\DependencyInjection\Definition;
use Veto\Http\Request;
use Veto\Http\Response;
use Veto\Http\RequestStack;
use Veto\Layer\LayerChainBuilder;

/**
 * App
 *
 * Represents the kernel of a web application.
 *
 * @since 0.1
 */
class App extends AbstractContainerAccessor
{
    /**
     * @var bool Whether or not the application is running in Debug mode
     */
    public $debug = false;

    /**
     * @var RequestStack
     */
    private $requestStack = null;

    /**
     * Create a new application instance.
     *
     * @param bool $debug A flag indicating whether or not to start the application in Debug mode.
     * @param array $config An associative array of configuration settings for the application.
     */
    public function __construct($debug = false, array $config = array())
    {
        // The debug mode flag
        $this->debug = $debug;
        
        // Load the base configuration
        $baseConfig = new Hive();
        $baseConfig->load(dirname(__DIR__) . '/config/base.yml');

        // Load the debug configuration if this application will start in Debug mode
        if ($this->debug) {
            $baseConfig->load(dirname(__DIR__) . '/config/debug.yml');
        }

        // Merge the actual config onto the base config
        $baseConfig->merge($config);

        // Initialise service container
        $this->container = new Container;

        // Register the kernel & configuration hive
        $this->container->defineInstance('config', $baseConfig);
        $this->container->defineInstance('app', $this);
        $this->container->defineInstance('container', $this->container);

        // Create the request stack and register it with the container
        $this->requestStack = new RequestStack;
        $this->container->defineInstance('request_stack', $this->requestStack);

        // Register parameters & services
        $this->registerParameters(isset($baseConfig['parameters']) ? $baseConfig['parameters'] : array());
        $this->registerServices(isset($baseConfig['services']) ? $baseConfig['services'] : array());

        // Set up layers
        $layerChain = LayerChainBuilder::initWithConfigurationAndContainer($baseConfig, $this->container);
        $this->container->defineInstance('chain', $layerChain);
    }

    /**
     * Register an array of parameters with the service container.
     *
     * @param array $parameters The parameters to register
     */
    private function registerParameters(array $parameters)
    {
        foreach ($parameters as $name => $value) {
            $this->container->setParameter($name, $value);
        }
    }

    /**
     * Recursively register an array of services as presented in the configuration JSON.
     *
     * @param array $services The services to register
     * @param string $namespace The namespace under which to register services
     */
    private function registerServices(array $services, $namespace = '')
    {
        foreach ($services as $name => $element) {

            if (isset($element['class'])) {

                // This is a service definition
                $definition = Definition::initWithArray($namespace . ($namespace ? '.' : '') . $name, $element);
                $this->container->define($definition);

            } else {

                // This is an array of services in a namespace
                $this->registerServices(
                    $element,
                    $namespace . ($namespace ? '.' : '') . $name
                );

            }
        }
    }

    /**
     * Handle a request using the defined layer chain.
     *
     * @param Request $request
     * @return Response
     */
    public function handle(Request $request)
    {
        $this->requestStack->push($request);

        try {

            // TODO: Not keen on this, need to find a way to avoid referencing the chain service, tags?
            $layerChain = $this->container->get('chain');
            $response = $layerChain->processLayers($request);
            $this->requestStack->pop();

        } catch (\Exception $exception) {

            // Invoke the exception controller action method
            $exceptionHandler = $this->container->get('controller._exception_handler');
            $exceptionHandler->setContainer($this->container);
            $response = $exceptionHandler->handleExceptionAction($request, $exception);
        }

        return $response;
    }
}