Micro::__construct() - Code Metrics - Inspection of "fix application requirements" - lugnsk/micro - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7ee34d...c3ef57 )

by Oleg

created 2016-03-02 05:07 UTC

Micro::__construct() A

↳ Parent: Micro

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	11
Ratio	100 %

Importance

Changes	9
Bugs	1	Features	2

Metric	Value
c	9
b	1
f	2
dl	11
loc	11
rs	9.4285
cc	2
eloc	6
nc	2
nop	2

<?php /** Micro */

namespace Micro;

use Micro\base\Autoload;
use Micro\base\Container;
use Micro\base\Dispatcher;
use Micro\base\IContainer;
use Micro\cli\DefaultConsoleCommand;
use Micro\resolver\ConsoleResolver;
use Micro\resolver\HMVCResolver;
use Micro\web\IOutput;
use Micro\web\IRequest;
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 string $environment Application environment */
    protected $environment = 'devel';
    /** @var bool $debug Debug-mode flag */
    protected $debug = true;
    /** @var float $startTime Time of start framework */
    protected $startTime;
    /** @var bool $loaded Micro loaded flag */
    protected $loaded;
    /** @var IContainer $container Container is a container for components and options */
    protected $container;


    /**
     * Initialize framework
     *
     * @access public
     *
     * @param string $environment Application environment: devel , prod , test
     * @param bool $debug Debug-mode flag
     *
     * @result void
     */
    public function __construct($environment = 'devel', $debug = true)

    {
        $this->environment = $environment;
        $this->debug = (bool)$debug;

        $this->loaded = false;

          if ($this->debug) {
            $this->startTime = microtime(true);
        }
    }

    /**
     * Clone application
     *
     * @access public
     *
     * @return void
     */
    public function __clone()

    {
        if ($this->debug) {
            $this->startTime = microtime(true);
        }

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

    /**
     * Default config path
     *
     * @return string
     */
    protected function getConfig()
    {
        return false;
    }

    /**
     * Running application
     *
     * @access public
     *
     * @param IRequest $request Request object
     * @param string $configPath Path to config file
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return Response
     * @throws \Exception
     */
    public function run(IRequest $request)
    {
        if (!$this->loaded) {
            $this->loader();
        }

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

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

        try {
            return $this->doRun();
        } catch (\Exception $e) {
            if ($this->debug) {
                $this->container->dispatcher->signal('kernel.stopped', ['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);

        }
    }

    /**
     * Boot Loader
     *
     * @access public
     *
     * @return void
     */
    public function loader()
    {
        if (true === $this->loaded) {
            return;
        }

        $this->initContainer();

        $this->loaded = true;
    }

    /**
     * Initialize container
     *
     * @access public
     *
     * @param string $configPath Path to configure Container
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return void
     */
    public function initContainer()
    {
        $this->container = new Container;
        $this->container->kernel = $this;

        $this->container->load($this->getConfig());
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        if (false === $this->container->dispatcher) {
            $this->container->dispatcher = new Dispatcher($this->container);

        }
    }

    /**
     * Starting ...
     *
     * @access public
     *
     * @return \Micro\web\IResponse
     * @throws \Micro\base\Exception
     */
    private function doRun()
    {
        $resolver = $this->getResolver();
        $this->container->dispatcher->signal('kernel.router', ['resolver' => $resolver]);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

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

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

        $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->container->dispatcher->signal('kernel.response', ['output' => $output]);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

        return $output;
    }

    /**
     * Get resolver
     *
     * @access public
     *
     * @param bool|false $isCli CLI or Web
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return ConsoleResolver|HMVCResolver
     */
    public 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;
    }
}
            return new ConsoleResolver($this->container);
        }

        return new HMVCResolver($this->container);
    }

    // Methods for components

    /**
     * Do exception
     *
     * @access private
     *
     * @param \Exception $e Exception
     *
     * @return IOutput
     * @throws \Micro\base\Exception
     */
    private function doException(\Exception $e)
    {
        $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;
    }
}

        $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();


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

            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.terminate', []);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

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

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            // Add timer into page
            echo '<div class=debug_timer>', (microtime(true) - $this->getStartTime()), '</div>';
        }

        $this->unloader();
    }

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

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

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

    // Methods helpers

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

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

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

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

    public function getAppDir()
    {
        return Autoload::getAlias('App')[0];
    }
}


Push — master ( 7ee34d...c3ef57 )

Micro::__construct() A

Complexity

Size

Duplication

Importance

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\Autoload;
6			use Micro\base\Container;
7			use Micro\base\Dispatcher;
8			use Micro\base\IContainer;
9			use Micro\cli\DefaultConsoleCommand;
10			use Micro\resolver\ConsoleResolver;
11			use Micro\resolver\HMVCResolver;
12			use Micro\web\IOutput;
13			use Micro\web\IRequest;
14			use Micro\web\Response;
15
16			/**
17			* Micro class file.
18			*
19			* Base class for initialize MicroPHP, used as bootstrap framework.
20			*
21			* @author Oleg Lunegov <[email protected]>
22			* @link https://github.com/lugnsk/micro
23			* @copyright Copyright © 2013 Oleg Lunegov
24			* @license /LICENSE
25			* @package micro
26			* @version 1.0
27			* @since 1.0
28			*/
29			class Micro
30			{
31			/** @const string VERSION Version framework */
32			const VERSION = '1.1';
33
34
35			/** @var string $environment Application environment */
36			protected $environment = 'devel';
37			/** @var bool $debug Debug-mode flag */
38			protected $debug = true;
39			/** @var float $startTime Time of start framework */
40			protected $startTime;

lugnsk / micro

Push — master ( 7ee34d...c3ef57 )

Micro::__construct() A

Complexity

Size

Duplication

Importance

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