Code Coverage for /var/www/collections/src/Easy/Collections/Linq/Expr/ClosureExpressionVisitor.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total		0.00%	0 / 1		0.00%	0 / 8	CRAP		0.00%	0 / 116
ClosureExpressionVisitor		0.00%	0 / 1		0.00%	0 / 8	1332		0.00%	0 / 116
getObjectFieldValue($object, $field)					0.00%	0 / 1	42		0.00%	0 / 19
sortByField($name, $orientation = 1, \Closure $next = null)					0.00%	0 / 1	20		0.00%	0 / 15
anonymous function ($object) use ($expressions)					0.00%	0 / 1	12		0.00%	0 / 7
walkComparison(Comparison $comparison)					0.00%	0 / 1	156		0.00%	0 / 43
walkValue(Value $value)					0.00%	0 / 1	2		0.00%	0 / 4
walkCompositeExpression(CompositeExpression $expr)					0.00%	0 / 1	20		0.00%	0 / 15
andExpressions($expressions)					0.00%	0 / 1	12		0.00%	0 / 10
orExpressions($expressions)					0.00%	0 / 1	12		0.00%	0 / 2

1	<?php
2
3	// Copyright (c) Lellys Informática. All rights reserved. See License.txt in the project root for license information.
4
5	namespace Easy\Collections\Linq\Expr;
6
7	/**
8	* Walks an expression graph and turns it into a PHP closure.
9	*
10	* This closure can be used with {@Collection#filter()} and is used internally
11	* by {@ArrayCollection#select()}.
12	*
13	* @author Benjamin Eberlei <kontakt@beberlei.de>
14	* @since 2.3
15	*/
16	class ClosureExpressionVisitor extends ExpressionVisitor
17	{
18
19	/**
20	* Accesses the field of a given object. This field has to be public
21	* directly or indirectly (through an accessor get, is, or a magic
22	* method, __get, __call).
23	*
24	* @param object $object
25	* @param string $field
26	*
27	* @return mixed
28	*/
29	public static function getObjectFieldValue($object, $field)
30	{
31	$accessors = array('get', 'is');
32
33	foreach ($accessors as $accessor) {
34	$accessor .= $field;
35
36	if (!method_exists($object, $accessor)) {
37	continue;
38	}
39
40	return $object->$accessor();
41	}
42
43	// __call should be triggered for get.
44	$accessor = $accessors[0] . $field;
45
46	if (method_exists($object, '__call')) {
47	return $object->$accessor();
48	}
49
50	if ($object instanceof \ArrayAccess \|\| is_array($object)) {
51	return $object[$field];
52	}
53
54	return $object->$field;
55	}
56
57	/**
58	* Helper for sorting arrays of objects based on multiple fields + orientations.
59	*
60	* @param string $name
61	* @param int $orientation
62	* @param \Closure $next
63	*
64	* @return \Closure
65	*/
66	public static function sortByField($name, $orientation = 1, \Closure $next = null)
67	{
68	if (!$next) {
69	$next = function() {
70	return 0;
71	};
72	}
73
74	return function ($a, $b) use ($name, $next, $orientation) {
75	$aValue = ClosureExpressionVisitor::getObjectFieldValue($a, $name);
76	$bValue = ClosureExpressionVisitor::getObjectFieldValue($b, $name);
77
78	if ($aValue === $bValue) {
79	return $next($a, $b);
80	}
81
82	return (($aValue > $bValue) ? 1 : -1) * $orientation;
83	};
84	}
85
86	/**
87	* {@inheritDoc}
88	*/
89	public function walkComparison(Comparison $comparison)
90	{
91	$field = $comparison->getField();
92	$value = $comparison->getValue()->getValue(); // shortcut for walkValue()
93
94	switch ($comparison->getOperator()) {
95	case Comparison::EQ:
96	return function ($object) use ($field, $value) {
97	return ClosureExpressionVisitor::getObjectFieldValue($object, $field) === $value;
98	};
99
100	case Comparison::NEQ:
101	return function ($object) use ($field, $value) {
102	return ClosureExpressionVisitor::getObjectFieldValue($object, $field) !== $value;
103	};
104
105	case Comparison::LT:
106	return function ($object) use ($field, $value) {
107	return ClosureExpressionVisitor::getObjectFieldValue($object, $field) < $value;
108	};
109
110	case Comparison::LTE:
111	return function ($object) use ($field, $value) {
112	return ClosureExpressionVisitor::getObjectFieldValue($object, $field) <= $value;
113	};
114
115	case Comparison::GT:
116	return function ($object) use ($field, $value) {
117	return ClosureExpressionVisitor::getObjectFieldValue($object, $field) > $value;
118	};
119
120	case Comparison::GTE:
121	return function ($object) use ($field, $value) {
122	return ClosureExpressionVisitor::getObjectFieldValue($object, $field) >= $value;
123	};
124
125	case Comparison::IN:
126	return function ($object) use ($field, $value) {
127	return in_array(ClosureExpressionVisitor::getObjectFieldValue($object, $field), $value);
128	};
129
130	case Comparison::NIN:
131	return function ($object) use ($field, $value) {
132	return !in_array(ClosureExpressionVisitor::getObjectFieldValue($object, $field), $value);
133	};
134
135	case Comparison::CONTAINS:
136	return function ($object) use ($field, $value) {
137	return false !== strpos(ClosureExpressionVisitor::getObjectFieldValue($object, $field), $value);
138	};
139
140	case Comparison::STARTS_WITH:
141	return function ($object) use ($field, $value) {
142	return strpos(ClosureExpressionVisitor::getObjectFieldValue($object, $field), $value) === 0;
143	};
144
145	case Comparison::ENDS_WITH:
146	return function ($object) use ($field, $value) {
147	$haystack = ClosureExpressionVisitor::getObjectFieldValue($object, $field);
148	return strpos($haystack, $value) + strlen($value) === strlen($haystack);
149	};
150
151	default:
152	throw new \RuntimeException("Unknown comparison operator: " . $comparison->getOperator());
153	}
154	}
155
156	/**
157	* {@inheritDoc}
158	*/
159	public function walkValue(Value $value)
160	{
161	return $value->getValue();
162	}
163
164	/**
165	* {@inheritDoc}
166	*/
167	public function walkCompositeExpression(CompositeExpression $expr)
168	{
169	$expressionList = array();
170
171	foreach ($expr->getExpressionList() as $child) {
172	$expressionList[] = $this->dispatch($child);
173	}
174
175	switch ($expr->getType()) {
176	case CompositeExpression::TYPE_AND:
177	return $this->andExpressions($expressionList);
178
179	case CompositeExpression::TYPE_OR:
180	return $this->orExpressions($expressionList);
181
182	default:
183	throw new \RuntimeException("Unknown composite " . $expr->getType());
184	}
185	}
186
187	/**
188	* @param array $expressions
189	*
190	* @return callable
191	*/
192	private function andExpressions($expressions)
193	{
194	return function ($object) use ($expressions) {
195	foreach ($expressions as $expression) {
196	if (!$expression($object)) {
197	return false;
198	}
199	}
200	return true;
201	};
202	}
203
204	/**
205	* @param array $expressions
206	*
207	* @return callable
208	*/
209	private function orExpressions($expressions)
210	{
211	return function ($object) use ($expressions) {
212	foreach ($expressions as $expression) {
213	if ($expression($object)) {
214	return true;
215	}
216	}
217	return false;
218	};
219	}
220
221	}