Engine - Code Metrics - Icybee/Patron - Measure and Improve Code Quality continuously with Scrutinizer

Engine C
last analyzed 2016-07-08 22:28 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	512
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	15
Bugs	1	Features	2

Metric	Value
c	15
b	1
f	2
dl	0
loc	512
rs	6.018
wmc	61
lcom	1
cbo	8

21 Methods

Rating	Name	Size	Complexity
A	get_markups()	4	1
A	get_functions()	4	1
A	__construct()	9	1
A	__clone()	4	1
A	evaluate()	6	2
A	get_singleton()	4	1
A	trace_enter()	4	1
A	trace_exit()	4	1
B	error()	56	9
A	handle_exception()	13	3
A	fetchErrors()	8	1
A	get_file()	12	3
A	get_template_dir()	4	1
A	addTemplate()	15	2
C	resolve_template()	46	7
A	create_template_from_file()	7	1
A	get_template()	9	2
B	callTemplate()	30	3
A	init_context()	4	1
A	get_compiled()	11	2
F	__invoke()	109	17

How to fix Complexity

<?php

/*
 * This file is part of the Patron package.
 *
 * (c) Olivier Laviale <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Patron;

use ICanBoogie\Accessor\AccessorTrait;
use ICanBoogie\Debug;
use ICanBoogie\Render;
use ICanBoogie\Render\TemplateName;

define('WDPATRON_DELIMIT_MACROS', false);

/**
 * Patron engine.
 *
 * @property-read MarkupCollection $markups
 * @property-read FunctionCollection $functions
 */
class Engine
{
	use AccessorTrait;

	const PREFIX = 'p:';

	protected $trace_templates = false;

	/**
	 * @var MarkupCollection
	 */
	private $markups;

	protected function get_markups()
	{
		return $this->markups;
	}

	/**
	 * @var FunctionCollection
	 */
	private $functions;

	protected function get_functions()
	{
		return $this->functions;
	}

	/**
	 * Expression evaluator.
	 *
	 * @var Evaluator
	 */
	private $evaluator;

	/**
	 * Initializes the {@link $evaluator} property, and a bunch of functions.
	 *
	 * @param MarkupCollection $markups
	 * @param FunctionCollection $functions
	 */
	public function __construct(MarkupCollection $markups, FunctionCollection $functions)
	{
		$this->markups = $markups;
		$this->functions = $functions;
		$this->evaluator = new Evaluator($this);
		$this->template_resolver = Render\get_template_resolver();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

		$this->init_context();
	}

	public function __clone()
	{
		$this->init_context();
	}

	/**
	 * Evaluate an expression relative to a context.
	 *
	 * @param mixed $context
	 * @param string $expression
	 * @param bool $silent
	 */
	public function evaluate($expression, $silent=false, $context=null)
	{
		$evaluator = $this->evaluator;

		return $evaluator($context ?: $this->context, $expression, $silent);
	}

	/**
	 * @return Engine
	 *
	 * @deprecated
	 */
	static public function get_singleton()
	{
		return get_patron();
	}

	/*
	**

	SYSTEM

	**
	*/

	protected $trace = [];
	protected $errors = [];

	public function trace_enter($a)
	{
		array_unshift($this->trace, $a);
	}

	public function trace_exit()
	{
		array_shift($this->trace);
	}

	public function error($alert, array $args=[])
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
	{
		if ($alert instanceof \ICanBoogie\Exception\Config)
if ($x instanceof DoesNotExist) {
    // Do something.
}
		{
			$this->errors[] = '<div class="alert alert-danger">' . $alert->getMessage() . '</div>';

			return;
		}
		else if ($alert instanceof \Exception)
		{
			$alert = class_exists('ICanBoogie\Debug') ? Debug::format_alert($alert) : (string) $alert;
		}
		else
		{
			$alert = \ICanBoogie\format($alert, $args);
		}

		#
		#
		#

		$trace_html = null;

		if ($this->trace)

		{
			$i = count($this->trace);
			$root = $_SERVER['DOCUMENT_ROOT'];
			$root_length = strlen($root);

			foreach ($this->trace as $trace)
			{
				list($which, $message) = $trace;

				if ($which == 'file')
				{
					if (strpos($message, $root_length) === 0)
					{
						$message = substr($message, $root_length);
					}
				}

				$trace_html .= sprintf('#%02d: in %s "%s"', $i--, $which, $message) . '<br />';
			}

			if ($trace_html)
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
			{
				$trace_html = '<pre>' . $trace_html . '</pre>';
			}
		}

		#
		#
		#

		$this->errors[] = '<div class="alert alert-danger">' . $alert . $trace_html . '</div>';
	}

	public function handle_exception(\Exception $e)
	{
		if ($e instanceof \ICanBoogie\HTTP\Exception)
if ($x instanceof DoesNotExist) {
    // Do something.
}
		{
			throw $e;
		}
		else if ($e instanceof \ICanBoogie\ActiveRecord\Exception)
if ($x instanceof DoesNotExist) {
    // Do something.
}
		{
			throw $e;
		}

		$this->error($e);
	}

	public function fetchErrors()
	{
		$rc = implode(PHP_EOL, $this->errors);

		$this->errors = [];

		return $rc;
	}

	public function get_file()
	{
		foreach ($this->trace as $trace)
		{
			list($which, $data) = $trace;

			if ($which == 'file')
			{
				return $data;
			}
		}
	}

	public function get_template_dir()
	{
		return dirname($this->get_file());
	}

	/*
	**

	TEMPLATES

	**
	*/

	protected $templates = [];

	public function addTemplate($name, $template)
	{
		if (isset($this->templates[$name]))
		{
			$this->error('The template %name is already defined ! !template', [

				'%name' => $name, '!template' => $template

			]);

			return;
		}

		$this->templates[$name] = $template;
	}

	protected function resolve_template($name)
	{
		$template_resolver = $this->template_resolver;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
		$file = $this->get_file();

		if ($file)
		{
			// FIXME-20150721: use a decorator

			$template_resolver = clone $this->template_resolver;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

			$basic_template_resolver = null;

			if ($template_resolver instanceof Render\BasicTemplateResolver)
			{
				$basic_template_resolver = $template_resolver;
			}
			else if ($template_resolver instanceof Render\TemplateResolverDecorator)
			{
				$basic_template_resolver = $template_resolver->find_renderer(Render\BasicTemplateResolver::class);
			}

			if ($basic_template_resolver)
			{
				$basic_template_resolver->add_path(dirname($file));
			}
		}

		$tries = [];
		$template_pathname = $template_resolver->resolve($name, [ '.patron', '.html' ], $tries);

		if ($template_pathname)
		{
			return $this->create_template_from_file($template_pathname);
		}

		$template_name = TemplateName::from($name);
		$template_pathname = $template_resolver->resolve($template_name->as_partial, [ '.patron', '.html' ], $tries);

		if ($template_pathname)
		{
			return $this->create_template_from_file($template_pathname);
		}

		throw new TemplateNotFound("Template not found: $name.", $tries);
	}

	protected function create_template_from_file($pathname)
	{
		$content = file_get_contents($pathname);
		$nodes = $this->get_compiled($content);

		return new Template($nodes, [ 'file' => $pathname ]);
	}

	protected function get_template($name)
	{
		if (isset($this->templates[$name]))
		{
			return $this->templates[$name];
		}

		return $this->resolve_template($name);
	}

	/**
	 * Calls a template.
	 *
	 * @param $name
	 * @param array $args
	 *
	 * @return string
	 */
	public function callTemplate($name, array $args=[])
	{
		$template = $this->get_template($name);

		if (!$template)
		{
			$er = 'Unknown template %name';
			$params = [ '%name' => $name ];

			if ($this->templates)

			{
				$er .= ', available templates: :list';
				$params[':list'] = implode(', ', array_keys($this->templates));
			}

			$this->error($er, $params);

			return null;
		}

		$this->trace_enter([ 'template', $name, $template ]);

		$this->context['self']['arguments'] = $args;

		$rc = $this($template);

		array_shift($this->trace);

		return $rc;
	}

	/*
	**

	CONTEXT

	**
	*/

	public $context;

	protected function init_context()
	{
		$this->context = new \BlueTihi\Context([ 'self' => null, 'this' => null ]);
	}

	/*
	**

	PUBLISH

	**
	*/

	protected function get_compiled($template)
	{
		static $compiler;

		if ($compiler === null)
		{
			$compiler = new Compiler();
		}

		return $compiler($template);
	}

	public function __invoke($template, $bind=null, array $options=[])
	{
		if (!$template)
		{
			return null;
		}

		if ($bind !== null)
		{
			$this->context['this'] = $bind;
		}

		$file = null;

		foreach ($options as $option => $value)
		{
			switch ((string) $option)
			{
				case 'variables':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B": //right
        doSomething();
        break;
}
				{
					foreach ($value as $k => $v)
					{
						$this->context[$k] = $v;
					}
				}
				break;

				case 'file':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B": //right
        doSomething();
        break;
}
				{
					$file = $value;
				}
				break;

				default:
switch ($expr) {
    default: { //wrong
        doSomething();
        break;
    }
}

switch ($expr) {
    default: //right
        doSomething();
        break;
}
				{
					trigger_error(\ICanBoogie\format('Suspicious option: %option :value', [

						'%option' => $option,
						':value' => $value

					]));
				}
				break;
			}
		}

		if (!($template instanceof Template))
		{
			if (is_array($template) && isset($template['file']))
			{
				$file = $template['file'];

				unset($template['file']);
			}

			if (!is_array($template))
			{
				$template = $this->get_compiled($template);
			}

			$template = new Template($template, [ 'file' => $file ]);
		}

		if ($template->file)
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
		{
			$this->trace_enter([ 'file', $template->file ]);
		}

		$rc = '';

		foreach ($template as $node)
		{
			if (!($node instanceof Node))
			{
				continue;
			}

			try
			{
				$rc .= $node($this, $this->context);
			}
			catch (\Exception $e)
			{
				if (class_exists('ICanBoogie\Debug'))
				{
					$rc .= Debug::format_alert($e);
				}
				else
				{
					$rc .= $e;
				}
			}

			$rc .= $this->fetchErrors();
		}

		$rc .= $this->fetchErrors();

		#
		#
		#

		if ($file)
		{
			array_shift($this->trace);
		}

		return $rc;
	}

	/*

	#
	# $context_markup is used to keep track of two variables associated with each markup :
	# self and this.
	#
	# 'self' is a reference to the markup itself, holding its name and the arguments with which
	# it was called, it is also used to store special markup data as for the foreach markup
	#
	# 'this' is a reference to the object of the markup, that being an array, an object or a value
	#
	#

	<p:articles>

		self.range.start
		self.range.limit
		self.range.count

		this = array of Articles

		<p:foreach>

			self.name = foreach
			self.arguments = []
			self.position
			self.key
			self.left

			this = an Article object

		</p:foreach>
	</p:articles>

	*/

	public $context_markup = []; // should be protected
}


Engine C
last analyzed 2016-07-08 22:28 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1			<?php
2
3			/*
4			* This file is part of the Patron package.
5			*
6			* (c) Olivier Laviale <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Patron;
13
14			use ICanBoogie\Accessor\AccessorTrait;
15			use ICanBoogie\Debug;
16			use ICanBoogie\Render;
17			use ICanBoogie\Render\TemplateName;
18
19			define('WDPATRON_DELIMIT_MACROS', false);
20
21			/**
22			* Patron engine.
23			*
24			* @property-read MarkupCollection $markups
25			* @property-read FunctionCollection $functions
26			*/
27			class Engine
28			{
29			use AccessorTrait;
30
31			const PREFIX = 'p:';
32
33			protected $trace_templates = false;
34
35			/**
36			* @var MarkupCollection
37			*/
38			private $markups;
39
40			protected function get_markups()

Icybee / Patron

Engine C last analyzed 2016-07-08 22:28 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like

Engine C
last analyzed 2016-07-08 22:28 UTC