Merge pull request #51 from thatportugueseguy/add-value-iterator

Add value iterator

Author: davesnx

source/Ast.ml

@@ -32,7 +32,8 @@ type expression =
   (* Objects *)
   | Walk of expression (* walk() *)
   | Transpose of expression (* transpose() *)
-  | Key of string * bool (* .foo *)
+  | Key of string (* .foo *)
+  | Optional of expression (* ? *)
   | Has of expression (* has(x) *)
   | Keys (* keys *)
   | Floor (* floor *)
@@ -58,6 +59,7 @@ type expression =
   | IsNan
   (* Array *)
   | Index of int (* .[1] *)
+  | Iterator (* .[] *)
   | Range of int * int option * int option (* range(1, 10) *)
   | Flatten (* flatten *)
   | Head (* head *)

source/Compiler.ml

@@ -229,15 +229,13 @@ let make_error_missing_member op key (value : Json.t) =
   ^ ":" ^ Formatting.enter 1
   ^ Chalk.gray (Json.to_string value ~colorize:false ~summarize:true)
 
-let member (key : string) (opt : bool) (json : Json.t) =
+let member (key : string) (json : Json.t) =
   match json with
   | `Assoc _assoc -> (
       let access_member = Json.member key json in
-      match (access_member, opt) with
-      | `Null, true -> Output.return access_member
-      | `Null, false -> Error (make_error_missing_member ("." ^ key) key json)
-      | _, false -> Output.return access_member
-      | _, true -> Output.return access_member)
+      match access_member with
+      | `Null -> Error (make_error_missing_member ("." ^ key) key json)
+      | _ -> Output.return access_member)
   | _ -> Error (make_error ("." ^ key) json)
 
 let index (value : int) (json : Json.t) =
@@ -288,13 +286,25 @@ let slice (start : int option) (finish : int option) (json : Json.t) =
            ("[" ^ string_of_int start ^ ":" ^ string_of_int finish ^ "]")
            json)
 
+let iterator (json : Json.t) =
+  match json with
+  | `List [] -> empty
+  | `List items -> Ok items
+  | `Assoc obj -> Ok (List.map snd obj)
+  | _ -> Error (make_error "[]" json)
+
 let rec compile expression json : (Json.t list, string) result =
   match expression with
   | Identity -> Output.return json
   | Empty -> empty
   | Keys -> keys json
-  | Key (key, opt) -> member key opt json
+  | Key key -> member key json
+  | Optional expr -> (
+      match compile expr json with
+      | Ok values -> Ok values (* If successful, return the values *)
+      | Error _ -> Output.return `Null)
   | Index idx -> index idx json
+  | Iterator -> iterator json
   | Slice (start, finish) -> slice start finish json
   | Head -> head json
   | Tail -> tail json
@@ -392,7 +402,7 @@ and handle_objects list json =
           r
       | Literal (String key), Some right_expr -> (
           match right_expr with
-          | Key (search_val, _) -> (
+          | Key search_val -> (
               match json with
               | `Assoc l -> (
                   match List.assoc_opt search_val l with

source/Parser.mly

@@ -123,7 +123,7 @@ term:
   | NULL
     { Literal(Null) }
   | RANGE; OPEN_PARENT; nl = separated_nonempty_list(SEMICOLON, NUMBER); CLOSE_PARENT;
-    { 
+    {
       let nl = List.map int_of_float nl in
       match nl with
       | [] -> assert false (* nonempty_list *)
@@ -217,7 +217,7 @@ term:
   // List elements are item_expr, not sequence_expr, separated by COMMA
   | e = delimited(OPEN_BRACKET, separated_nonempty_list(COMMA, item_expr), CLOSE_BRACKET);
     { List e }
-  
+
   | OPEN_BRACE; CLOSE_BRACE;
     { Object [] }
 
@@ -230,6 +230,14 @@ term:
   | e = term; OPEN_BRACKET; i = number; CLOSE_BRACKET
     { Pipe (e, Index (int_of_float i)) }
 
+  /* Iterator: .[] */
+  | e = term; OPEN_BRACKET; CLOSE_BRACKET
+    { Pipe (e, Iterator) }
+
+  /* Optiona iterator: .[]? */
+  | e = term; OPEN_BRACKET; CLOSE_BRACKET; QUESTION_MARK
+    { Pipe (e, Optional (Iterator)) }
+
   /* Full slice with both indices: .[1:5] */
   | e = term; OPEN_BRACKET; start = number; COLON; end_ = number; CLOSE_BRACKET
     { Pipe (e, Slice (Some (int_of_float start), Some (int_of_float end_))) }
@@ -243,16 +251,18 @@ term:
     { Pipe (e, Slice (None, Some (int_of_float end_))) }
 
   | DOT; k = STRING; opt = boption(QUESTION_MARK)
-    { Key (k, opt) }
-
-  | e = term; DOT; k = STRING; opt = boption(QUESTION_MARK)
-    { Pipe (e, Key (k, opt)) }
-
   | DOT; k = IDENTIFIER; opt = boption(QUESTION_MARK)
-    { Key (k, opt) }
+    { match opt with
+      | true -> Optional (Key k)
+      | false -> Key k
+    }
 
+  | e = term; DOT; k = STRING; opt = boption(QUESTION_MARK)
   | e = term; DOT; k = IDENTIFIER; opt = boption(QUESTION_MARK)
-    { Pipe (e, Key (k, opt)) }
+    { match opt with
+      | true -> Pipe (e, Optional (Key k))
+      | false -> Pipe (e, Key k)
+    }
 
   | IF; cond = item_expr; THEN e1 = term; elifs = list(elif_term) ELSE; e2 = term; END
     {

test/Test_parse.ml

@@ -22,20 +22,17 @@ let tests =
     case ".[-1]" (Pipe (Identity, Index (-1)));
     case ".[1]" (Pipe (Identity, Index 1));
     case "[1]" (List [ Literal (Number 1.) ]);
-    case ".store.books" (Pipe (Key ("store", false), Key ("books", false)));
-    case ".books[1]" (Pipe (Key ("books", false), Index 1));
-    case ".books[1].author"
-      (Pipe (Pipe (Key ("books", false), Index 1), Key ("author", false)));
-    case ".store" (Key ("store", false));
+    case ".store.books" (Pipe (Key "store", Key "books"));
+    case ".books[1]" (Pipe (Key "books", Index 1));
+    case ".books[1].author" (Pipe (Pipe (Key "books", Index 1), Key "author"));
+    case ".store" (Key "store");
     case "." Identity;
-    case ".store | .books" (Pipe (Key ("store", false), Key ("books", false)));
+    case ".store | .books" (Pipe (Key "store", Key "books"));
     case ". | map(.price + 1)"
-      (Pipe
-         ( Identity,
-           Map (Operation (Key ("price", false), Add, Literal (Number 1.))) ));
-    case ".WAT" (Key ("WAT", false));
+      (Pipe (Identity, Map (Operation (Key "price", Add, Literal (Number 1.)))));
+    case ".WAT" (Key "WAT");
     case "head" Head;
-    case ".WAT?" (Key ("WAT", true));
+    case ".WAT?" (Optional (Key "WAT"));
     case "1, 2" (Comma (Literal (Number 1.), Literal (Number 2.)));
     case "empty" Empty;
     case "(1, 2) + 3"
@@ -51,12 +48,17 @@ let tests =
     case "[1, 2]" (List [ Literal (Number 1.); Literal (Number 2.) ]);
     case "select(true)" (Select (Literal (Bool true)));
     case "[1][0]" (Pipe (List [ Literal (Number 1.) ], Index 0));
-    case "[1].foo" (Pipe (List [ Literal (Number 1.) ], Key ("foo", false)));
-    case "(empty).foo?" (Pipe (Empty, Key ("foo", true)));
+    case "[1].foo" (Pipe (List [ Literal (Number 1.) ], Key "foo"));
+    case "(empty).foo?" (Pipe (Empty, Optional (Key "foo")));
     case ".[1:3]" (Pipe (Identity, Slice (Some 1, Some 3)));
     case ".[1:]" (Pipe (Identity, Slice (Some 1, None)));
     case ".[:3]" (Pipe (Identity, Slice (None, Some 3)));
     case ".[-2:]" (Pipe (Identity, Slice (Some (-2), None)));
+    case ".[]" (Pipe (Identity, Iterator));
+    case ".foo[]" (Pipe (Key "foo", Iterator));
+    case ".foo[]?" (Pipe (Key "foo", Optional Iterator));
+    case ".foo?[]" (Pipe (Optional (Key "foo"), Iterator));
+    case ".foo?[]?" (Pipe (Optional (Key "foo"), Optional Iterator));
     case "{}" (Object []);
     case "{\"foo\": 42, bar: [\"hello world\", 42], user}"
       (Object

test/Test_runtime.ml

@@ -31,6 +31,9 @@ let tests =
     (* test "[{}]" "[2]" "[{}]"; *)
     (* test "[.[]]" "[\"a\"]" "[\"a\"]"; *)
 
+    test ".foo?" {|{"foo": 42}|} {|42|};
+    test ".foo?" {|{}|} "null";
+
     (* Array index tests *)
     test ".[0]" {|["a","b","c","d","e"]|} {|"a"|};
     test ".[3]" {|["a","b"]|} "null";
@@ -54,6 +57,12 @@ let tests =
     test ".[-4:-2]" {|"abcdefghi"|} {|"fg"|};
     test ".[-2:-4]" {|"abcde"|} {|""|};
 
+    (* Iterator tests *)
+    test ".[]" {|["a","b","c"]|} "\"a\"\n\"b\"\n\"c\"";
+    test ".[]" {|[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]|} "{ \"name\": \"JSON\", \"good\": true }\n{ \"name\": \"XML\", \"good\": false }";
+    test ".foo[]" {|{"foo":[1,2,3]}|} "1\n2\n3";
+    test ".[]" {|{"a": 1, "b": 1}|} "1\n1";
+
     test "1,1" "[]" "1\n1";
     test "1,." "[]" "1\n[]";
     test {|.foo | .bar|} {|{"foo": {"bar": 42}, "bar": "badvalue"}|} {|42|};

test/access.t

@@ -22,8 +22,25 @@ non defined field gives back null when "?"
   $ echo '{ "foo": { "bar": {} }}' | query-json '.foo.bar.baz?'
   null
 
+  $ echo '{}' | query-json '.foo'
+  
+  Error:  Trying to ".foo" on an object, that don't have the field "foo":
+  {}
+  
   $ echo '{ "foo": { "bar": {} }}' | query-json '.foo.bar.baz'
 
   Error:  Trying to ".baz" on an object, that don't have the field "baz":
   {}
 
+  $ echo '{"foo":[1,2,3]}' | query-json '.foo[]'
+  1
+  2
+  3
+
+  $ echo '{"foo":[1,2,3]}' | query-json '.fool[]'
+  
+  Error:  Trying to ".fool" on an object, that don't have the field "fool":
+  { "foo": ... }
+  
+  $ echo '{"foo":[1,2,3]}' | query-json '.fool?[]?'
+  null