App::initialize() - Code Metrics - Inspection of "remove database & model features from framework" - zewadesign/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#81)

unknown

created 2016-11-09 10:44 UTC

App::initialize() A

↳ Parent: App

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	5
ccs	0
cts	0
cp	0
rs	9.4285
cc	1
eloc	3
nc	1
nop	0
crap	2

<?php

namespace Zewa;

//use Zewa\Interfaces\ContainerInterface;

/**
 * This class is the starting point for application
 *
 * @author Zechariah Walden<zech @ zewadesign.com>
 */
class App
{
    /**
     * Events
     */
    private static $events;

    /**
     * Return value from application
     *
     * @var string
     */
    private $output = false;

    /**
     * Namespaced controller path
     *
     * @var string
     */
    private $class;

    /**
     * Instantiated class object
     *
     * @var Controller
     */
    private $instantiatedClass;

    /**
     * Module being accessed
     *
     * @var string
     */
    private $module;

    /**
     * Controller being accessed
     *
     * @var string
     */
    private $controller;

    /**
     * Method being accessed
     *
     * @var string
     */
    private $method;

    /**
     * Params being passed
     *
     * @var array
     */
    private $params;

    /**
     * @var DIContainer $container
     */
    private $container;

    /**
     * Application bootstrap process
     *
     * The application registers the configuration in the app/config/core.php
     * and then processes, and makes available the configured resources
     *
     * App constructor.
     * @param Config $config
     * @param DIContainer $container
     */
    public function __construct(Config $config, DIContainer $container)
    {
        $this->configuration = $config;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->container = $container;
        $this->router = $container->resolve('Zewa\Router', true);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->request = $container->resolve('Zewa\Request', true);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->view = $container->resolve('Zewa\View');
class MyClass { }

$x = new MyClass();
$x->foo = true;

        $this->prepare();
    }

    /**
     * Calls the proper shell for app execution
     *
     * @access private
     */
    public function initialize()
    {
        $this->start();
        return $this;
    }

    /**
     * App preparation cycle
     */
    private function prepare()
    {
        $routerConfig = $this->configuration->get('Routing');

        $this->module = ucfirst($routerConfig->module);
        $this->controller = ucfirst($routerConfig->controller);
        $this->method = $routerConfig->method;
        $this->params = $routerConfig->params;
        $this->class = 'Zewa\\App\\Modules\\' . $this->module . '\\Controllers\\' . ucfirst($this->controller);
    }

//    public function setContainer(Container $container)

//    {
//        $this->container = $container;
//    }

    /**
     * Verifies the provided application request is a valid request
     *
     * @access private
     */
    private function validateRequest()
    {
        //catch exception and handle
        try {
            $class = new \ReflectionClass($this->class);
            $class->getMethod($this->method);
        } catch (\ReflectionException $e) {
            $view = $this->container->resolve('Zewa\View');
            $this->output = $view->render404(['Invalid method requests']); //Router::show404(
            return false;
        }

        return true;
    }

    /**
     * Processes the application request
     *
     * @access private
     */
    private function start()
    {
        if ($this->validateRequest() === false) {
            return false;
        }

        App::callEvent('preController');
        $this->instantiatedClass = $this->container->resolve($this->class);
        App::callEvent('postController');

        $this->instantiatedClass->setConfig($this->configuration);
        $this->instantiatedClass->setRouter($this->router);
        $this->instantiatedClass->setRequest($this->request);
        $this->instantiatedClass->setContainer($this->container);
        $this->instantiatedClass->setView($this->view);

        $this->output = call_user_func_array(
            [&$this->instantiatedClass, $this->method],
            $this->params
        );
    }

    /**
     * Attach (or remove) multiple callbacks to an event and trigger those callbacks when that event is called.
     *
     * @param string $event    name
     * @param mixed  $value    the optional value to pass to each callback
     * @param mixed  $callback the method or function to call - FALSE to remove all callbacks for event
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */

    public static function addEvent($event, $callback = false)
    {
        // Adding or removing a callback?
        if ($callback !== false) {
            self::$events[$event][] = $callback;
        } else {
            unset(self::$events[$event]);
        }
    }

    public function callEvent($event, $method = false, $arguments = [])
    {
        if (isset(self::$events[$event])) {
            foreach (self::$events[$event] as $e) {
                if ($method !== false) { // class w/ method specified
                    $object = new $e();
                    $value = call_user_func_array(
                        [&$object, $method],
                        $arguments
                    );
                } else {
                    if (class_exists($e)) {
                        $value = new $e($arguments); // class w/o method specified
                    } else {
                        $value = call_user_func($e, $arguments); // function yuk
                    }
                }
            }

            return $value;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
        }
    }


    /**
     * Prepare application return value into a string
     *
     * @access public
     * @return string
     */
    public function __toString()
    {
        if (!$this->output) {
            $this->output = '';
        }

        App::callEvent('postApplication');

        return $this->output;
    }
}


1		<?php
2
3		namespace Zewa;
4
5		//use Zewa\Interfaces\ContainerInterface;
6
7		/**
8		* This class is the starting point for application
9		*
10		* @author Zechariah Walden<zech @ zewadesign.com>
11		*/
12		class App
13		{
14		/**
15		* Events
16		*/
17		private static $events;
18
19		/**
20		* Return value from application
21		*
22		* @var string
23		*/
24		private $output = false;
25
26		/**
27		* Namespaced controller path
28		*
29		* @var string
30		*/
31		private $class;
32
33		/**
34		* Instantiated class object
35		*
36		* @var Controller
37		*/
38		private $instantiatedClass;
39
40		/**
41		* Module being accessed
42		*
43		* @var string
44		*/
45		private $module;
46
47		/**
48		* Controller being accessed
49		*
50		* @var string
51		*/
52		private $controller;
53
54		/**
55		* Method being accessed
56		*
57		* @var string
58		*/
59		private $method;
60
61		/**
62		* Params being passed
63		*
64		* @var array
65		*/
66		private $params;
67
68		/**
69		* @var DIContainer $container
70		*/
71		private $container;
72
73		/**
74		* Application bootstrap process
75		*
76		* The application registers the configuration in the app/config/core.php
77		* and then processes, and makes available the configured resources
78		*
79		* App constructor.
80		* @param Config $config
81		* @param DIContainer $container
82		*/
83		public function __construct(Config $config, DIContainer $container)
84		{
85		$this->configuration = $config;
		0 ignored issues – show Bug introduced 2016-11-09 10:46 UTC by Report Bug Copy Issue Report The property `configuration` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
86		$this->container = $container;
87		$this->router = $container->resolve('Zewa\Router', true);
		0 ignored issues – show Bug introduced 2016-11-09 10:46 UTC by Report Bug Copy Issue Report The property `router` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
88		$this->request = $container->resolve('Zewa\Request', true);
		0 ignored issues – show Bug introduced 2016-11-09 10:46 UTC by Report Bug Copy Issue Report The property `request` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
89		$this->view = $container->resolve('Zewa\View');
		0 ignored issues – show Bug introduced 2016-11-09 10:46 UTC by Report Bug Copy Issue Report The property `view` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
90
91		$this->prepare();
92		}
93
94		/**
95		* Calls the proper shell for app execution
96		*
97		* @access private
98		*/
99		public function initialize()
100		{
101		$this->start();
102		return $this;
103		}
104
105		/**
106		* App preparation cycle
107		*/
108		private function prepare()
109		{
110		$routerConfig = $this->configuration->get('Routing');
111
112		$this->module = ucfirst($routerConfig->module);
113		$this->controller = ucfirst($routerConfig->controller);
114		$this->method = $routerConfig->method;
115		$this->params = $routerConfig->params;
116		$this->class = 'Zewa\\App\\Modules\\' . $this->module . '\\Controllers\\' . ucfirst($this->controller);
117		}
118
119		// public function setContainer(Container $container)
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-11-09 10:46 UTC by Report Bug Copy Issue Report `41%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
120		// {
121		// $this->container = $container;
122		// }
123	28
124		/**
125	28	* Verifies the provided application request is a valid request
126		*
127		* @access private
128		*/
129		private function validateRequest()
130	28	{
131	28	//catch exception and handle
132		try {
133	28	$class = new \ReflectionClass($this->class);
134	28	$class->getMethod($this->method);
135	28	} catch (\ReflectionException $e) {
136	28	$view = $this->container->resolve('Zewa\View');
137	28	$this->output = $view->render404(['Invalid method requests']); //Router::show404(
138	28	return false;
139		}
140
141	28	return true;
142	28	}
143
144	28	/**
145	18	* Processes the application request
146		*
147		* @access private
148		*/
149		private function start()
150		{
151		if ($this->validateRequest() === false) {
152		return false;
153		}
154
155		App::callEvent('preController');
156		$this->instantiatedClass = $this->container->resolve($this->class);
157		App::callEvent('postController');
158
159		$this->instantiatedClass->setConfig($this->configuration);
160		$this->instantiatedClass->setRouter($this->router);
161	28	$this->instantiatedClass->setRequest($this->request);
162		$this->instantiatedClass->setContainer($this->container);
163	28	$this->instantiatedClass->setView($this->view);
164
165	28	$this->output = call_user_func_array(
166		[&$this->instantiatedClass, $this->method],
167	28	$this->params
168	18	);
169	18	}
170
171	18	/**
172	18	* Attach (or remove) multiple callbacks to an event and trigger those callbacks when that event is called.
173	18	*
174		* @param string $event name
175	18	* @param mixed $value the optional value to pass to each callback
176	18	* @param mixed $callback the method or function to call - FALSE to remove all callbacks for event
		0 ignored issues – show Bug introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report There is no parameter named `$value`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
177	18	*/
178	18
179	18	public static function addEvent($event, $callback = false)
180	18	{
181		// Adding or removing a callback?
182	18	if ($callback !== false) {
183		self::$events[$event][] = $callback;
184	18	} else {
185		unset(self::$events[$event]);
186		}
187		}
188
189		public function callEvent($event, $method = false, $arguments = [])
190		{
191	18	if (isset(self::$events[$event])) {
192	18	foreach (self::$events[$event] as $e) {
193		if ($method !== false) { // class w/ method specified
194	18	$object = new $e();
195		$value = call_user_func_array(
196	3	[&$object, $method],
197		$arguments
198	3	);
199		} else {
200		if (class_exists($e)) {
201		$value = new $e($arguments); // class w/o method specified
202	3	} else {
203	3	$value = call_user_func($e, $arguments); // function yuk
204		}
205		}
206		}
207
208		return $value;
		0 ignored issues – show Bug introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report The variable `$value` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
209		}
210	18	}
211
212	18
213	18	/**
214		* Prepare application return value into a string
215		*
216	18	* @access public
217	18	* @return string
218		*/
219		public function __toString()
220		{
221		if (!$this->output) {
222		$this->output = '';
223	28	}
224
225	28	App::callEvent('postApplication');
226	28
227	15	return $this->output;
228	28	}
229		}
230

zewadesign / framework

Pull Request — master (#81)

App::initialize() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like