json-write-stream 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7445d1cf85a82a9414433ebbdb06008eac6ac4e2
-  data.tar.gz: a82b04356133b8b46c21906bab7d413aebeac855
+SHA256:
+  metadata.gz: f3f098796321aaf71c015a22ee3b2c5fc7044ad0d67e5cbfd1c6c11ec8f47bec
+  data.tar.gz: 476ab378e44c73e9630642a91422224db73812414d2e9fb0bb504699a19c1d57
 SHA512:
-  metadata.gz: 3818ce8ae032e722dbde636aaefa818975e91ab25a80e20045da648564051dffde7c12fb9e9291c9ecb2ad0bad48c2438665b672f2f773549f60339f6f4b163a
-  data.tar.gz: 3632c1b6c3b499f20f46e3577f60221a15aec7a10e523a3d39b84b9d6513a9ff83deb6ee8bed07cc4d3dad5fedd7ef6f9b3a1cc255ce7a00f397ee2835cbc27a
+  metadata.gz: 5be8cc906b92bef8ab60e81c535af4937ceccb412271d3eedfbabf41f05fc0a4e4f12877c1bf65054981c19e36e4ee6d8c57471eb9d4574beeb4f51513c3b16b
+  data.tar.gz: acc20ad490eed07edaa2d93263d3ab5927570c410c4d8be7da5c71b05e60a051b25b52f2c056d376cca7dff64afd2ebaa1426c82879160b23d75bb65e1096d3c

data/Gemfile

@@ -3,12 +3,10 @@ source "https://rubygems.org"
 gemspec
 
 group :development, :test do
-  gem 'pry', '~> 0.9.0'
-  gem 'pry-nav'
+  gem 'pry-byebug'
   gem 'rake'
 end
 
 group :test do
   gem 'rspec'
-  gem 'rr'
 end

data/README.md

@@ -102,6 +102,31 @@ writer.write_object
 writer.close
 ```
 
+### Options
+
+JsonWriteStream supports generating "pretty" JSON, i.e. JSON formatted in a more human-readable way. Currently only the stateful writer supports pretty generation. Example:
+
+```ruby
+stream = StringIO.new
+writer = JsonWriteStream.from_stream(stream, pretty: true)
+writer.write_object
+writer.write_key_value('foo', 'bar')
+writer.write_array('baz')
+writer.write_element('goo')
+writer.close
+```
+
+Now `stream.string` will contain
+
+```json
+{
+  "foo": "bar",
+  "baz": [
+    "goo"
+  ]
+}
+```
+
 ## Requirements
 
 No external requirements.

data/lib/json-write-stream.rb

@@ -6,21 +6,22 @@ require 'json-write-stream/stateful'
 
 class JsonWriteStream
   DEFAULT_ENCODING = Encoding::UTF_8
-  DEFAULT_OPTIONS = { before: '', between: '' }.freeze
 
   class << self
-    def from_stream(stream, encoding = DEFAULT_ENCODING)
+    def from_stream(stream, options = {})
+      encoding = options.fetch(:encoding, DEFAULT_ENCODING)
       stream.set_encoding(encoding)
 
       if block_given?
         yield writer = YieldingWriter.new(stream)
         writer.close
       else
-        StatefulWriter.new(stream)
+        StatefulWriter.new(stream, options)
       end
     end
 
-    def open(file, encoding = DEFAULT_ENCODING)
+    def open(file, options = {})
+      encoding = options.fetch(:encoding, DEFAULT_ENCODING)
       handle = File.open(file, 'w')
       handle.set_encoding(encoding)
 
@@ -28,7 +29,7 @@ class JsonWriteStream
         yield writer = YieldingWriter.new(handle)
         writer.close
       else
-        StatefulWriter.new(handle)
+        StatefulWriter.new(handle, options)
       end
     end
   end

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

@@ -1,35 +1,47 @@
 # encoding: UTF-8
 
+require 'json'
+
 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
+    attr_reader :stream, :stack, :index, :closed, :options
+    alias_method :closed?, :closed
 
-    def initialize(stream)
+    def initialize(stream, options = {})
       @stream = stream
-      @index = 0
       @stack = []
       @closed = false
-      after_initialize
-    end
-
-    def after_initialize
+      @options = options
+      @index = 0
     end
 
     def write_object(*args)
       check_eos
-      current.write_object(*args) if current
-      stack.push(StatefulObjectWriter.new(stream))
+      new_indent_level = 1
+
+      if current
+        current.write_object(*args)
+        new_indent_level = current.indent_level + 1
+      end
+
+      stack.push(StatefulObjectWriter.new(self, new_indent_level))
     end
 
     def write_array(*args)
       check_eos
-      current.write_array(*args) if current
-      stack.push(StatefulArrayWriter.new(stream))
+
+      new_indent_level = 1
+
+      if current
+        current.write_array(*args)
+        new_indent_level = current.indent_level + 1
+      end
+
+      stack.push(StatefulArrayWriter.new(self, new_indent_level))
     end
 
     def write_key_value(*args)
@@ -93,8 +105,20 @@ class JsonWriteStream
       (stack.size == 0 && index > 0) || closed?
     end
 
+    def pretty?
+      options.fetch(:pretty, false)
+    end
+
+    def indent_size
+      options.fetch(:indent_size, 2)
+    end
+
     protected
 
+    def increment
+      @index += 1
+    end
+
     def check_eos
       if eos?
         raise EndOfStreamError, 'end of stream.'
@@ -104,53 +128,99 @@ class JsonWriteStream
     def current
       stack.last
     end
+  end
+
+  class BaseWriter
+    attr_reader :writer, :indent_level, :index
+
+    def initialize(writer, indent_level)
+      @writer = writer
+      @indent_level = indent_level
+      @index = 0
+      after_initialize
+    end
+
+    def after_initialize
+    end
+
+    def stream
+      writer.stream
+    end
+
+    def increment
+      @index += 1
+    end
+
+    def indent(level = indent_level)
+      stream.write(' ' * indent_size * level) if pretty?
+    end
+
+    def indent_size
+      writer.indent_size
+    end
 
     def escape(str)
       JSON.generate([str])[1..-2]
     end
 
     def write_comma
-      stream.write(',') if index > 0
+      if index > 0
+        stream.write(",")
+        write_newline
+      end
     end
 
-    def increment
-      @index += 1
+    def write_colon
+      stream.write(':')
+      stream.write(' ') if pretty?
+    end
+
+    def write_newline
+      stream.write("\n") if pretty?
+    end
+
+    def pretty?
+      writer.pretty?
     end
   end
 
-  class StatefulObjectWriter < StatefulWriter
+  class StatefulObjectWriter < BaseWriter
     def after_initialize
-      stream.write('{')
+      stream.write("{")
+      write_newline
     end
 
     # prep work (array is written afterwards)
     def write_array(key)
       write_comma
       increment
+      indent
       write_key(key)
-      stream.write(':')
+      write_colon
     end
 
     # prep work (object is written afterwards)
     def write_object(key)
       write_comma
       increment
+      indent
       write_key(key)
-      stream.write(':')
+      write_colon
     end
 
-    def write_key_value(key, value, options = DEFAULT_OPTIONS)
+    def write_key_value(key, value)
       write_comma
-      stream.write(options.fetch(:before, DEFAULT_OPTIONS[:before]))
       increment
+      indent
       write_key(key)
-      stream.write(':')
-      stream.write(options.fetch(:between, DEFAULT_OPTIONS[:between]))
+      write_colon
       stream.write(escape(value))
     end
 
     def close
-      stream.write('}')
+      write_newline
+      indent(indent_level - 1)
+      stream.write("}")
     end
 
     def is_object?
@@ -173,15 +243,16 @@ class JsonWriteStream
     end
   end
 
-  class StatefulArrayWriter < StatefulWriter
+  class StatefulArrayWriter < BaseWriter
     def after_initialize
-      stream.write('[')
+      stream.write("[")
+      write_newline
     end
 
-    def write_element(element, options = DEFAULT_OPTIONS)
+    def write_element(element)
       write_comma
-      stream.write(options.fetch(:before, DEFAULT_OPTIONS[:before]))
       increment
+      indent
       stream.write(escape(element))
     end
 
@@ -189,16 +260,20 @@ class JsonWriteStream
     def write_array
       write_comma
       increment
+      indent
     end
 
     # prep work
     def write_object
       write_comma
       increment
+      indent
     end
 
     def close
-      stream.write(']')
+      write_newline
+      indent(indent_level - 1)
+      stream.write("]")
     end
 
     def is_object?

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

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 class JsonWriteStream
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

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

@@ -2,11 +2,12 @@
 
 class JsonWriteStream
   class YieldingWriter
-    attr_reader :stream, :index
+    attr_reader :stream, :index, :options
 
-    def initialize(stream)
+    def initialize(stream, options = {})
       @stream = stream
       @index = 0
+      @options = options
       after_initialize
     end
 
@@ -60,33 +61,27 @@ class JsonWriteStream
       stream.write('{')
     end
 
-    def write_array(key, options = DEFAULT_OPTIONS)
+    def write_array(key)
       write_comma
-      stream.write(options.fetch(:before, DEFAULT_OPTIONS[:before]))
       increment
       write_key(key)
       stream.write(':')
-      stream.write(options.fetch(:between, DEFAULT_OPTIONS[:between]))
       super(true)
     end
 
-    def write_object(key, options = DEFAULT_OPTIONS)
+    def write_object(key)
       write_comma
-      stream.write(options.fetch(:before, DEFAULT_OPTIONS[:before]))
       increment
       write_key(key)
       stream.write(':')
-      stream.write(options.fetch(:between, DEFAULT_OPTIONS[:between]))
       super(true)
     end
 
-    def write_key_value(key, value, options = DEFAULT_OPTIONS)
+    def write_key_value(key, value)
       write_comma
-      stream.write(options.fetch(:before, DEFAULT_OPTIONS[:before]))
       increment
       write_key(key)
       stream.write(':')
-      stream.write(options.fetch(:between, DEFAULT_OPTIONS[:between]))
       stream.write(escape(value))
     end
 
@@ -106,9 +101,8 @@ class JsonWriteStream
       stream.write('[')
     end
 
-    def write_element(element, options = DEFAULT_OPTIONS)
+    def write_element(element)
       write_comma
-      stream.write(options.fetch(:before, DEFAULT_OPTIONS[:before]))
       increment
       stream.write(escape(element))
     end

data/spec/json-write-stream_spec.rb

@@ -25,7 +25,7 @@ describe JsonWriteStream do
     end
 
     it 'supports specifying a different encoding' do
-      stream_writer.from_stream(stream, Encoding::UTF_16BE) do |writer|
+      stream_writer.from_stream(stream, encoding: Encoding::UTF_16BE) do |writer|
         writer.write_object do |obj_writer|
           obj_writer.write_key_value('foo', 'bar')
         end
@@ -38,7 +38,7 @@ describe JsonWriteStream do
 
   describe '#open' do
     it 'opens a file and yields a yielding stream if given a block' do
-      mock.proxy(File).open(tempfile, 'w')
+      expect(File).to receive(:open).with(tempfile, 'w').and_return(tempfile)
       stream_writer.open(tempfile) do |writer|
         expect(writer).to be_a(yielding_writer)
         expect(writer.stream.path).to eq(tempfile.path)
@@ -46,14 +46,14 @@ describe JsonWriteStream do
     end
 
     it 'opens a file and returns a stateful writer if not given a block' do
-      mock.proxy(File).open(tempfile, 'w')
+      expect(File).to receive(:open).with(tempfile, 'w').and_return(tempfile)
       writer = stream_writer.open(tempfile)
       expect(writer).to be_a(stateful_writer)
       expect(writer.stream.path).to eq(tempfile.path)
     end
 
     it 'supports specifying a different encoding' do
-      stream_writer.open(tempfile, Encoding::UTF_16BE) do |writer|
+      stream_writer.open(tempfile, encoding: Encoding::UTF_16BE) do |writer|
         writer.write_object do |obj_writer|
           obj_writer.write_key_value('foo', 'bar')
         end

data/spec/shared_examples.rb

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

data/spec/spec_helper.rb

@@ -3,19 +3,18 @@
 require 'rspec'
 require 'json-write-stream'
 require 'shared_examples'
-require 'pry-nav'
+require 'pry-byebug'
 
 RSpec.configure do |config|
-  config.mock_with :rr
 end
 
 class RoundtripChecker
   class << self
     include RSpec::Matchers
 
-    def check_roundtrip(obj)
+    def check_roundtrip(obj, options = {})
       stream = StringIO.new
-      writer = create_writer(stream)
+      writer = create_writer(stream, options)
       serialize(obj, writer)
       writer.close
       new_obj = JSON.parse(stream.string)
@@ -49,8 +48,8 @@ class YieldingRoundtripChecker < RoundtripChecker
   class << self
     protected
 
-    def create_writer(stream)
-      JsonWriteStream::YieldingWriter.new(stream)
+    def create_writer(stream, options = {})
+      JsonWriteStream::YieldingWriter.new(stream, options)
     end
 
     def serialize(obj, writer)
@@ -106,8 +105,8 @@ class StatefulRoundtripChecker < RoundtripChecker
   class << self
     protected
 
-    def create_writer(stream)
-      JsonWriteStream::StatefulWriter.new(stream)
+    def create_writer(stream, options = {})
+      JsonWriteStream::StatefulWriter.new(stream, options)
     end
 
     def serialize(obj, writer)

data/spec/stateful_spec.rb

@@ -9,10 +9,11 @@ describe JsonWriteStream::YieldingWriter do
     end
   end
 
-  let(:stream_writer) { JsonWriteStream::StatefulWriter.new(stream) }
+  let(:options) { {} }
+  let(:stream_writer) { JsonWriteStream::StatefulWriter.new(stream, options) }
 
-  def check_roundtrip(obj)
-    StatefulRoundtripChecker.check_roundtrip(obj)
+  def check_roundtrip(obj, options = {})
+    StatefulRoundtripChecker.check_roundtrip(obj, options)
   end
 
   def utf8(str)
@@ -21,20 +22,105 @@ describe JsonWriteStream::YieldingWriter do
 
   it_behaves_like 'a json stream'
 
-  it 'respects the "before" option' do
-    stream_writer.write_object
-    stream_writer.write_key_value('foo', 'bar', before: "\n  ")
-    stream_writer.close
+  context 'with the pretty option' do
+    let(:options) { { pretty: true } }
 
-    expect(stream.string).to eq("{\n  \"foo\":\"bar\"}")
-  end
+    it_behaves_like 'a json stream', pretty: true
 
-  it 'respects the "between" option' do
-    stream_writer.write_object
-    stream_writer.write_key_value('foo', 'bar', between: ' ')
-    stream_writer.close
+    it 'prettifies a basic array' do
+      stream_writer.write_array
+      stream_writer.write_element('foo')
+      stream_writer.close
+      expect(stream.string).to eq(<<~END.strip)
+        [
+          "foo"
+        ]
+      END
+    end
 
-    expect(stream.string).to eq('{"foo": "bar"}')
+    it 'prettifies a basic object' do
+      stream_writer.write_object
+      stream_writer.write_key_value('foo', 'bar')
+      stream_writer.close
+      expect(stream.string).to eq(<<~END.strip)
+        {
+          "foo": "bar"
+        }
+      END
+    end
+
+    it 'prettifies a complex structure' do
+      stream_writer.write_object
+      stream_writer.write_array('foo')
+      stream_writer.write_element('bar')
+      stream_writer.write_object
+      stream_writer.write_key_value('baz', 'moo')
+      stream_writer.write_array('gaz')
+      stream_writer.write_element('doo')
+      stream_writer.close_array
+      stream_writer.close_object
+      stream_writer.write_element('kal')
+      stream_writer.close_array
+      stream_writer.write_array('jim')
+      stream_writer.write_element('jill')
+      stream_writer.write_array
+      stream_writer.write_element('john')
+      stream_writer.close
+      expect(stream.string).to eq(<<~END.strip)
+        {
+          "foo": [
+            "bar",
+            {
+              "baz": "moo",
+              "gaz": [
+                "doo"
+              ]
+            },
+            "kal"
+          ],
+          "jim": [
+            "jill",
+            [
+              "john"
+            ]
+          ]
+        }
+      END
+    end
+
+    context 'and the indent_size option' do
+      let(:options) { super().merge(indent_size: 4) }
+
+      it 'indents a basic object correctly' do
+        stream_writer.write_object
+        stream_writer.write_key_value('foo', 'bar')
+        stream_writer.close
+        expect(stream.string).to eq(<<~END.strip)
+          {
+              "foo": "bar"
+          }
+        END
+      end
+
+      it 'indents a more complicated object correctly' do
+        stream_writer.write_object
+        stream_writer.write_array('foo')
+        stream_writer.write_element('bar')
+        stream_writer.write_object
+        stream_writer.write_key_value('baz', 'moo')
+        stream_writer.close
+        expect(stream.string).to eq(<<~END.strip)
+          {
+              "foo": [
+                  "bar",
+                  {
+                      "baz": "moo"
+                  }
+              ]
+          }
+        END
+      end
+    end
   end
 
   describe '#close' do

data/spec/yielding_spec.rb

@@ -11,8 +11,8 @@ describe JsonWriteStream::YieldingWriter do
 
   let(:stream_writer) { JsonWriteStream::YieldingWriter.new(stream) }
 
-  def check_roundtrip(obj)
-    YieldingRoundtripChecker.check_roundtrip(obj)
+  def check_roundtrip(obj, options = {})
+    YieldingRoundtripChecker.check_roundtrip(obj, options)
   end
 
   def utf8(str)
@@ -20,22 +20,7 @@ describe JsonWriteStream::YieldingWriter do
   end
 
   it_behaves_like 'a json stream'
-
-  it 'respects the "before" option' do
-    stream_writer.write_object do |object_writer|
-      object_writer.write_key_value('foo', 'bar', before: "\n  ")
-    end
-
-    expect(stream.string).to eq("{\n  \"foo\":\"bar\"}")
-  end
-
-  it 'respects the "between" option' do
-    stream_writer.write_object do |object_writer|
-      object_writer.write_key_value('foo', 'bar', between: ' ')
-    end
-
-    expect(stream.string).to eq('{"foo": "bar"}')
-  end
+  it_behaves_like 'a json stream', pretty: true
 
   describe '#write_key_value' do
     it 'converts all keys to strings' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-write-stream
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-27 00:00:00.000000000 Z
+date: 2019-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_pure
@@ -32,7 +32,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- History.txt
 - README.md
 - Rakefile
 - json-write-stream.gemspec
@@ -64,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: An easy, streaming way to generate JSON.

data/History.txt

@@ -1,19 +0,0 @@
-== 1.0.0
-
-* Birthday!
-
-== 1.0.1
-
-* Support custom encodings (UTF-8, UTF-16, etc).
-
-== 1.0.2
-
-* Add flush methods
-
-== 1.1.0
-
-* Add way of inserting text after commas.
-
-== 1.2.0
-
-* Add way of inserting text between key/value pairs.