jmespath.php/src/CompilerRuntime.php at master · jmespath/jmespath.php · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
<?php
namespaceJmesPath;

/**
 * Compiles JMESPath expressions to PHP source code and executes it.
 *
 * JMESPath file names are stored in the cache directory using the following
 * logic to determine the filename:
 *
 * 1. Start with the string "jmespath_"
 * 2. Append the MD5 checksum of the expression salted with the PHP version
 * and compiled-cache epoch.
 * 3. Append ".php"
 */
class CompilerRuntime
{
constCACHE_VERSION = 5;

private$parser;
private$compiler;
private$cacheDir;
private$interpreter;

/**
 * @param string|null $dir Directory used to store compiled PHP files.
 * @param Parser|null $parser JMESPath parser to utilize
 * @throws \RuntimeException if the cache directory cannot be created
 */
publicfunction__construct($dir = null, ?Parser$parser = null)
 {
$this->parser = $parser ?: newParser();
$this->compiler = newTreeCompiler();
$dir = $dir ?: sys_get_temp_dir();

if (!is_dir($dir) && !mkdir($dir, 0755, true)) {
thrownew \RuntimeException("Unable to create cache directory: $dir");
 }

$this->cacheDir = realpath($dir);
$this->interpreter = newTreeInterpreter();
 }

/**
 * Returns data from the provided input that matches a given JMESPath
 * expression.
 *
 * @param string $expression JMESPath expression to evaluate
 * @param mixed $data Data to search. This data should be data that
 * is similar to data returned from json_decode
 * using associative arrays rather than objects.
 *
 * @return mixed Returns the matching data or null
 * @throws \RuntimeException
 */
publicfunction__invoke($expression, $data)
 {
$functionName = self::functionName($expression);

if (!function_exists($functionName)) {
$filename = "{$this->cacheDir}/{$functionName}.php";
if (!file_exists($filename)) {
$this->compile($filename, $expression, $functionName);
 }
require$filename;
 }

return$functionName($this->interpreter, $data);
 }

/**
 * @internal Shared with DebugRuntime so cache naming cannot drift.
 */
publicstaticfunctionfunctionName($expression)
 {
return'jmespath_' . md5(
'jmespath:' . PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION
 . ':' . self::CACHE_VERSION . ':' . $expression
 );
 }

/** @internal */
publicfunctiongetCacheDir()
 {
return$this->cacheDir;
 }

privatefunctioncompile($filename, $expression, $functionName)
 {
$code = $this->compiler->visit(
$this->parser->parse($expression),
$functionName,
$expression
 );

$tempFile = $filename . '.' . bin2hex(random_bytes(12)) . '.tmp';

if (!file_put_contents($tempFile, $code)) {
thrownew \RuntimeException(sprintf(
'Unable to write the compiled PHP code to: %s (%s)',
$tempFile,
var_export(error_get_last(), true)
 ));
 }

if (!rename($tempFile, $filename)) {
 @unlink($tempFile);
if (!file_exists($filename)) {
thrownew \RuntimeException(
"Unable to move the compiled PHP code to: {$filename}"
 );
 }
// Another process won the race; its file is equivalent.
 } elseif (function_exists('opcache_invalidate')) {
opcache_invalidate($filename, true);
 }
 }
}