json_reassembler.pony

  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
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
use pc = "collections/persistent"

class ref _ObjectInProgress
  var map: pc.Map[String, JSONValue]
  var pending_key: (String | None)

  new ref create() =>
    map = pc.Map[String, JSONValue]
    pending_key = None

class ref _ArrayInProgress
  var vec: pc.Vec[JSONValue]

  new ref create() =>
    vec = pc.Vec[JSONValue]

class ref JSONReassembler is JSONTokenNotify
  """
  Assembles a run of JSON tokens into `JSONValue`s.

  This is the opt-in path from a token stream back to a materialized value. Plug
  it into a `JSONTokenParser` — it is a `JSONTokenNotify`, so tokens flow
  into it directly — or hand it tokens yourself with `add()`. Either way,
  `take_values()` returns the top-level values that have completed, the same
  `JSONValue` the batch `JSONParser` would build:

  ```pony
  let re = JSONReassembler
  let parser = JSONTokenParser(re)
  parser.feed(chunk)?
  for value in re.take_values().values() do
    // value : JSONValue — use with JSONNav, JSONLens, JSONPath, JSONPrinter
  end
  ```

  Memory is the caller's choice: building a value costs memory proportional
  to that value, so hand the reassembler only the tokens you actually want
  materialized and drop the rest. There is no built-in size cap on what it
  builds, so do not blind-drain an untrusted stream into it.

  `take_values()` returns only top-level values that have completed, and
  drains them — it is not a plain accessor. If a run ends part-way through
  a value, that value stays buffered — `mid_value()` reports it — and the
  tokens that finish it can arrive later. `add()` expects tokens in the
  order `JSONTokenParser` emits them; a run that is not a valid emission
  sequence produces an unspecified result.
  """
  embed _stack: Array[(_ObjectInProgress | _ArrayInProgress)]
  var _completed: Array[JSONValue] iso

  new ref create() =>
    _stack = Array[(_ObjectInProgress | _ArrayInProgress)]
    _completed = recover iso Array[JSONValue] end

  fun ref add(token: JSONToken) =>
    """
    Fold one token into the value under construction. Tokens must arrive in the
    order `JSONTokenParser` emits them; a run that is not a valid emission
    sequence produces an unspecified result (but never corrupts a well-formed
    run that follows a `take_values()`).
    """
    match \exhaustive\ token
    | JSONTokenObjectStart => _stack.push(_ObjectInProgress)
    | JSONTokenArrayStart => _stack.push(_ArrayInProgress)
    | let k: JSONTokenKey =>
      try
        match _stack(_stack.size() - 1)?
        | let obj: _ObjectInProgress => obj.pending_key = k.value
        end
      end
    | let s: JSONTokenString => _add_value(s.value)
    | let n: JSONTokenNumber => _add_value(n.value)
    | JSONTokenTrue => _add_value(true)
    | JSONTokenFalse => _add_value(false)
    | JSONTokenNull => _add_value(None)
    | JSONTokenObjectEnd =>
      // Check the top's type before popping, so a mismatched closer on an
      // invalid run leaves the stack intact rather than dropping the container
      // it popped.
      try
        match _stack(_stack.size() - 1)?
        | let obj: _ObjectInProgress =>
          _stack.pop()?
          _add_value(JSONObject(obj.map))
        end
      end
    | JSONTokenArrayEnd =>
      try
        match _stack(_stack.size() - 1)?
        | let arr: _ArrayInProgress =>
          _stack.pop()?
          _add_value(JSONArray(arr.vec))
        end
      end
    end

  fun ref apply(parser: JSONTokenParser, token: JSONToken) =>
    """
    `JSONTokenNotify` entry point — folds the token in, ignoring `parser`.
    """
    add(token)

  fun ref take_values(): Array[JSONValue] iso^ =>
    """
    Take the top-level values completed since the last call, and reset — a
    second call returns an empty array unless more values have completed. A
    value whose root container has not yet closed is not included; check
    `mid_value()` for it.
    """
    _completed = recover iso Array[JSONValue] end

  fun mid_value(): Bool =>
    """
    True while tokens have been folded for a value that has not closed yet.
    This reports only the reassembler's own buffered partial; for byte-level
    truncation of a stream, use `JSONTokenParser.incomplete()`.
    """
    _stack.size() > 0

  fun ref _add_value(v: JSONValue) =>
    if _stack.size() == 0 then
      _completed.push(v)
    else
      try
        match \exhaustive\ _stack(_stack.size() - 1)?
        | let obj: _ObjectInProgress =>
          match obj.pending_key
          | let key: String =>
            obj.map = obj.map(key) = v
            obj.pending_key = None
          end
        | let arr: _ArrayInProgress =>
          arr.vec = arr.vec.push(v)
        end
      end
    end