Slick\Mvc\Application

Complexity

Total Complexity

20

Size/Duplication

Total Lines	212
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

78.69%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setRequest()	0	6	1
A	setContainer()	0	4	1
A	setRunner()	0	5	1
A	setConfigPath()	0	6	1
A	__construct()	0	10	1
A	getContainer()	0	7	2
A	container()	0	8	2
A	getResponse()	0	7	2
A	getRunner()	0	11	2
A	getConfigPath()	0	8	2
A	getRequest()	0	8	2
A	checkContainer()	0	17	3

<?php

/**
 * This file is part of slick/mvc package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Mvc;

use Interop\Container\ContainerInterface;
use Slick\Configuration\Configuration;
use Slick\Di\Container;
use Slick\Di\ContainerBuilder;
use Slick\Http\PhpEnvironment\MiddlewareRunnerInterface;
use Slick\Http\PhpEnvironment\Request;
use Slick\Http\PhpEnvironment\Response;

/**
 * Class Application
 * @package Slick\Mvc
 */
class Application
{

    /**
     * @var ContainerInterface
     */
    private static $container;

    /**
     * @var string
     */
    private $configPath;

    /**
     * @var Request
     */
    private $request;

    /**
     * @var MiddlewareRunnerInterface
     */
    private $runner;

    /**
     * @var Response
     */
    private $response;

    /**
     * @var ContainerInterface
     */
    private static $defaultContainer;

    /**
     * Creates an application with an HTTP request
     *
     * If no request is provided then a Slick\Http\PhpEnvironment\Request is
     * created with values form current php environment settings.
     *
     * @param Request $request
     */
    public function __construct(Request $request = null)
    {
        $this->request = $request;
        Configuration::addPath(__DIR__.'/Configuration');
        $definitions = include __DIR__.'/Configuration/services.php';
        self::$defaultContainer = (
            new ContainerBuilder($definitions)
        )
        ->getContainer();
    }

    /**
     * Sets a new request
     *
     * @param Request $request
     *
     * @return Application
     */
    public function setRequest(Request $request)
    {
        $this->request = $request;
        $this->getContainer()->register('request', $request);

It seems like you code against a concrete implementation and not the interface Interop\Container\ContainerInterface as the method register() does only exist in the following implementations of said interface: Slick\Di\Container.

        return $this;
    }

    /**
     * Gets the application dependency injection container
     *
     * @return ContainerInterface|Container
     */
    public function getContainer()
    {
        if (is_null(self::$container)) {
            self::$container = $this->checkContainer();
        }
        return self::$container;
    }

    /**
     * Sets the dependency injection container
     *
     * @param ContainerInterface $container
     */
    public static function setContainer(ContainerInterface $container)
    {
        self::$container = $container;
    }

    /**
     * Returns the application dependency container
     *
     * @return ContainerInterface|Container
     */
    public static function container()
    {
        if (null == self::$container) {
            $app = new static;
            $app->getContainer();
        }
        return self::$container;
    }

    /**
     * Set middleware runner
     *
     * @param MiddlewareRunnerInterface $runner
     *
     * @return $this|self|Application
     */
    public function setRunner(MiddlewareRunnerInterface $runner)
    {
        $this->runner = $runner;
        return $this;
    }

    /**
     * Returns the processed response
     *
     * @return Response
     */
    public function getResponse()
    {
        if (is_null($this->response)) {
            $this->response = $this->getRunner()->run();
        }
        return $this->response;
    }

    /**
     * Gets the HTTP middleware runner for this application
     *
     * @return MiddlewareRunnerInterface
     */
    public function getRunner()
    {
        if (null === $this->runner) {
            $runner = $this->getContainer()
                ->get('middleware.runner')
                ->setRequest($this->getRequest())
            ;
            $this->setRunner($runner);
        }
        return $this->runner;
    }

    /**
     * Set configuration path
     * 
     * @param string $configPath
     * 
     * @return Application|self
     */
    public function setConfigPath($configPath)
    {
        $this->configPath = $configPath;
        Configuration::addPath($configPath);
        return $this;
    }

    /**
     * Gets configuration path
     * 
     * @return string
     */
    public function getConfigPath()
    {
        if (null == $this->configPath) {
            $this->configPath = getcwd().'/Configuration';
            Configuration::addPath($this->configPath);
        }
        return $this->configPath;
    }

    /**
     * Gets HTTP request object
     *
     * @return Request
     */
    public function getRequest()
    {
        if (null === $this->request) {
            $this->request = $this->getContainer()
                ->get('request');
        }
        return $this->request;
    }

    /**
     * Gets container with user overridden settings
     * 
     * @return ContainerInterface|\Slick\Di\Container
     */
    protected function checkContainer()
    {
        $container = self::$defaultContainer;
        if (
            null != $this->configPath &&
            file_exists($this->configPath.'/services.php')
        ) {
            $definitions = include $this->configPath.'/services.php';
            $container = (
                new ContainerBuilder(
                    $definitions,
                    true
                )
            )->getContainer();
        }
        return $container;
    }

}