Merge pull request #47 from ProgramingIsTheFuture/implementing_new_features

Improving the parser and implementing new features for query-json

Author: davesnx

README.md

@@ -124,21 +124,22 @@ The report shows that **query-json** is between 2x and 5x faster than **jq** in
 
 #### [Builtin operators and functions](https://stedolan.github.io/jq/manual/v1.6/#Builtinoperatorsandfunctions)
 
+  - Abs: `abs` ✅
   - Addition: `+` ✅
   - Subtraction: `-` ✅
   - Multiplication, division, modulo: `*`, `/`, and `%` ✅
   - `length` ✅
   - `keys` ✅
   - `map` ✅
   - `select` ✅
-  - `has(key)` ⚠️
-  - `in` ⚠️
+  - `has(key)` ✅
+  - `in` ✅
   - `path(path_expression)` ⚠️
   - `to_entries`, `from_entries`, `with_entries` ⚠️
   - `any`, `any(condition)`, `any(generator; condition)` ⚠️
   - `all`, `all(condition)`, `all(generator; condition)` ⚠️
   - `flatten` ✅
-  - `range(upto)`, `range(from;upto)` `range(from;upto;by)` ⚠️
+  - `range(upto)`, `range(from;upto)` `range(from;upto;by)` ✅
   - `floor`, `sqrt` ⚠️
   - `tonumber`, `tostring` ⚠️
   - `type` ⚠️
@@ -147,12 +148,12 @@ The report shows that **query-json** is between 2x and 5x faster than **jq** in
   - `group_by(path_expression)` ⚠️
   - `min, max, min_by(path_exp), max_by(path_exp)` ⚠️
   - `unique, unique_by(path_exp)` ⚠️
-  - `reverse` ⚠️
+  - `reverse` ✅
   - `contains(element)` ⚠️
   - `index(s), rindex(s)` ⚠️
   - `startswith(str)`, `endswith(str)` ⚠️
   - `explode`, `implode` ⚠️
-  - `split(str)`, `join(str)` ⚠️
+  - `split(str)`, `join(str)` ✅
   - `while(cond; update)`, `until(cond; next)` ⚠️
   - `recurse(f)`, `recurse`, `recurse(f; condition)`, `recurse_down` ⚠️
   - `walk(f)` ⚠️
@@ -161,7 +162,7 @@ The report shows that **query-json** is between 2x and 5x faster than **jq** in
 
 #### [Conditionals and Comparisons](https://stedolan.github.io/jq/manual/v1.6/#ConditionalsandComparisons)
   - `==`, `!=` ✅
-  - `if-then-else` ⚠️
+  - `if-then-else` ✅
   - `>`, `>=`, `<=`, `<` ✅
   - `and`, `or`, `not` ⚠️
   - `break` 🔴

source/Ast.ml

@@ -5,6 +5,21 @@ type literal =
   | Null (* null *)
 [@@deriving show { with_path = false }]
 
+type op =
+  | Add
+  | Sub
+  | Mult
+  | Div
+  | Eq
+  | Neq
+  | Gt (* > *)
+  | St (* < *)
+  | Ge (* >=*)
+  | Se (* <= *)
+  | And
+  | Or
+[@@deriving show { with_path = false }]
+
 type expression =
   | Identity (* . *)
   | Empty (* empty *)
@@ -13,7 +28,7 @@ type expression =
   | Literal of literal
   (* Constructors *)
   | List of expression list (* [ expr ] *)
-  | Object of (string * expression) list (* {} *)
+  | Object of (expression * expression option) list (* {} *)
   (* Objects *)
   | Walk of expression (* walk() *)
   | Transpose of expression (* transpose() *)
@@ -32,7 +47,7 @@ type expression =
   | Implode (* implode *)
   | Any (* any *)
   | All (* all *)
-  | In (* in *)
+  | In of expression (* in *)
   | Recurse (* recurse *)
   | RecurseDown (* recurse_down *)
   | ToEntries (* to_entries *)
@@ -43,7 +58,7 @@ type expression =
   | IsNan
   (* Array *)
   | Index of int (* .[1] *)
-  | Range of int * int (* range(1, 10) *)
+  | Range of int * int option * int option (* range(1, 10) *)
   | Flatten (* flatten *)
   | Head (* head *)
   | Tail (* tail *)
@@ -65,10 +80,8 @@ type expression =
   | Some_ of expression (* some, Some_ to not collide with option *)
   | Find of expression (* find(x) *)
   (* operations *)
-  | Addition of expression * expression (* + *)
-  | Subtraction of expression * expression (* - *)
-  | Division of expression * expression (* / *)
-  | Multiply of expression * expression (* * *)
+  | Abs
+  | Operation of expression * op * expression
   (* Generic *)
   | Length (* length *)
   | Contains of expression (* contains *)
@@ -82,18 +95,9 @@ type expression =
   | Join of expression (* join *)
   | Path of expression (* path(x) *)
   (* Logic *)
-  | If of expression (* if *)
-  | Then of expression (* then *)
-  | Else of expression (* else *)
+  | IfThenElse of
+      expression * expression * expression (* If then (elseif) else end *)
   | Break (* break *)
   (* Conditionals *)
-  | And of expression * expression (* and *)
-  | Or of expression * expression (* or *)
   | Not (* not *)
-  | Greater of expression * expression (* > *)
-  | Lower of expression * expression (* < *)
-  | GreaterEqual of expression * expression (* >= *)
-  | LowerEqual of expression * expression (* <= *)
-  | Equal of expression * expression (* == *)
-  | NotEqual of expression * expression (* != *)
 [@@deriving show { with_path = false }]

source/Compiler.ml

@@ -66,6 +66,77 @@ let keys (json : Json.t) =
       Output.return (`List (Json.keys json |> List.map (fun i -> `String i)))
   | _ -> Error (make_error "keys" json)
 
+let has (json : Json.t) key =
+  match key with
+  | String key -> (
+      match json with
+      | `Assoc list -> Output.return (`Bool (List.mem_assoc key list))
+      | _ -> Error (make_error "has" json))
+  | Number n -> (
+      match json with
+      | `List list ->
+          Output.return (`Bool (List.length list - 1 >= int_of_float n))
+      | _ -> Error (make_error "has" json))
+  | _ -> Error (make_error "has" json)
+
+let in_ (json : Json.t) expr =
+  match json with
+  | `Int n -> (
+      match expr with
+      | List list -> Output.return (`Bool (List.length list - 1 >= n))
+      | _ -> Error (make_error "in" json))
+  | `String key -> (
+      match expr with
+      | Object list ->
+          let cmp_literal_str key = function
+            | Literal (String s) when s = key -> true
+            | _ -> false
+          in
+          let s = List.map fst list |> List.find_opt (cmp_literal_str key) in
+          Output.return (`Bool (Option.is_some s))
+      | _ -> Error (make_error "in" json))
+  | _ -> Error (make_error "in" json)
+
+let range ?step from upto =
+  let rec range ?(step = 1) start stop =
+    if step = 0 then []
+    else if (step > 0 && start >= stop) || (step < 0 && start <= stop) then []
+    else start :: range ~step (start + step) stop
+  in
+  match upto with
+  | None ->
+      List.map (fun i -> Output.return (`Int i)) (range 1 from)
+      |> Output.collect
+  | Some upto ->
+      List.map (fun i -> Output.return (`Int i)) (range ?step from upto)
+      |> Output.collect
+
+let split expr json =
+  match json with
+  | `String s ->
+      let* rcase =
+        match expr with
+        | Literal (String s) -> Output.return s
+        | _ -> Error "split input should be a string"
+      in
+      Output.return
+        (`List (Str.split (Str.regexp rcase) s |> List.map (fun s -> `String s)))
+  | _ -> Error "input should be a JSON string"
+
+let join expr json =
+  let* rcase =
+    match expr with
+    | Literal (String s) -> Output.return s
+    | _ -> Error "join input should be a string"
+  in
+  match json with
+  | `List l ->
+      Output.return
+        (`String
+           (List.map (function `String s -> s | _ -> "") l
+           |> String.concat rcase))
+  | _ -> Error "input should be a list"
+
 let length (json : Json.t) =
   match json with
   | `List list -> Output.return (`Int (list |> List.length))
@@ -230,10 +301,20 @@ let rec compile expression json : (Json.t list, string) result =
   | Length -> length json
   | Not -> not json
   | Map expr -> map expr json
-  | Addition (left, right) -> operation left right add json
-  | Subtraction (left, right) -> operation left right sub json
-  | Multiply (left, right) -> operation left right mult json
-  | Division (left, right) -> operation left right div json
+  | Operation (left, op, right) -> (
+      match op with
+      | Add -> operation left right add json
+      | Sub -> operation left right sub json
+      | Mult -> operation left right mult json
+      | Div -> operation left right div json
+      | Gt -> operation left right gt json
+      | Ge -> operation left right gte json
+      | St -> operation left right lt json
+      | Se -> operation left right lte json
+      | Eq -> operation left right eq json
+      | Neq -> operation left right notEq json
+      | And -> operation left right and_ json
+      | Or -> operation left right or_ json)
   | Literal literal -> (
       match literal with
       | Bool b -> Output.return (`Bool b)
@@ -248,20 +329,36 @@ let rec compile expression json : (Json.t list, string) result =
       match res with
       | `Bool b -> ( match b with true -> Output.return json | false -> empty)
       | _ -> Error (make_error "select" res))
-  | Greater (left, right) -> operation left right gt json
-  | GreaterEqual (left, right) -> operation left right gte json
-  | Lower (left, right) -> operation left right lt json
-  | LowerEqual (left, right) -> operation left right lte json
-  | Equal (left, right) -> operation left right eq json
-  | NotEqual (left, right) -> operation left right notEq json
-  | And (left, right) -> operation left right and_ json
-  | Or (left, right) -> operation left right or_ json
   | List exprs ->
       Output.collect (List.map (fun expr -> compile expr json) exprs)
       |> Result.map (fun x -> [ `List x ])
   | Comma (leftR, rightR) ->
       Result.bind (compile leftR json) (fun left ->
           Result.bind (compile rightR json) (fun right -> Ok (left @ right)))
+  | Object list -> handle_objects list json
+  | Has e -> (
+      match e with
+      | Literal ((String _ | Number _) as e) -> has json e
+      | _ -> Error (show_expression e ^ " is not allowed"))
+  | In e -> in_ json e
+  | Range (from, upto, step) -> range ?step from upto
+  | Reverse -> (
+      match json with
+      | `List l -> Output.return (`List (List.rev l))
+      | _ -> Error (make_error "reverse" json))
+  | Split expr -> split expr json
+  | Join expr -> join expr json
+  | Abs -> (
+      match json with
+      | `Int n -> Output.return (`Int (if n < 0 then -n else n))
+      | `Float j -> Output.return (`Float (if j < 0. then -.j else j))
+      | _ -> Error (make_error "reverse" json))
+  | IfThenElse (cond, if_branch, else_branch) -> (
+      let* cond = compile cond json in
+      match cond with
+      | `Bool b ->
+          if b then compile if_branch json else compile else_branch json
+      | json -> Error (make_error "if condition should be a bool" json))
   | _ -> Error (show_expression expression ^ " is not implemented")
 
 and operation leftR rightR op json =
@@ -276,3 +373,35 @@ and map (expr : expression) (json : Json.t) =
       |> Result.map (fun x -> [ `List x ])
   | `List _list -> Error (make_empty_list_error "map")
   | _ -> Error (make_error "map" json)
+
+and handle_objects list json =
+  List.map
+    (fun (left_expr, right_expr) ->
+      match (left_expr, right_expr) with
+      | Literal (String n), None ->
+          (* Search for this key in JSON *)
+          let r =
+            match json with
+            | `Null -> Output.return (`Assoc [ (n, `Null) ])
+            | `Assoc l -> (
+                match List.assoc_opt n l with
+                | None -> Output.return (`Assoc [ (n, `Null) ])
+                | Some v -> Output.return (`Assoc [ (n, v) ]))
+            | _ -> Error (Json.show json ^ " is not implemented")
+          in
+          r
+      | Literal (String key), Some right_expr -> (
+          match right_expr with
+          | Key (search_val, _) -> (
+              match json with
+              | `Assoc l -> (
+                  match List.assoc_opt search_val l with
+                  | None -> Output.return (`Assoc [ (key, `Null) ])
+                  | Some v -> Output.return (`Assoc [ (key, v) ]))
+              | _ -> assert false)
+          | rexp ->
+              let* rexp = compile rexp json in
+              Output.return (`Assoc [ (key, rexp) ]))
+      | _ -> Error (show_expression left_expr ^ " is not implemented"))
+    list
+  |> Output.collect