Moved the syntax module in its own library

8 files changed, 13 insertions, 247 deletions

diff --git a/lib/configuration/cte.ml b/lib/configuration/cte.ml
deleted file mode 100644
index ff43d6d..0000000
--- a/lib/configuration/cte.ml
+++ /dev/null
@@ -1,53 +0,0 @@
-open StdLabels
-module Path = ImportDataTypes.Path
-module Expression = ImportExpression.T
-
-type t = {
-  filters : Path.t Expression.t list;
-  group : Path.t Expression.t option;
-}
-
-(** Ensure the group criteria in window functions match the global group by
-    criteria.
-
-    Traverse the configuration tree until finding a group window. *)
-
-(** Check if the expression contains a group function *)
-let matchWindowGroup : 'a ImportExpression.T.t -> bool =
- fun expression ->
-  let exception Found in
-  let open ImportExpression.T in
-  let rec f = function
-    | Empty | Literal _ | Integer _ | Path _ -> ()
-    | Expr e -> f e
-    | Concat pp | Function' (_, pp) | Function (_, pp) | Nvl pp | Join (_, pp)
-      -> List.iter ~f pp
-    | Window (_, _, _) -> raise Found
-    | BOperator (_, arg1, arg2) ->
-        f arg1;
-        f arg2
-    | GEquality (_, arg1, args) ->
-        f arg1;
-        List.iter ~f args
-  in
-  try
-    f expression;
-    false
-  with
-  | Found -> true
-
-(** Transform a list of expression into a list of CTE to evaluate. *)
-let of_filters : Path.t Expression.t list -> t list =
- fun filters ->
-  let last_group, prev =
-    List.fold_left filters
-      ~init:({ filters = []; group = None }, [])
-      ~f:(fun (cte, acc) expr ->
-        begin
-          if matchWindowGroup expr then
-            ( { filters = []; group = None },
-              { cte with group = Some expr } :: acc )
-          else ({ cte with filters = expr :: cte.filters }, acc)
-        end)
-  in
-  List.rev (last_group :: prev)
diff --git a/lib/configuration/cte.mli b/lib/configuration/cte.mli
deleted file mode 100644
index 0f2b3e3..0000000
--- a/lib/configuration/cte.mli
+++ /dev/null
@@ -1,20 +0,0 @@
-module Path = ImportDataTypes.Path
-module Expression = ImportExpression.T
-
-type t = {
-  filters : Path.t Expression.t list;
-  group : Path.t Expression.t option;
-}
-(** Represent a filter to apply in the querry
-
-    The CTE can have filters applied on the previous CTE (or directly in the
-    sources if there is any yet) and can hold a group (an only one).
-
-    If there is a group, it must be applied after the others filters.
-
-    The order in which the filters are presented in the configuration can change
-    the results ; it does not matter when we only have classicals filters,
-    because all cf them can be evaluated at the same time, but as soon we have a
-    group function, the result become dependant of the previous ones. *)
-
-val of_filters : Path.t Expression.t list -> t list
diff --git a/lib/configuration/dune b/lib/configuration/dune
index 6a0bc61..7f78cca 100755
--- a/lib/configuration/dune
+++ b/lib/configuration/dune
@@ -4,17 +4,14 @@
    decoders

    otoml

    menhirLib

-   importCSV

-   re

    helpers

    importDataTypes

-   importExpression

    importErrors

+   importExpression

+   importerSyntax

  )

  (preprocess (pps 

    ppx_deriving.ord

-   ppx_deriving.show 

-   ppx_deriving.eq 

  ))

 )

 

diff --git a/lib/configuration/expression_parser.mly b/lib/configuration/expression_parser.mly
index 18b79c8..1761cce 100644
--- a/lib/configuration/expression_parser.mly
+++ b/lib/configuration/expression_parser.mly
@@ -36,8 +36,8 @@ path_:
     | COLUMN
       column = IDENT    
         { ImportExpression.T.Path 
-             Syntax.Path.{ alias = None
-            ; column = ImportCSV.Csv.column_of_string column
+             ImportDataTypes.Path.{ alias = None
+            ; column = ImportDataTypes.Path.column_of_string column
             }
         }
 
@@ -46,14 +46,14 @@ path_:
       DOT
       column = IDENT    
       { ImportExpression.T.Path
-             Syntax.Path.{ alias = Some table 
-            ; column = ImportCSV.Csv.column_of_string column}
+             ImportDataTypes.Path.{ alias = Some table 
+            ; column = ImportDataTypes.Path.column_of_string column}
       }
 
 column_: 
     | COLUMN
       column = IDENT
-        { try ImportExpression.T.Path (ImportCSV.Csv.column_of_string column)
+        { try ImportExpression.T.Path (ImportDataTypes.Path.column_of_string column)
         with _ -> ImportExpression.T.Literal column }
 
 arguments(PATH):
diff --git a/lib/configuration/importConf.ml b/lib/configuration/importConf.ml
index 8516008..2df24bd 100644
--- a/lib/configuration/importConf.ml
+++ b/lib/configuration/importConf.ml
@@ -1,68 +1,17 @@
-open StdLabels
-module Syntax = Syntax
-module CTE = Cte
-module Table = ImportDataTypes.Table
-module Path = ImportDataTypes.Path
-module T = Read_conf
-module Expression = ImportExpression.T
-
-let latest_version = 1
-
 module TomlReader = Read_conf.Make (Helpers.Toml.Decode)
 
-let t_of_toml : Otoml.t -> (Syntax.t, string) result =
+let t_of_toml : Otoml.t -> (ImporterSyntax.t, string) result =
  fun toml ->
   let version =
-    Otoml.find_or ~default:latest_version toml
+    Otoml.find_or ~default:ImporterSyntax.latest_version toml
       (Otoml.get_integer ~strict:false)
       [ "version" ]
   in
   match version with
-  | n when n = latest_version -> TomlReader.read toml
+  | n when n = ImporterSyntax.latest_version -> TomlReader.read toml
   | _ ->
       Printf.eprintf "Unsuported version : %d\n" version;
       exit 1
 
-let dummy_conf =
-  Syntax.
-    {
-      source = { file = ""; tab = 0; name = "" };
-      version = latest_version;
-      locale = Some "C";
-      externals = [];
-      columns = [];
-      filters = [];
-      sort = [];
-      uniq = [];
-    }
-
-let get_table_for_name : Syntax.t -> string option -> Table.t =
- fun conf name ->
-  match name with
-  | None -> conf.source
-  | Some name ->
-      if String.equal name conf.source.name then conf.source
-      else
-        let ext =
-          List.find conf.externals ~f:(fun (ext : Syntax.Extern.t) ->
-              String.equal name ext.target.name)
-        in
-        ext.target
-
-let root_table : Syntax.t -> Table.t = fun conf -> conf.source
-
-let get_dependancies_for_table : Syntax.t -> Table.t -> Syntax.Extern.t list =
- fun conf source ->
-  let is_root = source = conf.source in
-
-  List.filter conf.externals ~f:(fun (ext : Syntax.Extern.t) ->
-      (* Enumerate the intern_key and check the source pointed by each column *)
-      Expression.fold_values ext.intern_key ~init:false ~f:(fun acc expr ->
-          if acc then acc
-          else
-            match expr.Syntax.Path.alias with
-            | Some v -> String.equal v source.name
-            | None -> is_root))
-
 let expression_from_string s =
   Read_conf.ExpressionParser.of_string Read_conf.ExpressionParser.path s
diff --git a/lib/configuration/importConf.mli b/lib/configuration/importConf.mli
index 40b985b..d2f65f2 100644
--- a/lib/configuration/importConf.mli
+++ b/lib/configuration/importConf.mli
@@ -1,18 +1,4 @@
-module Syntax = Syntax
-module CTE = Cte
-
-val dummy_conf : Syntax.t
-
-val root_table : Syntax.t -> ImportDataTypes.Table.t
-(** Get the root table, this table is the main table to load and each line in
-    this table will be processed *)
-
-val t_of_toml : Otoml.t -> (Syntax.t, string) result
-val get_table_for_name : Syntax.t -> string option -> ImportDataTypes.Table.t
-
-val get_dependancies_for_table :
-  Syntax.t -> ImportDataTypes.Table.t -> Syntax.Extern.t list
-(** Get all the externals refered by the source *)
+val t_of_toml : Otoml.t -> (ImporterSyntax.t, string) result
 
 val expression_from_string :
   string -> (ImportDataTypes.Path.t ImportExpression.T.t, string) result
diff --git a/lib/configuration/read_conf.ml b/lib/configuration/read_conf.ml
index 11f6726..d406b0e 100644
--- a/lib/configuration/read_conf.ml
+++ b/lib/configuration/read_conf.ml
@@ -222,7 +222,7 @@ module Make (S : Decoders.Decode.S) = struct
         in
 
         S.succeed
-          Syntax.Extern.
+          ImporterSyntax.Extern.
             {
               intern_key;
               extern_key;
@@ -256,7 +256,7 @@ module Make (S : Decoders.Decode.S) = struct
                   ExpressionParser.path)
         in
         S.succeed @@ fun version source externals locale ->
-        Syntax.
+        ImporterSyntax.
           { version; source; externals; columns; filters; sort; uniq; locale }
 
       method conf =
diff --git a/lib/configuration/syntax.ml b/lib/configuration/syntax.ml
deleted file mode 100644
index ee47277..0000000
--- a/lib/configuration/syntax.ml
+++ /dev/null
@@ -1,93 +0,0 @@
-open StdLabels
-module E = ImportExpression.T
-module Table = ImportDataTypes.Table
-module Path = ImportDataTypes.Path
-
-let toml_of_table Table.{ file; tab; name } =
-  let values = [ ("file", Otoml.string file); ("name", Otoml.string name) ] in
-  let values =
-    match tab with
-    | 1 -> values
-    | tab -> ("tab", Otoml.integer tab) :: values
-  in
-
-  Otoml.table values
-
-module Extern = struct
-  type t = {
-    intern_key : Path.t E.t;
-    target : Table.t;
-    extern_key : Path.column E.t;
-    allow_missing : bool;
-    match_rule : string option;
-  }
-  [@@deriving show, eq]
-  (** Describe a relation beteween two tables *)
-
-  let toml_of_extern extern =
-    let values =
-      [
-        ( "intern_key",
-          Otoml.string
-          @@ ImportExpression.Repr.repr ~top:true Path.show extern.intern_key );
-        ( "extern_key",
-          Otoml.string
-          @@ ImportExpression.Repr.repr ~top:true
-               (fun v -> ":" ^ ImportCSV.Csv.column_to_string v)
-               extern.extern_key );
-        ("file", Otoml.string extern.target.file);
-        ("allow_missing", Otoml.boolean extern.allow_missing);
-      ]
-    in
-
-    let values =
-      match extern.target.tab with
-      | 1 -> values
-      | tab -> ("tab", Otoml.integer tab) :: values
-    in
-
-    Otoml.table values
-
-  let toml externs =
-    List.map externs ~f:(fun e -> (e.target.name, toml_of_extern e))
-    |> Otoml.table
-end
-
-type t = {
-  version : int;
-  locale : string option;
-  source : Table.t;
-  externals : Extern.t list;
-  columns : Path.t E.t list;
-  filters : Path.t E.t list;
-  sort : Path.t E.t list;
-  uniq : Path.t E.t list;
-}
-
-let repr t =
-  let repr_expression_list l =
-    Otoml.array
-      (List.map l ~f:(fun v ->
-           Otoml.string (ImportExpression.Repr.repr ~top:true Path.show v)))
-  in
-
-  let sheet =
-    Otoml.table
-      [
-        ("columns", repr_expression_list t.columns);
-        ("filters", repr_expression_list t.filters);
-        ("sort", repr_expression_list t.sort);
-        ("uniq", repr_expression_list t.uniq);
-      ]
-  in
-
-  let values =
-    [
-      ("version", Otoml.integer t.version);
-      ("source", toml_of_table t.source);
-      ("externals", Extern.toml t.externals);
-      ("sheet", sheet);
-    ]
-  in
-
-  Otoml.table values