|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
namespace Pinq\Queries\Builders; |
|
4
|
|
|
|
|
5
|
|
|
use Pinq\Expressions as O; |
|
6
|
|
|
use Pinq\PinqException; |
|
7
|
|
|
|
|
8
|
|
|
/** |
|
9
|
|
|
* Base class for expression interpreters. |
|
10
|
|
|
* |
|
11
|
|
|
* @author Elliot Levin <[email protected]> |
|
12
|
|
|
*/ |
|
13
|
|
|
abstract class ExpressionInterpreter |
|
14
|
|
|
{ |
|
15
|
|
|
/** |
|
16
|
|
|
* @var string |
|
17
|
|
|
*/ |
|
18
|
|
|
protected $idPrefix; |
|
19
|
|
|
|
|
20
|
|
|
/** |
|
21
|
|
|
* @var O\IEvaluationContext|null |
|
22
|
|
|
*/ |
|
23
|
|
|
protected $evaluationContext; |
|
24
|
|
|
|
|
25
|
|
|
public function __construct($idPrefix, O\IEvaluationContext $evaluationContext = null) |
|
26
|
|
|
{ |
|
27
|
|
|
$this->idPrefix = $idPrefix; |
|
28
|
|
|
$this->evaluationContext = $evaluationContext; |
|
29
|
|
|
} |
|
30
|
|
|
|
|
31
|
|
|
final protected function getId($id) |
|
32
|
|
|
{ |
|
33
|
|
|
return "{$this->idPrefix}-{$id}"; |
|
34
|
|
|
} |
|
35
|
|
|
|
|
36
|
|
|
final protected function getFunction($id, O\Expression $expression) |
|
37
|
|
|
{ |
|
38
|
|
|
if ($expression instanceof O\ClosureExpression) { |
|
39
|
|
|
return new Functions\ClosureExpressionFunction( |
|
40
|
|
|
$this->getId($id), $expression, $this->evaluationContext); |
|
41
|
|
|
} else { |
|
42
|
|
|
return new Functions\CallableFunction($this->getId($id), $expression->evaluate($this->evaluationContext)); |
|
43
|
|
|
} |
|
44
|
|
|
} |
|
45
|
|
|
|
|
46
|
|
|
final protected function getOptionalFunctionAt($name, $index, O\MethodCallExpression $expression) |
|
47
|
|
|
{ |
|
48
|
|
|
$argument = $this->getOptionalArgumentAt($index, $expression); |
|
49
|
|
|
|
|
50
|
|
|
if ($argument === null || ($argument instanceof O\ValueExpression && $argument->getValue() === null)) { |
|
51
|
|
|
return null; |
|
52
|
|
|
} |
|
53
|
|
|
|
|
54
|
|
|
return $this->getFunction("{$name}-{$index}", $argument); |
|
55
|
|
|
} |
|
56
|
|
|
|
|
57
|
|
|
final protected function getFunctionAt($name, $index, O\MethodCallExpression $expression) |
|
58
|
|
|
{ |
|
59
|
|
|
return $this->getFunction("{$name}-{$index}", $this->getArgumentAt($index, $expression)); |
|
60
|
|
|
} |
|
61
|
|
|
|
|
62
|
|
|
final protected function getArgumentValueAt($index, O\MethodCallExpression $methodExpression) |
|
63
|
|
|
{ |
|
64
|
|
|
$instance = new \stdClass(); |
|
65
|
|
|
|
|
66
|
|
|
$argument = $this->getOptionalArgumentValueAt($index, $methodExpression, $instance); |
|
67
|
|
|
|
|
68
|
|
|
if ($argument === $instance) { |
|
69
|
|
|
throw new PinqException( |
|
70
|
|
|
'Could not get argument value of method %s at index %d: argument not supplied', |
|
71
|
|
|
$methodExpression->getName()->compileDebug(), |
|
72
|
|
|
$index); |
|
73
|
|
|
} |
|
74
|
|
|
|
|
75
|
|
|
return $argument; |
|
76
|
|
|
} |
|
77
|
|
|
|
|
78
|
|
View Code Duplication |
final protected function getOptionalArgumentValueAt( |
|
|
|
|
|
|
79
|
|
|
$index, |
|
80
|
|
|
O\MethodCallExpression $methodExpression, |
|
81
|
|
|
$default = null |
|
82
|
|
|
) { |
|
83
|
|
|
$argumentExpression = $this->getOptionalArgumentAt($index, $methodExpression); |
|
84
|
|
|
|
|
85
|
|
|
if ($argumentExpression === null) { |
|
86
|
|
|
return $default; |
|
87
|
|
|
} |
|
88
|
|
|
|
|
89
|
|
|
return $argumentExpression->evaluate($this->evaluationContext); |
|
90
|
|
|
} |
|
91
|
|
|
|
|
92
|
|
View Code Duplication |
final protected function getArgumentAt($index, O\MethodCallExpression $methodExpression) |
|
|
|
|
|
|
93
|
|
|
{ |
|
94
|
|
|
$argumentExpression = $this->getOptionalArgumentAt($index, $methodExpression); |
|
95
|
|
|
|
|
96
|
|
|
if ($argumentExpression === null) { |
|
97
|
|
|
throw new PinqException( |
|
98
|
|
|
'Could not get argument at index %d of method %s: argument not supplied', |
|
99
|
|
|
$index, |
|
100
|
|
|
$methodExpression->getName()->compileDebug()); |
|
101
|
|
|
} |
|
102
|
|
|
|
|
103
|
|
|
return $argumentExpression; |
|
104
|
|
|
} |
|
105
|
|
|
|
|
106
|
|
|
final protected function getOptionalArgumentAt($index, O\MethodCallExpression $methodExpression) |
|
107
|
|
|
{ |
|
108
|
|
|
$argumentExpressions = $methodExpression->getArguments(); |
|
109
|
|
|
|
|
110
|
|
|
if (isset($argumentExpressions[$index])) { |
|
111
|
|
|
if ($argumentExpressions[$index]->isUnpacked()) { |
|
112
|
|
|
throw new PinqException( |
|
113
|
|
|
'Cannot get argument from method call %s at index %d: argument unpacking is not supported', |
|
114
|
|
|
$methodExpression->getName()->compileDebug(), |
|
115
|
|
|
$index); |
|
116
|
|
|
} |
|
117
|
|
|
|
|
118
|
|
|
return $argumentExpressions[$index]->getValue(); |
|
119
|
|
|
} else { |
|
120
|
|
|
return null; |
|
121
|
|
|
} |
|
122
|
|
|
} |
|
123
|
|
|
|
|
124
|
|
|
final protected function getMethodName(O\MethodCallExpression $methodExpression) |
|
125
|
|
|
{ |
|
126
|
|
|
return $this->getValue($methodExpression->getName()); |
|
127
|
|
|
} |
|
128
|
|
|
|
|
129
|
|
|
final protected function getValue(O\Expression $expression) |
|
130
|
|
|
{ |
|
131
|
|
|
return $expression->evaluate($this->evaluationContext); |
|
132
|
|
|
} |
|
133
|
|
|
|
|
134
|
|
|
/** |
|
135
|
|
|
* @param O\MethodCallExpression $methodExpression |
|
136
|
|
|
* |
|
137
|
|
|
* @return O\MethodCallExpression |
|
138
|
|
|
* @throws PinqException |
|
139
|
|
|
*/ |
|
140
|
|
|
final protected function getSourceMethodCall(O\MethodCallExpression $methodExpression) |
|
141
|
|
|
{ |
|
142
|
|
|
$sourceExpression = $methodExpression->getValue(); |
|
143
|
|
|
|
|
144
|
|
|
if (!($sourceExpression instanceof O\MethodCallExpression)) { |
|
145
|
|
|
throw new PinqException( |
|
146
|
|
|
'Cannot get source method call expression: source is not a method call, %s given', |
|
147
|
|
|
get_class($methodExpression)); |
|
148
|
|
|
} |
|
149
|
|
|
|
|
150
|
|
|
return $sourceExpression; |
|
151
|
|
|
} |
|
152
|
|
|
} |
|
153
|
|
|
|
TimeToogo /
Pinq
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.