json-write-stream 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a397871c57d6b78327b37cac6e9848b212b4a2d6
+  data.tar.gz: 2a0437147cacd67a906a1c1d34b266001ae1f2fc
+SHA512:
+  metadata.gz: 6af47c318296dd8bfc6bc981fcb420e7ba9b42905cd08ac459668dae13c588cc67bc1159e00f98c06d740304d6c1c6b3c27a36b50457ebef9951254430665e20
+  data.tar.gz: 619674607994da2fe54e97608869ae70ebf81a5f9e9100f0e2771c7dddae56af537f262f4a997221a31d28c7609f1523351b9d7a50d5e6a978954ed562b8c4b4

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rr'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/README.md

@@ -0,0 +1,113 @@
+json-write-stream
+=================
+
+An easy, streaming way to generate JSON.
+
+## Installation
+
+`gem install json-write-stream`
+
+## Usage
+
+```ruby
+require 'json-write-stream'
+```
+
+### Examples for the Impatient
+
+There are two types of JSON write stream: one that uses blocks and `yield` to delimit arrays and objects, and one that's purely stateful. Here are two examples that produce the same output:
+
+Yielding:
+
+```ruby
+stream = StringIO.new
+JsonWriteStream.from_stream(stream) do |writer|
+  writer.write_object do |obj_writer|
+    obj_writer.write_key_value('foo', 'bar')
+    obj_writer.write_array('baz') do |arr_writer|
+      arr_writer.write_element('goo')
+    end
+  end
+end
+```
+
+Stateful:
+
+```ruby
+stream = StringIO.new
+writer = JsonWriteStream.from_stream(stream)
+writer.write_object
+writer.write_key_value('foo', 'bar')
+writer.write_array('baz')
+writer.write_element('goo')
+writer.close  # automatically adds closing punctuation for all nested types
+```
+
+Output:
+
+```ruby
+stream.string # => {"foo":"bar","baz":["goo"]}
+```
+
+### Yielding Writers
+
+As far as yielding writers go, the example above contains everything you need. The stream will be automatically closed when the outermost block terminates.
+
+### Stateful Writers
+
+Stateful writers have a number of additional methods:
+
+```ruby
+stream = StringIO.new
+writer = JsonWriteStream.from_stream(stream)
+writer.write_object
+
+writer.in_object?    # => true, currently writing an object
+writer.in_array?     # => false, not currently writing an array
+writer.eos?          # => false, the stream is open and the outermost object hasn't been closed yet
+
+writer.close_object  # explicitly close the current object
+writer.eos?          # => true, the outermost object has been closed
+
+writer.write_array   # => raises JsonWriteStream::EndOfStreamError
+writer.close_array   # => raises JsonWriteStream::NotInArrayError
+
+writer.closed?       # => false, the stream is still open
+writer.close         # close the stream
+writer.closed?       # => true, the stream has been closed
+```
+
+### Writing to a File
+
+JsonWriteStream also supports streaming to a file via the `open` method:
+
+Yielding:
+
+```ruby
+JsonWriteStream.open('path/to/file.json') do |writer|
+  writer.write_object do |obj_writer|
+    ...
+  end
+end
+```
+
+Stateful:
+
+```ruby
+writer = JsonWriteStream.open('path/to/file.json')
+writer.write_object
+...
+writer.close
+```
+
+## Requirements
+
+No external requirements.
+
+## Running Tests
+
+`bundle exec rake` should do the trick. Alternatively you can run `bundle exec rspec`, which does the same thing.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/json-write-stream'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/json-write-stream.gemspec

@@ -0,0 +1,20 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'json-write-stream/version'
+
+Gem::Specification.new do |s|
+  s.name     = "json-write-stream"
+  s.version  = ::JsonWriteStream::VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron"
+
+  s.description = s.summary = "An easy, streaming way to generate JSON."
+
+  s.add_dependency 'json_pure', '~> 1.8.0'
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "json-write-stream.gemspec"]
+end

data/lib/json-write-stream.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+require 'json'
+require 'json-write-stream/yielding'
+require 'json-write-stream/stateful'
+
+class JsonWriteStream
+  class << self
+    def from_stream(stream)
+      if block_given?
+        yield writer = YieldingWriter.new(stream)
+        writer.close
+      else
+        StatefulWriter.new(stream)
+      end
+    end
+
+    def open(file)
+      handle = File.open(file, 'w')
+
+      if block_given?
+        yield writer = YieldingWriter.new(handle)
+        writer.close
+      else
+        StatefulWriter.new(handle)
+      end
+    end
+  end
+end

data/lib/json-write-stream/stateful.rb

@@ -0,0 +1,203 @@
+# encoding: UTF-8
+
+class JsonWriteStream
+  class NotInObjectError < StandardError; end
+  class NotInArrayError < StandardError; end
+  class EndOfStreamError < StandardError; end
+
+  class StatefulWriter
+    attr_reader :stream, :index, :stack, :closed
+    alias :closed? :closed
+
+    def initialize(stream)
+      @stream = stream
+      @index = 0
+      @stack = []
+      @closed = false
+      after_initialize
+    end
+
+    def after_initialize
+    end
+
+    def write_object(*args)
+      check_eos
+      current.write_object(*args) if current
+      stack.push(StatefulObjectWriter.new(stream))
+    end
+
+    def write_array(*args)
+      check_eos
+      current.write_array(*args) if current
+      stack.push(StatefulArrayWriter.new(stream))
+    end
+
+    def write_key_value(*args)
+      check_eos
+      current.write_key_value(*args)
+    end
+
+    def write_element(*args)
+      check_eos
+      current.write_element(*args)
+    end
+
+    def close_object
+      if in_object?
+        stack.pop.close
+        current.increment if current
+        increment
+      else
+        raise NotInObjectError, 'not currently writing an object.'
+      end
+    end
+
+    def close_array
+      if in_array?
+        stack.pop.close
+        current.increment if current
+        increment
+      else
+        raise NotInArrayError, 'not currently writing an array.'
+      end
+    end
+
+    def close
+      until stack.empty?
+        if in_object?
+          close_object
+        else
+          close_array
+        end
+      end
+
+      stream.close
+      @closed = true
+      nil
+    end
+
+    def in_object?
+      current ? current.is_object? : false
+    end
+
+    def in_array?
+      current ? current.is_array? : false
+    end
+
+    def eos?
+      (stack.size == 0 && index > 0) || closed?
+    end
+
+    protected
+
+    def check_eos
+      if eos?
+        raise EndOfStreamError, 'end of stream.'
+      end
+    end
+
+    def current
+      stack.last
+    end
+
+    def escape(str)
+      JSON.generate([str])[1..-2]
+    end
+
+    def write_comma
+      stream.write(',') if index > 0
+    end
+
+    def increment
+      @index += 1
+    end
+  end
+
+  class StatefulObjectWriter < StatefulWriter
+    def after_initialize
+      stream.write('{')
+    end
+
+    # prep work (array is written afterwards)
+    def write_array(key)
+      write_comma
+      increment
+      write_key(key)
+      stream.write(':')
+    end
+
+    # prep work (object is written afterwards)
+    def write_object(key)
+      write_comma
+      increment
+      write_key(key)
+      stream.write(':')
+    end
+
+    def write_key_value(key, value)
+      write_comma
+      increment
+      write_key(key)
+      stream.write(":#{escape(value)}")
+    end
+
+    def close
+      stream.write('}')
+    end
+
+    def is_object?
+      true
+    end
+
+    def is_array?
+      false
+    end
+
+    private
+
+    def write_key(key)
+      case key
+        when String
+          stream.write(escape(key))
+        else
+          raise ArgumentError, "'#{key}' must be a string"
+      end
+    end
+  end
+
+  class StatefulArrayWriter < StatefulWriter
+    def after_initialize
+      stream.write('[')
+    end
+
+    def write_element(element)
+      write_comma
+      increment
+      stream.write(escape(element))
+    end
+
+    # prep work
+    def write_array
+      write_comma
+      increment
+    end
+
+    # prep work
+    def write_object
+      write_comma
+      increment
+    end
+
+    def close
+      stream.write(']')
+    end
+
+    def is_object?
+      false
+    end
+
+    def is_array?
+      true
+    end
+  end
+end

data/lib/json-write-stream/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+class JsonWriteStream
+  VERSION = "1.0.0"
+end

data/lib/json-write-stream/yielding.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+class JsonWriteStream
+  class YieldingWriter
+    attr_reader :stream, :index
+
+    def initialize(stream)
+      @stream = stream
+      @index = 0
+      after_initialize
+    end
+
+    def after_initialize
+    end
+
+    def write_object(comma_written = false)
+      unless comma_written
+        write_comma
+        increment
+      end
+
+      yield writer = YieldingObjectWriter.new(stream)
+      writer.close
+    end
+
+    def write_array(comma_written = false)
+      unless comma_written
+        write_comma
+        increment
+      end
+
+      yield writer = YieldingArrayWriter.new(stream)
+      writer.close
+    end
+
+    def close
+      stream.close
+    end
+
+    protected
+
+    def escape(str)
+      JSON.generate([str])[1..-2]
+    end
+
+    def write_comma
+      stream.write(',') if index > 0
+    end
+
+    def increment
+      @index += 1
+    end
+  end
+
+  class YieldingObjectWriter < YieldingWriter
+    def after_initialize
+      stream.write('{')
+    end
+
+    def write_array(key)
+      write_comma
+      increment
+      write_key(key)
+      stream.write(':')
+      super(true)
+    end
+
+    def write_object(key)
+      write_comma
+      increment
+      write_key(key)
+      stream.write(':')
+      super(true)
+    end
+
+    def write_key_value(key, value)
+      write_comma
+      increment
+      write_key(key)
+      stream.write(":#{escape(value)}")
+    end
+
+    def close
+      stream.write('}')
+    end
+
+    private
+
+    def write_key(key)
+      stream.write(escape(key.to_s))
+    end
+  end
+
+  class YieldingArrayWriter < YieldingWriter
+    def after_initialize
+      stream.write('[')
+    end
+
+    def write_element(element)
+      write_comma
+      increment
+      stream.write(escape(element))
+    end
+
+    def close
+      stream.write(']')
+    end
+  end
+end

data/spec/json-write-stream_spec.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'tempfile'
+
+describe JsonWriteStream do
+  let(:yielding_writer) { JsonWriteStream::YieldingWriter }
+  let(:stateful_writer) { JsonWriteStream::StatefulWriter }
+  let(:stream_writer) { JsonWriteStream }
+  let(:tempfile) { Tempfile.new('temp') }
+  let(:stream) { StringIO.new }
+
+  describe '#from_stream' do
+    it 'yields a yielding stream if given a block' do
+      stream_writer.from_stream(stream) do |writer|
+        expect(writer).to be_a(yielding_writer)
+        expect(writer.stream).to equal(stream)
+      end
+    end
+
+    it 'returns a stateful writer if not given a block' do
+      writer = stream_writer.from_stream(stream)
+      expect(writer).to be_a(stateful_writer)
+      expect(writer.stream).to equal(stream)
+    end
+  end
+
+  describe '#open' do
+    it 'opens a file and yields a yielding stream if given a block' do
+      mock.proxy(File).open(tempfile, 'w')
+      stream_writer.open(tempfile) do |writer|
+        expect(writer).to be_a(yielding_writer)
+        expect(writer.stream.path).to eq(tempfile.path)
+      end
+    end
+
+    it 'opens a file and returns a stateful writer if not given a block' do
+      mock.proxy(File).open(tempfile, 'w')
+      writer = stream_writer.open(tempfile)
+      expect(writer).to be_a(stateful_writer)
+      expect(writer.stream.path).to eq(tempfile.path)
+    end
+  end
+end

data/spec/shared_examples.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+shared_examples 'a json stream' do
+  it 'handles a simple array' do
+    check_roundtrip(['abc'])
+  end
+
+  it 'handles a simple object' do
+    check_roundtrip({ 'foo' => 'bar' })
+  end
+
+  it 'handles one level of array nesting' do
+    check_roundtrip([['def'],'abc'])
+    check_roundtrip(['abc',['def']])
+  end
+
+  it 'handles one level of object nesting' do
+    check_roundtrip({ 'foo' => { 'bar' => 'baz' } })
+  end
+
+  it 'handles one level of mixed nesting' do
+    check_roundtrip({ 'foo' => ['bar', 'baz'] })
+    check_roundtrip([{ 'foo' => 'bar' }])
+  end
+
+  it 'handles multiple levels of mixed nesting' do
+    check_roundtrip({'foo' => ['bar', { 'baz' => 'moo', 'gaz' => ['doo'] }, 'kal'], 'jim' => ['jill', ['john']] })
+    check_roundtrip(['foo', { 'bar' => 'baz', 'moo' => ['gaz', ['jim', ['jill']], 'jam'] }])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+
+require 'rspec'
+require 'json-write-stream'
+require 'shared_examples'
+require 'pry-nav'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+
+class RoundtripChecker
+  class << self
+    include RSpec::Matchers
+
+    def check_roundtrip(obj)
+      stream = StringIO.new
+      writer = create_writer(stream)
+      serialize(obj, writer)
+      new_obj = JSON.parse(stream.string)
+      compare(obj, new_obj)
+    end
+
+    private
+
+    def compare(old_obj, new_obj)
+      expect(old_obj.class).to equal(new_obj.class)
+
+      case old_obj
+        when Hash
+          expect(old_obj.keys).to eq(new_obj.keys)
+
+          old_obj.each_pair do |key, old_val|
+            compare(old_val, new_obj[key])
+          end
+        when Array
+          old_obj.each_with_index do |old_element, idx|
+            compare(old_element, new_obj[idx])
+          end
+        else
+          expect(old_obj).to eq(new_obj)
+      end
+    end
+  end
+end
+
+class YieldingRoundtripChecker < RoundtripChecker
+  class << self
+    protected
+
+    def create_writer(stream)
+      JsonWriteStream::YieldingWriter.new(stream)
+    end
+
+    def serialize(obj, writer)
+      case obj
+        when Hash
+          writer.write_object do |object_writer|
+            serialize_object(obj, object_writer)
+          end
+        when Array
+          writer.write_array do |array_writer|
+            serialize_array(obj, array_writer)
+          end
+      end
+    end
+
+    def serialize_object(obj, writer)
+      obj.each_pair do |key, val|
+        case val
+          when Hash
+            writer.write_object(key) do |object_writer|
+              serialize_object(val, object_writer)
+            end
+          when Array
+            writer.write_array(key) do |array_writer|
+              serialize_array(val, array_writer)
+            end
+          else
+            writer.write_key_value(key, val)
+        end
+      end
+    end
+
+    def serialize_array(obj, writer)
+      obj.each do |element|
+        case element
+          when Hash
+            writer.write_object do |object_writer|
+              serialize_object(element, object_writer)
+            end
+          when Array
+            writer.write_array do |array_writer|
+              serialize_array(element, array_writer)
+            end
+          else
+            writer.write_element(element)
+        end
+      end
+    end
+  end
+end
+
+class StatefulRoundtripChecker < RoundtripChecker
+  class << self
+    protected
+
+    def create_writer(stream)
+      JsonWriteStream::StatefulWriter.new(stream)
+    end
+
+    def serialize(obj, writer)
+      case obj
+        when Hash
+          writer.write_object
+          serialize_object(obj, writer)
+          writer.close_object
+        when Array
+          writer.write_array
+          serialize_array(obj, writer)
+          writer.close_array
+      end
+    end
+
+    def serialize_object(obj, writer)
+      obj.each_pair do |key, val|
+        case val
+          when Hash
+            writer.write_object(key)
+            serialize_object(val, writer)
+            writer.close_object
+          when Array
+            writer.write_array(key)
+            serialize_array(val, writer)
+            writer.close_array
+          else
+            writer.write_key_value(key, val)
+        end
+      end
+    end
+
+    def serialize_array(obj, writer)
+      obj.each do |element|
+        case element
+          when Hash
+            writer.write_object
+            serialize_object(element, writer)
+            writer.close_object
+          when Array
+            writer.write_array
+            serialize_array(element, writer)
+            writer.close_array
+          else
+            writer.write_element(element)
+        end
+      end
+    end
+  end
+end

data/spec/stateful_spec.rb

@@ -0,0 +1,131 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe JsonWriteStream::YieldingWriter do
+  let(:stream) { StringIO.new }
+  let(:stream_writer) { JsonWriteStream::StatefulWriter.new(stream) }
+
+  def check_roundtrip(obj)
+    StatefulRoundtripChecker.check_roundtrip(obj)
+  end
+
+  it_behaves_like 'a json stream'
+
+  describe '#close' do
+    it 'unwinds the stack, adds appropriate closing punctuation for each unclosed item, and closes the stream' do
+      stream_writer.write_array
+      stream_writer.write_element('abc')
+      stream_writer.write_object
+      stream_writer.write_key_value('def', 'ghi')
+      stream_writer.close
+
+      expect(stream.string).to eq('["abc",{"def":"ghi"}]')
+      expect(stream_writer).to be_closed
+      expect(stream).to be_closed
+    end
+  end
+
+  describe '#closed?' do
+    it 'returns false if the stream is still open' do
+      expect(stream_writer).to_not be_closed
+    end
+
+    it 'returns true if the stream is closed' do
+      stream_writer.close
+      expect(stream_writer).to be_closed
+    end
+  end
+
+  describe '#in_object?' do
+    it 'returns true if the writer is currently writing an object' do
+      stream_writer.write_object
+      expect(stream_writer).to be_in_object
+    end
+
+    it 'returns false if the writer is not currently writing an object' do
+      expect(stream_writer).to_not be_in_object
+      stream_writer.write_array
+      expect(stream_writer).to_not be_in_object
+    end
+  end
+
+  describe '#in_array?' do
+    it 'returns true if the writer is currently writing an array' do
+      stream_writer.write_array
+      expect(stream_writer).to be_in_array
+    end
+
+    it 'returns false if the writer is not currently writing an array' do
+      expect(stream_writer).to_not be_in_array
+      stream_writer.write_object
+      expect(stream_writer).to_not be_in_array
+    end
+  end
+
+  describe '#eos?' do
+    it 'returns false if nothing has been written yet' do
+      expect(stream_writer).to_not be_eos
+    end
+
+    it 'returns false if the writer is in the middle of writing' do
+      stream_writer.write_object
+      expect(stream_writer).to_not be_eos
+    end
+
+    it "returns true if the writer has finished it's top-level" do
+      stream_writer.write_object
+      stream_writer.close_object
+      expect(stream_writer).to be_eos
+    end
+
+    it 'returns true if the writer is closed' do
+      stream_writer.close
+      expect(stream_writer).to be_eos
+    end
+  end
+
+  describe '#close_object' do
+    it 'raises an error if an object is not currently being written' do
+      stream_writer.write_array
+      expect(-> { stream_writer.close_object }).to raise_error(JsonWriteStream::NotInObjectError)
+    end
+  end
+
+  describe '#close_array' do
+    it 'raises an error if an array is not currently being written' do
+      stream_writer.write_object
+      expect(-> { stream_writer.close_array }).to raise_error(JsonWriteStream::NotInArrayError)
+    end
+  end
+
+  context 'with a closed stream writer' do
+    before(:each) do
+      stream_writer.close
+    end
+
+    describe '#write_object' do
+      it 'raises an error if eos' do
+        expect(-> { stream_writer.write_object }).to raise_error(JsonWriteStream::EndOfStreamError)
+      end
+    end
+
+    describe '#write_array' do
+      it 'raises an error if eos' do
+        expect(-> { stream_writer.write_object }).to raise_error(JsonWriteStream::EndOfStreamError)
+      end
+    end
+
+    describe '#write_key_value' do
+      it 'raises an error if eos' do
+        expect(-> { stream_writer.write_key_value('abc', 'def') }).to raise_error(JsonWriteStream::EndOfStreamError)
+      end
+    end
+
+    describe '#write_element' do
+      it 'raises an error if eos' do
+        expect(-> { stream_writer.write_element('foo') }).to raise_error(JsonWriteStream::EndOfStreamError)
+      end
+    end
+  end
+end

data/spec/yielding_spec.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe JsonWriteStream::YieldingWriter do
+  let(:stream) { StringIO.new }
+  let(:stream_writer) { JsonWriteStream::YieldingWriter.new(stream) }
+
+  def check_roundtrip(obj)
+    YieldingRoundtripChecker.check_roundtrip(obj)
+  end
+
+  it_behaves_like 'a json stream'
+
+  describe '#write_key_value' do
+    it 'converts all keys to strings' do
+      stream_writer.write_object do |object_writer|
+        object_writer.write_key_value(123, 'abc')
+      end
+
+      expect(stream.string).to eq('{"123":"abc"}')
+    end
+
+    it 'supports non-string values' do
+      stream_writer.write_object do |object_writer|
+        object_writer.write_key_value('abc', 123)
+        object_writer.write_key_value('def', true)
+      end
+
+      expect(stream.string).to eq('{"abc":123,"def":true}')
+    end
+  end
+
+  describe '#close' do
+    it 'closes the underlying stream' do
+      stream_writer.close
+      expect(stream).to be_closed
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: json-write-stream
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+description: An easy, streaming way to generate JSON.
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- json-write-stream.gemspec
+- lib/json-write-stream.rb
+- lib/json-write-stream/stateful.rb
+- lib/json-write-stream/version.rb
+- lib/json-write-stream/yielding.rb
+- spec/json-write-stream_spec.rb
+- spec/shared_examples.rb
+- spec/spec_helper.rb
+- spec/stateful_spec.rb
+- spec/yielding_spec.rb
+homepage: http://github.com/camertron
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: An easy, streaming way to generate JSON.
+test_files: []