outstream-json 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb20f4f2c4d3bd0e47eff8c74a58066c9c0a8ccc
+  data.tar.gz: 0145f35292dfb81f1c2f19e7b28b06d507b7cefa
+SHA512:
+  metadata.gz: 70215a331d253f1bc969c432dd351e54665d59a60673c8c952ac49c00796440f5028bda6d0680677f6ad0987330c70193d35a88ec6cf51b01c00dbc92d17933b
+  data.tar.gz: 2f741ba68be98df355d460a6f97a74862a93a9adc3ef2ead32209df347a3c63c582734d603cf6b254f4b2a2bf5e5030d688608a9f48738c1bf56ea1ff354c8a2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ryan Calhoun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+[![Gem Version](https://badge.fury.io/rb/outstream-json.svg)](http://badge.fury.io/rb/outstream-json)
+
+# Outstream::Json
+
+A library for producing JSON output in a streaming fashion. It is designed to work with lambdas and lazy enumerators, to minimize the need to create the entire JSON-encoding string at once.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'outstream-json'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install outstream-json
+
+## Usage
+
+The Json.create method defines a JSON object
+
+	out = OutStream::Json.create do
+	  ...
+	end
+	# use out.to_s or out.each to product result
+
+Use with basic ruby types
+
+	Outstream::Json.create do
+	  add string: "hello", number: 42
+	  add array: [1,2,3]
+	end
+	# {"string":"hello","number":42,"array":[1,2,3]}
+
+	Outstream::Json.create do
+	  add "nested_object" {
+		add "foo" => "bar"
+	  }
+	end
+	# {"nested_object":{"foo":"bar"}}
+
+Use with transformed SQL result set
+
+	client = Mysql2::Client.new
+  	results = client.query("SELECT * FROM huge\_table", stream: true)	
+	Outstream::Json.create do
+	  add results: results.lazy.map {|row| transform_row(row)}
+	end
+	# {"results":[{<transformed_result>},...]}
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new {|t|
+	t.libs << 'test'
+}
+
+desc 'Run tests'
+task :default => :test

data/lib/outstream/json.rb

@@ -0,0 +1,125 @@
+require 'json'
+
+module Outstream
+  # Produce a stream of JSON tokens.
+  class Json
+    # Define an output JSON object, given a block. The block
+    # is executed in a context which provides the add method,
+    # for adding key-value pairs to the object.
+    #
+    # Example:
+    #   Outstream::Json.create do
+	  #     add string: "hello", number: 42
+	  #     add array: [1,2,3]
+	  #     add "nested_object" {
+		#       add "foo" => "bar"
+	  #     }
+    #   end
+    def self.create(&body_block)
+      new body_block
+    end
+
+    # Iterate the output tokens. The block will receive JSON delimeters individually as strings,
+    # and string values as quoted strings. If called without a block, returns an enumerator.
+    #
+    # Example:
+    #   json.each {|token| puts token}
+    def each(&out_block)
+      e = Enumerator.new {|yielder|
+        Collector.new(yielder).collect &@body_block
+      }
+
+      out_block ? e.each(&out_block) : e
+    end
+
+    # Produce a compact string of the JSON. The entire string is produced at once; this is not
+    # suitable for very large JSON output.
+    def to_s
+      "".tap {|s| each {|str| s.concat str } }
+    end
+
+    private
+
+    def initialize(body_block)
+      @body_block = body_block
+    end
+
+    class Receiver
+      def initialize(collector)
+        @_collector = collector
+      end
+      def add(objs, &block)
+        @_collector.add objs, &block
+      end
+    end
+
+    class Collector
+      def initialize(yielder)
+        @yielder = yielder
+        @count = [0]
+      end
+      def collect(&block)
+        add_object {
+          receiver = Receiver.new self
+          if block.arity == 1
+            block[receiver]
+          else
+            (class << receiver; self; end).send(:define_method, :__call_block, &block)
+            receiver.__call_block
+          end
+        }
+      end
+      def write(str)
+        @yielder << str
+      end
+      def add(objs, &block)
+        if block
+          add_key objs
+          add_object &block
+        else
+          add_to_object objs
+        end
+      end
+      def add_to_object(objs)
+        objs.each_pair {|key,val|
+          add_key key
+          add_value val
+        }
+      end
+      def add_key(key)
+        write "," if @count.last > 0
+        write key.to_json
+        write ":"
+        @count[@count.size-1] += 1
+      end
+      def add_object
+        write "{"
+        @count.push 0
+        result = yield
+        @count.pop
+        write "}"
+
+        result
+      end
+      def add_array(a)
+        write "["
+        a.enum_for(:each).each_with_index {|v,i|
+          write "," if i > 0
+          add_value v
+        }
+        write "]"
+      end
+      def add_value(value)
+        if value.respond_to?:each_pair
+          add_object { add_to_object value }
+        elsif value.respond_to?:each
+          add_array value
+        elsif value.respond_to?:call
+          add_value value.call
+        else
+          write value.to_json
+        end
+      end
+    end
+  end
+end

data/lib/outstream-json.rb

@@ -0,0 +1 @@
+require_relative 'outstream/json'

data/test/test_json.rb

@@ -0,0 +1,108 @@
+require 'test/unit'
+require 'outstream-json'
+
+class TestJson < Test::Unit::TestCase
+
+  def testScalar
+    out = Outstream::Json.create {
+      add "foo" => "bar"
+    }
+    assert_equal '{"foo":"bar"}', out.to_s
+  end
+  def testScalarWithBlockParam
+    out = Outstream::Json.create {|json|
+      json.add "foo" => "bar"
+    }
+    assert_equal '{"foo":"bar"}', out.to_s
+  end
+  def testMultipleScalars
+    out = Outstream::Json.create {
+      add "foo" => "bar", "wow" => true
+    }
+
+    assert_equal '{"foo":"bar","wow":true}', out.to_s
+  end
+  def testArray
+    out = Outstream::Json.create {
+      add "foo" => [1,2,3]
+    }
+
+    assert_equal '{"foo":[1,2,3]}', out.to_s
+  end
+  def testHash
+    out = Outstream::Json.create {
+      add "foo" => {a: 1, b: 2}
+    }
+    assert_equal '{"foo":{"a":1,"b":2}}', out.to_s
+  end
+
+  def testProc
+    out = Outstream::Json.create {
+      add "foo" => lambda { "bar" }
+    }
+    assert_equal '{"foo":"bar"}', out.to_s
+  end
+  def testProcArray
+    out = Outstream::Json.create {
+      add "foo" => lambda { [1,2,3] }
+    }
+    assert_equal '{"foo":[1,2,3]}', out.to_s
+  end
+  def testProcArrayEach
+    out = Outstream::Json.create {
+      add "foo" => lambda { [1,2,3].each }
+    }
+    assert_equal '{"foo":[1,2,3]}', out.to_s
+  end
+  def testProcHash
+    out = Outstream::Json.create {
+      add "foo" => lambda { { a: 1, b: 2 } }
+    }
+    assert_equal '{"foo":{"a":1,"b":2}}', out.to_s
+  end
+  def testProcHashOfProc
+    out = Outstream::Json.create {
+      add "foo" => lambda { { a: lambda { 1 }, b: lambda { 2 } } }
+    }
+    assert_equal '{"foo":{"a":1,"b":2}}', out.to_s
+  end
+
+  def testLocalVariableScope
+    x = "bar"
+    out = Outstream::Json.create {
+      y = "cool"
+      add "foo" => x, "wow" => y
+    }
+    assert_equal '{"foo":"bar","wow":"cool"}', out.to_s
+  end
+
+  def testEnumerator
+    x = "fun"
+    out = Outstream::Json.create {
+      add "foo" => "bar", "wow" => x
+    }
+    e = out.each
+    assert_equal '{', e.next
+    assert_equal '"foo"', e.next
+    assert_equal ':', e.next
+    assert_equal '"bar"', e.next
+    assert_equal ',', e.next
+    assert_equal '"wow"', e.next
+    assert_equal ':', e.next
+
+    x.upcase!
+    assert_equal '"FUN"', e.next
+    assert_equal '}', e.next
+
+  end
+
+  def testObjectBlock
+    out = Outstream::Json.create {
+      add "foo" do
+        add "bar" => "wow"
+      end
+    }
+    assert_equal '{"foo":{"bar":"wow"}}', out.to_s
+  end
+end
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: outstream-json
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Calhoun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-13 00:00:00.000000000 Z
+dependencies: []
+description: A library which provides a DSL for writing a large number of object as
+  json without building the entire set in memory first.
+email:
+- ryanjamescalhoun@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/outstream-json.rb
+- lib/outstream/json.rb
+- test/test_json.rb
+homepage: https://github.com/ryanjamescalhoun/outstream-json
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A streaming library for writing large json output
+test_files:
+- test/test_json.rb
+- Rakefile