Merge branch '2.0'

Author: mtdowling

CHANGELOG.md

@@ -0,0 +1,28 @@
+# CHANGELOG
+
+## 2.0.0 - 2014-01-11
+
+* Moving to a flattened namespace structure.
+* Runtimes are now only PHP callables.
+* Fixed an error in the way empty JSON literals are parsed so that they now
+  return an empty string to match the Python and JavaScript implementations.
+* Removed functions from runtimes. Instead there is now a function dispatcher
+  class, FnDispatcher, that provides function implementations behind a single
+  dispatch function.
+* Removed ExprNode in lieu of just using a PHP callable with bound variables.
+* Removed debug methods from runtimes and instead into a new Debugger class.
+* Heavily cleaned up function argument validation.
+* Slice syntax is now properly validated (i.e., colons are followed by the
+  appropriate value).
+* Lots of code cleanup and performance improvements.
+* Added a convenient `JmesPath\search()` function.
+* **IMPORTANT**: Relocating the project to https://github.com/jmespath/jmespath.php
+
+## 1.1.1 - 2014-10-08
+
+* Added support for using ArrayAccess and Countable as arrays and objects.
+
+## 1.1.0 - 2014-08-06
+
+* Added the ability to search data returned from json_decode() where JSON
+  objects are returned as stdClass objects.

CHANGELOG.rst

@@ -22,7 +22,7 @@ using the ``mtdowling/jmespath.php`` package.
         ]
     ];
 
-    \JmesPath\Env::search($expression, $data);
+    JmesPath\search($expression, $data);
     // Returns: [1, 2, 3]
 
 - `JMESPath documentation <http://jmespath.readthedocs.org/en/latest/>`_
@@ -32,26 +32,26 @@ using the ``mtdowling/jmespath.php`` package.
 PHP Usage
 =========
 
-The ``JmesPath\Env::search`` function can be used in most cases when using the
+The ``JmesPath\search`` function can be used in most cases when using the
 library. This function utilizes a JMESPath runtime based on your environment.
 The runtime utilized can be configured using environment variables and may at
 some point in the future automatically utilize a C extension if available.
 
 .. code-block:: php
 
-    $result = \JmesPath\Env::search($expression, $data);
+    $result = JmesPath\search($expression, $data);
+
+    // or, if you require PSR-4 compliance.
+    $result = JmesPath\Env::search($expression, $data);
 
 Runtimes
 --------
 
 jmespath.php utilizes *runtimes*. There are currently two runtimes:
 AstRuntime and CompilerRuntime.
 
-AstRuntime is utilized by ``JmesPath\Env::search()`` by default. Depending on
-your application, it may be useful to customize the runtime used by
-``JmesPath\Env::search()``. You can change the runtime utilized by
-``JmesPath\Env::search()`` by calling ``JmesPath\registerRuntime()``, passing in an
-instance of ``JmesPath\Runtime\RuntimeInterface``.
+AstRuntime is utilized by ``JmesPath\search()`` and ``JmesPath\Env::search()``
+by default.
 
 AstRuntime
 ~~~~~~~~~~
@@ -61,10 +61,16 @@ and interpret the AST using an external tree visitor. AstRuntime provides a
 good general approach for interpreting JMESPath expressions that have a low to
 moderate level of reuse.
 
+.. code-block:: php
+
+    $runtime = new JmesPath\AstRuntime();
+    $runtime('foo.bar', ['foo' => ['bar' => 'baz']]);
+    // > 'baz'
+
 CompilerRuntime
 ~~~~~~~~~~~~~~~
 
-``JmesPath\Runtime\CompilerRuntime`` provides the most performance for
+``JmesPath\CompilerRuntime`` provides the most performance for
 applications that have a moderate to high level of reuse of JMESPath
 expressions. The CompilerRuntime will walk a JMESPath AST and emit PHP source
 code, resulting in anywhere from 7x to 60x speed improvements.
@@ -80,10 +86,17 @@ Use the CompilerRuntime if you know that you will be executing JMESPath
 expressions more than once or if you can pre-compile JMESPath expressions
 before executing them (for example, server-side applications).
 
+.. code-block:: php
+
+    // Note: The cache directory argument is optional.
+    $runtime = new JmesPath\CompilerRuntime('/path/to/compile/folder');
+    $runtime('foo.bar', ['foo' => ['bar' => 'baz']]);
+    // > 'baz'
+
 Environment Variables
 ^^^^^^^^^^^^^^^^^^^^^
 
-You can utilize the CompilerRuntime in ``JmesPath\Env::search()`` by setting
+You can utilize the CompilerRuntime in ``JmesPath\search()`` by setting
 the ``JP_PHP_COMPILE`` environment variable to "on" or to a directory
 on disk used to store cached expressions.
 

README.rst

@@ -1,6 +1,9 @@
 #!/usr/bin/env php
 <?php
-require 'vendor/autoload.php';
+require __DIR__ . '/../vendor/autoload.php';
+
+use JmesPath\Env;
+use JmesPath\DebugRuntime;
 
 $description = <<<EOT
 Runs a JMESPath expression on the provided input or a test case.
@@ -13,10 +16,8 @@
 
 EOT;
 
-// Parse the provided arguments
-$args = array();
+$args = [];
 $currentKey = null;
-
 for ($i = 1, $total = count($argv); $i < $total; $i++) {
     if ($i % 2) {
         if (substr($argv[$i], 0, 2) == '--') {
@@ -31,21 +32,17 @@
 }
 
 $expression = $currentKey;
-$runtime = \JmesPath\Env::createRuntime();
 
 if (isset($args['file']) || isset($args['suite']) || isset($args['case'])) {
-
     if (!isset($args['file']) || !isset($args['suite']) || !isset($args['case'])) {
         die($description);
     }
-
     // Manually run a compliance test
     $path = realpath($args['file']);
     file_exists($path) or die('File not found at ' . $path);
     $json = json_decode(file_get_contents($path), true);
     $set = $json[$args['suite']];
     $data = $set['given'];
-
     if (!isset($expression)) {
         $expression = $set['cases'][$args['case']]['expression'];
         echo "Expects\n=======\n";
@@ -57,12 +54,12 @@
             echo "NULL\n\n";
         }
     }
-
 } elseif (isset($expression)) {
     // Pass in an expression and STDIN as a standalone argument
     $data = json_decode(stream_get_contents(STDIN), true);
 } else {
     die($description);
 }
 
-$runtime->debug($expression, $data);
+$runtime = new DebugRuntime(Env::createRuntime());
+$runtime($expression, $data);

bin/jp.php

@@ -1,36 +1,19 @@
 #!/usr/bin/env php
 <?php
-require 'vendor/autoload.php';
-
-use JmesPath\Runtime\RuntimeInterface;
-
-$runtime = \JmesPath\Env::createRuntime();
-
-if (!isset($_SERVER['CACHE'])) {
-    $_SERVER['CACHE'] = false;
-}
-
-if (isset($argv[1])) {
-    $dir = $argv[1];
-} else {
-    $dir = __DIR__ . '/../tests/compliance/perf';
-}
+require __DIR__ . '/../vendor/autoload.php';
 
+$dir = isset($argv[1]) ? $argv[1] : __DIR__ . '/../tests/compliance/perf';
 is_dir($dir) or die('Dir not found: ' . $dir);
-
 // Warm up the runner
-$runtime->search('abcdefg', array());
+\JmesPath\Env::search('foo', []);
 
 $total = 0;
 foreach (glob($dir . '/*.json') as $file) {
-    if (!strpos($file, 'syntax')) {
-        $total += runSuite($file, $runtime);
-    }
+    $total += runSuite($file);
 }
+echo "\nTotal time: {$total}\n";
 
-echo "\nTotal time: {$total}ms\n";
-
-function runSuite($file, RuntimeInterface $runtime)
+function runSuite($file)
 {
     $contents = file_get_contents($file);
     $json = json_decode($contents, true);
@@ -40,43 +23,37 @@ function runSuite($file, RuntimeInterface $runtime)
             $total += runCase(
                 str_replace(getcwd(), '.', $file),
                 $suite['given'],
-                $case['expression'],
-                $runtime
+                $case['expression']
             );
         }
     }
-
     return $total;
 }
 
-function runCase(
-    $file,
-    $given,
-    $expression,
-    RuntimeInterface $runtime
-) {
+function runCase($file, $given, $expression)
+{
     $best = 99999;
+    $runtime = \JmesPath\Env::createRuntime();
 
     for ($i = 0; $i < 1000; $i++) {
-        if (!$_SERVER['CACHE']) {
-            $runtime->clearCache();
-        }
-        try {
-            $t = microtime(true);
-            $runtime->search($expression, $given);
-            $tryTime = (microtime(true) - $t) * 1000;
-        } catch (\Exception $e) {
-            // Failure test cases shouldn't be tested
-            return 0;
-        }
+        $t = microtime(true);
+        $runtime($expression, $given);
+        $tryTime = (microtime(true) - $t) * 1000;
         if ($tryTime < $best) {
             $best = $tryTime;
         }
+        if (!getenv('CACHE')) {
+            $runtime = \JmesPath\Env::createRuntime();
+            // Delete compiled scripts if not caching.
+            if ($runtime instanceof \JmesPath\CompilerRuntime) {
+                array_map('unlink', glob(sys_get_temp_dir() . '/jmespath_*.php'));
+            }
+        }
     }
 
-    $template = "time: %fms, description: %s, name: %s\n";
+    $template = "time: %fms, %s: %s\n";
     $expression = str_replace("\n", '\n', $expression);
-    printf($template, $best, $file, $expression);
+    printf($template, $best, basename($file), substr($expression, 0, 50));
 
     return $best;
 }

bin/perf.php

@@ -23,14 +23,15 @@
   "autoload": {
     "psr-4": {
       "JmesPath\\": "src/"
-    }
+    },
+    "files": ["src/JmesPath.php"]
   },
 
   "bin": ["bin/jp.php"],
 
   "extra": {
     "branch-alias": {
-      "dev-master": "1.1-dev"
+      "dev-master": "2.0-dev"
     }
   }
 }

composer.json

@@ -0,0 +1,47 @@
+<?php
+namespace JmesPath;
+
+/**
+ * Uses an external tree visitor to interpret an AST.
+ */
+class AstRuntime
+{
+    private $parser;
+    private $interpreter;
+    private $cache = [];
+    private $cachedCount = 0;
+
+    public function __construct(
+        Parser $parser = null,
+        callable $fnDispatcher = null
+    ) {
+        $fnDispatcher = $fnDispatcher ?: FnDispatcher::getInstance();
+        $this->interpreter = new TreeInterpreter($fnDispatcher);
+        $this->parser = $parser ?: new Parser();
+    }
+
+    /**
+     * 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|null Returns the matching data or null
+     */
+    public function __invoke($expression, $data)
+    {
+        if (!isset($this->cache[$expression])) {
+            // Clear the AST cache when it hits 1024 entries
+            if (++$this->cachedCount > 1024) {
+                $this->cache = [];
+                $this->cachedCount = 0;
+            }
+            $this->cache[$expression] = $this->parser->parse($expression);
+        }
+
+        return $this->interpreter->visit($this->cache[$expression], $data);
+    }
+}