json-schema-pvdgm 2.3.1

data/lib/json-schema/attributes/type.rb

@@ -0,0 +1,102 @@
+module JSON
+  class Schema
+    class TypeAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        union = true
+        if options[:disallow]
+          types = current_schema.schema['disallow']
+        else
+          types = current_schema.schema['type']
+        end
+
+        if !types.is_a?(Array)
+          types = [types]
+          union = false
+        end
+        valid = false
+
+        # Create an array to hold errors that are generated during union validation
+        union_errors = []
+
+        types.each do |type|
+          if type.is_a?(String)
+            valid = data_valid_for_type?(data, type)
+          elsif type.is_a?(Hash) && union
+            # Validate as a schema
+            schema = JSON::Schema.new(type,current_schema.uri,validator)
+
+            # We're going to add a little cruft here to try and maintain any validation errors that occur in this union type
+            # We'll handle this by keeping an error count before and after validation, extracting those errors and pushing them onto a union error
+            pre_validation_error_count = validation_errors(processor).count
+
+            begin
+              schema.validate(data,fragments,processor,options)
+              valid = true
+            rescue ValidationError
+              # We don't care that these schemas don't validate - we only care that one validated
+            end
+
+            diff = validation_errors(processor).count - pre_validation_error_count
+            valid = false if diff > 0
+            while diff > 0
+              diff = diff - 1
+              union_errors.push(validation_errors(processor).pop)
+            end
+          end
+
+          break if valid
+        end
+
+        if (options[:disallow])
+          if valid
+            message = "The property '#{build_fragment(fragments)}' matched one or more of the following types:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :type })
+          end
+        elsif !valid
+          if union
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match one or more of the following types:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :type })
+            validation_errors(processor).last.sub_errors = union_errors
+          else
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match the following type:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :type })
+          end
+        end
+      end
+
+      TYPE_CLASS_MAPPINGS = {
+        "string" => String,
+        "number" => Numeric,
+        "integer" => Integer,
+        "boolean" => [TrueClass, FalseClass],
+        "object" => Hash,
+        "array" => Array,
+        "null" => NilClass,
+        "any" => Object
+      }
+
+      def self.data_valid_for_type?(data, type)
+        valid_classes = TYPE_CLASS_MAPPINGS.fetch(type) { return true }
+        Array(valid_classes).any? { |c| data.is_a?(c) }
+      end
+
+      # Lookup Schema type of given class instance
+      def self.type_of_data(data)
+        type, klass = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |i|
+          k,v = i
+          -Array(v).map { |klass| klass.ancestors.size }.max
+        }.find { |i|
+          k,v = i
+          Array(v).any? { |klass| data.kind_of?(klass) }
+        }
+        type
+      end
+    end
+  end
+end

data/lib/json-schema/attributes/type_v4.rb

@@ -0,0 +1,54 @@
+module JSON
+  class Schema
+    class TypeV4Attribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        union = true
+        types = current_schema.schema['type']
+        if !types.is_a?(Array)
+          types = [types]
+          union = false
+        end
+        valid = false
+
+        # Create an array to hold errors that are generated during union validation
+        union_errors = []
+
+        types.each do |type|
+          valid = data_valid_for_type?(data, type)
+          break if valid
+        end
+
+        if !valid
+          if union
+            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match one or more of the following types:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :type })
+            validation_errors(processor).last.sub_errors = union_errors
+          else
+            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match the following type:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :type })
+          end
+        end
+      end
+
+      TYPE_CLASS_MAPPINGS = {
+        "string" => String,
+        "number" => Numeric,
+        "integer" => Integer,
+        "boolean" => [TrueClass, FalseClass],
+        "object" => Hash,
+        "array" => Array,
+        "null" => NilClass,
+        "any" => Object
+      }
+
+      def self.data_valid_for_type?(data, type)
+        valid_classes = TYPE_CLASS_MAPPINGS.fetch(type) { return true }
+        Array(valid_classes).any? { |c| data.is_a?(c) }
+      end
+    end
+  end
+end

data/lib/json-schema/attributes/uniqueitems.rb

@@ -0,0 +1,16 @@
+module JSON
+  class Schema
+    class UniqueItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Array)
+          d = data.clone
+          dupes = d.uniq!
+          if dupes
+            message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :unique })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json-schema/model_validator.rb

@@ -0,0 +1,85 @@
+module JSON
+
+  class ModelValidator
+
+    attr_reader :schema
+
+    DYNAMIC_VALIDATORS = [
+                          [ [ 'requiredIf', :requiredIf ], :process_required_if ],
+                          [ [ 'noneOfTheAbove', :noneOfTheAbove ], :process_none_of_the_above ]
+                         ]
+
+    def initialize(schema)
+      if schema.is_a?(String)
+        @schema = JSON.parse(File.new(schema).read)
+      elsif schema.is_a?(Hash)
+        @schema = schema
+      else
+        raise "Schema must be a path or a hash!"
+      end
+    end
+
+    #
+    # Validate the specified model having the hash data contained
+    # in the hash_attribute attribute. By default the hash data
+    # is assumed to be located in the model's 'responses' 
+    # attribute.
+    #
+    def validate(model, hash_attribute=:responses)
+      data = model[hash_attribute] || {}
+      
+      # Put the hash data into an OpenStruct to allow access to
+      # the hash data as an object. We're using the short variable
+      # name of 'r' because that's what we're using in the schema
+      # definition; it keeps the schema stuff short and to the point.
+      r = OpenStruct.new(data)
+
+      m = model
+
+      # Do the static validation first
+      errors = JSON::Validator.fully_validate(schema, data, errors_as_objects: true).map { | e | e[:error_details] }.uniq
+
+      # Now perform dynamic validation
+      schema['properties'].each_pair do | property, sch |
+        errors.concat process_dynamic_validation(property, sch, r, m)
+      end
+
+      # Add the errors to the model
+      errors.each do | error |
+        model.errors.add(error[:property], stringize_error(error))
+      end
+
+      errors
+    end
+
+    def stringize_error(error)
+      s = "#{error[:property]}_#{error[:failure]}"
+      defined?(I18n) ? I18n.t(s) : s
+    end
+
+    def process_dynamic_validation(property, sch, r, m)
+      errors = []
+      DYNAMIC_VALIDATORS.each do | dv |
+        dv_value = sch[dv.first.first] || sch[dv.first.last]
+        error = send(dv.last, m, r, property, dv_value) if dv_value.present?
+        errors << error if error.present?
+      end
+      errors
+    end
+
+    def process_required_if(m, r, property, required_if_expression)
+      if eval(required_if_expression)
+        { property: property.to_sym, failure: :required } if r[property.to_sym].blank?
+      end
+    end
+
+    def process_none_of_the_above(m, r, property, none_of_the_above_value)
+      value = r[property.to_sym]
+      if value.is_a?(Array)
+        { property: property.to_sym, failure: :noneOfTheAbove } if value.include?(none_of_the_above_value) && value.size > 1
+      end
+    end
+
+  end
+
+end

data/lib/json-schema/schema.rb

@@ -0,0 +1,73 @@
+require 'pathname'
+
+module JSON
+  class Schema
+
+    attr_accessor :schema, :uri, :validator
+
+    def initialize(schema,uri,parent_validator=nil)
+      @schema = schema
+      @uri = uri
+
+      self.class.add_indifferent_access(@schema)
+
+      # If there is an ID on this schema, use it to generate the URI
+      if @schema['id'] && @schema['id'].kind_of?(String)
+        temp_uri = URI.parse(@schema['id'])
+        if temp_uri.relative?
+          uri = uri.merge(@schema['id'])
+          temp_uri = uri
+        end
+        @uri = temp_uri
+      end
+      @uri.fragment = ''
+
+      # If there is a $schema on this schema, use it to determine which validator to use
+      if @schema['$schema']
+        u = URI.parse(@schema['$schema'])
+        @validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
+        if @validator.nil?
+          raise SchemaError.new("This library does not have support for schemas defined by #{u.scheme}://#{u.host}#{u.path}")
+        end
+      elsif parent_validator
+        @validator = parent_validator
+      else
+        @validator = JSON::Validator.default_validator
+      end
+    end
+
+    def validate(data, fragments, processor, options = {})
+      @validator.validate(self, data, fragments, processor, options)
+    end
+
+    def self.add_indifferent_access(schema)
+      if schema.is_a?(Hash)
+        schema.default_proc = proc do |hash,key|
+          if hash.has_key?(key)
+            hash[key]
+          else
+            key = case key
+            when Symbol then key.to_s
+            when String then key.to_sym
+            end
+            hash.has_key?(key) ? hash[key] : nil
+          end
+        end
+        schema.keys.each do |key|
+          add_indifferent_access(schema[key])
+        end
+      end
+    end
+
+    def base_uri
+      parts = @uri.to_s.split('/')
+      parts.pop
+      parts.join('/') + '/'
+    end
+
+    def to_s
+      @schema.to_json
+    end
+  end
+end
+

data/lib/json-schema/uri/file.rb

@@ -0,0 +1,36 @@
+require 'rbconfig'
+require 'uri'
+
+module URI
+
+  # Ruby does not have built-in support for filesystem URIs, and definitely does not have built-in support for
+  # using open-uri with filesystem URIs
+  class File < Generic
+
+    COMPONENT = [
+          :scheme,
+          :path,
+          :fragment,
+          :host
+        ].freeze
+
+    def initialize(*arg)
+      # arg[2] is the 'host'; this logic to set it to "" causes file schemes with UNC to break
+      # so don't do it on windows platforms
+      is_windows = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+      arg[2] = "" unless is_windows
+      super(*arg)
+    end
+
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+      return super(tmp)
+    end
+
+    def open(*rest, &block)
+      ::File.open(self.path, *rest, &block)
+    end
+
+    @@schemes['FILE'] = File
+  end
+end

data/lib/json-schema/uri/uuid.rb

@@ -0,0 +1,285 @@
+#!/usr/bin/env ruby
+### http://mput.dip.jp/mput/uuid.txt
+
+# Copyright(c) 2005 URABE, Shyouhei.
+#
+# Permission is hereby granted, free of  charge, to any person obtaining a copy
+# of  this code, to  deal in  the code  without restriction,  including without
+# limitation  the rights  to  use, copy,  modify,  merge, publish,  distribute,
+# sublicense, and/or sell copies of the code, and to permit persons to whom the
+# code 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 code.
+#
+# THE  CODE 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
+# AUTHOR  OR  COPYRIGHT  HOLDER 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 CODE OR THE  USE OR OTHER  DEALINGS IN THE
+# CODE.
+#
+# 2009-02-20:  Modified by Pablo Lorenzoni <pablo@propus.com.br>  to  correctly
+# include the version in the raw_bytes.
+
+
+require 'digest/md5'
+require 'digest/sha1'
+require 'tmpdir'
+
+module JSON
+  module Util
+  
+    # Pure ruby UUID generator, which is compatible with RFC4122
+    UUID = Struct.new :raw_bytes
+  
+    class UUID
+    	private_class_method :new
+
+    	class << self
+    		def mask19 v, str # :nodoc
+    			nstr = str.bytes.to_a
+    			version = [0, 16, 32, 48, 64, 80][v]
+    			nstr[6] &= 0b00001111
+    			nstr[6] |= version
+    #			nstr[7] &= 0b00001111
+    #			nstr[7] |= 0b01010000
+    			nstr[8] &= 0b00111111
+    			nstr[8] |= 0b10000000
+    			str = ''
+    			nstr.each { |s| str << s.chr }
+    			str
+    		end
+
+    		def mask18 v, str # :nodoc
+    			version = [0, 16, 32, 48, 64, 80][v]
+    			str[6] &= 0b00001111
+    			str[6] |= version
+    #			str[7] &= 0b00001111
+    #			str[7] |= 0b01010000
+    			str[8] &= 0b00111111
+    			str[8] |= 0b10000000
+    			str
+    		end
+
+    		def mask v, str
+    			if RUBY_VERSION >= "1.9.0"
+    				return mask19 v, str
+    			else
+    				return mask18 v, str
+    			end
+    		end
+    		private :mask, :mask18, :mask19
+
+    		# UUID generation using SHA1. Recommended over create_md5.
+    		# Namespace object is another UUID, some of them are pre-defined below.
+    		def create_sha1 str, namespace
+    			sha1 = Digest::SHA1.new
+    			sha1.update namespace.raw_bytes
+    			sha1.update str
+    			sum = sha1.digest
+    			raw = mask 5, sum[0..15]
+    			ret = new raw
+    			ret.freeze
+    			ret
+    		end
+    		alias :create_v5 :create_sha1
+
+    		# UUID generation using MD5 (for backward compat.)
+    		def create_md5 str, namespace
+    			md5 = Digest::MD5.new
+    			md5.update namespace.raw_bytes
+    			md5.update str
+    			sum = md5.digest
+    			raw = mask 3, sum[0..16]
+    			ret = new raw
+    			ret.freeze
+    			ret
+    		end
+    		alias :create_v3 :create_md5
+
+    		# UUID  generation  using  random-number  generator.   From  it's  random
+    		# nature, there's  no warranty that  the created ID is  really universaly
+    		# unique.
+    		def create_random
+    			rnd = [
+    				rand(0x100000000),
+    				rand(0x100000000),
+    				rand(0x100000000),
+    				rand(0x100000000),
+    			].pack "N4"
+    			raw = mask 4, rnd
+    			ret = new raw
+    			ret.freeze
+    			ret
+    		end
+    		alias :create_v4 :create_random
+
+    		def read_state fp			  # :nodoc:
+    			fp.rewind
+    			Marshal.load fp.read
+    		end
+
+    		def write_state fp, c, m  # :nodoc:
+    			fp.rewind
+    			str = Marshal.dump [c, m]
+    			fp.write str
+    		end
+
+    		private :read_state, :write_state
+    		STATE_FILE = 'ruby-uuid'
+
+    		# create  the "version  1" UUID  with current  system clock,  current UTC
+    		# timestamp, and the IEEE 802 address (so-called MAC address).
+    		#
+    		# Speed notice: it's slow.  It writes  some data into hard drive on every
+    		# invokation. If you want to speed  this up, try remounting tmpdir with a
+    		# memory based filesystem  (such as tmpfs).  STILL slow?  then no way but
+    		# rewrite it with c :)
+    		def create clock=nil, time=nil, mac_addr=nil
+    			c = t = m = nil
+    			Dir.chdir Dir.tmpdir do
+    				unless FileTest.exist? STATE_FILE then
+    					# Generate a pseudo MAC address because we have no pure-ruby way
+    					# to know  the MAC  address of the  NIC this system  uses.  Note
+    					# that cheating  with pseudo arresses here  is completely legal:
+    					# see Section 4.5 of RFC4122 for details.
+    					sha1 = Digest::SHA1.new
+    					256.times do
+    						r = [rand(0x100000000)].pack "N"
+    						sha1.update r
+    					end
+    					str = sha1.digest
+    					r = rand 14 # 20-6
+    					node = str[r, 6] || str
+    					if RUBY_VERSION >= "1.9.0"
+    						nnode = node.bytes.to_a
+    						nnode[0] |= 0x01
+    						node = ''
+    						nnode.each { |s| node << s.chr }
+    					else
+    						node[0] |= 0x01 # multicast bit
+    					end
+    					k = rand 0x40000
+    					open STATE_FILE, 'w' do |fp|
+    						fp.flock IO::LOCK_EX
+    						write_state fp, k, node
+    						fp.chmod 0o777 # must be world writable
+    					end
+    				end
+    				open STATE_FILE, 'r+' do |fp|
+    					fp.flock IO::LOCK_EX
+    					c, m = read_state fp
+    					c = clock % 0x4000 if clock
+    					m = mac_addr if mac_addr
+    					t = time
+    					if t.nil? then
+    						# UUID epoch is 1582/Oct/15
+    						tt = Time.now
+    						t = tt.to_i*10000000 + tt.tv_usec*10 + 0x01B21DD213814000
+    					end
+    					c = c.succ # important; increment here
+    					write_state fp, c, m
+    				end
+    			end
+
+    			tl = t & 0xFFFF_FFFF
+    			tm = t >> 32
+    			tm = tm & 0xFFFF
+    			th = t >> 48
+    			th = th & 0x0FFF
+    			th = th | 0x1000
+    			cl = c & 0xFF
+    			ch = c & 0x3F00
+    			ch = ch >> 8
+    			ch = ch | 0x80
+    			pack tl, tm, th, cl, ch, m
+    		end
+    		alias :create_v1 :create
+
+    		# A  simple GUID  parser:  just ignores  unknown  characters and  convert
+    		# hexadecimal dump into 16-octet object.
+    		def parse obj
+    			str = obj.to_s.sub %r/\Aurn:uuid:/, ''
+    			str.gsub! %r/[^0-9A-Fa-f]/, ''
+    			raw = str[0..31].lines.to_a.pack 'H*'
+    			ret = new raw
+    			ret.freeze
+    			ret
+    		end
+
+    		# The 'primitive constructor' of this class
+    		# Note UUID.pack(uuid.unpack) == uuid
+    		def pack tl, tm, th, ch, cl, n
+    			raw = [tl, tm, th, ch, cl, n].pack "NnnCCa6"
+    			ret = new raw
+    			ret.freeze
+    			ret
+    		end
+    	end
+
+    	# The 'primitive deconstructor', or the dual to pack.
+    	# Note UUID.pack(uuid.unpack) == uuid
+    	def unpack
+    		raw_bytes.unpack "NnnCCa6"
+    	end
+
+    	# Generate the string representation (a.k.a GUID) of this UUID
+    	def to_s
+    		a = unpack
+    		tmp = a[-1].unpack 'C*'
+    		a[-1] = sprintf '%02x%02x%02x%02x%02x%02x', *tmp
+    		"%08x-%04x-%04x-%02x%02x-%s" % a
+    	end
+    	alias guid to_s
+
+    	# Convert into a RFC4122-comforming URN representation
+    	def to_uri
+    		"urn:uuid:" + self.to_s
+    	end
+    	alias urn to_uri
+
+    	# Convert into 128-bit unsigned integer
+    	# Typically a Bignum instance, but can be a Fixnum.
+    	def to_int
+    		tmp = self.raw_bytes.unpack "C*"
+    		tmp.inject do |r, i|
+    			r * 256 | i
+    		end
+    	end
+    	alias to_i to_int
+
+    	# Gets the version of this UUID
+    	# returns nil if bad version
+    	def version
+    		a = unpack
+    		v = (a[2] & 0xF000).to_s(16)[0].chr.to_i
+    		return v if (1..5).include? v
+    		return nil
+    	end
+
+    	# Two  UUIDs  are  said  to  be  equal if  and  only  if  their  (byte-order
+    	# canonicalized) integer representations are equivallent.  Refer RFC4122 for
+    	# details.
+    	def == other
+    		to_i == other.to_i
+    	end
+
+    	include Comparable
+    	# UUIDs are comparable (don't know what benefits are there, though).
+    	def <=> other
+    		to_s <=> other.to_s
+    	end
+
+    	# Pre-defined UUID Namespaces described in RFC4122 Appendix C.
+    	NameSpace_DNS = parse "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+    	NameSpace_URL = parse "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+    	NameSpace_OID = parse "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
+    	NameSpace_X500 = parse "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
+
+    	# The Nil UUID in RFC4122 Section 4.1.7
+    	Nil = parse "00000000-0000-0000-0000-000000000000"
+    end
+  end
+end