tabnas-alchemy 0.1.1

The alchemy grammar plugin and language for the tabnas parsing engine: declarative streaming transducers and renderers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

; The standard table transducer: JsonEvents in, TableRows out, with the
; metadata-first policy (design document section 12.2), or with the
; columns taken from the first row when the binding's `:columns` is the
; keyword `:infer`. The only engine operations here are route capture,
; transitions, value operations and stream scanning; the runtime runs
; `table-from-json` natively when the binding is a record of two
; selectors and a column function, or of `:infer` and a rows selector,
; and the differential test proves that path and this text produce the
; same bytes. The captures name the limits the native table holds the
; same scopes to: the metadata under max_metadata_bytes, each row under
; max_record_bytes.

def public-column [column]
  record
    entry :label (get :label column)

def table-inferred-column [key]
  record
    entry :label key
    entry :source (path key)

def table-row [columns raw]
  row
    map
      fn [column]
        get-path (get :source column) raw
      columns

def table-first-row [binding state raw]
  match (get :columns binding)
    case :infer
      match (kind raw)
        case :record
          let [columns (map table-inferred-column (keys raw))]
            transition (ready columns)
              vector
                schema
                  map public-column columns
                table-row columns raw
        case _
          fail "The first row is not an object, so no columns can be inferred from it"
    case _
      transition state
        vector
          table-row (require-columns state) raw

def table-step [binding state event]
  match event
    case (selected :columns raw)
      if (is-ready state)
        fail "Metadata selected more than once"
        let [columns (map (get :column binding) (as-vector raw))]
          transition (ready columns)
            vector
              schema
                map public-column columns
    case (selected :row raw)
      if (is-ready state)
        transition state
          vector
            table-row (require-columns state) raw
        table-first-row binding state raw

def table-finish [state]
  if (is-ready state)
    vector
      table-end
    fail "Required metadata was not found"

def table-finish-for [binding state]
  match (get :columns binding)
    case :infer
      if (is-ready state)
        vector
          table-end
        vector
          schema []
          table-end
    case _
      table-finish state

def table-captures [binding]
  match (get :columns binding)
    case :infer
      vector
        capture :row (get :rows binding) :max_record_bytes
    case _
      vector
        capture :columns (get :columns binding) :max_metadata_bytes
        capture :row (get :rows binding) :max_record_bytes

def table-from-json [binding input]
  pipe input
    route (table-captures binding)
    scan-emit no-schema (partial table-step binding) (partial table-finish-for binding)