feat: implement feature parity with jsonpath-js 0.2.0

Author: loilo

.prettierignore

@@ -1,3 +1,4 @@
 composer.lock
 package-lock.json
-src/PeggyParser.php
+src/PeggyParser.php
+readme.md

composer.json

@@ -32,9 +32,12 @@
             "src/parsers/root.php",
             "src/parsers/filter-selector.php",
             "src/types/nothing.php",
+            "src/types/node.php",
             "src/PeggyParser.php",
             "src/parser.php",
             "src/JsonPath.php",
+            "src/utils/enumerate-node.php",
+            "src/utils/escape-member-name.php",
             "src/utils/is-equal.php",
             "src/utils/traverse-descendant.php",
             "src/utils/helpers.php",

readme.md

@@ -27,7 +27,7 @@ Note that at least PHP 8.0 is needed to use jsonpath-php. For technical reasons,
 ## Usage
 
 ```php
-use Loilo\JSONPath\JsonPath;
+use Loilo\JsonPath\JsonPath;
 
 $query = new JsonPath('$.users[*].name');
 

src/JsonPath.php

@@ -16,6 +16,18 @@ public function __construct(private $query)
 	public function find($json)
 	{
 		$result_node_list = run($json, $this->root_node);
-		return $result_node_list;
+		return array_map(fn(Node $node) => $node->value, $result_node_list);
+	}
+
+	public function paths($json)
+	{
+		$result_node_list = run($json, $this->root_node);
+		return array_map(
+			fn(Node $node) => [
+				'value' => $node->value,
+				'path' => $node->path,
+			],
+			$result_node_list,
+		);
 	}
 }

src/functions/function-definitions.php

@@ -25,12 +25,15 @@ public function convert($arg)
 		if (is_json_primitive($arg)) {
 			return $arg;
 		}
-		if (is_json_array($arg)) {
+		if (is_node($arg)) {
+			return $arg->value;
+		}
+		if (is_node_list($arg)) {
 			if (sizeof($arg) === 0) {
 				return nothing();
 			}
 			if (sizeof($arg) === 1) {
-				return $arg[0];
+				return $arg[0]->value;
 			}
 		}
 
@@ -51,7 +54,7 @@ public function get_type(): string
 
 	public function convert($arg)
 	{
-		if (is_json_array($arg)) {
+		if (is_node_list($arg)) {
 			return $arg;
 		}
 

src/functions/length.php

@@ -36,7 +36,7 @@ function ($node) {
 
 				// If the argument value is an object, the result is the number of members in the object.
 				if (is_json_object($node)) {
-					return sizeof(get_object_vars($node));
+					return sizeof(is_array($node) ? $node : get_object_vars($node));
 				}
 
 				// For any other argument value, the result is the special result Nothing.

src/functions/value.php

@@ -23,7 +23,7 @@ function ($nodes) {
 				// Its only argument is an instance of NodesType (possibly taken from a filter-query, as in the example above). The result is an instance of ValueType.
 				// If the argument contains a single node, the result is the value of the node.
 				if (sizeof($nodes) === 1) {
-					return $nodes[0];
+					return $nodes[0]->value;
 				}
 
 				// If the argument is the empty nodelist or contains multiple nodes, the result is Nothing.

src/parser.php

@@ -4,6 +4,6 @@
 
 function run($json, $query): array
 {
-	$root_node = $json;
+	$root_node = create_node($json, '$');
 	return apply_root($query, $root_node);
 }

src/parsers/array-slice-selector.php

@@ -7,18 +7,18 @@
 // It matches elements from arrays starting at index < start >
 // and ending at(but not including)<end>,
 // while incrementing by step with a default of 1.
-function apply_slice_selector($selector, $json)
+function apply_slice_selector($selector, Node $node)
 {
-	if (!is_json_array($json)) {
+	if (!is_json_array($node->value)) {
 		return [];
 	}
 
 	$step = $selector->step ?? 1;
-	$start = $selector->start ?? ($step >= 0 ? 0 : sizeof($json) - 1);
-	$end = $selector->end ?? ($step >= 0 ? sizeof($json) : -sizeof($json) - 1);
+	$start = $selector->start ?? ($step >= 0 ? 0 : sizeof($node->value) - 1);
+	$end = $selector->end ?? ($step >= 0 ? sizeof($node->value) : -sizeof($node->value) - 1);
 	$array = [];
 
-	[$lower, $upper] = bounds($start, $end, $step, sizeof($json));
+	[$lower, $upper] = bounds($start, $end, $step, sizeof($node->value));
 
 	// IF step > 0 THEN
 	//
@@ -39,11 +39,11 @@ function apply_slice_selector($selector, $json)
 	// END IF
 	if ($step > 0) {
 		for ($i = $lower; $i < $upper; $i += $step) {
-			$array[] = $json[$i];
+			$array[] = add_index_path($node, $node->value[$i], $i);
 		}
 	} elseif ($step < 0) {
 		for ($i = $upper; $lower < $i; $i += $step) {
-			$array[] = $json[$i];
+			$array[] = add_index_path($node, $node->value[$i], $i);
 		}
 	}
 

src/parsers/filter-selector.php

@@ -2,37 +2,37 @@
 
 namespace Loilo\JsonPath;
 
-function apply_filter_selector($selector, $root_node, $json)
+function apply_filter_selector($selector, $root_node, Node $node)
 {
 	// The filter selector works with arrays and objects exclusively.
 	// Its result is a list of(zero, one, multiple, or all)
 	// their array elements or member values, respectively.
 	// Applied to a primitive value,
 	// it selects nothing(and therefore does not contribute to the result of the filter selector).
-	if (is_json_primitive($json)) {
+	if (is_json_primitive($node->value)) {
 		return [];
 	}
 
-	return Array\filter(to_array($json), function ($item) use ($selector, $root_node) {
-		return apply_filter_expression($selector->expr, $root_node, $item);
+	return Array\filter(enumerate_node($node), function (Node $node) use ($selector, $root_node) {
+		return apply_filter_expression($selector->expr, $root_node, $node);
 	});
 }
 
-function apply_filter_expression($expr, $root_node, $json)
+function apply_filter_expression($expr, $root_node, Node $node)
 {
 	$exp_type = $expr->type;
 	return match ($exp_type) {
-		'ComparisonExpr' => apply_compare($expr, $root_node, $json),
-		'TestExpr' => apply_test($expr, $root_node, $json),
-		'LogicalBinary', 'LogicalUnary' => apply_logical($expr, $root_node, $json),
+		'ComparisonExpr' => apply_compare($expr, $root_node, $node),
+		'TestExpr' => apply_test($expr, $root_node, $node),
+		'LogicalBinary', 'LogicalUnary' => apply_logical($expr, $root_node, $node),
 		default => throw new \Exception("Unexpected expression type: $exp_type"),
 	};
 }
 
-function apply_compare($compare, $root_node, $json)
+function apply_compare($compare, $root_node, Node $node)
 {
-	$left = apply_comparable($compare->left, $root_node, $json);
-	$right = apply_comparable($compare->right, $root_node, $json);
+	$left = apply_comparable($compare->left, $root_node, $node);
+	$right = apply_comparable($compare->right, $root_node, $node);
 
 	return eval_compare($left, $right, $compare->operator);
 }
@@ -86,33 +86,33 @@ function apply_current_node($current_node, $root_node, $node_list)
 	return apply_segments($current_node->segments, $root_node, $node_list);
 }
 
-function apply_comparable($comparable, $root_node, $json)
+function apply_comparable($comparable, $root_node, Node $node)
 {
 	// These can be obtained via literal values; singular queries,
 	// each of which selects at most one node
 	return match ($comparable->type) {
 		'Literal' => $comparable->member,
 		'CurrentNode' => array_key_exists(
 			0,
-			$result = apply_current_node($comparable, $root_node, [$json]),
+			$result = apply_current_node($comparable, $root_node, [$node]),
 		)
-			? $result[0]
+			? $result[0]->value
 			: nothing(),
-		'Root' => apply_root($comparable, $root_node)[0] ?? nothing(),
-		'FunctionExpr' => apply_function($comparable, $root_node, $json),
+		'Root' => apply_root($comparable, $root_node)[0]?->value ?? nothing(),
+		'FunctionExpr' => apply_function($comparable, $root_node, $node),
 	};
 }
 
-function apply_test($expr, $root_node, $json)
+function apply_test($expr, $root_node, Node $node)
 {
-	return apply_query($expr->query, $root_node, $json);
+	return apply_query($expr->query, $root_node, $node);
 }
 
-function apply_query($query, $root_node, $json)
+function apply_query($query, $root_node, Node $node)
 {
 	switch ($query->type) {
 		case 'FunctionExpr':
-			$function_result = apply_function($query, $root_node, $json);
+			$function_result = apply_function($query, $root_node, $node);
 
 			// LogicalType
 			if ($function_result === LogicalType::true()) {
@@ -129,40 +129,40 @@ function apply_query($query, $root_node, $json)
 			// ValueType
 			throw new \Exception("Function {$query->name} result must be compared");
 		case 'CurrentNode':
-			return sizeof(apply_current_node($query, $root_node, [$json])) > 0;
+			return sizeof(apply_current_node($query, $root_node, [$node])) > 0;
 		case 'Root':
 			return sizeof(apply_root($query, $root_node)) > 0;
 	}
 
 	return false;
 }
 
-function apply_logical($expr, $root_node, $json)
+function apply_logical($expr, $root_node, Node $node)
 {
 	return match ($expr->operator) {
-		'||' => apply_or($expr, $root_node, $json),
-		'&&' => apply_and($expr, $root_node, $json),
-		'!' => apply_not($expr, $root_node, $json),
+		'||' => apply_or($expr, $root_node, $node),
+		'&&' => apply_and($expr, $root_node, $node),
+		'!' => apply_not($expr, $root_node, $node),
 	};
 }
 
-function apply_or($or, $root_node, $json)
+function apply_or($or, $root_node, Node $node)
 {
 	// TODO: make efficient
-	$left = apply_filter_expression($or->left, $root_node, $json);
-	$right = apply_filter_expression($or->right, $root_node, $json);
+	$left = apply_filter_expression($or->left, $root_node, $node);
+	$right = apply_filter_expression($or->right, $root_node, $node);
 	return $left || $right;
 }
 
-function apply_and($and, $root_node, $json)
+function apply_and($and, $root_node, Node $node)
 {
-	$left = apply_filter_expression($and->left, $root_node, $json);
-	$right = apply_filter_expression($and->right, $root_node, $json);
+	$left = apply_filter_expression($and->left, $root_node, $node);
+	$right = apply_filter_expression($and->right, $root_node, $node);
 	return $left && $right;
 }
 
-function apply_not($not, $root_node, $json)
+function apply_not($not, $root_node, Node $node)
 {
-	$result = apply_filter_expression($not->expr, $root_node, $json);
+	$result = apply_filter_expression($not->expr, $root_node, $node);
 	return !$result;
 }