Micro::getLogDir() - Code Metrics - Inspection of "remove requirements...." - lugnsk/micro - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c3ef57...f7ee5f )

by Oleg

created 2016-03-04 05:53 UTC

Micro::getLogDir() A

↳ Parent: Micro

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	1

Metric	Value
c	3
b	0
f	1
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php /** Micro */

namespace Micro;

use Micro\base\Container;
use Micro\base\Dispatcher;
use Micro\base\IContainer;
use Micro\cli\Consoles\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 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;

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


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

        /** @TODO: add handler for fatal errors... */

        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
    }

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

    /**
     * Running application
     *
     * @access public
     *
     * @param IRequest $request Request object
     *
     * @return Response
     * @throws \Exception
     */
    public function run(IRequest $request)
    {
        if (!$this->loaded) {
            $this->initializeContainer();

            $this->loaded = true;
        }

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

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

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

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

        try {
            return $this->doRun(); // run application
        } catch (\Exception $e) { // if not caught exception
            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

        }
    }

    /**
     * Starting ...
     *
     * @access private
     *
     * @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;
    }

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

    /**
     * Add listener on event
     *
     * @access public
     *
     * @param string $listener listener name
     * @param mixed $event ['Object', 'method'] or callable
     * @param int|null $prior priority
     *
     * @return void
     */
    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;
    }

    // Methods for components

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

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

    /**
     * Get resolver
     *
     * @access protected
     *
     * @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
     */
    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;
    }
}
            return new ConsoleResolver($this->container);
        }

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

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

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

    // Methods helpers

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

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

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

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

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

        return $this->appDir;
    }

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


Push — master ( c3ef57...f7ee5f )

Micro::getLogDir() 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

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

lugnsk / micro

Push — master ( c3ef57...f7ee5f )

Micro::getLogDir() 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

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like