json-schema-ouidou 2.9.0

data/lib/json-schema/errors/validation_error.rb

@@ -0,0 +1,46 @@
+module JSON
+  class Schema
+    class ValidationError < StandardError
+      INDENT = "    "
+      attr_accessor :fragments, :schema, :failed_attribute, :sub_errors, :message
+
+      def initialize(message, fragments, failed_attribute, schema)
+        @fragments = fragments.clone
+        @schema = schema
+        @sub_errors = {}
+        @failed_attribute = failed_attribute
+        @message = message
+        super(message_with_schema)
+      end
+
+      def to_string(subschema_level = 0)
+        if @sub_errors.empty?
+          subschema_level == 0 ? message_with_schema : message
+        else
+          messages = ["#{message}. The schema specific errors were:\n"]
+          @sub_errors.each do |subschema, errors|
+            messages.push "- #{subschema}:"
+            messages.concat Array(errors).map { |e| "#{INDENT}- #{e.to_string(subschema_level + 1)}" }
+          end
+          messages.map { |m| (INDENT * subschema_level) + m }.join("\n")
+        end
+      end
+
+      def to_hash
+        base = {:schema => @schema.uri, :fragment => ::JSON::Schema::Attribute.build_fragment(fragments), :message => message_with_schema, :failed_attribute => @failed_attribute.to_s.split(":").last.split("Attribute").first}
+        if !@sub_errors.empty?
+          base[:errors] = @sub_errors.inject({}) do |hsh, (subschema, errors)|
+            subschema_sym = subschema.downcase.gsub(/\W+/, '_').to_sym
+            hsh[subschema_sym] = Array(errors).map{|e| e.to_hash}
+            hsh
+          end
+        end
+        base
+      end
+
+      def message_with_schema
+        "#{message} in schema #{schema.uri}"
+      end
+    end
+  end
+end

data/lib/json-schema/schema/reader.rb

@@ -0,0 +1,140 @@
+require 'open-uri'
+require 'pathname'
+
+module JSON
+  class Schema
+    # Base for any reading exceptions encountered by {JSON::Schema::Reader}
+    class ReadError < StandardError
+      # @return [String] the requested schema location which was refused
+      attr_reader :location
+
+      # @return [Symbol] either +:uri+ or +:file+
+      attr_reader :type
+
+      def initialize(location, type)
+        @location = location
+        @type = type
+        super(error_message)
+      end
+
+      private
+
+      def type_string
+        type == :uri ? 'URI' : type.to_s
+      end
+    end
+
+    # Raised by {JSON::Schema::Reader} when one of its settings indicate
+    # a schema should not be read.
+    class ReadRefused < ReadError
+      private
+      def error_message
+        "Read of #{type_string} at #{location} refused"
+      end
+    end
+
+    # Raised by {JSON::Schema::Reader} when an attempt to read a schema fails
+    class ReadFailed < ReadError
+      private
+      def error_message
+        "Read of #{type_string} at #{location} failed"
+      end
+    end
+
+    # When an unregistered schema is encountered, the {JSON::Schema::Reader} is
+    # used to fetch its contents and register it with the {JSON::Validator}.
+    #
+    # This default reader will read schemas from the filesystem or from a URI.
+    class Reader
+      # The behavior of the schema reader can be controlled by providing
+      # callbacks to determine whether to permit reading referenced schemas.
+      # The options +accept_uri+ and +accept_file+ should be procs which
+      # accept a +URI+ or +Pathname+ object, and return a boolean value
+      # indicating whether to read the referenced schema.
+      #
+      # URIs using the +file+ scheme will be normalized into +Pathname+ objects
+      # and passed to the +accept_file+ callback.
+      #
+      # @param options [Hash]
+      # @option options [Boolean, #call] accept_uri (true)
+      # @option options [Boolean, #call] accept_file (true)
+      #
+      # @example Reject all unregistered schemas
+      #   JSON::Validator.schema_reader = JSON::Schema::Reader.new(
+      #     :accept_uri => false,
+      #     :accept_file => false
+      #   )
+      #
+      # @example Only permit URIs from certain hosts
+      #   JSON::Validator.schema_reader = JSON::Schema::Reader.new(
+      #     :accept_file => false,
+      #     :accept_uri => proc { |uri| ['mycompany.com', 'json-schema.org'].include?(uri.host) }
+      #   )
+      def initialize(options = {})
+        @accept_uri = options.fetch(:accept_uri, true)
+        @accept_file = options.fetch(:accept_file, true)
+      end
+
+      # @param location [#to_s] The location from which to read the schema
+      # @return [JSON::Schema]
+      # @raise [JSON::Schema::ReadRefused] if +accept_uri+ or +accept_file+
+      #   indicated the schema could not be read
+      # @raise [JSON::Schema::ParseError] if the schema was not a valid JSON object
+      # @raise [JSON::Schema::ReadFailed] if reading the location was acceptable but the
+      #   attempt to retrieve it failed
+      def read(location)
+        uri  = JSON::Util::URI.parse(location.to_s)
+        body = if uri.scheme.nil? || uri.scheme == 'file'
+                 uri = JSON::Util::URI.file_uri(uri)
+                 read_file(Pathname.new(uri.path).expand_path)
+               else
+                 read_uri(uri)
+               end
+
+        JSON::Schema.new(JSON::Validator.parse(body), uri)
+      end
+
+      # @param uri [Addressable::URI]
+      # @return [Boolean]
+      def accept_uri?(uri)
+        if @accept_uri.respond_to?(:call)
+          @accept_uri.call(uri)
+        else
+          @accept_uri
+        end
+      end
+
+      # @param pathname [Pathname]
+      # @return [Boolean]
+      def accept_file?(pathname)
+        if @accept_file.respond_to?(:call)
+          @accept_file.call(pathname)
+        else
+          @accept_file
+        end
+      end
+
+      private
+
+      def read_uri(uri)
+        if accept_uri?(uri)
+          open(uri.to_s).read
+        else
+          raise JSON::Schema::ReadRefused.new(uri.to_s, :uri)
+        end
+      rescue OpenURI::HTTPError, SocketError
+        raise JSON::Schema::ReadFailed.new(uri.to_s, :uri)
+      end
+
+      def read_file(pathname)
+        if accept_file?(pathname)
+          File.read(JSON::Util::URI.unescaped_path(pathname.to_s))
+        else
+          raise JSON::Schema::ReadRefused.new(pathname.to_s, :file)
+        end
+      rescue Errno::ENOENT
+        raise JSON::Schema::ReadFailed.new(pathname.to_s, :file)
+      end
+    end
+  end
+end

data/lib/json-schema/schema/validator.rb

@@ -0,0 +1,40 @@
+module JSON
+  class Schema
+    class Validator
+      attr_accessor :attributes, :formats, :uri, :names
+      attr_reader :default_formats
+
+      def initialize()
+        @attributes = {}
+        @formats = {}
+        @default_formats = {}
+        @uri = nil
+        @names = []
+        @metaschema_name = ''
+      end
+
+      def extend_schema_definition(schema_uri)
+        warn "[DEPRECATION NOTICE] The preferred way to extend a Validator is by subclassing, rather than #extend_schema_definition. This method will be removed in version >= 3."
+        validator = JSON::Validator.validator_for_uri(schema_uri)
+        @attributes.merge!(validator.attributes)
+      end
+
+      def validate(current_schema, data, fragments, processor, options = {})
+        current_schema.schema.each do |attr_name,attribute|
+          # Added: don't try to validate if
+          # - Attribute is false and does not needs to validate anything (eg: uniqueItems) some still needs validation (eg: additionalProperties)
+          # - Attribute is nil and it makes crash the validation (eg: divisibleBy). This should fixed on mountapi side
+          if @attributes.has_key?(attr_name.to_s) && (attribute != false || @attributes[attr_name.to_s].validate_on_false?) && !attribute.nil?
+            @attributes[attr_name.to_s].validate(current_schema, data, fragments, processor, self, options)
+          end
+        end
+        data
+      end
+
+      def metaschema
+        resources = File.expand_path('../../../../resources', __FILE__)
+        File.join(resources, @metaschema_name)
+      end
+    end
+  end
+end

data/lib/json-schema/schema.rb

@@ -0,0 +1,62 @@
+require 'pathname'
+
+module JSON
+  class Schema
+
+    attr_accessor :schema, :uri, :validator
+
+    def initialize(schema,uri,parent_validator=nil)
+      @schema = schema
+      @uri = uri
+
+      # If there is an ID on this schema, use it to generate the URI
+      if @schema['id'] && @schema['id'].kind_of?(String)
+        temp_uri = JSON::Util::URI.parse(@schema['id'])
+        if temp_uri.relative?
+          temp_uri = uri.join(temp_uri)
+        end
+        @uri = temp_uri
+      end
+      @uri = JSON::Util::URI.strip_fragment(@uri)
+
+      # If there is a $schema on this schema, use it to determine which validator to use
+      if @schema['$schema']
+        @validator = JSON::Validator.validator_for_uri(@schema['$schema'])
+      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.stringify(schema)
+      case schema
+      when Hash then
+        Hash[schema.map { |key, value| [key.to_s, stringify(schema[key])] }]
+      when Array then
+        schema.map do |schema_item|
+          stringify(schema_item)
+        end
+      when Symbol then
+        schema.to_s
+      else
+        schema
+      end
+    end
+
+    # @return [JSON::Schema] a new schema matching an array whose items all match this schema.
+    def to_array_schema
+      array_schema = { 'type' => 'array', 'items' => schema }
+      array_schema['$schema'] = schema['$schema'] unless schema['$schema'].nil?
+      self.class.new(array_schema, uri, validator)
+    end
+
+    def to_s
+      @schema.to_json
+    end
+  end
+end

data/lib/json-schema/util/array_set.rb

@@ -0,0 +1,20 @@
+require 'set'
+
+# This is a hack that I don't want to ever use anywhere else or repeat EVER, but we need enums to be
+# an Array to pass schema validation. But we also want fast lookup!
+
+class ArraySet < Array
+  def include?(obj)
+    if !defined? @values
+      @values = Set.new
+      self.each { |x| @values << convert_to_float_if_numeric(x) }
+    end
+    @values.include?(convert_to_float_if_numeric(obj))
+  end
+
+  private
+
+  def convert_to_float_if_numeric(value)
+    value.is_a?(Numeric) ? value.to_f : value
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'addressable/uri'
+
+module JSON
+  module Util
+    module URI
+      SUPPORTED_PROTOCOLS = %w(http https ftp tftp sftp ssh svn+ssh telnet nntp gopher wais ldap prospero)
+
+      def self.normalized_uri(uri, base_path = Dir.pwd)
+        @normalize_cache ||= {}
+        normalized_uri = @normalize_cache[uri]
+
+        if !normalized_uri
+          normalized_uri = parse(uri)
+          # Check for absolute path
+          if normalized_uri.relative?
+            data = normalized_uri
+            data = File.join(base_path, data) if data.path[0,1] != "/"
+            normalized_uri = file_uri(data)
+          end
+          @normalize_cache[uri] = normalized_uri.freeze
+        end
+
+        normalized_uri
+      end
+
+      def self.absolutize_ref(ref, base)
+        ref_uri = strip_fragment(ref.dup)
+
+        return ref_uri if ref_uri.absolute?
+        return parse(base) if ref_uri.path.empty?
+
+        uri = strip_fragment(base.dup).join(ref_uri.path)
+        normalized_uri(uri)
+      end
+
+      def self.normalize_ref(ref, base)
+        ref_uri = parse(ref)
+        base_uri = parse(base)
+
+        ref_uri.defer_validation do
+          if ref_uri.relative?
+            ref_uri.merge!(base_uri)
+
+            # Check for absolute path
+            path, fragment = ref.to_s.split("#")
+            if path.nil? || path == ''
+              ref_uri.path = base_uri.path
+            elsif path[0,1] == "/"
+              ref_uri.path = Pathname.new(path).cleanpath.to_s
+            else
+              ref_uri.join!(path)
+            end
+
+            ref_uri.fragment = fragment
+          end
+
+          ref_uri.fragment = "" if ref_uri.fragment.nil? || ref_uri.fragment.empty?
+        end
+
+        ref_uri
+      end
+
+      def self.parse(uri)
+        if uri.is_a?(Addressable::URI)
+          return uri.dup
+        else
+          @parse_cache ||= {}
+          parsed_uri = @parse_cache[uri]
+          if parsed_uri
+            parsed_uri.dup
+          else
+            @parse_cache[uri] = Addressable::URI.parse(uri)
+          end
+        end
+      rescue Addressable::URI::InvalidURIError => e
+        raise JSON::Schema::UriError.new(e.message)
+      end
+
+      def self.strip_fragment(uri)
+        parsed_uri = parse(uri)
+        if parsed_uri.fragment.nil? || parsed_uri.fragment.empty?
+          parsed_uri
+        else
+          parsed_uri.merge(:fragment => "")
+        end
+      end
+
+      def self.file_uri(uri)
+        parsed_uri = parse(uri)
+
+        Addressable::URI.convert_path(parsed_uri.path)
+      end
+
+      def self.unescape_uri(uri)
+        Addressable::URI.unescape(uri)
+      end
+
+      def self.unescaped_path(uri)
+        parsed_uri = parse(uri)
+
+        Addressable::URI.unescape(parsed_uri.path)
+      end
+
+      def self.clear_cache
+        @parse_cache = {}
+        @normalize_cache = {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,284 @@
+#!/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
+    	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