json-stream 0.1.2 → 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d404ae0a1e8e03bb1551ead94eda3e413c1f492
+  data.tar.gz: 0f14c4b8a6de9f53b4bddaf824a0c0184f969399
+SHA512:
+  metadata.gz: 3640958bef5a32726c09c723a459d15986564bc7afe70bfc0db9faa15037bddd6539fa04a8d79bb95674b56a08901771f33118d3c43e862cc51984d9eca12b39
+  data.tar.gz: 260eac9e6ff3b440fce89231e0f013bb490ed5666ace3e2c5ee28c3d17cd2eb36a589a5340c42862cf4317a9737e80a976e3ce805b4979ed9dc1df3e9b39ae70

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2011 David Graham
+Copyright (c) 2010-2013 David Graham
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/{README → README.md}

@@ -1,42 +1,48 @@
-== Welcome to JSON::Stream
+# JSON::Stream
 
-JSON::Stream is a finite state machine based JSON parser that generates events
-for each state change. This allows us to stream both the JSON document into
-memory and the parsed object graph out of memory to some other process.  This
-is much like an XML SAX parser that generates events during parsing.  There is
-no requirement for the document nor the object graph to be fully buffered in
-memory.  This is best suited for huge JSON documents that won't fit in memory.
-For example, streaming and processing large map/reduce views from Apache CouchDB.
+JSON::Stream is a JSON parser, based on a finite state machine, that generates
+events for each state change. This allows streaming both the JSON document into
+memory and the parsed object graph out of memory to some other process. This
+is much like an XML SAX parser that generates events during parsing. There is
+no requirement for the document, or the object graph, to be fully buffered in
+memory. This is best suited for huge JSON documents that won't fit in memory.
+For example, streaming and processing large map/reduce views from Apache
+CouchDB.
 
-== Usage
+## Usage
 
 The simplest way to parse is to read the full JSON document into memory
-and then parse it into a full object graph.  This is fine for small documents
+and then parse it into a full object graph. This is fine for small documents
 because we have room for both the document and parsed object in memory.
 
+```ruby
 require 'json/stream'
 json = File.read('/tmp/test.json')
 obj = JSON::Stream::Parser.parse(json)
+```
 
 While it's possible to do this with JSON::Stream, we really want to use the json
-gem for documents like this.  JSON.parse() is much faster than this parser
+gem for documents like this. JSON.parse() is much faster than this parser,
 because it can rely on having the entire document in memory to analyze.
 
 For larger documents we can use an IO object to stream it into the parser.
 We still need room for the parsed object, but the document itself is never
 fully read into memory.
 
+```ruby
 require 'json/stream'
 stream = File.open('/tmp/test.json')
 obj = JSON::Stream::Parser.parse(stream)
+```
 
-Again, while we can do this with JSON::Stream, if we just need to stream the
+Again, while JSON::Stream can be used this way, if we just need to stream the
 document from disk or the network, we're better off using the yajl-ruby gem.
 
 Huge documents arriving over the network in small chunks to an EventMachine
-receive_data loop is where JSON::Stream is really useful.  Inside our
+receive_data loop is where JSON::Stream is really useful. Inside an
 EventMachine::Connection subclass we might have:
 
+```ruby
 def post_init
   @parser = JSON::Stream::Parser.new do
     start_document { puts "start document" }
@@ -57,26 +63,27 @@ def receive_data(data)
     close_connection
   end
 end
+```
 
 Notice how the parser accepts chunks of the JSON document and parses up
-up to the end of the available buffer.  Passing in more data resumes the
-parse from the prior state.  When an interesting state change happens, the
+to the end of the available buffer. Passing in more data resumes the
+parse from the prior state. When an interesting state change happens, the
 parser notifies all registered callback procs of the event.
 
 The event callback is where we can do interesting data filtering and passing
-to other processes.  The above example simply prints state changes, but
+to other processes. The above example simply prints state changes, but
 imagine the callbacks looking for an array named "rows" and processing sets
-of these row objects in small batches.  We can process millions of rows streaming
-over the network in constant memory space this way.
+of these row objects in small batches. Millions of rows, streaming over the
+network, can be processed in constant memory space this way.
 
-== Dependencies
+## Dependencies
 
-* ruby >= 1.9.1
+* ruby >= 1.9.2
 
-== Contact
+## Contact
 
 Project contact: David Graham <david.malcom.graham@gmail.com>
 
-== License
+## License
 
 JSON::Stream is released under the MIT license.  Check the LICENSE file for details.

data/Rakefile

@@ -1,37 +1,20 @@
 require 'rake'
 require 'rake/clean'
-require 'rake/gempackagetask'
 require 'rake/testtask'
-require_relative 'lib/json/stream/version'
 
-spec = Gem::Specification.new do |s|
-  s.name = "json-stream"
-  s.version = JSON::Stream::VERSION
-  s.date = Time.now.strftime("%Y-%m-%d")
-  s.summary = "A streaming JSON parser that generates SAX-like events."
-  s.description = "A finite state machine based JSON parser that generates events
-for each state change. This allows us to stream both the JSON document into
-memory and the parsed object graph out of memory to some other process. This
-is much like an XML SAX parser that generates events during parsing. There is
-no requirement for the document nor the object graph to be fully buffered in
-memory. This is best suited for huge JSON documents that won't fit in memory.
-For example, streaming and processing large map/reduce views from Apache CouchDB."
-  s.email = "david.malcom.graham@gmail.com"
-  s.homepage = "http://dgraham.github.com/json-stream/"
-  s.authors = ["David Graham"]
-  s.files = FileList['[A-Z]*', "{lib}/**/*"]
-  s.require_path = "lib"
-  s.test_files = FileList["{test}/**/*test.rb"]
-  s.required_ruby_version = '>= 1.9.1'
-end
+CLOBBER.include('pkg')
+
+directory 'pkg'
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar = true 
+desc 'Build distributable packages'
+task :build => [:pkg] do
+  system 'gem build json-stream.gemspec && mv json-*.gem pkg/'
 end
 
 Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
   test.pattern = 'test/**/*_test.rb'
   test.warning = true
 end
 
-task :default => [:clobber, :test, :gem]
+task :default => [:clobber, :test, :build]

data/json-stream.gemspec

@@ -0,0 +1,20 @@
+require './lib/json/stream/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'json-stream'
+  s.version     = JSON::Stream::VERSION
+  s.summary     = %q[A streaming JSON parser that generates SAX-like events.]
+  s.description = %q[A parser best suited for huge JSON documents that don't fit in memory.]
+
+  s.authors      = ['David Graham']
+  s.email        = %w[david.malcom.graham@gmail.com]
+  s.homepage     = 'http://dgraham.github.io/json-stream/'
+  s.license      = 'MIT'
+
+  s.files        = Dir['[A-Z]*', 'json-stream.gemspec', '{lib}/**/*']
+  s.test_files   = Dir['test/**/*']
+  s.require_path = 'lib'
+
+  s.add_development_dependency 'rake'
+  s.required_ruby_version = '>= 1.9.2'
+end

data/lib/json/stream/buffer.rb

@@ -58,6 +58,5 @@ module JSON
         raise ParserError, message
       end
     end
-
   end
 end

data/lib/json/stream/builder.rb

@@ -82,11 +82,10 @@ module JSON
           @obj[@key] = node
           @key = nil
         else
-          @key = node 
+          @key = node
         end
         self
       end
     end
-
   end
 end

data/lib/json/stream/parser.rb

@@ -2,7 +2,6 @@
 
 module JSON
   module Stream
-
     class ParserError < RuntimeError; end
 
     # A streaming JSON parser that generates SAX-like events for
@@ -10,7 +9,7 @@ module JSON
     # for huge documents that won't fit in memory.
     class Parser
       BUF_SIZE      = 512
-      CONTROL       = /[[:cntrl:]]/
+      CONTROL       = /[\x00-\x1F]/
       WS            = /\s/
       HEX           = /[0-9a-fA-F]/
       DIGIT         = /[0-9]/
@@ -194,7 +193,7 @@ module JSON
             end
           when :start_surrogate_pair
             case ch
-            when BACKSLASH 
+            when BACKSLASH
               @state = :start_surrogate_pair_u
             else
               error('Expected low surrogate pair half')
@@ -425,6 +424,5 @@ module JSON
         raise ParserError, "#{message}: char #{@pos}"
       end
     end
-
   end
 end

data/lib/json/stream/version.rb

@@ -2,6 +2,6 @@
 
 module JSON
   module Stream
-    VERSION = "0.1.2"
+    VERSION = '0.1.3'
   end
 end

data/test/parser_test.rb

@@ -220,6 +220,9 @@ class ParserTest < Test::Unit::TestCase
 
     expected = [:start_document, :start_object, :error]
     assert_equal(expected, events("{\" \u0000 \":12}"))
+
+    expected = [:start_document, :start_array, [:value, " \u007F "], :end_array, :end_document]
+    assert_equal(expected, events("[\" \u007f \"]"))
   end
 
   def test_unicode_escape
@@ -447,5 +450,4 @@ class ParserTest < Test::Unit::TestCase
       @events << :error
     end
   end
-
 end

metadata

@@ -1,38 +1,40 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: json-stream
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.2
+version: !ruby/object:Gem::Version
+  version: 0.1.3
 platform: ruby
-authors: 
+authors:
 - David Graham
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-22 00:00:00 -06:00
-default_executable: 
-dependencies: []
-
-description: |-
-  A finite state machine based JSON parser that generates events
-  for each state change. This allows us to stream both the JSON document into
-  memory and the parsed object graph out of memory to some other process. This
-  is much like an XML SAX parser that generates events during parsing. There is
-  no requirement for the document nor the object graph to be fully buffered in
-  memory. This is best suited for huge JSON documents that won't fit in memory.
-  For example, streaming and processing large map/reduce views from Apache CouchDB.
-email: david.malcom.graham@gmail.com
+date: 2013-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A parser best suited for huge JSON documents that don't fit in memory.
+email:
+- david.malcom.graham@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - LICENSE
 - Rakefile
-- README
+- README.md
+- json-stream.gemspec
 - lib/json/stream/buffer.rb
 - lib/json/stream/builder.rb
 - lib/json/stream/parser.rb
@@ -41,35 +43,31 @@ files:
 - test/buffer_test.rb
 - test/builder_test.rb
 - test/parser_test.rb
-has_rdoc: true
-homepage: http://dgraham.github.com/json-stream/
-licenses: []
-
+homepage: http://dgraham.github.io/json-stream/
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.9.1
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A streaming JSON parser that generates SAX-like events.
-test_files: 
+test_files:
 - test/buffer_test.rb
 - test/builder_test.rb
 - test/parser_test.rb