sk-api 1.1.0 → 1.1.1

data/vendor/jsonschema-1.0.0/Rakefile

@@ -1,94 +0,0 @@
-# vim: fileencoding=utf-8
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
-require 'rake/contrib/sshpublisher'
-require 'fileutils'
-require 'lib/jsonschema'
-include FileUtils
-
-$version = JSON::Schema::VERSION
-$readme = 'README.rdoc'
-$rdoc_opts = %W(--main #{$readme} --charset utf-8 --line-numbers --inline-source)
-$name = 'jsonschema'
-$github_name = 'ruby-jsonschema'
-$summary = 'json schema library ruby porting from http://code.google.com/p/jsonschema/'
-$author = 'Constellation'
-$email = 'utatane.tea@gmail.com'
-$page = 'http://github.com/Constellation/ruby-jsonchema/tree/master'
-#$exec = %W(jsonschema)
-$rubyforge_project = 'jsonschema'
-
-
-task :default => [:test]
-task :package => [:clean]
-
-Rake::TestTask.new("test") do |t|
-  t.libs << "test"
-  t.pattern = "test/**/*_test.rb"
-  t.verbose = true
-end
-
-spec = Gem::Specification.new do |s|
-  s.name = $name
-  s.version = $version
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = [$readme]
-  s.rdoc_options += $rdoc_opts
-  s.summary = $summary
-  s.description = $summary
-  s.author = $author
-  s.email = $email
-  s.homepage = $page
-  s.executables = $exec
-  s.rubyforge_project = $rubyforge_project
-#  s.bindir = 'bin'
-  s.require_path = 'lib'
-  s.test_files = Dir["test/*_test.rb"]
-#  {
-#  }.each do |dep, ver|
-#    s.add_dependency(dep, ver)
-#  end
-  s.files = %w(README.rdoc Rakefile) + Dir["{bin,test,lib}/**/*"]
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-  p.need_tar = true
-  p.gem_spec = spec
-end
-
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.options += $rdoc_opts
-#  rdoc.template = 'resh'
-  rdoc.rdoc_files.include("README.rdoc", "lib/**/*.rb", "ext/**/*.c")
-end
-
-desc "gem spec"
-task :gemspec do
-  File.open("#{$github_name}.gemspec", "wb") do |f|
-    f << spec.to_ruby
-  end
-end
-
-desc "gem build"
-task :build => [:gemspec] do
-  sh "gem build #{$github_name}.gemspec"
-end
-
-desc "gem install"
-task :install => [:build] do
-  sh "sudo gem install #{$name}-#{$version}.gem --local"
-end
-
-desc "gem uninstall"
-task :uninstall do
-  sh "sudo gem uninstall #{$name}"
-end
-# vim: syntax=ruby

data/vendor/jsonschema-1.0.0/lib/jsonschema.rb

@@ -1,292 +0,0 @@
-# vim: fileencoding=utf-8
-
-module JSON
-  class Schema
-    VERSION = '2.0.0'
-    class ValueError < Exception;end
-    class Undefined;end
-    TypesMap = {
-      "string"  => String,
-      "integer" => [Integer, Fixnum],
-      "number"  => [Integer, Float, Fixnum, Numeric],
-      "boolean" => [TrueClass, FalseClass],
-      "object"  => Hash,
-      "array"   => Array,
-      "null"    => NilClass,
-      "any"     => nil
-    }
-    TypesList = [String, Integer, Float, Fixnum, Numeric, TrueClass, FalseClass, Hash, Array, NilClass]
-    def initialize interactive
-      @interactive = interactive
-      @refmap = {}
-    end
-
-    def check_property value, schema, key, parent
-      return unless schema
-      # if id field is present, set refmap to schema
-      @refmap[schema['id']] = schema if schema['id']
-      # recurse with extended scheme
-      check_property(value, schema['extends'], key, parent) if schema['extends']
-      #
-      if value == Undefined
-        # value is NOT optional 
-        raise ValueError, "#{key} is missing and it is not optional" unless schema['optional']     
-        # a default value ??
-        if @interactive && !parent.include?(key) && !schema['default'].nil? && !schema["readonly"]
-          parent[key] = schema['default']
-        end
-      else # At least not undefined
-        # type given, validates if value is of given type(Hash, Array, String, ...)
-        # if val ist NOT NIL and required
-        check_type(value, schema['type'], key, parent) if schema['type'] #&& !value.nil? && !schema['optional']
-
-        # disallowed value type given
-        if schema['disallow']
-          flag = true
-          begin
-            check_type(value, schema['disallow'], key, parent)
-          rescue ValueError
-            flag = false
-          end
-          raise ValueError, "disallowed value was matched" if flag
-        end
-
-        # dont go further for nil values
-        return if value.nil?
-        if value.instance_of? Array
-          if schema['items']
-            if schema['items'].instance_of?(Array)
-              schema['items'].each_with_index {|val, index|
-                check_property(undefined_check(value, index), schema['items'][index], index, value)
-              }
-              if schema.include?('additionalProperties')
-                additional = schema['additionalProperties']
-                if additional.instance_of?(FalseClass)
-                  if schema['items'].size < value.size
-                    raise ValueError, "There are more values in the array than are allowed by the items and additionalProperties restrictions."
-                  end
-                else
-                  value.each_with_index {|val, index|
-                    check_property(undefined_check(value, index), schema['additionalProperties'], index, value)
-                  }
-                end
-              end
-            else
-              value.each_with_index {|val, index|
-                check_property(undefined_check(value, index), schema['items'], index, value)
-              }
-            end
-          end
-          if schema['minItems'] && value.size < schema['minItems']
-            raise ValueError, "There must be a minimum of #{schema['minItems']} in the array"
-          end
-          if schema['maxItems'] && value.size > schema['maxItems']
-            raise ValueError, "There must be a maximum of #{schema['maxItems']} in the array"
-          end
-        elsif schema['properties']
-          check_object(value, schema['properties'], schema['additionalProperties'])
-        elsif schema.include?('additionalProperties')
-          additional = schema['additionalProperties']
-          unless additional.instance_of?(TrueClass)
-            if additional.instance_of?(Hash) || additional.instance_of?(FalseClass)
-              properties = {}
-              value.each {|k, val|
-                if additional.instance_of?(FalseClass)
-                  raise ValueError, "Additional properties not defined by 'properties' are not allowed in field '#{k}'"
-                else
-                  check_property(val, schema['additionalProperties'], k, value)
-                end
-              }
-            else
-              raise ValueError, "additionalProperties schema definition for field '#{}' is not an object"
-            end
-          end
-        end
-
-        if value.instance_of?(String)
-          # pattern
-          if schema['pattern'] && !(value =~ Regexp.new(schema['pattern']))
-            raise ValueError, "does not match the regex pattern #{schema['pattern']}"
-          end
-
-          strlen = value.split(//).size
-          # maxLength
-          if schema['maxLength'] && strlen > schema['maxLength']
-            raise ValueError, "may only be #{schema['maxLength']} characters long"
-          end
-
-          # minLength
-          if schema['minLength'] && strlen < schema['minLength']
-            raise ValueError, "must be at least #{schema['minLength']} characters long"
-          end
-        end
-
-        if value.kind_of?(Numeric)
-
-          # minimum + minimumCanEqual
-          if schema['minimum']
-            minimumCanEqual = schema.fetch('minimumCanEqual', Undefined)
-            if minimumCanEqual == Undefined || minimumCanEqual
-              if value < schema['minimum']
-                raise ValueError, "must have a minimum value of #{schema['minimum']}"
-              end
-            else
-              if value <= schema['minimum']
-                raise ValueError, "must have a minimum value of #{schema['minimum']}"
-              end
-            end
-          end
-
-          # maximum + maximumCanEqual
-          if schema['maximum']
-            maximumCanEqual = schema.fetch('maximumCanEqual', Undefined)
-            if maximumCanEqual == Undefined || maximumCanEqual
-              if value > schema['maximum']
-                raise ValueError, "must have a maximum value of #{schema['maximum']}"
-              end
-            else
-              if value >= schema['maximum']
-                raise ValueError, "must have a maximum value of #{schema['maximum']}"
-              end
-            end
-          end
-
-          # maxDecimal
-          if schema['maxDecimal'] && schema['maxDecimal'].kind_of?(Numeric)
-            if value.to_s =~ /\.\d{#{schema['maxDecimal']+1},}/
-              raise ValueError, "may only have #{schema['maxDecimal']} digits of decimal places"
-            end
-          end
-
-        end
-
-        # enum
-        if schema['enum']
-          unless(schema['enum'].detect{|enum| enum == value })
-            raise ValueError, "does not have a value in the enumeration #{schema['enum'].join(", ")}"
-          end
-        end
-
-        # description
-        if schema['description'] && !schema['description'].instance_of?(String)
-          raise ValueError, "The description for field '#{value}' must be a string"
-        end
-
-        # title
-        if schema['title'] && !schema['title'].instance_of?(String)
-          raise ValueError, "The title for field '#{value}' must be a string"
-        end
-
-        # format
-        if schema['format']
-        end
-
-      end
-    end
-
-    def check_object value, object_type_def, additional
-      if object_type_def.instance_of? Hash
-        if !value.instance_of?(Hash) || value.instance_of?(Array)
-          raise ValueError, "an object is required"
-        end
-
-        object_type_def.each {|key, odef|
-          if key.index('__') != 0
-            check_property(undefined_check(value, key), odef, key, value)
-          end
-        }
-      end
-      value.each {|key, val|
-        if key.index('__') != 0 && object_type_def && !object_type_def[key] && additional == false
-          raise ValueError, "#{value.class} The property #{key} is not defined in the schema and the schema does not allow additional properties"
-        end
-        requires = object_type_def && object_type_def[key] && object_type_def[key]['requires']
-        if requires && !value.include?(requires)
-          raise ValueError, "the presence of the property #{key} requires that #{requires} also be present"
-        end
-        if object_type_def && object_type_def.instance_of?(Hash) && !object_type_def.include?(key)
-          check_property(val, additional, key, value)
-        end
-        if !@interactive && val && val['$schema']
-          check_property(val, val['$schema'], key, value)
-        end
-      }
-    end
-
-    # Checks the type of a given value
-    # === Parameter
-    # value<>::
-    # type<>::
-    # key<>::
-    # parent<>::
-    def check_type value, type, key, parent
-      converted_fieldtype = convert_type(type)
-      if converted_fieldtype
-        if converted_fieldtype.instance_of? Array
-          datavalid = false
-          converted_fieldtype.each do |t|
-            begin
-              check_type(value, t, key, parent)
-              datavalid = true
-              break
-            rescue ValueError
-              next
-            end
-          end
-          unless datavalid
-            raise ValueError, "#{value.class} value found, but a #{type} is required"
-          end
-        elsif converted_fieldtype.instance_of? Hash
-          check_property(value, type, key, parent)
-        else
-          unless value.instance_of? converted_fieldtype
-            raise ValueError, "#{value.class} value found, but a #{type} is required"
-          end
-        end
-      end
-    end
-
-    def undefined_check value, key
-      value.fetch(key, Undefined)
-    end
-
-    def convert_type fieldtype
-      if TypesList.include?(fieldtype) || fieldtype.kind_of?(Hash)
-        return fieldtype
-      elsif fieldtype.kind_of? Array
-        converted_fields = []
-        fieldtype.each do |subfieldtype|
-          converted_fields << convert_type(subfieldtype)
-        end
-        return converted_fields
-      elsif !fieldtype
-        return nil
-      else
-        fieldtype = fieldtype.to_s
-        if TypesMap.include?(fieldtype)
-          return TypesMap[fieldtype]
-        else
-          raise ValueError, "Field type '#{fieldtype}' is not supported."
-        end
-      end
-    end
-
-    # Validates an instance against a given schema
-    # === Parameter
-    # instance<Hash{String=>Mixed}:: The instanciated record as hash with fields
-    # as keys and values of the to be checked types=> Int, String, Bool, Nil...
-    #   {'name'=>'Chubby', :total=>1.234, :=>}
-    # instance<Hash{String=>String, Hash}:: the schema used to validate the instance
-    # {'properties'=>{}}
-    def validate instance, schema
-      schema ||= instance['$schema'] # self defined schema
-      check_property(instance, schema, 'self', @tree)
-      return instance
-    end
-
-    def self.validate data, schema=nil, interactive=true
-      validator = JSON::Schema.new(interactive)
-      validator.validate(data, schema)
-    end
-end
-end

data/vendor/jsonschema-1.0.0/ruby-jsonschema.gemspec

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{jsonschema}
-  s.version = "1.0.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Constellation"]
-  s.date = %q{2009-09-13}
-  s.description = %q{json schema library ruby porting from http://code.google.com/p/jsonschema/}
-  s.email = %q{utatane.tea@gmail.com}
-  s.extra_rdoc_files = ["README.rdoc"]
-  s.files = ["README.rdoc", "Rakefile", "test/jsonschema_test.rb", "lib/jsonschema.rb"]
-  s.homepage = %q{http://github.com/Constellation/jsonschema/tree/master}
-  s.rdoc_options = ["--main", "README.rdoc", "--charset", "utf-8", "--line-numbers", "--inline-source"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{jsonschema}
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{json schema library ruby porting from http://code.google.com/p/jsonschema/}
-  s.test_files = ["test/jsonschema_test.rb"]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end

data/vendor/jsonschema-1.0.0/test/jsonschema_test.rb

@@ -1,998 +0,0 @@
-require 'test/unit'
-require 'open-uri'
-require 'pp'
-require File.dirname(__FILE__) + '/../lib/jsonschema'
-
-class JSONSchemaTest < Test::Unit::TestCase
-  def test_self_schema
-    data1 =  {
-      "$schema"=> {
-          "properties"=> {
-              "name"=> {
-                  "type"=> "string"
-              },
-              "age" => {
-                  "type"=> "integer",
-                  "maximum"=> 125,
-                  "optional"=> true
-              }
-          }
-      },
-      "name" => "John Doe",
-      "age"  => 30,
-      "type" => "object"
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1)
-    }
-    data2 =  {
-      "$schema"=> {
-          "properties"=> {
-              "name"=> {
-                  "type"=> "integer"
-              },
-              "age" => {
-                  "type"=> "integer",
-                  "maximum"=> 125,
-                  "optional"=> true
-              }
-          }
-      },
-      "name" => "John Doe",
-      "age"  => 30,
-      "type" => "object"
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data2)
-    }
-    data3 =  {
-      "$schema"=> {
-          "properties"=> {
-              "name"=> {
-                  "type"=> "integer"
-              },
-              "age" => {
-                  "type"=> "integer",
-                  "maximum"=> 125,
-                  "optional"=> true
-              }
-          }
-      },
-      "name" => "John Doe",
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3)
-    }
-  end
-
-  def test_maximum
-    schema1 = {
-      "type" => "object",
-       "properties" => {
-        "prop01" => {
-          "type" => "number",
-          "maximum" => 10
-        },
-        "prop02" => {
-          "type" => "integer",
-          "maximum" => 20
-        }
-      }
-    }
-    data1 = {
-      "prop01"=> 5,
-      "prop02"=> 10
-    }
-    data2 = {
-      "prop01"=> 10,
-      "prop02"=> 20
-    }
-    data3 = {
-      "prop01"=> 11,
-      "prop02"=> 19
-    }
-    data4 = {
-      "prop01"=> 9,
-      "prop02"=> 21
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema1)
-    }
-    schema2 = {
-      "type" => "object",
-       "properties" => {
-        "prop01" => {
-          "type" => "number",
-          "maximum" => 10,
-          "maximumCanEqual" => true
-        },
-        "prop02" => {
-          "type" => "integer",
-          "maximum" => 20,
-          "maximumCanEqual" => false
-        }
-      }
-    }
-    data5 = {
-      "prop01"=> 10,
-      "prop02"=> 10
-    }
-    data6 = {
-      "prop01"=> 10,
-      "prop02"=> 19
-    }
-    data7 = {
-      "prop01"=> 11,
-      "prop02"=> 19
-    }
-    data8 = {
-      "prop01"=> 9,
-      "prop02"=> 20
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data5, schema2)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data6, schema2)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data7, schema2)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data8, schema2)
-    }
-  end
-
-  def test_extends
-    schema = {
-      "type" => "object",
-      "properties" => {
-        "prop01" => {
-          "type" => "number",
-          "minimum" => 10
-        },
-        "prop02" => {}
-      }
-    }
-    schema["properties"]["prop02"]["extends"] = schema["properties"]["prop01"]
-    data1 = {
-      "prop01"=> 21,
-      "prop02"=> 21
-    }
-    data2 = {
-      "prop01"=> 10,
-      "prop02"=> 20
-    }
-    data3 = {
-      "prop01"=> 9,
-      "prop02"=> 21
-    }
-    data4 = {
-      "prop01"=> 10,
-      "prop02"=> 9
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema)
-    }
-  end
-
-  def test_minimum
-    schema1 = {
-      "type" => "object",
-      "properties" => {
-        "prop01" => {
-          "type" => "number",
-          "minimum" => 10
-        },
-        "prop02" => {
-          "type" => "integer",
-          "minimum" => 20
-        }
-      }
-    }
-    data1 = {
-      "prop01"=> 21,
-      "prop02"=> 21
-    }
-    data2 = {
-      "prop01"=> 10,
-      "prop02"=> 20
-    }
-    data3 = {
-      "prop01"=> 9,
-      "prop02"=> 21
-    }
-    data4 = {
-      "prop01"=> 10,
-      "prop02"=> 19
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema1)
-    }
-    schema2 = {
-      "type" => "object",
-      "properties" => {
-        "prop01" => {
-          "type" => "number",
-          "minimum" => 10,
-          "minimumCanEqual" => false
-        },
-        "prop02" => {
-          "type" => "integer",
-          "minimum" => 19,
-          "minimumCanEqual" => true
-        }
-      }
-    }
-    data5 = {
-      "prop01"=> 11,
-      "prop02"=> 19
-    }
-    data6 = {
-      "prop01"=> 10,
-      "prop02"=> 19
-    }
-    data7 = {
-      "prop01"=> 11,
-      "prop02"=> 18
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data5, schema2)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data6, schema2)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data7, schema2)
-    }
-  end
-
-  def test_minItems
-    schema1 = {
-      "type" => "array",
-      "minItems" => 4
-    }
-    schema2 = {
-      "minItems" => 4
-    }
-    data1 = [1, 2, "3", 4.0]
-    data2 = [1, 2, "3", 4.0, 5.00]
-    data3 = "test"
-    data4 = [1, 2, "3"]
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data3, schema2)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema2)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema2)
-    }
-  end
-
-  def test_maxItems
-    schema1 = {
-      "type" => "array",
-      "maxItems" => 4
-    }
-    schema2 = {
-      "maxItems" => 4
-    }
-    data1 = [1, 2, "3", 4.0]
-    data2 = [1, 2, "3"]
-    data3 = "test"
-    data4 = [1, 2, "3", 4.0, 5.00]
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data3, schema2)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema2)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema2)
-    }
-  end
-
-  def test_minLength
-    schema = {
-      "minLength" => 4
-    }
-    data1 = "test"
-    data2 = "string"
-    data3 = 123
-    data4 = [1, 2, "3"]
-    data5 = "car"
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data3, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data4, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data5, schema)
-    }
-  end
-  def test_maxLength
-    schema = {
-      "maxLength" => 4
-    }
-    data1 = "test"
-    data2 = "car"
-    data3 = 12345
-    data4 = [1, 2, "3", 4, 5]
-    data5 = "string"
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data3, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data4, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data5, schema)
-    }
-  end
-
-  def test_maxDecimal
-    schema = {
-      "type" => "number",
-      "maxDecimal" => 3
-    }
-    data1 = 10.20
-    data2 = 10.204
-    data3 = 10
-    data4 = 10.04092
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data3, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema)
-    }
-  end
-
-  def test_properties
-    schema = {
-      "type"=>"object",
-      "properties"=>{
-        "prop01"=>{
-          "type"=>"string",
-        },
-        "prop02"=>{
-          "type"=>"number",
-          "optional"=>true
-        },
-        "prop03"=>{
-          "type"=>"integer",
-        },
-        "prop04"=>{
-          "type"=>"boolean",
-        },
-        "prop05"=>{
-          "type"=>"object",
-          "optional"=>true,
-          "properties"=>{
-            "subprop01"=>{
-              "type"=>"string",
-            },
-            "subprop02"=>{
-              "type"=>"string",
-              "optional"=>false
-            }
-          }
-        }
-      }
-    }
-    data1 = {
-      "prop01"=>"test",
-      "prop02"=>1.20,
-      "prop03"=>1,
-      "prop04"=>true,
-      "prop05"=>{
-        "subprop01"=>"test",
-        "subprop02"=>"test2"
-      }
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    data2 = {
-      "prop01"=>"test",
-      "prop02"=>1.20,
-      "prop03"=>1,
-      "prop04"=>true
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    data3 = {
-      "prop02"=>1.60,
-      "prop05"=>{
-        "subprop01"=>"test"
-      }
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema)
-    }
-  end
-
-  def test_title
-    schema1 = {
-      "title"=>"My Title for My Schema"
-    }
-    schema2 = {
-      "title"=>1233
-    }
-    data = "whatever"
-    assert_nothing_raised{
-      JSON::Schema.validate(data, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data, schema2)
-    }
-  end
-
-  def test_requires
-    schema = {
-      "type"=>"object",
-      "properties"=>{
-        "prop01"=>{
-          "type"=>"string",
-          "optional"=>true
-        },
-        "prop02"=>{
-          "type"=>"number",
-          "optional"=>true,
-          "requires"=>"prop01"
-        }
-      }
-    }
-    data1 = {}
-    data2 = {
-      "prop01"=>"test",
-      "prop02"=>2
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    data3 = {
-      "prop02"=>2
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema)
-    }
-  end
-
-  def test_pattern
-    schema = {
-      "pattern"=>"^[A-Za-z0-9][A-Za-z0-9\.]*@([A-Za-z0-9]+\.)+[A-Za-z0-9]+$"
-    }
-    data1 = "my.email01@gmail.com"
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    data2 = 123
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema)
-    }
-    data3 = "whatever"
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema)
-    }
-  end
-
-  def test_optional
-    schema = {
-      "type"=>"object",
-      "properties"=>{
-        "prop01"=>{
-          "type"=>"string"
-        },
-        "prop02"=>{
-          "type"=>"number",
-          "optional"=>true
-        },
-        "prop03"=>{
-          "type"=>"integer"
-        },
-        "prop04"=>{
-          "type"=>"boolean",
-          "optional"=>false
-        }
-      }
-    }
-    data1 = {
-      "prop01"=>"test",
-      "prop03"=>1,
-      "prop04"=>false
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema)
-    }
-    data2 = {
-      "prop02"=>"blah"
-    }
-    data3 = {
-      "prop01"=>"blah"
-    }
-    data4 = {
-      "prop01"=>"test",
-      "prop03"=>1,
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data2, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data4, schema)
-    }
-  end
-
-  def test_default
-    schema1 = {
-      "properties"=>{
-        "test"=>{
-          "optional"=>true,
-          "default"=>10
-        },
-      }
-    }
-    schema2 = {
-      "properties"=>{
-        "test"=>{
-          "optional"=>true,
-          "default"=>10,
-          "readonly"=>true
-        }
-      }
-    }
-    data1 = {}
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_equal(10, data1["test"])
-
-    data2 = {}
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema2)
-    }
-    assert_not_equal(10, data2["test"])
-
-    data3 = {}
-    assert_nothing_raised{
-      JSON::Schema.validate(data3, schema1, true)
-    }
-    assert_equal(10, data3["test"])
-
-    data4 = {}
-    assert_nothing_raised{
-      JSON::Schema.validate(data4, schema1, false)
-    }
-    assert_not_equal(10, data4["test"])
-  end
-
-  def test_description
-    schema1 = {
-      "description"=>"My Description for My Schema"
-    }
-    schema2 = {
-      "description"=>1233
-    }
-    data = "whatever"
-    assert_nothing_raised{
-      JSON::Schema.validate(data, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data, schema2)
-    }
-  end
-
-	def test_type
-		# schema
-		schema1 = {
-			"type"=>[
-				{
-          "type"=>"array",
-					"minItems"=>10
-				},
-				{
-          "type"=>"string",
-          "pattern"=>"^0+$"
-				}
-			]
-		}
-		data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-		data2 = "0"
-		data3 = 1203
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema1)
-    }
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema1)
-    }
-
-    # integer phase
-    [1, 89, 48, 32, 49, 42].each do |item|
-			assert_nothing_raised{
-				JSON::Schema.validate(item, {"type"=>"integer"})
-			}
-    end
-    [1.2, "bad", {"test" => "blah"}, [32, 49], nil, true].each do |item|
-			assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"integer"})
-      }
-    end
-
-    # string phase
-    ["surrender?", "nuts!", "ok", "@hsuha", "\'ok?\'", "blah"].each do |item|
-			assert_nothing_raised{
-        JSON::Schema.validate(item, {"type"=>"string"})
-      }
-    end
-    [1.2, 1, {"test" => "blah"}, [32, 49], nil, true].each do |item|
-			assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"string"})
-      }
-    end
-
-    # number phase
-    [1.2, 89.42, 48.5224242, 32, 49, 42.24324].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"type"=>"number"})
-      }
-    end
-    ["bad", {"test"=>"blah"}, [32.42, 494242], nil, true].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"number"})
-      }
-    end
-
-    # boolean phase
-    [true, false].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"type"=>"boolean"})
-      }
-    end
-    [1.2, "False", {"test" => "blah"}, [32, 49], nil, 1, 0].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"boolean"})
-      }
-    end
-
-    # object phase
-    [{"blah"=>"test"}, {"this"=>{"blah"=>"test"}}, {1=>2, 10=>20}].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"type"=>"object"})
-      }
-    end
-    [1.2, "bad", 123, [32, 49], nil, true].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"object"})
-      }
-    end
-
-    # array phase
-    [[1, 89], [48, {"test"=>"blah"}, "49", 42]].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"type"=>"array"})
-      }
-    end
-    [1.2, "bad", {"test"=>"blah"}, 1234, nil, true].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"array"})
-      }
-    end
-
-    # null phase
-      assert_nothing_raised{
-      JSON::Schema.validate(nil, {"type"=>"null"})
-    }
-    [1.2, "bad", {"test"=>"blah"}, [32, 49], 1284, true].each do |item|
-			assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"type"=>"null"})
-      }
-    end
-
-    # any phase
-    [1.2, "bad", {"test"=>"blah"}, [32, 49], nil, 1284, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"type"=>"any"})
-      }
-    end
-
-	end
-
-  def test_items
-    schema1 = {
-      "type"=>"array",
-      "items"=>{
-        "type"=>"string"
-      }
-    }
-    schema2 = {
-      "type"=>"array",
-      "items"=>[
-        {"type"=>"integer"},
-        {"type"=>"string"},
-        {"type"=>"boolean"}
-      ]
-    }
-    data1 = ["string", "another string", "mystring"]
-    data2 = ["JSON Schema is cool", "yet another string"]
-    assert_nothing_raised{
-      JSON::Schema.validate(data1, schema1)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data2, schema1)
-    }
-    data3 = ["string", "another string", 1]
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data3, schema1)
-    }
-    data4 = [1, "More strings?", true]
-    data5 = [12482, "Yes, more strings", false]
-    assert_nothing_raised{
-      JSON::Schema.validate(data4, schema2)
-    }
-    assert_nothing_raised{
-      JSON::Schema.validate(data5, schema2)
-    }
-    data6 = [1294, "Ok. I give up"]
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data6, schema2)
-    }
-    data7 = [1294, "Ok. I give up", "Not a boolean"]
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(data7, schema2)
-    }
-  end
-
-  def test_enum
-    schema = {
-      "enum"=>["test", true, 123, ["???"]]
-    }
-    ["test", true, 123, ["???"]].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, schema)
-      }
-    end
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate("unknown", schema)
-    }
-  end
-
-
-  def test_additionalProperties
-    schema1 = {
-      "additionalProperties"=>{
-        "type" => "integer"
-      }
-    }
-    [1, 89, 48, 32, 49, 42].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate({"prop" => item}, schema1)
-      }
-    end
-    [1.2, "bad", {"test"=>"blah"}, [32, 49], nil, true].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate({"prop" => item}, schema1)
-      }
-    end
-    schema2 = {
-      "properties" => {
-        "prop1" => {"type" => "integer"},
-        "prop2" => {"type" => "string" }
-      },
-      "additionalProperties" => {
-        "type" => ["string", "number"]
-      }
-    }
-    [1, "test", 48, "ok", 4.9, 42].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate({
-          "prop1" => 123,
-          "prop2" => "this is prop2",
-          "prop3" => item
-        }, schema2)
-      }
-    end
-    [{"test"=>"blah"}, [32, 49], nil, true].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate({
-          "prop1" => 123,
-          "prop2" => "this is prop2",
-          "prop3" => item
-        }, schema2)
-      }
-    end
-    schema3 = {
-      "additionalProperties" => true
-    }
-    [1.2, 1, {"test"=>"blah"}, [32, 49], nil, true, "blah"].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate({"prop" => item}, schema3)
-      }
-    end
-    schema4 = {
-      "additionalProperties" => false
-    }
-    ["bad", {"test"=>"blah"}, [32.42, 494242], nil, true, 1.34].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate({"prop" => item}, schema4)
-      }
-    end
-  end
-
-  def test_disallow
-    # multi phase
-    schema = {"disallow"=>["null","integer","string"]}
-    [nil, 183, "mystring"].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, schema)
-      }
-    end
-    [1.2, {"test"=>"blah"}, [32, 49], true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, schema)
-      }
-    end
-
-    # any phase
-    [1.2, "bad", {"test"=>"blah"}, [32, 49], nil, 1284, true].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"any"})
-      }
-    end
-
-    # null phase
-    assert_raise(JSON::Schema::ValueError){
-      JSON::Schema.validate(nil, {"disallow"=>"null"})
-    }
-    [1.2, "bad", {"test"=>"blah"}, [32, 49], 1284, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"null"})
-      }
-    end
-
-    # array phase
-    [[1, 89], [48, {"test"=>"blah"}, "49", 42]].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"array"})
-      }
-    end
-    [1.2, "bad", {"test"=>"blah"}, 1234, nil, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"array"})
-      }
-    end
-
-    # object phase
-    [{"blah"=>"test"}, {"this"=>{"blah"=>"test"}}, {1=>2, 10=>20}].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"object"})
-      }
-    end
-    [1.2, "bad", 123, [32, 49], nil, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"object"})
-      }
-    end
-
-    # boolean phase
-    [true, false].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"boolean"})
-      }
-    end
-    [1.2, "False", {"test" => "blah"}, [32, 49], nil, 1, 0].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"boolean"})
-      }
-    end
-
-    # number phase
-    [1.2, 89.42, 48.5224242, 32, 49, 42.24324].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"number"})
-      }
-    end
-    ["bad", {"test"=>"blah"}, [32.42, 494242], nil, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"number"})
-      }
-    end
-
-    # integer phase
-    [1, 89, 48, 32, 49, 42].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"integer"})
-      }
-    end
-    [1.2, "bad", {"test" => "blah"}, [32, 49], nil, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"integer"})
-      }
-    end
-
-    # string phase
-    ["surrender?", "nuts!", "ok", "@hsuha", "\'ok?\'", "blah"].each do |item|
-      assert_raise(JSON::Schema::ValueError){
-        JSON::Schema.validate(item, {"disallow"=>"string"})
-      }
-    end
-    [1.2, 1, {"test" => "blah"}, [32, 49], nil, true].each do |item|
-      assert_nothing_raised{
-        JSON::Schema.validate(item, {"disallow"=>"string"})
-      }
-    end
-  end
-end