muskox 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3510d3fe36c918d6bd4d03adcb3c0e7c2d97b483
+  data.tar.gz: c363d6428df50d83487ef2225f7a0406ee070a44
+SHA512:
+  metadata.gz: aeed441cc11da57916011743180f57bbae7e558aed19e5b1580858674b379e0de610602299d611b345b658e169bc4a13b42f755be1ba7cbf47359179500a946a
+  data.tar.gz: 5a9120f14d48e687e2fd836bb85bd83bc93de4ef3bf5a90543f420056ba7e6129dbb33e597f3ad55719b49a8f2014d374627c1ae98a6b648ab4ece611e82def9

data/.gitignore

@@ -0,0 +1,17 @@
+*.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/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "json_schema_test_suite"]
+	path = json_schema_test_suite
+	url = https://github.com/json-schema/JSON-Schema-Test-Suite.git

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nick Howard
+
+MIT License
+
+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,62 @@
+# Muskox
+
+A JSON Parser-Generator that takes a json-schema and converts it into a parser.
+
+## Why?
+
+Using a parser to handle inputs makes your app safe from attacks that rely on passing disallowed params, because disallowed params will either be ignored or rejected.
+
+> Be definite about what you accept.(*) 
+>
+> Treat inputs as a language, accept it with a matching computational
+> power, generate its recognizer from its grammar.
+>
+> Treat input-handling computational power as privilege, and reduce it
+> whenever possible.
+
+http://www.cs.dartmouth.edu/~sergey/langsec/postel-principle-patch.txt
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'muskox'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install muskox
+
+## Usage
+
+```ruby
+    # to generate a parser, call generate w/ a JSON-Schema
+    parser = Muskox.generate({
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "number" => {
+            "type" => "integer"
+          }
+        },
+        "required" => ["number"]
+      })
+
+    # then call parse with the string you want to have parsed
+    n = parser.parse "{\"number\": 1}"
+    # => {"number" => 1}
+    
+    # invalid types are disallowed
+    parser.parse "{\"number\": true}" rescue puts $!
+```
+
+## 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,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+Rake::TestTask.new :spec do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :spec

data/lib/muskox.rb

@@ -0,0 +1,165 @@
+require "muskox/version"
+require "muskox/json_lexer"
+
+module Muskox
+  def self.generate schema
+    Parser.new schema
+  end
+
+  class Parser
+    ROOT = nil
+    attr_reader :schema
+    def initialize schema
+      @schema = schema
+    end
+
+    def parse input
+      r = nil
+      schema_stack = [schema]
+      stack = [[ROOT, ROOT]]
+      lexer = Pure::Lexer.new input, :quirks_mode => true
+      lexer.lex do |type, value|
+#        puts "token #{type}: #{value}"
+#        puts "stack #{stack.inspect}"
+#        puts "schema stack #{schema_stack.last["type"]}"
+        case type
+        when :property
+          if schema_stack.last["properties"] && schema_stack.last["properties"].keys.include?(value)
+            stack.push [type, value]
+          else
+            raise ParserError, "Unexpected property: #{value}"
+          end
+        when :array_begin
+          case stack.last.first
+          when :property
+            last = stack.last
+            matching_type expected_type(schema_stack.last, last), "array" do
+              stack.push [:array, []]
+              schema_stack.push(schema["properties"][last.last])
+            end
+          when ROOT
+            stack.push [:array, []]
+          else
+            raise "unknown stack type #{stack.last}"
+          end
+        when :array_end
+          array_top = stack.pop
+
+          case stack.last.first
+          when :property
+            schema_stack.pop
+            last = stack.pop
+            matching_type expected_type(schema_stack.last, last), "array" do
+              stack.last.last[last.last] = array_top.last
+            end
+          when :array
+            matching_type expected_type(schema_stack.last, last), "array" do
+              stack.last.last << array_top.last
+            end
+          when ROOT
+            matching_type schema_stack.last["type"], "array" do
+              r = stack.last.last
+            end
+          else
+            raise "unknown stack type #{stack.last}"
+          end
+        when :object_begin
+          case stack.last.first
+          when :property
+            last = stack.last
+            matching_type expected_type(schema_stack.last, last), "object" do
+              stack.push [:object, {}]
+              schema_stack.push(schema["properties"][last.last])
+            end
+          when ROOT
+            stack.push [:object, {}]
+          end
+        when :object_end
+          object_top = stack.pop
+
+          if schema_stack.last["required"] && !(schema_stack.last["required"] - object_top.last.keys).empty?
+            raise ParserError
+          end
+
+          case stack.last.first
+          when :property
+            schema_stack.pop
+            last = stack.pop
+            matching_type expected_type(schema_stack.last, last), "object", stack.last.first == :object do
+              stack.last.last[last.last] = object_top.last
+            end
+          when ROOT
+            matching_type schema_stack.last["type"], "object" do
+              r = object_top.last
+            end
+          else
+            raise "unknown stack type #{stack.last.first}"
+          end
+        when :integer, :string, :float, :boolean, :null
+          case stack.last.first
+          when :property
+            last = stack.pop
+            matching_type expected_type(schema_stack.last, last), type, stack.last.first == :object do
+              stack.last.last[last.last] = value
+            end
+          when :array
+            case schema_stack.last["items"]
+            when Hash
+              matching_type schema_stack.last["items"]["type"], type do
+                stack.last.last << value
+              end
+            when Array
+              matching_type schema_stack.last["items"][stack.last.last.size]["type"], type do
+                stack.last.last << value
+              end
+            else
+              raise "Unexpected items type #{schema_stack.last["items"]}"
+            end
+          when ROOT
+            matching_type schema_stack.last["type"], type do
+              r = stack.last.last
+            end
+          else
+            raise "unknown stack type #{stack.last.inspect}"
+          end
+        else
+          raise "unhandled token type: #{type}: #{value}"
+        end
+      end
+      r
+    end
+
+    def expected_type schema, last
+      schema["properties"][last.last] && schema["properties"][last.last]["type"]
+    end
+
+    def matching_type expected, actual, opt=true
+      if is_type(expected, actual.to_s) && opt
+        yield
+      else
+        raise ParserError, "expected node of type #{expected} but was #{actual}"
+      end
+    end
+
+    TYPE_WIDENINGS = {
+      'integer' => 'number',
+      'float' => 'number'
+    }
+    def is_type expected, actual
+      case expected
+      when String
+        expected == actual || expected == TYPE_WIDENINGS[actual]
+      when Array
+        expected.any? {|e| is_type e, actual }
+      when nil
+        true # is this really what the spec wants? really?
+      else
+        raise "unexpected type comparison #{expected}, #{actual}"
+      end
+    end
+  end
+
+  class ParserError < StandardError
+  end
+
+end

data/lib/muskox/json_lexer.rb

@@ -0,0 +1,336 @@
+# comes from https://github.com/flori/json/blob/master/lib/json/pure/parser.rb + modifications to make it a lexer
+# terrible, I know, but this is a hack afterall
+
+require 'strscan'
+
+module Muskox
+  module Pure
+    class Lexer < StringScanner
+      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               = /(-?0|-?[1-9]\d*)/
+      FLOAT                 = /(-?
+                                (?:0|[1-9]\d*)
+                                (?:
+                                  \.\d+(?i:e[+-]?\d+) |
+                                  \.\d+ |
+                                  (?i:e[+-]?\d+)
+                                )
+                                )/x
+      NAN                   = /NaN/
+      INFINITY              = /Infinity/
+      MINUS_INFINITY        = /-Infinity/
+      OBJECT_OPEN           = /\{/
+      OBJECT_CLOSE          = /\}/
+      ARRAY_OPEN            = /\[/
+      ARRAY_CLOSE           = /\]/
+      PAIR_DELIMITER        = /:/
+      COLLECTION_DELIMITER  = /,/
+      TRUE                  = /true/
+      FALSE                 = /false/
+      NULL                  = /null/
+      IGNORE                = %r(
+        (?:
+         //[^\n\r]*[\n\r]| # line comments
+         /\*               # c-style comments
+         (?:
+          [^*/]|        # normal chars
+          /[^*]|        # slashes that do not start a nested comment
+          \*[^/]|       # asterisks that do not end this comment
+          /(?=\*/)      # single slash before this comment's end
+         )*
+           \*/               # the End of this comment
+           |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+        )+
+      )mx
+
+      UNPARSED = Object.new
+
+      # Creates a new JSON::Pure::Parser instance for the string _source_.
+      #
+      # It will be configured by the _opts_ hash. _opts_ can have the following
+      # keys:
+      # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+      #   structures. Disable depth checking with :max_nesting => false|nil|0,
+      #   it defaults to 100.
+      # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+      #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+      #   to false.
+      # * *symbolize_names*: If set to true, returns symbols for the names
+      #   (keys) in a JSON object. Otherwise strings are returned, which is also
+      #   the default.
+      # * *quirks_mode*: Enables quirks_mode for parser, that is for example
+      #   parsing single JSON values instead of documents is possible.
+      def initialize(source, opts = {})
+        opts ||= {}
+        unless @quirks_mode = opts[:quirks_mode]
+          source = convert_encoding source
+        end
+        super source
+        if !opts.key?(:max_nesting) # defaults to 100
+          @max_nesting = 100
+        elsif opts[:max_nesting]
+          @max_nesting = opts[:max_nesting]
+        else
+          @max_nesting = 0
+        end
+        @allow_nan = !!opts[:allow_nan]
+        @symbolize_names = !!opts[:symbolize_names]
+        @match_string = opts[:match_string]
+      end
+
+      alias source string
+
+      def quirks_mode?
+        !!@quirks_mode
+      end
+
+      def reset
+        super
+        @current_nesting = 0
+      end
+
+      # Parses the current JSON string _source_ and returns the complete data
+      # structure as a result.
+      def lex &block
+        @callback = block
+        reset
+        if @quirks_mode
+          while !eos? && skip(IGNORE)
+          end
+          if eos?
+            raise ParserError, "source did not contain any JSON!"
+          else
+            obj = lex_value
+            obj == UNPARSED and raise ParserError, "source did not contain any JSON!"
+          end
+        else
+          until eos?
+            case
+            when scan(OBJECT_OPEN)
+#              obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+              @current_nesting = 1
+              lex_object
+            when scan(ARRAY_OPEN)
+#              obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+              @current_nesting = 1
+              lex_array
+            when skip(IGNORE)
+              ;
+            else
+              raise ParserError, "source '#{peek(20)}' not in JSON!"
+            end
+          end
+#          obj or raise ParserError, "source did not contain any JSON!"
+        end
+#        obj
+      end
+
+      private
+
+      def convert_encoding(source)
+        if source.respond_to?(:to_str)
+          source = source.to_str
+        else
+          raise TypeError, "#{source.inspect} is not like a string"
+        end
+        if defined?(::Encoding)
+          if source.encoding == ::Encoding::ASCII_8BIT
+            b = source[0, 4].bytes.to_a
+            source =
+              case
+              when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+                source.dup.force_encoding(::Encoding::UTF_32BE).encode!(::Encoding::UTF_8)
+              when b.size >= 4 && b[0] == 0 && b[2] == 0
+                source.dup.force_encoding(::Encoding::UTF_16BE).encode!(::Encoding::UTF_8)
+              when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+                source.dup.force_encoding(::Encoding::UTF_32LE).encode!(::Encoding::UTF_8)
+              when b.size >= 4 && b[1] == 0 && b[3] == 0
+                source.dup.force_encoding(::Encoding::UTF_16LE).encode!(::Encoding::UTF_8)
+              else
+                source.dup
+              end
+          else
+            source = source.encode(::Encoding::UTF_8)
+          end
+          source.force_encoding(::Encoding::ASCII_8BIT)
+        else
+          b = source
+          source =
+            case
+            when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+              JSON.iconv('utf-8', 'utf-32be', b)
+            when b.size >= 4 && b[0] == 0 && b[2] == 0
+              JSON.iconv('utf-8', 'utf-16be', b)
+            when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+              JSON.iconv('utf-8', 'utf-32le', b)
+            when b.size >= 4 && b[1] == 0 && b[3] == 0
+              JSON.iconv('utf-8', 'utf-16le', b)
+            else
+              b
+            end
+        end
+        source
+      end
+
+      # Unescape characters in strings.
+      UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+      UNESCAPE_MAP.update({
+        ?"  => '"',
+        ?\\ => '\\',
+        ?/  => '/',
+        ?b  => "\b",
+        ?f  => "\f",
+        ?n  => "\n",
+        ?r  => "\r",
+        ?t  => "\t",
+        ?u  => nil,
+      })
+
+      EMPTY_8BIT_STRING = ''
+      if ::String.method_defined?(:encode)
+        EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+      end
+
+      def parse_string
+        if scan(STRING)
+          return '' if self[1].empty?
+          string = self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+            if u = UNESCAPE_MAP[$&[1]]
+              u
+            else # \uXXXX
+              bytes = EMPTY_8BIT_STRING.dup
+              i = 0
+              while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+                bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+                i += 1
+              end
+              JSON.iconv('utf-8', 'utf-16be', bytes)
+            end
+          end
+          if string.respond_to?(:force_encoding)
+            string.force_encoding(::Encoding::UTF_8)
+          end
+          string
+        else
+          UNPARSED
+        end
+      rescue => e
+        raise ParserError, "Caught #{e.class} at '#{peek(20)}': #{e}"
+      end
+
+      def lex_value
+        case
+        when scan(FLOAT)
+          @callback.call :float, Float(self[1])
+        when scan(INTEGER)
+          @callback.call :integer, Integer(self[1])
+        when scan(TRUE)
+          @callback.call :boolean, true
+        when scan(FALSE)
+          @callback.call :boolean, false
+        when scan(NULL)
+          @callback.call :null, nil
+        when (string = parse_string) != UNPARSED
+          @callback.call :string, string
+        when scan(ARRAY_OPEN)
+          @current_nesting += 1
+          lex_array
+          @current_nesting -= 1
+        when scan(OBJECT_OPEN)
+          @current_nesting += 1
+          lex_object
+          @current_nesting -= 1
+#        when @allow_nan && scan(NAN)
+#          NaN
+#        when @allow_nan && scan(INFINITY)
+#          Infinity
+#        when @allow_nan && scan(MINUS_INFINITY)
+#          MinusInfinity
+        else
+          UNPARSED
+        end
+      end
+
+      def lex_array
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        @callback.call :array_begin, nil
+        delim = false
+        until eos?
+          case
+          when (value = lex_value) != UNPARSED
+            delim = false
+
+            skip(IGNORE)
+            if scan(COLLECTION_DELIMITER)
+              delim = true
+            elsif match?(ARRAY_CLOSE)
+              ;
+            else
+              raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+            end
+          when scan(ARRAY_CLOSE)
+            if delim
+              raise ParserError, "expected next element in array at '#{peek(20)}'!"
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+          end
+        end
+        @callback.call :array_end, nil
+      end
+
+      def lex_object
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+
+
+        @callback.call :object_begin, nil
+        delim = false
+        until eos?
+          case
+          when (string = parse_string) != UNPARSED
+            @callback.call :property, string
+            skip(IGNORE)
+            unless scan(PAIR_DELIMITER)
+              raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+            end
+            skip(IGNORE)
+            unless (value = lex_value).equal? UNPARSED
+              delim = false
+              skip(IGNORE)
+              if scan(COLLECTION_DELIMITER)
+                delim = true
+              elsif match?(OBJECT_CLOSE)
+                ;
+              else
+                raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+              end
+            else
+              raise ParserError, "expected value in object at '#{peek(20)}'!"
+            end
+          when scan(OBJECT_CLOSE)
+            if delim
+              raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+          end
+        end
+        @callback.call :object_end, nil
+      end
+    end
+  end
+end

data/lib/muskox/version.rb

@@ -0,0 +1,3 @@
+module Muskox
+  VERSION = "0.0.1"
+end

data/muskox.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'muskox/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "muskox"
+  spec.version       = Muskox::VERSION
+  spec.authors       = ["Nick Howard"]
+  spec.email         = ["ndh@baroquebobcat.com"]
+  spec.description   = %q{A JSON-Schema based Parser-Generator}
+  spec.summary       = %q{A JSON-Schema based Parser-Generator}
+  spec.homepage      = "https://github.com/baroquebobcat/muskox"
+  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"
+end

data/spec/json_schema_spec.rb

@@ -0,0 +1,35 @@
+require 'minitest/autorun'
+require 'muskox'
+require 'json'
+
+
+to_skip = [
+# Allows wrong type sometimes for some reason
+["ignores non-arrays", "draft4/items.json", "a schema given for items"]
+]
+
+['draft4/items.json', 'draft4/type.json'].each do |file|
+  json = JSON.parse(open("json_schema_test_suite/tests/#{file}").read)
+  describe file do
+    json.each do |t|
+      describe t["description"] do
+        before do
+          schema = t["schema"]
+          @parser = Muskox.generate schema
+        end
+        t["tests"].each do |test|
+          it test["description"] do
+            skip if to_skip.include? [test["description"], file, t["description"]]
+            if test["valid"]
+              @parser.parse test["data"].to_json
+            else
+              assert_raises Muskox::ParserError do 
+                @parser.parse test["data"].to_json
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/muskox_spec.rb

@@ -0,0 +1,278 @@
+require 'minitest/autorun'
+require 'muskox'
+
+describe Muskox do  
+  describe "simple object[number]=integer schema, error on extra property" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "number" => {
+            "type" => "integer"
+          }
+        },
+        "required" => ["number"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"number": 1}!
+      assert_equal({"number" => 1 }, result)
+    end
+
+    it "parses successfully when passed a different valid string" do
+      result = @parser.parse %!{"number": 2}!
+      assert_equal({"number" => 2 }, result)
+    end
+
+    it "raises an error when there is an extra property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"number": 2, "grug":[]}!
+      end
+    end
+    it "raises an error when there is an invalid type of property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"number": "string-not-number"}!
+      end
+    end
+    it "raises an error when there is a missing property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{}!
+      end
+    end
+
+  end
+
+
+  describe "simple object[string]=string schema, error on extra property" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "string" => {
+            "type" => "string"
+          }
+        },
+        "required" => ["string"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"string": "one"}!
+      assert_equal({"string" => "one" }, result)
+    end
+
+    it "parses successfully when passed a different valid string" do
+      result = @parser.parse %!{"string": "two"}!
+      assert_equal({"string" => "two" }, result)
+    end
+
+    it "raises an error when there is an extra property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"string": "two", "grug":[]}!
+      end
+    end
+    it "raises an error when there is an invalid type of property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"string": 1701}!
+      end
+    end
+  end
+
+  describe " object[array]=array[string] schema, error on extra property" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "array" => {
+            "type" => "array",
+            "items" => {"type" => "string"}
+          }
+        },
+        "required" => ["array"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"array": ["one"]}!
+      assert_equal({"array" => ["one"] }, result)
+    end
+
+    it "parses successfully when passed a different valid array" do
+      result = @parser.parse %!{"array": ["two"]}!
+      assert_equal({"array" => ["two"] }, result)
+    end
+
+    it "parses successfully when passed a valid array of size 2" do
+      result = @parser.parse %!{"array": ["two", "one"]}!
+      assert_equal({"array" => ["two", "one"] }, result)
+    end
+
+    it "raises an error when there is an extra property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"array": ["two"], "grug":[]}!
+      end
+    end
+
+    it "raises an error when there is an invalid component type of property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"array": [1701]}!
+        p result
+      end
+    end
+  end
+
+
+  describe "object[object]=object schema, error on extra property" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "object" => {
+            "type" => "object"
+          }
+        },
+        "required" => ["object"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"object": {}}!
+      assert_equal({"object" => {} }, result)
+    end
+
+    it "parses successfully when passed a different valid string" do
+      result = @parser.parse %!{"object": {}}!
+      assert_equal({"object" => {} }, result)
+    end
+
+    it "raises an error when there is an extra property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"object": {}, "grug":[]}!
+      end
+    end
+    it "raises an error when there is an invalid type of property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"object": "string"}!
+      end
+    end
+  end
+
+  describe "object[object]=object[string]=string schema, error on extra property" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "object" => {
+            "type" => "object",
+            "properties" => {"string" => {"type" => "string"}},
+            "required" => ["string"]
+          }
+        },
+        "required" => ["object"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"object": {"string":"a"}}!
+      assert_equal({"object" => {"string" => "a"} }, result)
+    end
+
+    it "parses successfully when passed a different valid string" do
+      result = @parser.parse %!{"object": {"string":"b"}}!
+      assert_equal({"object" => {"string" => "b"} }, result)
+    end
+
+    it "raises an error when there is an extra nested property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"object": {"string":"a","grug":[]}, }!
+      end
+    end
+
+    it "raises an error when there is an invalid type of nested property" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"object": {"string":1}}!
+      end
+    end
+  end
+
+  describe "simple object[number]=float happy path" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "number" => {
+            "type" => "float"
+          }
+        },
+        "required" => ["number"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"number": 1.0}!
+      assert_equal({"number" => 1.0 }, result)
+    end
+  end
+
+
+  describe "simple object[number]=boolean happy path" do
+    before do
+      schema = {
+        "title" => "Schema",
+        "type" => "object",
+        "properties" => {
+          "number" => {
+            "type" => "boolean"
+          }
+        },
+        "required" => ["number"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "parses successfully when passed a valid string" do
+      result = @parser.parse %!{"number": true}!
+      assert_equal({"number" => true }, result)
+    end
+  end
+
+  describe "malformed json handling" do
+    before do
+      schema = {
+        "type" => "object",
+        "properties" => {
+          "number" => {
+            "type" => "boolean"
+          }
+        },
+        "required" => ["number"]
+      }
+      
+      @parser = Muskox.generate schema
+    end
+    it "raises an error when object unended" do
+      assert_raises Muskox::ParserError do
+        result = @parser.parse %!{"number": true!
+      end
+    end
+  end
+
+#null
+  #array size limits
+# bad JSON strings
+
+end
+

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: muskox
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nick Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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 JSON-Schema based Parser-Generator
+email:
+- ndh@baroquebobcat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/muskox.rb
+- lib/muskox/json_lexer.rb
+- lib/muskox/version.rb
+- muskox.gemspec
+- spec/json_schema_spec.rb
+- spec/muskox_spec.rb
+homepage: https://github.com/baroquebobcat/muskox
+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.0.3
+signing_key: 
+specification_version: 4
+summary: A JSON-Schema based Parser-Generator
+test_files:
+- spec/json_schema_spec.rb
+- spec/muskox_spec.rb