jsonschema 1.0.0

data/README.rdoc

@@ -0,0 +1,94 @@
+= Ruby/jsonschema
+
+* http://github.com/Constellation/jsonchema
+
+== DESCRIPTION:
+
+json schema library ruby porting
+from http://code.google.com/p/jsonschema/
+
+== SYNOPSIS:
+ruby code
+  require 'jsonschema'
+  schema = {
+    "type" => "object",
+     "properties" => {
+      "prop01" => {
+        "type" => "number",
+        "maximum" => 10
+      },
+      "prop02" => {
+        "type" => "integer",
+        "maximum" => 20
+      }
+    }
+  }
+  data = {
+    "prop01"=> 5,
+    "prop02"=> 10
+  }
+  JSON::Schema.validate(data, schema)
+
+if you have json library
+  require 'json'
+  require 'jsonschema'
+  schema = File.open("path/to/schema.json", "rb"){|f| JSON.parse(f.read)}
+  data   = File.open("path/to/data.json",   "rb"){|f| JSON.parse(f.read)}
+  JSON::Schema.validate(data, schema)
+
+== INSTALL:
+
+  gem source -a http://gemcutter.org
+  sudo gem install jsonschema
+
+== LICENSE:
+
+Ruby/jsonschema
+(The MIT License)
+
+Copyright (c) 2009 Constellation
+
+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.
+
+
+jsonschema
+http://code.google.com/p/jsonschema/
+(The MIT License)
+
+Copyright (c) 2008 Ian Lewis, Yusuke Muraoka
+
+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/Rakefile

@@ -0,0 +1,94 @@
+# 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/lib/jsonschema.rb

@@ -0,0 +1,432 @@
+# vim: fileencoding=utf-8
+
+module JSON
+  class Schema
+    VERSION = '1.0.0'
+    class ValueError < Exception;end
+    TypesMap = {
+      "string"  => String,
+      "integer" => Integer,
+      "number"  => [Integer, Float],
+      "boolean" => [TrueClass, FalseClass],
+      "object"  => Hash,
+      "array"   => Array,
+      "null"    => NilClass,
+      "any"     => nil
+    }
+    TypesList = [String, Integer, Float, TrueClass, FalseClass, Hash, Array, NilClass]
+    DefaultSchema = {
+      "id"                    => nil,
+      "type"                  => nil,
+      "properties"            => nil,
+      "items"                 => nil,
+      "optional"              => false,
+      "additionalProperties" => nil,
+      "requires"              => nil,
+      "identity"              => nil,
+      "minimum"               => nil,
+      "maximum"               => nil,
+      "minItems"             => nil,
+      "maxItems"             => nil,
+      "pattern"               => nil,
+      "maxLength"            => nil,
+      "minLength"            => nil,
+      "enum"                  => nil,
+      "options"               => nil,
+      "readonly"              => nil,
+      "title"                 => nil,
+      "description"           => nil,
+      "format"                => nil,
+      "default"               => nil,
+      "transient"             => nil,
+      "maxDecimal"           => nil,
+      "hidden"                => nil,
+      "disallow"              => nil,
+      "extends"               => nil
+    }
+    def initialize interactive=true
+      @interactive = interactive
+      @refmap = {}
+    end
+
+    def validate data, schema
+      @refmap = {
+        '$' => schema
+      }
+      _validate(data, schema)
+    end
+
+    private
+    def validate_id x, fieldname, schema, id=nil
+      unless id.nil?
+        if id == '$'
+          raise ValueError, "Reference id for field '#{fieldname}' cannot equal '$'"
+        end
+        @refmap[id] = schema
+      end
+      return x
+    end
+
+    def validate_type x, fieldname, schema, fieldtype=nil
+      converted_fieldtype = convert_type(fieldtype)
+      fieldexists = true
+      begin
+        val = x.fetch(fieldname)
+      rescue IndexError
+        fieldexists = false
+      ensure
+        val = x[fieldname]
+      end
+      if converted_fieldtype && fieldexists
+        if converted_fieldtype.kind_of? Array
+          datavalid = false
+          converted_fieldtype.each do |type|
+            begin
+              validate_type(x, fieldname, type, type)
+              datavalid = true
+              break
+            rescue ValueError
+              next
+            end
+          end
+          unless datavalid
+            raise ValueError, "Value #{val} for field '#{fieldname}' is not of type #{fieldtype}"
+          end
+        elsif converted_fieldtype.kind_of? Hash
+          begin
+            __validate(fieldname, x, converted_fieldtype)
+          rescue ValueError => e
+            raise e
+          end
+        else
+          unless val.kind_of? converted_fieldtype
+            raise ValueError, "Value #{val} for field '#{fieldname}' is not of type #{fieldtype}"
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_properties x, fieldname, schema, properties=nil
+      if !properties.nil? && x[fieldname]
+        value = x[fieldname]
+        if value
+          if value.kind_of? Hash
+            if properties.kind_of? Hash
+              properties.each do |key, val|
+                __validate(key, value, val)
+              end
+            else
+              raise ValueError, "Properties definition of field '#{fieldname}' is not an object"
+            end
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_items x, fieldname, schema, items=nil
+      if !items.nil? && x[fieldname]
+        value = x[fieldname]
+        unless value.nil?
+          if value.kind_of? Array
+            if items.kind_of? Array
+              if items.size == value.size
+                items.each_with_index do |item, index|
+                  begin
+                    validate(value[index], item)
+                  rescue ValueError => e
+                    raise ValueError, "Failed to validate field '#{fieldname}' list schema: #{e.message}"
+                  end
+                end
+              else
+                raise ValueError, "Length of list #{value} for field '#{fieldname}' is not equal to length of schema list"
+              end
+            elsif items.kind_of? Hash
+              value.each do |val|
+                begin
+                  _validate(val, items)
+                rescue ValueError => e
+                  raise ValueError, "Failed to validate field '#{fieldname}' list schema: #{e.message}"
+                end
+              end
+            else
+              raise ValueError, "Properties definition of field '#{fieldname}' is not a list or an object"
+            end
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_optional x, fieldname, schema, optional=false
+      if !x.include?(fieldname) && !optional
+        raise ValueError, "Required field '#{fieldname}' is missing"
+      end
+      return x
+    end
+
+    def validate_additionalProperties x, fieldname, schema, additional_properties=nil
+      unless additional_properties.nil?
+        if additional_properties.kind_of? TrueClass
+          return x
+        end
+        value = x[fieldname]
+        if additional_properties.kind_of?(Hash) || additional_properties.kind_of?(FalseClass)
+          properties = schema["properties"]
+          unless properties
+            properties = {}
+          end
+          value.keys.each do |key|
+            unless properties.include? key
+              if additional_properties.kind_of? FalseClass
+                raise ValueError, "Additional properties not defined by 'properties' are not allowed in field '#{fieldname}'"
+              else
+                __validate(key, value, additional_properties)
+              end
+            end
+          end
+        else
+          raise ValueError, "additionalProperties schema definition for field '#{fieldname}' is not an object"
+        end
+      end
+      return x
+    end
+
+    def validate_requires x, fieldname, schema, requires=nil
+      if x[fieldname] && !requires.nil?
+        unless x[requires]
+          raise ValueError, "Field '#{requires}' is required by field '#{fieldname}'"
+        end
+      end
+      return x
+    end
+
+    def validate_identity x, fieldname, schema, unique=false
+      return x
+    end
+
+    def validate_minimum x, fieldname, schema, minimum=nil
+      if !minimum.nil? && x[fieldname]
+        value = x[fieldname]
+        if value
+          if (value.kind_of?(Integer) || value.kind_of?(Float)) && value < minimum
+            raise ValueError, "Value #{value} for field '#{fieldname}' is less than minimum value: #{minimum}"
+          elsif value.kind_of?(Array) && value.size < minimum
+            raise ValueError, "Value #{value} for field '#{fieldname}' has fewer values than the minimum: #{minimum}"
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_maximum x, fieldname, schema, maximum=nil
+      if !maximum.nil? && x[fieldname]
+        value = x[fieldname]
+        if value
+          if (value.kind_of?(Integer) || value.kind_of?(Float)) && value > maximum
+            raise ValueError, "Value #{value} for field '#{fieldname}' is greater than maximum value: #{maximum}"
+          elsif value.kind_of?(Array) && value.size > maximum
+            raise ValueError, "Value #{value} for field '#{fieldname}' has more values than the maximum: #{maximum}"
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_minItems x, fieldname, schema, minitems=nil
+      if !minitems.nil? && x[fieldname]
+        value = x[fieldname]
+        if value
+          if value.kind_of?(Array) && value.size < minitems
+            raise ValueError, "Value #{value} for field '#{fieldname}' must have a minimum of #{minitems} items"
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_maxItems x, fieldname, schema, maxitems=nil
+      if !maxitems.nil? && x[fieldname]
+        value = x[fieldname]
+        if value
+          if value.kind_of?(Array) && value.size > maxitems
+            raise ValueError, "Value #{value} for field '#{fieldname}' must have a maximum of #{maxitems} items"
+          end
+        end
+      end
+      return x
+    end
+
+    def validate_pattern x, fieldname, schema, pattern=nil
+      value = x[fieldname]
+      if !pattern.nil? && value && value.kind_of?(String)
+        p = Regexp.new(pattern)
+        if !p.match(value)
+          raise ValueError, "Value #{value} for field '#{fieldname}' does not match regular expression '#{pattern}'"
+        end
+      end
+      return x
+    end
+
+    def validate_maxLength x, fieldname, schema, length=nil
+      value = x[fieldname]
+      if !length.nil? && value && value.kind_of?(String)
+        # string length => 正規表現で分割して計測
+        if value.split(//).size > length
+          raise ValueError, "Length of value #{value} for field '#{fieldname}' must be less than or equal to #{length}"
+        end
+      end
+      return x
+    end
+
+    def validate_minLength x, fieldname, schema, length=nil
+      value = x[fieldname]
+      if !length.nil? && value && value.kind_of?(String)
+        if value.split(//).size < length
+          raise ValueError, "Length of value #{value} for field '#{fieldname}' must be more than or equal to #{length}"
+        end
+      end
+      return x
+    end
+
+    def validate_enum x, fieldname, schema, options=nil
+      value = x[fieldname]
+      if !options.nil? && value
+        unless options.kind_of? Array
+          raise ValueError, "Enumeration #{options} for field '#{fieldname}' is not a list type"
+        end
+        unless options.include? value
+          raise ValueError, "Value #{value} for field '#{fieldname}' is not in the enumeration: #{options}"
+        end
+      end
+      return x
+    end
+
+    def validate_options x, fieldname, schema, options=nil
+      return x
+    end
+
+    def validate_readonly x, fieldname, schema, readonly=false
+      return x
+    end
+
+    def validate_title x, fieldname, schema, title=nil
+      if !title.nil? && !title.kind_of?(String)
+        raise ValueError, "The title for field '#{fieldname}' must be a string"
+      end
+      return x
+    end
+
+    def validate_description x, fieldname, schema, description=nil
+      if !description.nil? && !description.kind_of?(String)
+        raise ValueError, "The description for field '#{fieldname}' must be a string"
+      end
+      return x
+    end
+
+    def validate_format x, fieldname, schema, format=nil
+      return x
+    end
+
+    def validate_default x, fieldname, schema, default=nil
+      if @interactive && !x.include?(fieldname) && !default.nil?
+        unless schema["readonly"]
+          x[fieldname] = default
+        end
+      end
+      return x
+    end
+
+    def validate_transient x, fieldname, schema, transient=false
+      return x
+    end
+
+    def validate_maxDecimal x, fieldname, schema, maxdecimal=nil
+      value = x[fieldname]
+      if !maxdecimal.nil? && value
+        maxdecstring = value.to_s
+        index = maxdecstring.index('.')
+        if index && maxdecstring[(index+1)...maxdecstring.size].split(//u).size > maxdecimal
+          raise ValueError, "Value #{value} for field '#{fieldname}' must not have more than #{maxdecimal} decimal places"
+        end
+      end
+      return x
+    end
+
+    def validate_hidden x, fieldname, schema, hidden=false
+      return x
+    end
+
+    def validate_disallow x, fieldname, schema, disallow=nil
+      if !disallow.nil?
+        begin
+          validate_type(x, fieldname, schema, disallow)
+        rescue ValueError
+          return x
+        end
+        raise ValueError, "Value #{x[fieldname]} of type #{disallow} is disallowed for field '#{fieldname}'"
+      end
+      return x
+    end
+
+    def validate_extends x, fieldname, schema, extends=nil
+      return x
+    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
+
+    def __validate fieldname, data, schema
+      if schema
+        if !schema.kind_of?(Hash)
+          raise ValueError, "Schema structure is invalid"
+        end
+        # copy
+        new_schema = Marshal.load(Marshal.dump(schema))
+        DefaultSchema.each do |key, val|
+          new_schema[key] = val unless new_schema.include?(key)
+        end
+        new_schema.each do |key ,val|
+          validatorname = "validate_"+key
+          begin
+            __send__(validatorname, data, fieldname, schema, new_schema[key])
+          rescue NoMethodError => e
+            raise ValueError, "Schema property '#{e.message}' is not supported"
+          end
+        end
+      end
+      return data
+    end
+
+    def _validate data, schema
+      __validate("_data", {"_data" => data}, schema)
+    end
+
+    class << self
+      def validate data, schema, interactive=true
+        validator = JSON::Schema.new(interactive)
+        validator.validate(data, schema)
+      end
+    end
+  end
+end
+