json-stream-path 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+.idea/
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in json-stream-path.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Manojs
+
+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,29 @@
+# Json::Stream::Path
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'json-stream-path'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install json-stream-path
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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,16 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*.rb'
+  test.verbose = true
+end
+#require 'rake/testtask'
+#
+#Rake::TestTask.new do |t|
+#  t.libs << 'test'
+#end
+#
+#desc "Run tests"
+#task :default => :test

data/json-stream-path.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json/stream/path/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json-stream-path"
+  spec.version       = Json::Stream::Path::VERSION
+  spec.authors       = ["Manojs"]
+  spec.email         = ["manojs.nitt@gmail.com"]
+  spec.description   = %q{Gem desc}
+  spec.summary       = %q{Gem summary}
+  spec.homepage      = "https://github.com/bethink/json-stream-path"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+end

data/lib/json/stream.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+require 'stringio'
+require 'json/stream/buffer'
+require 'json/stream/builder'
+require 'json/stream/parser'
+require 'json/stream/j_path_tree'
+require 'json/stream/version'

data/lib/json/stream/buffer.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+module JSON
+  module Stream
+
+    # A character buffer that expects a UTF-8 encoded stream of bytes.
+    # This handles truncated multi-byte characters properly so we can just
+    # feed it binary data and receive a properly formatted UTF-8 String as
+    # output. See here for UTF-8 parsing details:
+    # http://en.wikipedia.org/wiki/UTF-8
+    # http://tools.ietf.org/html/rfc3629#section-3
+    class Buffer
+      def initialize
+        @state, @buf, @need = :start, [], 0
+      end
+
+      # Fill the buffer with a String of binary UTF-8 encoded bytes. Returns
+      # as much of the data in a UTF-8 String as we have. Truncated multi-byte
+      # characters are saved in the buffer until the next call to this method
+      # where we expect to receive the rest of the multi-byte character.
+      def <<(data)
+        bytes = []
+        data.bytes.each do |b|
+          case @state
+          when :start
+            if b < 128
+              bytes << b
+            elsif b >= 192
+              @state = :multi_byte
+              @buf << b
+              @need = case
+                when b >= 240 then 4
+                when b >= 224 then 3
+                when b >= 192 then 2 end
+            else
+              error('Expected start of multi-byte or single byte char')
+            end
+          when :multi_byte
+            if b > 127 && b < 192
+              @buf << b
+              if @buf.size == @need
+                bytes += @buf.slice!(0, @buf.size)
+                @state = :start
+              end
+            else
+              error('Expected continuation byte')
+            end
+          end
+        end
+        bytes.pack('C*').force_encoding(Encoding::UTF_8).tap do |str|
+          error('Invalid UTF-8 byte sequence') unless str.valid_encoding?
+        end
+      end
+
+      private
+
+      def error(message)
+        raise ParserError, message
+      end
+    end
+
+  end
+end

data/lib/json/stream/builder.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+
+module JSON
+  module Stream
+    # A parser listener that builds a full, in memory, object graph from a
+    # JSON document. Typically, we would use the json gem's JSON.parse() method
+    # when we have the full JSON document because it's much faster than this.
+    # JSON::Stream is typically used when we have a huge JSON document streaming
+    # to us and we don't want to hold the entire parsed object in memory.
+    # Regardless, this is a good example of how to write parser callbacks.
+    #
+    # parser = JSON::Stream::Parser.new
+    # builder = JSON::Stream::Builder.new(parser)
+    # parser << json
+    # obj = builder.result
+    class Builder
+      METHODS = %w[start_document end_document start_object end_object start_array end_array key value]
+
+      attr_reader :result
+
+      def initialize(parser)
+        METHODS.each do |name|
+          parser.send(name, &method(name))
+        end
+      end
+
+      def start_document
+        @stack, @result = [], nil
+      end
+
+      def end_document
+        #puts "====EOD===== #{@stack.inspect} ========\n"
+        @result = @stack.pop.obj
+      end
+
+      def start_object
+        #puts "BUILDER: ========= #{@stack.inspect} ========\n"
+        @stack.push(ObjectNode.new)
+      end
+
+      def end_object
+        #puts "BUILDER: ========= #{@stack.inspect} ========\n"
+        unless @stack.size == 1
+          node = @stack.pop
+          @stack[-1] << node.obj
+        end
+      end
+      alias :end_array :end_object
+
+      def start_array
+        #puts "BUILDER: ========= #{@stack.inspect} ========\n"
+        @stack.push(ArrayNode.new)
+      end
+
+      def key(key)
+        #puts "BUILDER: ========= #{@stack.inspect} ========\n"
+        @stack[-1] << key
+      end
+
+      def value(value)
+        #puts "BUILDER: ========= #{@stack.inspect} ========\n"
+        @stack[-1] << value
+      end
+    end
+
+    class ArrayNode
+      attr_reader :obj
+
+      def initialize
+        @obj = []
+      end
+
+      def <<(node)
+        @obj << node
+        self
+      end
+
+      def to_s
+        obj.inspect
+      end
+    end
+
+    class ObjectNode
+      attr_reader :obj
+
+      def initialize
+        @obj, @key = {}, nil
+      end
+
+      def <<(node)
+        if @key
+          @obj[@key] = node
+          @key = nil
+        else
+          @key = node 
+        end
+        self
+      end
+
+      def to_s
+        "OBJ Node: {#{@key.inspect}: #{@obj.inspect}}"
+      end
+    end
+
+  end
+end

data/lib/json/stream/j_path_tree.rb

@@ -0,0 +1,44 @@
+class JPathTree
+  attr_accessor :jpath, :tree
+
+  def initialize(jpath)
+    self.jpath = jpath
+    self.tree = (jpath.nil? or jpath.empty? or !jpath.match(/^\//)) ? nil : {}
+    self.tree || return
+
+    prev_key = nil
+    self.jpath.split('/')[1..-1].each do |name|
+      name = name.intern
+      self.tree[name] = {prev: prev_key, value: false, next: nil}
+      self.tree[prev_key][:next] = name if prev_key
+      prev_key = name
+    end
+  end
+
+  def parsing_feasible?(key)
+    key = key.is_a?(String) ? key.intern : nil
+    return if key.nil? or self.tree.nil? or self.tree.empty?
+
+    node = self.tree[key]
+
+    return unless (node)
+    return if (node[:value])
+
+    prev_node = self.tree[node[:prev]]
+    next_node = self.tree[node[:next]]
+
+    if (next_node.nil?)
+      if (prev_node.nil? || prev_node[:value])
+        node[:value] = true
+        return true
+      end
+    elsif (prev_node.nil? || prev_node[:value])
+      node[:value] = true
+      return nil
+    else
+      return nil
+    end
+  end
+
+end
+

data/lib/json/stream/parser.rb

@@ -0,0 +1,545 @@
+# encoding: UTF-8
+
+module JSON
+  module Stream
+
+    class ParserError < RuntimeError;
+    end
+
+    # A streaming JSON parser that generates SAX-like events for
+    # state changes. Use the json gem for small documents. Use this
+    # for huge documents that won't fit in memory.
+    class Parser
+      BUF_SIZE = 512
+      CONTROL = /[[:cntrl:]]/
+      WS = /\s/
+      HEX = /[0-9a-fA-F]/
+      DIGIT = /[0-9]/
+      DIGIT_1_9 = /[1-9]/
+      DIGIT_END = /\d$/
+      TRUE_RE = /[rue]/
+      FALSE_RE = /[alse]/
+      NULL_RE = /[ul]/
+      TRUE_KEYWORD = 'true'
+      FALSE_KEYWORD = 'false'
+      NULL_KEYWORD = 'null'
+      LEFT_BRACE = '{'
+      RIGHT_BRACE = '}'
+      LEFT_BRACKET = '['
+      RIGHT_BRACKET = ']'
+      BACKSLASH = '\\'
+      SLASH = '/'
+      QUOTE = '"'
+      COMMA = ','
+      COLON = ':'
+      ZERO = '0'
+      MINUS = '-'
+      PLUS = '+'
+      POINT = '.'
+      EXPONENT = /[eE]/
+      B, F, N, R, T, U = %w[b f n r t u]
+
+      # Parses a full JSON document from a String or an IO stream and returns
+      # the parsed object graph. For parsing small JSON documents with small
+      # memory requirements, use the json gem's faster JSON.parse method instead.
+      def self.parse(json)
+        stream = json.is_a?(String) ? StringIO.new(json) : json
+        parser = Parser.new
+        builder = Builder.new(parser)
+        while (buf = stream.read(BUF_SIZE)) != nil
+          parser << buf
+        end
+        raise ParserError, "unexpected eof" unless builder.result
+        builder.result
+      ensure
+        stream.close
+      end
+
+      # Create a new parser with an optional initialization block where
+      # we can register event callbacks. For example:
+      # parser = JSON::Stream::Parser.new do
+      #   start_document { puts "start document" }
+      #   end_document   { puts "end document" }
+      #   start_object   { puts "start object" }
+      #   end_object     { puts "end object" }
+      #   start_array    { puts "start array" }
+      #   end_array      { puts "end array" }
+      #   key            {|k| puts "key: #{k}" }
+      #   value          {|v| puts "value: #{v}" }
+      # end
+      def initialize(&block)
+        @state = :start_document
+        @utf8 = Buffer.new
+        @listeners = Hash.new { |h, k| h[k] = [] }
+        @stack, @unicode, @buf, @pos = [], "", "", -1
+        @partial_stack = []
+        @jpath, @jpath_tree = nil, nil
+        @stop_parsing = nil
+        instance_eval(&block) if block_given?
+      end
+
+      def parse(json, jpath=nil)
+        jpath && jpath.strip!
+
+        if (jpath.nil? || jpath.match(/^\/$/) || jpath.empty?)
+          return self.class.parse(json)
+        end
+
+        @jpath = jpath
+        @jpath_tree = JPathTree.new(jpath)
+        stream = json.is_a?(String) ? StringIO.new(json) : json
+        builder = Builder.new(self)
+        while (buf = stream.read(BUF_SIZE)) != nil
+          self << buf
+        end
+
+        raise ParserError, "unexpected eof" unless builder.result
+        result = builder.result
+        (result && result.values.first) || nil
+      ensure
+        stream.close unless stream.nil?
+      end
+
+      %w[start_document end_document start_object end_object
+          start_array end_array key value].each do |name|
+
+        define_method(name) do |&block|
+          @listeners[name] << block
+        end
+
+        define_method("notify_#{name}") do |*args|
+
+          @listeners[name].each do |block|
+            #puts "----------------------------------------------"
+            #puts "#{name} ----- #{@parsing_area.inspect} ---- args #{args.inspect} --------- stack #{@stack.inspect} -------- State #{@state.inspect} --------- Partial Stack #{@partial_stack.inspect} ------ \n\n"
+            #puts "----------------------------------------------\n"
+
+            name = name.intern
+
+            if (!@jpath) # If use not used jpath, it should parse whole file
+                         #puts "#{name} ----- #{@parsing_area.inspect} ---- args #{args.inspect} --------- stack #{@stack.inspect} -------- State #{@state.inspect} --------- Partial Stack #{@partial_stack.inspect} ------ \n\n"
+              block.call(*args)
+            else
+
+              if (!@jpath_tree.tree) # If jpath is invalid it should through error
+                class InvalidJSONPath < Exception;
+                end;
+                raise InvalidJSONPath.new "Invalid json path. Example: '/root/child'"
+              end
+
+              if (!@parsing_area and @jpath_tree.parsing_feasible?(args[0])) # Check whether passed args[0] is comes under parsable area
+                @parsing_area = true
+              end
+
+              if (name == :end_document) # An :end_document call is required
+                                         #puts "#{name} ----- #{@parsing_area.inspect} ---- args #{args.inspect} --------- stack #{@stack.inspect} -------- State #{@state.inspect} --------- Partial Stack #{@partial_stack.inspect} ------ \n\n"
+                block.call(*args)
+              end
+
+              if (@parsing_area)
+                #puts "#{name} ----- #{@parsing_area.inspect} ---- args #{args.inspect} --------- stack #{@stack.inspect} -------- State #{@state.inspect} --------- Partial Stack #{@partial_stack.inspect} ------ \n\n"
+                block.call(*args)
+
+                if (name == :key and @partial_stack.empty?) # Reached first key in the parsable JSON area
+                  @partial_stack << :start_document
+                  @partial_stack << :key
+                end
+
+                poped_partial_stack_value = @partial_stack[-1]
+
+                if ( poped_partial_stack_value == :key || poped_partial_stack_value == :start_array || poped_partial_stack_value == :start_object)
+                  if (name == :start_array)
+                    @partial_stack << :start_array
+                  elsif (name == :start_object)
+                    @partial_stack << :start_object
+                  end
+                end
+
+                if (poped_partial_stack_value == :key)
+                  #if (name == :start_array)   # this commented code in all the elsif block moved up to reduce the code
+                  #  @partial_stack << :start_array
+                  #elsif (name == :start_object)
+                  #  @partial_stack << :start_object
+                  if (name == :value)
+                    @parsing_area = false
+                    @stop_parsing = true
+                    @partial_stack.pop
+                  end
+                elsif (poped_partial_stack_value == :start_array)
+                  if (name == :end_array)
+                    @partial_stack.pop
+                    if (poped_partial_stack_value == :key)
+                      @parsing_area = false
+                      @stop_parsing = true
+                      @partial_stack.pop
+                    end
+                  end
+                elsif (poped_partial_stack_value == :start_object)
+                  if (name == :end_object)
+                    @partial_stack.pop
+                    if (poped_partial_stack_value == :key)
+                      @parsing_area = false
+                      @stop_parsing = true
+                      @partial_stack.pop
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+        end
+        private "notify_#{name}"
+      end
+
+      # Pass data into the parser to advance the state machine and
+      # generate callback events. This is well suited for an EventMachine
+      # receive_data loop.
+      def <<(data)
+        (@utf8 << data).each_char do |ch|
+
+          if (@stop_parsing)
+            #notify_end_object
+            #notify_end_document
+            #end_container(:object)
+            puts "========== #{@stack.inspect} ========="
+            #print ch
+            #break
+          end
+
+          @pos += 1
+          case @state
+            when :start_document
+              case ch
+                when LEFT_BRACE
+                  @state = :start_object
+                  @stack.push(:object)
+                  @parsing_area = true
+                  notify_start_document
+                  notify_start_object
+                  @parsing_area = false
+                when LEFT_BRACKET
+                  @state = :start_array
+                  @stack.push(:array)
+                  notify_start_document
+                  notify_start_array
+                when WS
+                  # ignore
+                else
+                  error("Expected object or array start")
+              end
+            when :start_object
+              case ch
+                when RIGHT_BRACE
+                  end_container(:object)
+                when QUOTE
+                  @state = :start_string
+                  @stack.push(:key)
+                when WS
+                  # ignore
+                else
+                  error("Expected object key start")
+              end
+            when :start_string
+              case ch
+                when QUOTE
+                  if @stack.pop == :string
+                    @state = :end_value
+                    notify_value(@buf)
+                  else # :key
+                    @state = :end_key
+                    notify_key(@buf)
+                  end
+                  @buf = ""
+                when BACKSLASH
+                  @state = :start_escape
+                when CONTROL
+                  error('Control characters must be escaped')
+                else
+                  @buf << ch
+              end
+            when :start_escape
+              case ch
+                when QUOTE, BACKSLASH, SLASH
+                  @buf << ch
+                  @state = :start_string
+                when B
+                  @buf << "\b"
+                  @state = :start_string
+                when F
+                  @buf << "\f"
+                  @state = :start_string
+                when N
+                  @buf << "\n"
+                  @state = :start_string
+                when R
+                  @buf << "\r"
+                  @state = :start_string
+                when T
+                  @buf << "\t"
+                  @state = :start_string
+                when U
+                  @state = :unicode_escape
+                else
+                  error("Expected escaped character")
+              end
+            when :unicode_escape
+              case ch
+                when HEX
+                  @unicode << ch
+                  if @unicode.size == 4
+                    codepoint = @unicode.slice!(0, 4).hex
+                    if codepoint >= 0xD800 && codepoint <= 0xDBFF
+                      error('Expected low surrogate pair half') if @stack[-1].is_a?(Fixnum)
+                      @state = :start_surrogate_pair
+                      @stack.push(codepoint)
+                    elsif codepoint >= 0xDC00 && codepoint <= 0xDFFF
+                      high = @stack.pop
+                      error('Expected high surrogate pair half') unless high.is_a?(Fixnum)
+                      pair = ((high - 0xD800) * 0x400) + (codepoint - 0xDC00) + 0x10000
+                      @buf << pair
+                      @state = :start_string
+                    else
+                      @buf << codepoint
+                      @state = :start_string
+                    end
+                  end
+                else
+                  error('Expected unicode escape hex digit')
+              end
+            when :start_surrogate_pair
+              case ch
+                when BACKSLASH
+                  @state = :start_surrogate_pair_u
+                else
+                  error('Expected low surrogate pair half')
+              end
+            when :start_surrogate_pair_u
+              case ch
+                when U
+                  @state = :unicode_escape
+                else
+                  error('Expected low surrogate pair half')
+              end
+            when :start_negative_number
+              case ch
+                when ZERO
+                  @state = :start_zero
+                  @buf << ch
+                when DIGIT_1_9
+                  @state = :start_int
+                  @buf << ch
+                else
+                  error('Expected 0-9 digit')
+              end
+            when :start_zero
+              case ch
+                when POINT
+                  @state = :start_float
+                  @buf << ch
+                when EXPONENT
+                  @state = :start_exponent
+                  @buf << ch
+                else
+                  @state = :end_value
+                  notify_value(@buf.to_i)
+                  @buf = ""
+                  @pos -= 1
+                  redo
+              end
+            when :start_float
+              case ch
+                when DIGIT
+                  @state = :in_float
+                  @buf << ch
+                else
+                  error('Expected 0-9 digit')
+              end
+            when :in_float
+              case ch
+                when DIGIT
+                  @buf << ch
+                when EXPONENT
+                  @state = :start_exponent
+                  @buf << ch
+                else
+                  @state = :end_value
+                  notify_value(@buf.to_f)
+                  @buf = ""
+                  @pos -= 1
+                  redo
+              end
+            when :start_exponent
+              case ch
+                when MINUS, PLUS, DIGIT
+                  @state = :in_exponent
+                  @buf << ch
+                else
+                  error('Expected +, -, or 0-9 digit')
+              end
+            when :in_exponent
+              case ch
+                when DIGIT
+                  @buf << ch
+                else
+                  error('Expected 0-9 digit') unless @buf =~ DIGIT_END
+                  @state = :end_value
+                  num = @buf.include?('.') ? @buf.to_f : @buf.to_i
+                  notify_value(num)
+                  @buf = ""
+                  @pos -= 1
+                  redo
+              end
+            when :start_int
+              case ch
+                when DIGIT
+                  @buf << ch
+                when POINT
+                  @state = :start_float
+                  @buf << ch
+                when EXPONENT
+                  @state = :start_exponent
+                  @buf << ch
+                else
+                  @state = :end_value
+                  notify_value(@buf.to_i)
+                  @buf = ""
+                  @pos -= 1
+                  redo
+              end
+            when :start_true
+              keyword(TRUE_KEYWORD, true, TRUE_RE, ch)
+            when :start_false
+              keyword(FALSE_KEYWORD, false, FALSE_RE, ch)
+            when :start_null
+              keyword(NULL_KEYWORD, nil, NULL_RE, ch)
+            when :end_key
+              case ch
+                when COLON
+                  @state = :key_sep
+                when WS
+                  # ignore
+                else
+                  error("Expected colon key separator")
+              end
+            when :key_sep
+              start_value(ch)
+            when :start_array
+              case ch
+                when RIGHT_BRACKET
+                  end_container(:array)
+                when WS
+                  # ignore
+                else
+                  start_value(ch)
+              end
+            when :end_value
+              case ch
+                when COMMA
+                  @state = :value_sep
+                when RIGHT_BRACKET
+                  end_container(:array)
+                when RIGHT_BRACE
+                  end_container(:object)
+                when WS
+                  # ignore
+                else
+                  error("Expected comma or object or array close")
+              end
+            when :value_sep
+              if @stack[-1] == :object
+                case ch
+                  when QUOTE
+                    @state = :start_string
+                    @stack.push(:key)
+                  when WS
+                    # ignore
+                  else
+                    error("Expected object key start")
+                end
+              else
+                start_value(ch)
+              end
+            when :end_document
+              error("Unexpected data") unless ch =~ WS
+          end
+        end
+      end
+
+      private
+
+      def end_container(type)
+        @state = :end_value
+        if @stack.pop == type
+          send("notify_end_#{type}")
+        else
+          error("Expected end of #{type}")
+        end
+        if @stack.empty?
+          @state = :end_document
+          notify_end_document
+        end
+      end
+
+      def keyword(word, value, re, ch)
+        if ch =~ re
+          @buf << ch
+        else
+          error("Expected #{word} keyword")
+        end
+        if @buf.size == word.size
+          if @buf == word
+            @state = :end_value
+            @buf = ""
+            notify_value(value)
+          else
+            error("Expected #{word} keyword")
+          end
+        end
+      end
+
+      def start_value(ch)
+        case ch
+          when LEFT_BRACE
+            @state = :start_object
+            @stack.push(:object)
+            notify_start_object
+          when LEFT_BRACKET
+            @state = :start_array
+            @stack.push(:array)
+            notify_start_array
+          when QUOTE
+            @state = :start_string
+            @stack.push(:string)
+          when T
+            @state = :start_true
+            @buf << ch
+          when F
+            @state = :start_false
+            @buf << ch
+          when N
+            @state = :start_null
+            @buf << ch
+          when MINUS
+            @state = :start_negative_number
+            @buf << ch
+          when ZERO
+            @state = :start_zero
+            @buf << ch
+          when DIGIT_1_9
+            @state = :start_int
+            @buf << ch
+          when WS
+            # ignore
+          else
+            error("Expected value")
+        end
+      end
+
+      def error(message)
+        raise ParserError, "#{message}: char #{@pos}"
+      end
+    end
+
+  end
+end