Micro - Code Metrics - Inspection of "Patch Resolver" - lugnsk/micro - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f7ee5f...7c37a7 )

by Oleg

created 2016-03-06 15:05 UTC

Micro B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	417
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	31
Bugs	1	Features	6

Metric	Value
wmc	51
c	31
b	1
f	6
lcom	1
cbo	9
dl	0
loc	417
rs	8.3206

21 Methods

Rating	Name	Size	Complexity
A	__construct()	14	2
A	__clone()	9	2
A	run()	13	3
B	initializeContainer()	26	6
A	getContainerClass()	4	1
A	getConfig()	4	1
A	getAppDir()	8	2
A	addListener()	10	3
A	sendSignal()	4	1
A	getStartTime()	4	1
C	doRun()	32	7
B	getResolver()	18	7
B	doException()	39	6
A	terminate()	6	1
A	unloader()	9	2
A	isDebug()	4	1
A	getContainer()	4	1
A	getCharset()	4	1
A	getLogDir()	4	1
A	getCacheDir()	4	1
A	getEnvironment()	4	1

How to fix Complexity

<?php /** Micro */

namespace Micro;

use Micro\base\Container;
use Micro\base\Dispatcher;
use Micro\Base\Exception;
use Micro\Base\FatalError;
use Micro\base\IContainer;
use Micro\cli\Consoles\DefaultConsoleCommand;
use Micro\resolver\HMVCResolver;
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 <[email protected]>
 * @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 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->environment = (string)$environment;
        $this->debug = (bool)$debug;
        $this->loaded = false;

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

        FatalError::register();

        if ($this->debug) {
            $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 Response
     * @throws \Exception
     */
    public function run(IRequest $request)
    {
        try {
            return $this->doRun($request);

        } catch (\Exception $e) {
            if ($this->debug) {
                $this->container->dispatcher->signal('kernel.exception', ['exception' => $e]);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                throw $e;
            }

            return $this->doException($e); // run exception

        }
    }

    /**
     * Initialization container
     *
     * @access protected
     * @return void
     */
    protected function initializeContainer()
    {
        $class = $this->getContainerClass();
        if ($class) {
            $class = new $class;
        }

        $this->container = ($class instanceof IContainer) ? $class : new Container;
        $this->container->kernel = $this;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $this->container->load($this->getConfig());

        if (false === $this->container->dispatcher) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $this->container->dispatcher = new Dispatcher;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

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

        $this->container->dispatcher->signal('kernel.boot', ['container' => $this->container]);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        $this->loaded = true;
    }

    /**
     * Get full class name
     * @return string
     */
    protected function getContainerClass()
    {
        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 = dirname((new \ReflectionObject($this))->getFileName());
        }

        return $this->appDir;
    }

    /**
     * Add listener on event
     *
     * @access public
     *
     * @param string $listener listener name
     * @param mixed $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;
        }

        $this->container->dispatcher->addListener($listener, $event, $prior);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        return true;
    }

    /**
     * Send signal to dispatcher
     *
     * @param $signal
     * @param $params
     * @return mixed
     */
    protected function sendSignal($signal, $params)
    {
        return $this->container->dispatcher->signal($signal, $params);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
    }

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

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

        $this->container->request = $request;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        if ($output = $this->sendSignal('kernel.request', ['container' => $this->container]) instanceof IResponse) {
            return $output;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $resolver = $this->getResolver();
        if ($output = $this->sendSignal('kernel.router', ['resolver' => $resolver]) instanceof IResponse) {
            return $output;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $app = $resolver->getApplication();
        if ($output = $this->sendSignal('kernel.controller', ['application' => $app]) instanceof IResponse) {
            return $output;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $output = $app->action($resolver->getAction());
        if (!$output instanceof IOutput) {
            $response = $this->container->response ?: new Response;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $response->setBody($output);
            $output = $response;
        }

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

        return $output;
    }

    /**
     * Get resolver
     *
     * @access protected
     *
     * @return IResolver
     * @throws \Micro\Base\Exception
     */
    protected function getResolver()
    {
        if ($this->container->request->isCli()) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $resolver = $this->container->consoleResolver ?: '\Micro\resolver\ConsoleResolver';
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        } else {
            $resolver = $this->container->resolver ?: '\Micro\Resolver\HMVCResolver';
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        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 IReslover');
        }

        return $resolver;
    }

    /**
     * Do exception
     *
     * @access private
     *
     * @param \Exception $e Exception
     *
     * @return IOutput
     * @throws \Micro\base\Exception
     */
    private function doException(\Exception $e)
    {
        $output = $this->container->request->isCli() ? new DefaultConsoleCommand([]) : new Response();
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        if ($this->container->request->isCli()) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $output->data = '"Error #' . $e->getCode() . ' - ' . $e->getMessage() . '"';
            $output->execute();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

            return $output;
        }

        if (!$this->container->errorController) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $output->setBody('Option `errorController` not configured');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

            return $output;
        }
        if (!$this->container->errorAction) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $output->setBody('Option `errorAction` not configured');

            return $output;
        }

        $controller = $this->container->errorController;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $action = $this->container->errorAction;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        $this->container->request->setPost('error', $e);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

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

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

        $output->setBody($result);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        return $output;
    }

    /**
     * Terminate application
     *
     * @access public
     *
     * @return void
     */
    public function terminate()
    {
        $this->container->dispatcher->signal('kernel.kill', ['container' => $this->container]);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        $this->unloader();
    }

    /**
     * Unloader subsystem
     *
     * @access public
     *
     * @return void
     */
    public function unloader()
    {
        if (false === $this->loaded) {
            return;
        }

        $this->container = null;
        $this->loaded = false;
    }

    /**
     * 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;
    }
}


Push — master ( f7ee5f...7c37a7 )

Micro B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php /** Micro */
2
3			namespace Micro;
4
5			use Micro\base\Container;
6			use Micro\base\Dispatcher;
7			use Micro\Base\Exception;
8			use Micro\Base\FatalError;
9			use Micro\base\IContainer;
10			use Micro\cli\Consoles\DefaultConsoleCommand;
11			use Micro\resolver\HMVCResolver;
12			use Micro\Resolver\IResolver;
13			use Micro\web\IOutput;
14			use Micro\web\IRequest;
15			use Micro\Web\IResponse;
16			use Micro\web\Response;
17
18			/**
19			* Micro class file.
20			*
21			* Base class for initialize MicroPHP, used as bootstrap framework.
22			*
23			* @author Oleg Lunegov <[email protected]>
24			* @link https://github.com/lugnsk/micro
25			* @copyright Copyright © 2013 Oleg Lunegov
26			* @license /LICENSE
27			* @package micro
28			* @version 1.0
29			* @since 1.0
30			*/
31			class Micro
32			{
33			/** @const string VERSION Version framework */
34			const VERSION = '1.1';
35
36			/** @var IContainer $container Container is a container for components and options */
37			protected $container;
38			/** @var string $appDir */
39			protected $appDir;
40

lugnsk / micro

Push — master ( f7ee5f...7c37a7 )

Micro B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like