Micro\Micro

Complexity

Total Complexity

63

Size/Duplication

Total Lines	434
Duplicated Lines	2.3 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	14
Bugs	3	Features	2

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	2
A	__clone()	0	9	2
B	run()	7	16	5
C	doRun()	0	52	11
B	initializeContainer()	0	21	5
A	getInjectorClass()	0	4	1
A	getConfig()	0	4	1
A	getAppDir()	0	8	2
B	addListener()	0	12	5
A	sendSignal()	0	8	3
B	getResolver()	0	18	7
C	doException()	0	33	8
A	getWebDir()	0	4	1
A	getStartTime()	0	4	1
A	terminate()	3	6	3
A	isDebug()	0	4	1
A	getContainer()	0	4	1
A	getCharset()	0	4	1
A	getLogDir()	0	4	1
A	getCacheDir()	0	4	1
A	getEnvironment()	0	4	1

<?php /** Micro */

namespace Micro;

use Micro\Base\Dispatcher;
use Micro\Base\Exception;
use Micro\Base\FatalError;
use Micro\Base\IContainer;
use Micro\Base\IDispatcher;
use Micro\Base\IInjector;
use Micro\Cli\Console;
use Micro\Cli\Consoles\DefaultConsoleCommand;
use Micro\Mvc\Controllers\IController;
use Micro\Resolver\IResolver;
use Micro\Web\IOutput;
use Micro\Web\IRequest;
use Micro\Web\IResponse;
use Micro\Web\Response;

/**
 * Micro class file.
 *
 * Base class for initialize MicroPHP, used as bootstrap framework.
 *
 * @author Oleg Lunegov <testuser@mail.linpax.org>
 * @link https://github.com/lugnsk/micro
 * @copyright Copyright &copy; 2013 Oleg Lunegov
 * @license /LICENSE
 * @package micro
 * @version 1.0
 * @since 1.0
 */
class Micro
{
    /** @const string VERSION Version framework */
    const VERSION = '1.1';

    /** @var IContainer $container Container is a container for components and options */
    protected $container;
    /** @var string $appDir */
    protected $appDir;
    /** @var string $webDir */
    protected $webDir;

    /** @var bool $loaded Micro loaded flag */
    private $loaded;
    /** @var bool $debug Debug-mode flag */
    private $debug = true;
    /** @var string $environment Application environment */
    private $environment = 'devel';
    /** @var float $startTime Time of start framework */
    private $startTime;


    /**
     * Initialize application
     *
     * @access public
     *
     * @param string $environment Application environment: devel , production , test, other
     * @param bool $debug Debug-mode flag
     *
     * @result void
     */
    public function __construct($environment = 'devel', $debug = true)
    {
        $this->webDir = getenv('DOCUMENT_ROOT');
        $this->environment = (string)$environment;
        $this->debug = (bool)$debug;
        $this->loaded = false;

        ini_set('display_errors', (integer)$this->debug);
        ini_set('log_errors', (integer)$this->debug);

        FatalError::register();

        if ($this->debug) {
            ini_set('error_reporting', -1);
            $this->startTime = microtime(true);
        }
    }

    /**
     * Clone application
     *
     * @access public
     *
     * @return void
     */
    public function __clone()
    {
        if ($this->debug) { // start new timer
            $this->startTime = microtime(true);
        }

        $this->loaded = false; // deactivate loaded
        $this->container = null; // remove configured container
    }

    /**
     * Running application
     *
     * @access public
     *
     * @param IRequest $request Request object
     *
     * @return \Micro\Web\IOutput|\Micro\Web\IResponse
     * @throws \Exception
     * @throws \Micro\Base\Exception
     */
    public function run(IRequest $request)
    {
        try {
            return $this->doRun($request);
        } catch (\Exception $e) {
            if ($this->debug) {

This code seems to be duplicated across your project.

                if (($dispatcher = $this->container->dispatcher) && $dispatcher instanceof IDispatcher) {

Accessing dispatcher on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

                    $dispatcher->signal('kernel.exception', ['exception' => $e]);
                }

                throw $e;
            }

            return $this->doException($e);
        }
    }

    /**
     * Starting ...
     *
     * @access private
     *
     * @param IRequest $request
     *
     * @return \Micro\Web\IResponse|\Micro\Web\IOutput
     * @throws \Micro\Base\Exception
     */
    private function doRun(IRequest $request)
    {
        if (!$this->loaded) {
            $this->initializeContainer();

            $this->addListener('kernel.kill', function(array $params) {
                if (
                    $params['container']->kernel->isDebug() &&
                    !$params['container']->request->isCli() &&
                    !$params['container']->request->isAjax()
                ) {
                    // Add timer into page
                    echo '<div class=debug_timer>', (microtime(true) - $params['container']->kernel->getStartTime()), '</div>';
                }

                if (false === $params['container']->kernel->loaded) {
                    return;
                }

                $params['container']->kernel->container = null;
                $params['container']->kernel->loaded = false;
            });
        }

        $this->container->request = $request;

Accessing request on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        if (($output = $this->sendSignal('kernel.request', ['container' => $this->container])) instanceof IResponse) {
            return $output;
        }

        /** @var IResolver $resolver */
        $resolver = $this->getResolver();
        if (($output = $this->sendSignal('kernel.router', ['resolver' => $resolver])) instanceof IResponse) {
            return $output;
        }

        /** @var IController|Console $app */
        $app = $resolver->getApplication();
        if (($output = $this->sendSignal('kernel.controller', ['application' => $app])) instanceof IResponse) {
            return $output;
        }

        $output = $app->action((string)$resolver->getAction());
        if (!$output instanceof IOutput) {
            $response = $this->container->response ?: new Response;

Accessing response on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $response->setBody((string)$output);
            $output = $response;
        }

        $this->sendSignal('kernel.response', ['output' => $output]);

        return $output;
    }

    /**
     * Initialization container
     *
     * @access protected
     * @return void
     */
    protected function initializeContainer()
    {
        $class = $this->getInjectorClass();
        if (!$class || !class_exists($class)) {
            $class = '\Micro\Base\Injector';
        }

        /** @var IInjector $inject */
        $inject = new $class($this->getConfig());
        $inject->addRequirement('kernel', $this);

        if (!$inject->check('dispatcher') || !($inject->get('dispatcher') instanceof IDispatcher)) {
            $inject->addRequirement('dispatcher', new Dispatcher);
        }

        /** @var IDispatcher $dispatcher */
        $dispatcher = $inject->get('dispatcher');
        $dispatcher->signal('kernel.boot', ['injector' => $inject]);

        $this->loaded = true;
    }

    /**
     * Get full class name
     * @return string
     */
    protected function getInjectorClass()
    {
        return '';
    }

    /**
     * Default config path
     *
     * @return string
     */
    protected function getConfig()
    {
        return $this->getAppDir().'/configs/index.php';
    }

    /**
     * Get application directory
     *
     * @return string
     */
    public function getAppDir()
    {
        if (!$this->appDir) {
            $this->appDir = realpath(dirname((new \ReflectionObject($this))->getFileName()));
        }

        return $this->appDir;
    }

    /**
     * Add listener on event
     *
     * @access public
     *
     * @param string $listener listener name
     * @param \Closure $event ['Object', 'method'] or callable
     * @param int|null $prior priority
     *
     * @return bool
     */
    protected function addListener($listener, $event, $prior = null)
    {
        if (!is_string($listener) || !$this->container) {
            return false;
        }

        if (($dispatcher = $this->container->dispatcher) && $dispatcher instanceof IDispatcher) {

Accessing dispatcher on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            return $dispatcher->addListener($listener, $event, $prior);
        }

        return null;
    }

    /**
     * Send signal to dispatcher
     *
     * @param string $signal
     * @param $params
     * @return mixed
     */
    protected function sendSignal($signal, $params)
    {
        if (($dispatcher = $this->container->dispatcher) && $dispatcher instanceof IDispatcher) {

Accessing dispatcher on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            return $dispatcher->signal($signal, $params);
        }

        return null;
    }

    /**
     * Get resolver
     *
     * @access protected
     *
     * @return IResolver
     * @throws \Micro\Base\Exception
     */
    protected function getResolver()
    {
        if ($this->container->request->isCli()) {

Accessing request on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $resolver = $this->container->consoleResolver ?: '\Micro\Resolver\ConsoleResolver';

Accessing consoleResolver on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        } else {
            $resolver = $this->container->resolver ?: '\Micro\Resolver\HMVCResolver';

Accessing resolver on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        }

        if (is_string($resolver) && is_subclass_of($resolver, '\Micro\Resolver\IResolver')) {
            $resolver = new $resolver($this->container);
        }

        if (!$resolver instanceof IResolver) {
            throw new Exception('Resolver is not implement an IResolver');
        }

        return $resolver;
    }

    /**
     * Do exception
     *
     * @access private
     *
     * @param \Exception $e Exception
     *
     * @return \Micro\Web\IOutput|\Micro\Web\IResponse
     * @throws \Micro\Base\Exception
     */
    private function doException(\Exception $e)
    {
        $output = $this->container->request->isCli() ? new DefaultConsoleCommand([]) : new Response();

Accessing request on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        if ($this->container->request->isCli()) {

Accessing request on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $output->data = '"Error #'.$e->getCode().' - '.$e->getMessage().'"';
            $output->execute();

The method execute does only exist in Micro\Cli\Consoles\DefaultConsoleCommand, but not in Micro\Web\Response.

            return $output;
        }
        if (!$this->container->errorController || !$this->container->errorAction) {

Accessing errorController on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing errorAction on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $output->setBody('Option `errorController` or `errorAction` not configured');

The method setBody does only exist in Micro\Web\Response, but not in Micro\Cli\Consoles\DefaultConsoleCommand.

            return $output;
        }

        if (($request = $this->container->request) && $request instanceof IRequest) {

Accessing request on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $request->setPost('error', $e);
        }

        $controller = $this->container->errorController;

Accessing errorController on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        /** @var \Micro\mvc\controllers\IController $result */
        $result = new $controller($this->container, false);
        $result = $result->action($this->container->errorAction);

Accessing errorAction on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

        if ($result instanceof IOutput) {
            return $result;
        }

        $output->setBody((string)$result);

        return $output;
    }

    /**
     * Get web root directory
     *
     * @return string
     */
    public function getWebDir()
    {
        return $this->webDir;
    }

    /**
     * Get start time
     *
     * @access public
     *
     * @return double
     */
    public function getStartTime()
    {
        return $this->startTime;
    }

    /**
     * Terminate application
     *
     * @access public
     *
     * @return void
     */
    public function terminate()
    {
        if (($dispatcher = $this->container->dispatcher) && $dispatcher instanceof IDispatcher) {

This code seems to be duplicated across your project.

Accessing dispatcher on the interface Micro\Base\IContainer suggest that you code against a concrete implementation. How about adding an instanceof check?

            $dispatcher->signal('kernel.kill', ['container' => $this->container]);
        }
    }

    /**
     * Get status of debug
     *
     * @access public
     *
     * @return bool
     */
    public function isDebug()
    {
        return $this->debug;
    }

    /**
     * Get components container
     *
     * @access public
     *
     * @return IContainer
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * Get character set
     *
     * @access public
     *
     * @return string
     */
    public function getCharset()
    {
        return 'UTF-8';
    }

    /**
     * Get logs directory
     *
     * @return string
     */
    public function getLogDir()
    {
        return $this->getAppDir().'/logs';
    }

    /**
     * Get cache directory
     *
     * @return string
     */
    public function getCacheDir()
    {
        return $this->getAppDir().'/cache/'.$this->getEnvironment();
    }

    /**
     * Get environment name
     *
     * @access public
     *
     * @return string
     */
    public function getEnvironment()
    {
        return $this->environment;
    }
}