json-expect-parser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a6dda865f0de7159d92fba2db57f98f9220bb68
+  data.tar.gz: aec146fb010f935f35b1ab79a3caa1cf7b2c4bab
+SHA512:
+  metadata.gz: 7f734a7edd681dd9a15ce6d65bfe0464dc693ef9594a541d039bd364d5c6dced4639a168734f4b8f881e426c7c162325dc7250c77ed1e11061aebdd226e57bd6
+  data.tar.gz: 4fbdeaffdfa23c1829459f6fe086554dd7ef87cc76e492c3c6c18c7cbef9ac3f02653267835efdadad30d7feb22681de734695177105028048dca344ecac90aa

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 ksss
+
+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,202 @@
+json-expect-parser
+===
+
+An alternative JSON parser.
+
+## Synopsis
+
+t.json
+
+```json
+[
+  {
+    "id": 1,
+    "name": "ksss",
+    "admin": true
+  },
+  {
+    "id": 2,
+    "name": "foo",
+    "admin": false
+  },
+  {
+    "id": 3,
+    "name": "bar",
+    "admin": false
+  }
+]
+```
+
+```rb
+require 'json/expect/parser'
+
+File.open("t.json") do |io|
+  expect = JSON::Expect::Parser.new(io)
+  expect.array do
+    expect.object do
+      case expect.key
+      when "id"
+        p expect.integer #=> 1, 2, 3
+      when "name"
+        p expect.string #=> "ksss", "foo", "bar"
+      when "admin"
+        p expect.boolean #=> true, false, false
+      end
+    end
+  end
+end
+```
+
+## Explicitly parse
+
+json-expect-parser parse JSON explicitly.
+
+```rb
+expect = JSON::Expect::Parser.new(%([10, 20, 30]))
+expect.array { p expect.integer } #=> 10, 20, 30
+```
+
+If get unexpected value, It failed.
+
+```rb
+expect = JSON::Expect::Parser.new(%([10, 20, 30]))
+expect.array { p expect.string }
+#=> JSON::Expect::ParseError: expected "\"" but was "1"
+```
+
+## API
+
+### object
+
+```rb
+expect = JSON::Expect::Parser.new(%({"a": 10, "b": 20}))
+
+expect.object
+#=> #<Enumerator: #<JSON::Expect::Parser ...>>
+
+expect.object do
+  expect.key #=> "a", "b"
+  expect.integer #=> 10, 20
+end
+```
+
+### array
+
+```rb
+expect = JSON::Expect::Parser.new(%(["foo", "bar", "baz"]))
+
+expect.array
+#=> #<Enumerator: #<JSON::Expect::Parser ...>>
+
+expect.array do  
+  expect.string #=> "foo", "bar", "baz"
+end
+
+expect.rewind
+
+expect.array.map { expect.string }
+#=> ["foo", "bar", "baz"]
+```
+
+### integer
+
+```rb
+expect = JSON::Expect::Parser.new(%(100))
+expect.integer #=> 100
+```
+
+### number(alias float)
+
+```rb
+expect = JSON::Expect::Parser.new(%(1.1))
+expect.float #=> 1.1
+```
+
+### string
+
+```rb
+expect = JSON::Expect::Parser.new(%("foo"))
+expect.string #=> "foo"
+```
+
+### key
+
+Use in `object` then get object key string
+
+### boolean
+
+```rb
+expect = JSON::Expect::Parser.new(%("true"))
+expect.boolean #=> true
+```
+
+### null
+
+```rb
+expect = JSON::Expect::Parser.new(%("null"))
+expect.null #=> nil
+```
+
+### object_or_null
+
+```rb
+expect = JSON::Expect::Parser.new(%([{"a": 1}, null]))
+expect.array do
+  expect.object_or_null do
+    expect.key #=> "a"
+    expect.integer #=> 1
+  end
+end
+```
+
+### array_or_null
+
+```rb
+expect = JSON::Expect::Parser.new(%([[1, 2, 3], null]))
+expect.array do
+  expect.array_or_null do
+    expect.integer #=> 1, 2, 3
+  end
+end
+```
+
+### null_or
+
+```rb
+expect = JSON::Expect::Parser.new(%({"a": "foo", "b": null}))
+expect.object do
+  expect.key #=> "a", "b"
+  expect.null_or { expect.string } #=> "foo", nil
+end
+```
+
+### value(alias parse)
+
+```rb
+expect = JSON::Expect::Parser.new(%([[true, false], null, 1, "foo"]))
+expect.value
+#=> [[true, false], nil, 1.0, "foo"]
+```
+
+### rewind
+
+```rb
+expect = JSON::Expect::Parser.new(%("foo"))
+expect.string #=> "foo"
+expect.string #=> "foo"
+#=> JSON::Expect::ParseError: expected "\"" but was nil
+expect.rewind
+expect.string #=> "foo"
+```
+
+# Benchmark
+
+```
+8320.0kb
+38420.0kb
+ruby t.rb  0.19s user 0.06s system 98% cpu 0.257 total
+
+8124.0kb
+10732.0kb
+ruby j.rb  0.83s user 0.06s system 99% cpu 0.891 total
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+task :test do
+  sh "bundle ex rgot -v --bench ."
+end
+task default: :test

data/benchmark/comparison.rb

@@ -0,0 +1,47 @@
+#! /usr/bin/env ruby
+
+require 'benchmark'
+require 'get_process_mem'
+require 'json/pure/parser'
+require 'json/ext/parser'
+require 'json/expect/parser'
+
+puts "ruby v#{RUBY_VERSION}"
+puts `uname -v`
+
+b = []
+30000.times do
+  b << %({"abcdefg": 123456, "hijklmn": "fooooooooooooooo", "opqrstu": -123.456})
+end
+json = "[#{b.join(",")}]"
+puts "#{json.length / 1024}KB json string"
+
+puts
+
+[
+  ['JSON::Ext::Parser', -> { JSON::Ext::Parser.new(json).parse }],
+  ['JSON::Pure::Parser', -> { JSON::Pure::Parser.new(json).parse }],
+  ['JSON::Expect::Parser', -> {
+    e = JSON::Expect::Parser.new(json)
+    e.array do
+      e.object do
+        e.key
+        e.integer
+        e.key
+        e.string
+        e.key
+        e.float
+      end
+    end
+  }],
+].each do |name, proc|
+  GC.start
+  Process.wait fork {
+    puts "=== #{name} ==="
+    mem = GetProcessMem.new.kb
+    print "time: "
+    puts Benchmark.realtime(&proc)
+    puts "memory: #{GetProcessMem.new.kb - mem}KB"
+    puts
+  }
+end

data/example/pipe.rb

@@ -0,0 +1,26 @@
+#! /usr/bin/env ruby
+require 'json/expect/parser'
+
+IO.pipe do |r, w|
+  t = Thread.new do
+    expect = JSON::Expect::Parser.new(r, buffer_size: 1)
+    expect.array do
+      puts expect.integer
+    end
+  end
+  w.write "["
+  w.write "10,"
+  sleep 1
+  w.write "20,"
+  sleep 1
+  w.write "30"
+  sleep 1
+  w.write "]"
+  w.close
+  t.join
+end
+__END__
+$ bundle ex ruby example/pipe.rb
+10
+20
+30

data/example/simple.rb

@@ -0,0 +1,38 @@
+#! /usr/bin/env ruby
+require 'json/expect/parser'
+
+values = []
+expect = JSON::Expect::Parser.new(DATA)
+expect.array do
+  expect.object do
+    case expect.key
+    when "id"
+      values << expect.integer
+    when "name"
+      values << expect.string
+    when "admin"
+      values << expect.boolean
+    end
+  end
+end
+p values
+# $ bundle ex ruby example/simple.rb
+# [1, "ksss", true, 2, "foo", false, 3, "bar", false]
+__END__
+[
+  {
+    "id": 1,
+    "name": "ksss",
+    "admin": true
+  },
+  {
+    "id": 2,
+    "name": "foo",
+    "admin": false
+  },
+  {
+    "id": 3,
+    "name": "bar",
+    "admin": false
+  }
+]

data/example/stdin.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+require 'json/expect/parser'
+require 'pp'
+
+pp JSON::Expect::Parser.new(STDIN).parse
+__END__
+$ echo '["Hello", "World!"]' | bundle ex ruby example/stdin.rb
+["Hello", "World!"]

data/example/string.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'json/expect/parser'
+
+values = []
+expect = JSON::Expect::Parser.new(%([10, 20, 30]))
+expect.array do
+  values << expect.integer
+end
+p values
+#=> [10, 20, 30]

data/json-expect-parser.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json/expect/parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json-expect-parser"
+  spec.version       = JSON::Expect::Parser::VERSION
+  spec.authors       = ["ksss"]
+  spec.email         = ["co000ri@gmail.com"]
+
+  spec.summary       = "JSON expect parser"
+  spec.description   = "An alternative JSON parser"
+  spec.homepage      = "https://github.com/ksss/json-expect-parser"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{_test.rb}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "json"
+  spec.add_development_dependency "get_process_mem"
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rgot"
+end

data/lib/json/expect/parser.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+module JSON
+  module Expect
+    ParseError = Class.new(StandardError)
+    class Buffer
+      def initialize(input, size)
+        unless 0 < size
+          raise ArgumentError, "negative buffer_size"
+        end
+        @io = case input
+        when String
+          StringIO.new(input)
+        when IO, StringIO
+          input
+        else
+          raise ArgumentError, "#{input.class} is not supported"
+        end
+        @string = String.new
+        @index = 0
+        @size = size
+      end
+
+      def fetch(len = 0)
+        if str = @io.read(@size + len)
+          @string = @string[@index..-1] << str
+          @index = 0
+        else
+          nil
+        end
+      end
+
+      def next(len = 1)
+        if @string.length - @index < len
+          if str = @io.read(@size + len)
+            @string = @string[@index..-1] << str
+            @index = 0
+          end
+        end
+
+        if @string.length <= @index
+          nil
+        else
+          r = @string[@index, len]
+          @index += r.length
+          r
+        end
+      end
+
+      def back(len = 1)
+        @index -= len
+      end
+
+      def scan(regexp)
+        if m = regexp.match(@string, @index)
+          @index += m[0].length
+          m[0]
+        else
+          nil
+        end
+      end
+
+      def next_without_whitespace
+        while ch = self.next
+          case ch
+          when " ", "\t", "\n", "\r"
+          else
+            return ch
+          end
+        end
+      end
+
+      def rewind
+        @string.clear
+        @index = 0
+        @io.rewind
+      end
+    end
+
+    class Parser
+      NUM_FIRST = /\A-|\d/
+      # from json/pure
+      STRING = /"(?:[^\x0-\x1f"\\] |
+         # escaped special characters:
+        \\["\\\/bfnrt] |
+        \\u[0-9a-fA-F]{4} |
+         # match all but escaped special characters:
+        \\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*
+      "/nx
+      INTEGER = /\A-?0|-?[1-9]\d*/
+      FLOAT = /\A-?
+        (?:0|[1-9]\d*)
+        (?:
+          \.\d+(?i:e[+-]?\d+) |
+          \.\d+ |
+          (?i:e[+-]?\d+)
+        )?
+      /x
+
+      def initialize(input, opts = {})
+        buffer_size = if opts[:buffer_size]
+          opts[:buffer_size]
+        else
+          4092
+        end
+        @count_stack = []
+        @buffer = Buffer.new(input, buffer_size)
+      end
+
+      def object
+        return to_enum(:object) unless block_given?
+
+        expect_char("{")
+        count_up
+        @count_stack.push(0)
+        while true
+          case ch = @buffer.next_without_whitespace
+          when "}"
+            check_tail
+            break @count_stack.pop
+          when "\""
+            @buffer.back(ch.length)
+            before_count = current_count
+            yield
+            raise ParseError, "nothing expectation in block" unless before_count != current_count
+            check_tail
+          else
+            raise ParseError, "expected \"}\" or \"\"\" but was #{ch.inspect}"
+          end
+        end
+      end
+
+      def array
+        return to_enum(:array) unless block_given?
+
+        expect_char("[")
+        count_up
+        @count_stack.push(0)
+        while true
+          case ch = @buffer.next_without_whitespace
+          when "]"
+            check_tail
+            break @count_stack.pop
+          when nil
+            raise ParseError, "expected any array item but EOF"
+          else
+            @buffer.back(ch.length)
+            before_count = current_count
+            yield
+            raise ParseError, "nothing expectation in block" unless before_count != current_count
+            check_tail
+          end
+        end
+      end
+
+      def key
+        expect_char("\"")
+        @buffer.back
+        until m = @buffer.scan(STRING)
+          if @buffer.fetch.nil?
+            raise ParseError, "expected \"\"\" but was EOF"
+          end
+        end
+        expect_char(":")
+        m[1..-2]
+      end
+
+      def string
+        expect_char("\"")
+        @buffer.back
+        until m = @buffer.scan(STRING)
+          if @buffer.fetch.nil?
+            raise ParseError, "expected \"\"\" but was EOF"
+          end
+        end
+        count_up
+        check_tail
+        m[1..-2]
+      end
+
+      def integer
+        buffer = @buffer.next_without_whitespace
+        if NUM_FIRST =~ buffer
+          i = @buffer.next(16)
+          buffer << i if i
+          while m = INTEGER.match(buffer)
+            break if m[0].length != buffer.length
+            i = @buffer.next(16)
+            break unless i
+            buffer << i
+          end
+          raise ParseError, "expected integer but was #{buffer.inspect}" unless m
+          @buffer.back(buffer.length - m[0].length)
+          count_up
+          check_tail
+          m[0].to_i
+        else
+          raise ParseError, "expected integer but was #{buffer.inspect}"
+        end
+      end
+
+      def number
+        buffer = @buffer.next_without_whitespace
+        if NUM_FIRST =~ buffer
+          i = @buffer.next(16)
+          buffer << i if i
+          if buffer[-1] == "."
+            i = @buffer.next(16)
+            raise ParseError, "expected number after \".\" but nothing" unless i
+            buffer << i
+          end
+          while m = FLOAT.match(buffer)
+            break if m[0].length != buffer.length
+            i = @buffer.next(16)
+            break unless i
+            buffer << i
+          end
+          raise ParseError, "expected number but was #{buffer.inspect}" unless m
+          @buffer.back(buffer.length - m[0].length)
+          count_up
+          check_tail
+          m[0].to_f
+        else
+          raise ParseError, "expected number but was #{buffer.inspect}"
+        end
+      end
+      alias float number
+
+      def boolean
+        case ch = @buffer.next_without_whitespace
+        when "t"
+          if "rue" == (rue = @buffer.next(3))
+            count_up
+            check_tail
+            true
+          else
+            raise ParseError, "expected true or false but was \"#{ch}#{rue}\""
+          end
+        when "f"
+          if "alse" == (alse = @buffer.next(4))
+            count_up
+            check_tail
+            false
+          else
+            raise ParseError, "expected true or false but was \"#{ch}#{alse}\""
+          end
+        else
+          raise ParseError, "expected true or false but was \"#{ch}\""
+        end
+      end
+
+      def null
+        case ch = @buffer.next_without_whitespace
+        when "n"
+          if "ull" == (ull = @buffer.next(3))
+            count_up
+            check_tail
+            nil
+          else
+            raise ParseError, "expected null but was \"#{ch}#{ull}\""
+          end
+        else
+          raise ParseError, "expected null but was #{ch.inspect}"
+        end
+      end
+
+      def object_or_null
+        null_or { object { yield } }
+      end
+
+      def array_or_null
+        null_or { array { yield } }
+      end
+
+      def null_or
+        ch = @buffer.next_without_whitespace
+        @buffer.back
+        if ch == 'n'
+          null
+        else
+          yield
+        end
+      end
+
+      def value
+        ch = @buffer.next_without_whitespace
+        @buffer.back
+        case ch
+        when "["
+          array.map { value }
+        when "{"
+          Hash[object.map { [key, value] }]
+        when "n"
+          null
+        when "t", "f"
+          boolean
+        when "\""
+          string
+        when NUM_FIRST
+          number
+        else
+          raise ParseError, "expected any value but was #{ch.inspect}"
+        end
+      end
+      alias parse value
+
+      def rewind
+        @buffer.rewind
+      end
+
+      private
+
+      def count_up
+        if !@count_stack.empty?
+          @count_stack[-1] += 1
+        end
+      end
+
+      def current_count
+        @count_stack[-1]
+      end
+
+      def check_tail
+        case ch = @buffer.next_without_whitespace
+        when ","
+          raise ParseError, "unexpected \",\"" if @count_stack.empty?
+          ch = @buffer.next_without_whitespace
+          raise ParseError, "expected next token but was EOF" unless ch
+          case ch
+          when "]", "}", ","
+            raise ParseError, "expected next token but was #{ch.inspect}"
+          else
+            @buffer.back
+          end
+        when nil
+        else
+          @buffer.back
+        end
+      end
+
+      def expect_char(expect)
+        actual = @buffer.next_without_whitespace
+        unless actual == expect
+          raise ParseError, "expected #{expect.inspect} but was #{actual.inspect}"
+        end
+        actual
+      end
+    end
+  end
+end

data/lib/json/expect/parser/version.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Expect
+    class Parser
+      VERSION = "0.0.1"
+    end
+  end
+end

data/mrbgem.rake

@@ -0,0 +1,8 @@
+MRuby::Gem::Specification.new('json-expect-parser') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'A JSON Parser'
+  spec.add_dependency('mruby-string-ext', core: 'mruby-string-ext')
+  spec.add_dependency('mruby-stringio')
+  spec.add_dependency('mruby-onig-regexp')
+end

data/mrblib

@@ -0,0 +1 @@
+lib

data/test/parser.rb

@@ -0,0 +1,12 @@
+assert('JSON::Expect::Parser') do
+  begin
+    e = JSON::Expect::Parser.new(%({"hello": "world"}))
+    e.object do
+      assert_equal "hello", e.key
+      assert_equal "world", e.string
+    end
+  rescue => e
+    puts e.backtrace
+    raise
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: json-expect-parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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'
+- !ruby/object:Gem::Dependency
+  name: get_process_mem
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rgot
+  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: An alternative JSON parser
+email:
+- co000ri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/comparison.rb
+- example/pipe.rb
+- example/simple.rb
+- example/stdin.rb
+- example/string.rb
+- json-expect-parser.gemspec
+- lib/json/expect/parser.rb
+- lib/json/expect/parser/version.rb
+- mrbgem.rake
+- mrblib
+- test/parser.rb
+homepage: https://github.com/ksss/json-expect-parser
+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.5.1
+signing_key: 
+specification_version: 4
+summary: JSON expect parser
+test_files: []