json-schema-openc-fork 0.0.1

data/lib/json-schema/schema.rb

@@ -0,0 +1,63 @@
+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 = Addressable::URI.parse(@schema['id'])
+        if temp_uri.relative?
+          temp_uri = uri.join(temp_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']
+        @validator = JSON::Validator.validator_for(@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?
+      JSON::Schema.new(array_schema, uri, validator)
+    end
+
+    def to_s
+      @schema.to_json
+    end
+  end
+end
+

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

@@ -0,0 +1,113 @@
+require 'open-uri'
+require 'addressable/uri'
+require 'pathname'
+
+module JSON
+  class Schema
+    # Raised by {JSON::Schema::Reader} when one of its settings indicate
+    # a schema should not be readed.
+    class ReadRefused < 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("Read of #{type == :uri ? 'URI' : type} at #{location} refused!")
+      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 should not be readed
+      # @raise [JSON::ParserError] if the schema was not a valid JSON object
+      def read(location)
+        uri  = Addressable::URI.parse(location.to_s)
+        body = if uri.scheme.nil? || uri.scheme == 'file'
+                 uri = Addressable::URI.convert_path(uri.path)
+                 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
+      end
+
+      def read_file(pathname)
+        if accept_file?(pathname)
+          File.read(Addressable::URI.unescape(pathname.to_s))
+        else
+          raise JSON::Schema::ReadRefused.new(pathname.to_s, :file)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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)
+        validator = JSON::Validator.validator_for(schema_uri)
+        @attributes.merge!(validator.attributes)
+      end
+
+      def validate(current_schema, data, fragments, processor, options = {})
+        current_schema.schema.each do |attr_name,attribute|
+          if @attributes.has_key?(attr_name.to_s)
+            @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/util/array_set.rb

@@ -0,0 +1,14 @@
+# 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! And we can't use sets because of
+# backport support... so...
+
+class ArraySet < Array
+	def include?(obj)
+		# On first invocation create a HASH (yeah, yeah) to act as our set given the array values
+		if !defined? @array_values
+			@array_values = {}
+			self.each {|x| @array_values[x] = 1}
+		end
+		@array_values.has_key? obj
+	end
+end

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

@@ -0,0 +1,16 @@
+module JSON
+  module Util
+    module URI
+      def self.normalized_uri(uri)
+        uri = Addressable::URI.parse(uri) unless uri.is_a?(Addressable::URI)
+        # Check for absolute path
+        if uri.relative?
+          data = uri.to_s
+          data = "#{Dir.pwd}/#{data}" if data[0,1] != '/'
+          uri = Addressable::URI.convert_path(data)
+        end
+        uri
+      end
+    end
+  end
+end

data/lib/json-schema/util/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