seomoz-json-schema 1.0.1

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

@@ -0,0 +1,32 @@
+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] = ""
+      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

data/lib/json-schema/validator.rb

@@ -0,0 +1,425 @@
+require 'uri'
+require 'open-uri'
+require 'pathname'
+require 'bigdecimal'
+require 'digest/sha1'
+require 'date'
+
+module JSON
+
+  class Schema
+    class ValidationError < StandardError
+      attr_reader :fragments, :schema
+
+      def initialize(message, fragments, schema)
+        @fragments = fragments
+        @schema = schema
+        message = "#{message} in schema #{schema.uri}"
+        super(message)
+      end
+    end
+
+    class SchemaError < StandardError
+    end
+
+    class JsonParseError < StandardError
+    end
+
+    class Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+      end
+
+      def self.build_fragment(fragments)
+        "#/#{fragments.join('/')}"
+      end
+
+      def self.validation_error(message, fragments, current_schema, record_errors)
+        error = ValidationError.new(message, fragments, current_schema)
+        if record_errors
+          ::JSON::Validator.validation_error(error.message)
+        else
+          raise error
+        end
+      end
+    end
+
+    class Validator
+      attr_accessor :attributes, :uri
+
+      def initialize()
+        @attributes = {}
+        @uri = nil
+      end
+
+      def extend_schema_definition(schema_uri)
+        u = URI.parse(schema_uri)
+        validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
+        if validator.nil?
+          raise SchemaError.new("Schema not found: #{u.scheme}://#{u.host}#{u.path}")
+        end
+        @attributes.merge!(validator.attributes)
+      end
+
+      def to_s
+        "#{@uri.scheme}://#{uri.host}#{uri.path}"
+      end
+
+      def validate(current_schema, data, fragments, 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, self, options)
+          end
+        end
+        data
+      end
+    end
+  end
+
+
+  class Validator
+
+    @@schemas = {}
+    @@cache_schemas = false
+    @@default_opts = {
+      :list => false,
+      :version => nil,
+      :validate_schema => false,
+      :record_errors => false
+    }
+    @@validators = {}
+    @@default_validator = nil
+    @@errors = []
+
+    def self.version_string_for(version)
+      # I'm not a fan of this, but it's quick and dirty to get it working for now
+      return "draft-03" unless version
+      case version.to_s
+      when "draft3"
+        "draft-03"
+      when "draft2"
+        "draft-02"
+      when "draft1"
+        "draft-01"
+      else
+        raise JSON::Schema::SchemaError.new("The requested JSON schema version is not supported")
+      end
+    end
+
+    def self.metaschema_for(version_string)
+      File.join(Pathname.new(File.dirname(__FILE__)).parent.parent, "resources", "#{version_string}.json").to_s
+    end
+
+    def initialize(schema_data, data, opts={})
+      @options = @@default_opts.clone.merge(opts)
+
+      # I'm not a fan of this, but it's quick and dirty to get it working for now
+      version_string = "draft-03"
+      if @options[:version]
+        version_string = @options[:version] = self.class.version_string_for(@options[:version])
+        u = URI.parse("http://json-schema.org/#{@options[:version]}/schema#")
+        validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
+        @options[:version] = validator
+      end
+
+      @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
+      
+      # validate the schema, if requested
+      if @options[:validate_schema]
+        begin
+          meta_validator = JSON::Validator.new(self.class.metaschema_for(version_string), schema_data)
+          meta_validator.validate
+        rescue JSON::Schema::ValidationError, JSON::Schema::SchemaError
+          raise $!
+        end
+      end
+      
+      @base_schema = initialize_schema(schema_data)
+      @data = initialize_data(data)
+      build_schemas(@base_schema)
+    end
+
+
+    # Run a simple true/false validation of data against a schema
+    def validate()
+      begin
+        Validator.clear_errors
+        @base_schema.validate(@data,[],@validation_options)
+        Validator.clear_cache
+        @@errors
+      rescue JSON::Schema::ValidationError
+        Validator.clear_cache
+        raise $!
+      end
+    end
+
+
+    def load_ref_schema(parent_schema,ref)
+      uri = URI.parse(ref)
+      if uri.relative?
+        uri = parent_schema.uri.clone
+
+        # Check for absolute path
+        path = ref.split("#")[0]
+
+        # This is a self reference and thus the schema does not need to be re-loaded
+        if path.nil? || path == ''
+          return
+        end
+
+        if path && path[0,1] == '/'
+          uri.path = Pathname.new(path).cleanpath.to_s
+        else
+          uri = parent_schema.uri.merge(path)
+        end
+        uri.fragment = ''
+      end
+
+      if Validator.schemas[uri.to_s].nil?
+        begin
+          schema = JSON::Schema.new(JSON::Validator.parse(open(uri.to_s).read), uri, @options[:version])
+          Validator.add_schema(schema)
+          build_schemas(schema)
+        rescue JSON::ParserError
+          # Don't rescue this error, we want JSON formatting issues to bubble up
+          raise $!
+        rescue Exception
+          # Failures will occur when this URI cannot be referenced yet. Don't worry about it,
+          # the proper error will fall out if the ref isn't ever defined
+        end
+      end
+    end
+
+
+    # Build all schemas with IDs, mapping out the namespace
+    def build_schemas(parent_schema)
+      # Build ref schemas if they exist
+      if parent_schema.schema["$ref"]
+        load_ref_schema(parent_schema, parent_schema.schema["$ref"])
+      end
+
+      # Check for schemas in union types
+      ["type", "disallow"].each do |key|
+        if parent_schema.schema[key] && parent_schema.schema[key].is_a?(Array)
+          parent_schema.schema[key].each_with_index do |type,i|
+            if type.is_a?(Hash)
+              handle_schema(parent_schema, type)
+            end
+          end
+        end
+      end
+
+      # All properties are schemas
+      if parent_schema.schema["properties"]
+        parent_schema.schema["properties"].each do |k,v|
+          handle_schema(parent_schema, v)
+        end
+      end
+
+      # Items are always schemas
+      if parent_schema.schema["items"]
+        items = parent_schema.schema["items"].clone
+        single = false
+        if !items.is_a?(Array)
+          items = [items]
+          single = true
+        end
+        items.each_with_index do |item,i|
+          handle_schema(parent_schema, item)
+        end
+      end
+
+      # Each of these might be schemas
+      ["additionalProperties", "additionalItems", "dependencies", "extends"].each do |key|
+        if parent_schema.schema[key].is_a?(Hash)
+          handle_schema(parent_schema, parent_schema.schema[key])
+        end
+      end
+
+    end
+
+    # Either load a reference schema or create a new schema
+    def handle_schema(parent_schema, obj)
+      schema_uri = parent_schema.uri.clone
+      schema = JSON::Schema.new(obj,schema_uri,@options[:version])
+      if obj['id']
+        Validator.add_schema(schema)
+      end
+      build_schemas(schema)
+    end
+
+
+    class << self
+      def validate(schema, data,opts={})
+        begin
+          validator = JSON::Validator.new(schema, data, opts)
+          validator.validate
+          return true
+        rescue JSON::Schema::ValidationError, JSON::Schema::SchemaError
+          return false
+        end
+      end
+
+      def validate!(schema, data,opts={})
+        validator = JSON::Validator.new(schema, data, opts)
+        validator.validate
+        return true
+      end
+      alias_method 'validate2', 'validate!'
+
+
+      def fully_validate(schema, data, opts={})
+        opts[:record_errors] = true
+        validator = JSON::Validator.new(schema, data, opts)
+        validator.validate
+      end
+
+      def fully_validate_schema(schema, opts={})
+        data = schema
+        schema = metaschema_for(version_string_for(opts[:version]))
+        fully_validate(schema, data, opts)
+      end
+
+
+      def clear_cache
+        @@schemas = {} if @@cache_schemas == false
+      end
+
+      def clear_errors
+        @@errors = []
+      end
+
+      def validation_error(error)
+        @@errors.push(error)
+      end
+
+      def schemas
+        @@schemas
+      end
+
+      def add_schema(schema)
+        @@schemas[schema.uri.to_s] = schema if @@schemas[schema.uri.to_s].nil?
+      end
+
+      def cache_schemas=(val)
+        @@cache_schemas = val == true ? true : false
+      end
+
+      def validators
+        @@validators
+      end
+
+      def default_validator
+        @@default_validator
+      end
+
+      def register_validator(v)
+        @@validators[v.to_s] = v
+      end
+
+      def register_default_validator(v)
+        @@default_validator = v
+      end
+
+      def json_backend=(backend)
+        warn "json_backend= is deprecated. Use MultiJson.engine= instead"
+      end
+
+      def parse(s)
+        MultiJson.decode(s)
+      end
+    end
+
+    private
+
+    if begin
+        Gem::Specification::find_by_name('uuidtools')
+      rescue Gem::LoadError
+        false
+      rescue
+        Gem.available?('uuidtools')
+      end
+      require 'uuidtools'
+      @@fake_uri_generator = lambda{|s| UUIDTools::UUID.sha1_create(UUIDTools::UUID_URL_NAMESPACE, s).to_s }
+    else
+      require 'uri/uuid'
+      @@fake_uri_generator = lambda{|s| JSON::Util::UUID.create_v5(s,JSON::Util::UUID::Nil).to_s }
+    end
+
+    def serialize schema
+      MultiJson.encode(schema)
+    end
+
+    def fake_uri schema
+      @@fake_uri_generator.call(schema)
+    end
+
+    def initialize_schema(schema)
+      if schema.is_a?(String)
+        begin
+          # Build a fake URI for this
+          schema_uri = URI.parse(fake_uri(schema))
+          schema = JSON::Validator.parse(schema)
+          if @options[:list]
+            schema = {"type" => "array", "items" => schema}
+          end
+          schema = JSON::Schema.new(schema,schema_uri,@options[:version])
+          Validator.add_schema(schema)
+        rescue
+          # Build a uri for it
+          schema_uri = URI.parse(schema)
+          if schema_uri.relative?
+            # Check for absolute path
+            if schema[0,1] == '/'
+              schema_uri = URI.parse("file://#{schema}")
+            else
+              schema_uri = URI.parse("file://#{Dir.pwd}/#{schema}")
+            end
+          end
+          if Validator.schemas[schema_uri.to_s].nil?
+            schema = JSON::Validator.parse(open(schema_uri.to_s).read)
+            if @options[:list]
+              schema = {"type" => "array", "items" => schema}
+            end
+            schema = JSON::Schema.new(schema,schema_uri,@options[:version])
+            Validator.add_schema(schema)
+          else
+            schema = Validator.schemas[schema_uri.to_s]
+          end
+        end
+      elsif schema.is_a?(Hash)
+        if @options[:list]
+          schema = {"type" => "array", "items" => schema}
+        end
+        schema_uri = URI.parse(fake_uri(serialize(schema)))
+        schema = JSON::Schema.new(schema,schema_uri,@options[:version])
+        Validator.add_schema(schema)
+      else
+        raise "Invalid schema - must be either a string or a hash"
+      end
+
+      schema
+    end
+
+
+    def initialize_data(data)
+      # Parse the data, if any
+      if data.is_a?(String)
+        begin
+          data = JSON::Validator.parse(data)
+        rescue
+          json_uri = URI.parse(data)
+          if json_uri.relative?
+            if data[0,1] == '/'
+              schema_uri = URI.parse("file://#{data}")
+            else
+              schema_uri = URI.parse("file://#{Dir.pwd}/#{data}")
+            end
+          end
+          data = JSON::Validator.parse(open(json_uri.to_s).read)
+        end
+      end
+      data
+    end
+
+  end
+end