json-projection 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed7412ad6cf14e0b9a5d5c7ae2667289d7e407b3
-  data.tar.gz: 0912f5a454752fe11c589a65d08ab1f0cb291668
+  metadata.gz: 779c9afb4cf147d1b4b0d63c895a5f4b433475e9
+  data.tar.gz: c7d47cc81038d3b0da4c8524ee8a560a935b772a
 SHA512:
-  metadata.gz: 9d5517cd1c7e2f69a08d0cada96df5cbd20f3a20d4152bea642e3b7920a81454b7cd8889399b1d538ffd5b74209249278336d34cf8253be810a86c52ef5ff992
-  data.tar.gz: 57e8cb50913047a8801a30a5fbf9259098a367e5ae38c500e1cc6be41096be6c4b730bab7c5330db81eebb220420db888be3ed33987b2643040eb61049bd3d50
+  metadata.gz: 234351fc085f508c49bf192fbbdcd3f19d48961ef1c0d5470fb046cc8b7cec00a214b37933b45966f1fa768f477535e96b046f4d5640507c886893d3cbb148d5
+  data.tar.gz: 6e4cfedb4829f40e3c54ca69b67f06b6319dba2bce71f08f9250c84f354cb9884a1594a5665b7284997c79fb5c265a693ceab178eae5bae0942fbd5a3bd9dfcb

data/lib/json-projection/projector.rb

@@ -0,0 +1,211 @@
+require_relative 'parser'
+
+module JsonProjection
+  class Projector
+
+    # Initialize a new projector with a stream. The stream is consumed until the
+    # JSON structure it contains is finished.
+    #
+    # stream :: IO
+    #           IO stream to read data from.
+    #
+    # Returns nothing.
+    def initialize(stream)
+      @parser = Parser.new(stream)
+    end
+
+    # Given a JSON schema of properties we are interested in, filter the input
+    # stream to just these properties.
+    #
+    # Note this is not a schema validator, the schema is _navigated_ to
+    # determine interesting-ness but if you specify a schema for a key that
+    # turns out to be a number it _will be included_. The projection only cares
+    # about whether things are interesting while advancing through the stream.
+    # To validate the schema, use another class on the resulting projection.
+    #
+    # schema :: nil | Hash<String, schema>
+    #           Map of the keys we are interested in, recurses.
+    #
+    # Returns a Hash<String, Any> instance or raises a parser error.
+    def project(schema)
+      event = @parser.next_event
+      unless event.is_a?(StartDocument)
+        raise StandardError, "expected document start"
+      end
+
+      value = filter_subtree(schema, next_event)
+
+      event = @parser.next_event
+      unless event.is_a?(EndDocument)
+        raise StandardError, "expected document end"
+      end
+
+      value
+    end
+
+    private
+
+    def next_event
+      @parser.next_event
+    end
+
+    def filter_subtree(schema, event)
+      if event.is_a?(StartArray)
+        return filter_array_subtree(schema, event)
+      end
+
+      if event.is_a?(StartObject)
+        return filter_object_subtree(schema, event)
+      end
+
+      raise StandardError, "cannot filter #{event.class} subtree"
+    end
+
+    def filter_array_subtree(schema, event)
+      unless event.is_a?(StartArray)
+        raise StandardError, "expected start array"
+      end
+
+      result = []
+
+      while (value_event = next_event) != EndArray.new
+        value = if value_event.is_a?(StartObject) || value_event.is_a?(StartArray)
+          filter_subtree(schema, value_event)
+        else
+          build_subtree(value_event)
+        end
+
+        result << value
+      end
+
+      result
+    end
+
+    def filter_object_subtree(schema, event)
+      unless event.is_a?(StartObject)
+        raise StandardError, "expected start object"
+      end
+
+      result = {}
+
+      while (event = next_event) != EndObject.new
+        key = event
+        unless key.is_a?(Key)
+          raise StandardError, "expected a key event"
+        end
+
+        # nil schema means reify the subtree from here on
+        # otherwise if the schema has a key for this we want it
+        is_interesting = schema.nil? || schema.key?(key.key)
+
+        if !is_interesting
+          ignore_value
+          next
+        end
+
+        value_event = next_event
+
+        value = if value_event.is_a?(StartObject) || value_event.is_a?(StartArray)
+          # objects can have subschemas, look it up then build the value using
+          # filter
+          key_schema = if schema.nil?
+            nil
+          else
+            schema[key.key]
+          end
+
+          filter_subtree(key_schema, value_event)
+        else
+          build_subtree(value_event)
+        end
+
+        result[key.key] = value
+      end
+
+      result
+    end
+
+    def build_subtree(event)
+      case event
+
+      when Null, Boolean, Number, String
+        event.value
+
+      when StartArray
+        result = []
+
+        while (event = next_event) != EndArray.new
+          result << build_subtree(event)
+        end
+
+        result
+
+      when StartObject
+        result = {}
+
+        while (event = next_event) != EndObject.new
+          key = event
+          unless key.is_a?(Key)
+            raise StandardError, "expected a key event"
+          end
+
+          result[key.key] = build_subtree(next_event)
+        end
+
+        result
+
+      else
+        raise StandardError, "cannot build subtree for #{event.class}"
+
+      end
+    end
+
+    # After reading a key if we know we are not interested in the next value,
+    # read and discard all its stream events.
+    #
+    # Values can be simple (string, numeric, boolean, null) or compound (object
+    # or array).
+    #
+    # Returns nothing.
+    def ignore_value
+      value_event = next_event
+
+      if value_event.is_a?(Value)
+        return
+      end
+
+      if value_event.is_a?(StartObject)
+        ignore_container
+        return
+      end
+
+      if value_event.is_a?(StartArray)
+        ignore_container
+      end
+
+      raise StandardError, "unknown value type to ignore #{value_event.class}"
+    end
+
+    # Given the start of an array or object, read until the closing event.
+    # Object structures can nest and this is considered.
+    #
+    # Returns nothing.
+    def ignore_container
+      depth = 1
+
+      increase_depth_on = [ StartObject.empty, StartArray.empty ]
+      decrease_depth_on = [ EndObject.empty, EndArray.empty ]
+
+      while depth > 0
+        event = next_event
+
+        if increase_depth_on.include?(event)
+          depth += 1
+        elsif decrease_depth_on.include?(event)
+          depth -= 1
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-projection
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Keith Duncan
@@ -73,12 +73,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/json-projection.rb
-- lib/json-projection/parser.rb
 - lib/json-projection/parser/buffer.rb
 - lib/json-projection/parser/errors.rb
 - lib/json-projection/parser/events.rb
 - lib/json-projection/parser/fifo.rb
+- lib/json-projection/parser.rb
+- lib/json-projection/projector.rb
+- lib/json-projection.rb
 homepage: https://github.com/keithduncan/json-projection
 licenses:
 - MIT