sk-api 1.0.6 → 1.1.0

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

@@ -2,379 +2,252 @@
 
 module JSON
   class Schema
-    VERSION = '1.0.0'
+    VERSION = '2.0.0'
     class ValueError < Exception;end
+    class Undefined;end
     TypesMap = {
       "string"  => String,
-      "integer" => Integer,
-      "number"  => [Integer, Float],
+      "integer" => [Integer, Fixnum],
+      "number"  => [Integer, Float, Fixnum, Numeric],
       "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
+    TypesList = [String, Integer, Float, Fixnum, Numeric, TrueClass, FalseClass, Hash, Array, NilClass]
+    def initialize interactive
       @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 '$'"
+    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
-        @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
-        # fld is optional, type is not nil, and field is nil
-        return x if val == nil && schema['optional'] && converted_fieldtype != NilClass
-        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
+      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
-            __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}"
+            check_type(value, schema['disallow'], key, parent)
+          rescue ValueError
+            flag = false
           end
+          raise ValueError, "disallowed value was matched" if flag
         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)
+        # 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
-              raise ValueError, "Properties definition of field '#{fieldname}' is not an object"
+              value.each_with_index {|val, index|
+                check_property(undefined_check(value, index), schema['items'], index, value)
+              }
             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}"
+          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
-              end
+              }
             else
-              raise ValueError, "Properties definition of field '#{fieldname}' is not a list or an object"
+              raise ValueError, "additionalProperties schema definition for field '#{}' is not 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 = {}
+        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
-          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
+
+          strlen = value.split(//).size
+          # maxLength
+          if schema['maxLength'] && strlen > schema['maxLength']
+            raise ValueError, "may only be #{schema['maxLength']} characters long"
           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}'"
+          # minLength
+          if schema['minLength'] && strlen < schema['minLength']
+            raise ValueError, "must be at least #{schema['minLength']} characters long"
+          end
         end
-      end
-      return x
-    end
 
-    def validate_identity x, fieldname, schema, unique=false
-      return x
-    end
+        if value.kind_of?(Numeric)
 
-    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}"
+          # 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
-        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}"
+          # 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
-        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"
+          # 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
-      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"
+        # 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
-      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}'"
+        # description
+        if schema['description'] && !schema['description'].instance_of?(String)
+          raise ValueError, "The description for field '#{value}' must be a string"
         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}"
+        # title
+        if schema['title'] && !schema['title'].instance_of?(String)
+          raise ValueError, "The title for field '#{value}' must be a string"
         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}"
+        # format
+        if schema['format']
         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 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
 
-    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"
+        object_type_def.each {|key, odef|
+          if key.index('__') != 0
+            check_property(undefined_check(value, key), odef, key, value)
+          end
+        }
       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
+      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
-      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"
+        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
-      end
-      return x
-    end
-
-    def validate_hidden x, fieldname, schema, hidden=false
-      return x
+        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
 
-    def validate_disallow x, fieldname, schema, disallow=nil
-      if !disallow.nil?
-        begin
-          validate_type(x, fieldname, schema, disallow)
-        rescue ValueError
-          return x
+    # 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
-        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
+    def undefined_check value, key
+      value.fetch(key, Undefined)
     end
 
     def convert_type fieldtype
@@ -398,37 +271,22 @@ module JSON
       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
+    # 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 _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
+    def self.validate data, schema=nil, interactive=true
+      validator = JSON::Schema.new(interactive)
+      validator.validate(data, schema)
     end
-  end
+end
 end