Logical::decodeLogicStatements() - Code Metrics - Inspection of "Adding logical statements isLength/isNotLength, an..." - bradcornford/Logical - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — v1.3.0 ( 18cd08 )

by Bradley

created 2016-05-10 14:43 UTC

Logical::decodeLogicStatements() C

↳ Parent: Logical

Complexity

Conditions	13
Paths	11

Size

Total Lines	53
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	1	Features	2

Metric	Value
dl	0
loc	53
rs	6.3327
c	4
b	1
f	2
cc	13
eloc	30
nc	11
nop	0

How to fix Long Method Complexity

<?php namespace Cornford\Logical;

use Cornford\Logical\Contracts\LogicalInterface;
use Cornford\Logical\Exceptions\LogicalDecodingException;
use Cornford\Logical\Exceptions\LogicalExecutionException;
use Cornford\Logical\Exceptions\LogicalFieldValueException;
use Exception;

class Logical extends LogicalAbstract implements LogicalInterface {

	/**
	 * The temporary logic method.
	 *
	 * @var string
	 */
	protected $tempLogic;

	/**
	 * The temporary logic method.
	 *
	 * @var string
	 */
	protected $tempMethod;

	/**
	 * The temporary logic expected.
	 *
	 * @var string|array
	 */
	protected $tempExpected;

	/**
	 * The temporary logic field.
	 *
	 * @var string
	 */
	protected $tempField;

	/**
	 * The temporary results.
	 *
	 * @var array
	 */
	protected $tempResults;

	/**
	 * Decode the logic string into an array of logical statements.
	 *
	 * @return boolean
	 */
	protected function decodeLogicStatements()
	{
		if (!$this->getLogic()) {
			return true;
		}

		$orStatements = preg_split("/.OR./", $this->getLogic());

		foreach ($orStatements as $orKey => $orStatement) {
			$andStatements = preg_split("/.AND./", $orStatement);

			foreach ($andStatements as $andStatement) {
				$items = preg_split("/\./", $andStatement, 2);
				$decodedStatement = [];

				foreach ($items as $item) {
					$matches = null;
					if (stristr($item, 'where')) {
						if (!preg_match("/\((?<field>.*)\)/", $item, $matches)) {
							return false;
						}

						$this->tempField = trim(trim($matches['field'], '\''), '"');

						continue;
					}

					if (!preg_match("/^(?<method>[a-zA-Z]{1,})\((?<expected>[\'\"]*.*[\'\"]*)\)/", $item, $matches)) {
						return false;
					} else {
						$this->tempMethod = trim(trim($matches['method'], '\''), '"');
						$this->tempExpected = trim(trim($matches['expected'], '\''), '"');
					}

					if (stristr($this->tempExpected, ',') && !stristr($this->tempExpected, '{') && !stristr($this->tempExpected, '}')) {
						$this->tempExpected = explode(', ', $this->tempExpected);
					}

					if (stristr($this->tempExpected, '{') && stristr($this->tempExpected, '}')) {
						$this->tempExpected = eval(str_replace('{', 'print_r(', str_replace('}', ', true);', $this->tempExpected)));
					}

					$decodedStatement[$orKey]['method'] = $this->tempMethod;
					$decodedStatement[$orKey]['expected'] = $this->tempExpected;
					$decodedStatement[$orKey]['field'] = $this->tempField;
				}

				$this->setDecodedLogicStatement($decodedStatement);
			}
		}

		return true;
	}

	/**
	 * Execute a logic statement method on an input value against an expected value.
	 *
	 * @param string                 $method
	 * @param string|integer|boolean $input
	 * @param string|integer|boolean $expected
	 *
	 * @throws LogicalExecutionException
	 *
	 * @return boolean
	 */
	protected function executeLogicStatement($method, $input, $expected = null)
	{
		$logicalStatementInstance = $this->getLogicalStatementInstance();
		$result = null;

		if (method_exists($logicalStatementInstance, $method)) {
			$result = $logicalStatementInstance->$method($input, $expected);
		}

		if ($logicalStatementInstance->customStatementExists($method)) {
			$result = $logicalStatementInstance->callCustomStatement($method, $input, $expected);
		}

		if (is_null($result)) {
			throw new LogicalExecutionException("Unable to execute logic statement method: {$method}().");
		}

		return $result;
	}

	/**
	 * Decodes logic input into statements and executes each statement removing un-matching results.
	 *
	 * @throws LogicalDecodingException
	 * @throws LogicalFieldValueException
	 *
	 * @return self
	 */
	public function execute()
	{
		if (!$this->decodeLogicStatements()) {
			throw new LogicalDecodingException('Unable to decode logic input.');
		}

		foreach ($this->getDecodedLogicStatements() as $orStatement) {
			$this->tempResults = $this->getInput();

			foreach ($this->getInput() as $key => $input) {
				foreach ($orStatement as $andStatement) {
					switch (gettype($input)) {
						case 'object':
							break;
						case 'array':
						default:
							$andStatement['field'] = '[' . $andStatement['field'] . ']';
					}

					try {
						$value = $this->getPropertyAccessorInstance()->getValue($input, $andStatement['field']);
					} catch (Exception $exception) {
						throw new LogicalFieldValueException('Unable to locate logical statement field value.');
					}

					if (!isset($value)) {
						throw new LogicalFieldValueException('Unable to locate logical statement field value.');
					}

					if (!$this->executeLogicStatement($andStatement['method'], $value, $andStatement['expected'])) {
						unset($this->tempResults[$key]);
					}
				}
			}

			$this->mergeResults($this->tempResults);
		}

		return $this;
	}

}

1			<?php namespace Cornford\Logical;
2
3			use Cornford\Logical\Contracts\LogicalInterface;
4			use Cornford\Logical\Exceptions\LogicalDecodingException;
5			use Cornford\Logical\Exceptions\LogicalExecutionException;
6			use Cornford\Logical\Exceptions\LogicalFieldValueException;
7			use Exception;
8
9			class Logical extends LogicalAbstract implements LogicalInterface {
10
11			/**
12			* The temporary logic method.
13			*
14			* @var string
15			*/
16			protected $tempLogic;
17
18			/**
19			* The temporary logic method.
20			*
21			* @var string
22			*/
23			protected $tempMethod;
24
25			/**
26			* The temporary logic expected.
27			*
28			* @var string\|array
29			*/
30			protected $tempExpected;
31
32			/**
33			* The temporary logic field.
34			*
35			* @var string
36			*/
37			protected $tempField;
38
39			/**
40			* The temporary results.
41			*
42			* @var array
43			*/
44			protected $tempResults;
45
46			/**
47			* Decode the logic string into an array of logical statements.
48			*
49			* @return boolean
50			*/
51			protected function decodeLogicStatements()
52			{
53			if (!$this->getLogic()) {
54			return true;
55			}
56
57			$orStatements = preg_split("/.OR./", $this->getLogic());
58
59			foreach ($orStatements as $orKey => $orStatement) {
60			$andStatements = preg_split("/.AND./", $orStatement);
61
62			foreach ($andStatements as $andStatement) {
63			$items = preg_split("/\./", $andStatement, 2);
64			$decodedStatement = [];
65
66			foreach ($items as $item) {
67			$matches = null;
68			if (stristr($item, 'where')) {
69			if (!preg_match("/\((?<field>.*)\)/", $item, $matches)) {
70			return false;
71			}
72
73			$this->tempField = trim(trim($matches['field'], '\''), '"');
74
75			continue;
76			}
77
78			if (!preg_match("/^(?<method>[a-zA-Z]{1,})\((?<expected>[\'\"].[\'\"]*)\)/", $item, $matches)) {
79			return false;
80			} else {
81			$this->tempMethod = trim(trim($matches['method'], '\''), '"');
82			$this->tempExpected = trim(trim($matches['expected'], '\''), '"');
83			}
84
85			if (stristr($this->tempExpected, ',') && !stristr($this->tempExpected, '{') && !stristr($this->tempExpected, '}')) {
86			$this->tempExpected = explode(', ', $this->tempExpected);
87			}
88
89			if (stristr($this->tempExpected, '{') && stristr($this->tempExpected, '}')) {
90			$this->tempExpected = eval(str_replace('{', 'print_r(', str_replace('}', ', true);', $this->tempExpected)));
91			}
92
93			$decodedStatement[$orKey]['method'] = $this->tempMethod;
94			$decodedStatement[$orKey]['expected'] = $this->tempExpected;
95			$decodedStatement[$orKey]['field'] = $this->tempField;
96			}
97
98			$this->setDecodedLogicStatement($decodedStatement);
99			}
100			}
101
102			return true;
103			}
104
105			/**
106			* Execute a logic statement method on an input value against an expected value.
107			*
108			* @param string $method
109			* @param string\|integer\|boolean $input
110			* @param string\|integer\|boolean $expected
111			*
112			* @throws LogicalExecutionException
113			*
114			* @return boolean
115			*/
116			protected function executeLogicStatement($method, $input, $expected = null)
117			{
118			$logicalStatementInstance = $this->getLogicalStatementInstance();
119			$result = null;
120
121			if (method_exists($logicalStatementInstance, $method)) {
122			$result = $logicalStatementInstance->$method($input, $expected);
123			}
124
125			if ($logicalStatementInstance->customStatementExists($method)) {
126			$result = $logicalStatementInstance->callCustomStatement($method, $input, $expected);
127			}
128
129			if (is_null($result)) {
130			throw new LogicalExecutionException("Unable to execute logic statement method: {$method}().");
131			}
132
133			return $result;
134			}
135
136			/**
137			* Decodes logic input into statements and executes each statement removing un-matching results.
138			*
139			* @throws LogicalDecodingException
140			* @throws LogicalFieldValueException
141			*
142			* @return self
143			*/
144			public function execute()
145			{
146			if (!$this->decodeLogicStatements()) {
147			throw new LogicalDecodingException('Unable to decode logic input.');
148			}
149
150			foreach ($this->getDecodedLogicStatements() as $orStatement) {
151			$this->tempResults = $this->getInput();
152
153			foreach ($this->getInput() as $key => $input) {
154			foreach ($orStatement as $andStatement) {
155			switch (gettype($input)) {
156			case 'object':
157			break;
158			case 'array':
159			default:
160			$andStatement['field'] = '[' . $andStatement['field'] . ']';
161			}
162
163			try {
164			$value = $this->getPropertyAccessorInstance()->getValue($input, $andStatement['field']);
165			} catch (Exception $exception) {
166			throw new LogicalFieldValueException('Unable to locate logical statement field value.');
167			}
168
169			if (!isset($value)) {
170			throw new LogicalFieldValueException('Unable to locate logical statement field value.');
171			}
172
173			if (!$this->executeLogicStatement($andStatement['method'], $value, $andStatement['expected'])) {
174			unset($this->tempResults[$key]);
175			}
176			}
177			}
178
179			$this->mergeResults($this->tempResults);
180			}
181
182			return $this;
183			}
184
185			}

bradcornford / Logical

Push — v1.3.0 ( 18cd08 )

Logical::decodeLogicStatements() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like