json-schema 0.9.1 → 0.9.2

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

@@ -6,98 +6,98 @@ module JSON
 
         # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ
         when 'date-time'
-          error_message = "The property '#{build_fragment(fragments)}' must be a string and be a date/time in the ISO-8601 format of YYYY-MM-DDThh:mm:ssZ"
-          raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
-          r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)Z$')
-          if (m = r.match(data))
-            parts = data.split("T")
-            begin
-              Date.parse(parts[0])
-            rescue Exception
-              raise ValidationError.new(error_message, fragments, current_schema)
-            end
-            begin
-              raise ValidationError.new(error_message, fragments, current_schema) if m[1].to_i > 23
-              raise ValidationError.new(error_message, fragments, current_schema) if m[2].to_i > 59
-              raise ValidationError.new(error_message, fragments, current_schema) if m[3].to_i > 59
-            rescue Exception
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a date/time in the ISO-8601 format of YYYY-MM-DDThh:mm:ssZ"
+            raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+            r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)Z$')
+            if (m = r.match(data))
+              parts = data.split("T")
+              begin
+                Date.parse(parts[0])
+              rescue Exception
+                raise ValidationError.new(error_message, fragments, current_schema)
+              end
+              begin
+                raise ValidationError.new(error_message, fragments, current_schema) if m[1].to_i > 23
+                raise ValidationError.new(error_message, fragments, current_schema) if m[2].to_i > 59
+                raise ValidationError.new(error_message, fragments, current_schema) if m[3].to_i > 59
+              rescue Exception
+                raise ValidationError.new(error_message, fragments, current_schema)
+              end
+            else
               raise ValidationError.new(error_message, fragments, current_schema)
             end
-          else
-            raise ValidationError.new(error_message, fragments, current_schema)
           end
 
         # Date in the format of YYYY-MM-DD
         when 'date'
-          error_message = "The property '#{build_fragment(fragments)}' must be a string and be a date in the format of YYYY-MM-DD"
-          raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
-          r = Regexp.new('^\d\d\d\d-\d\d-\d\d$')
-          if (m = r.match(data))
-            begin
-              Date.parse(data)
-            rescue Exception
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a date in the format of YYYY-MM-DD"
+            raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+            r = Regexp.new('^\d\d\d\d-\d\d-\d\d$')
+            if (m = r.match(data))
+              begin
+                Date.parse(data)
+              rescue Exception
+                raise ValidationError.new(error_message, fragments, current_schema)
+              end
+            else
               raise ValidationError.new(error_message, fragments, current_schema)
             end
-          else
-            raise ValidationError.new(error_message, fragments, current_schema)
           end
 
         # Time in the format of HH:MM:SS
         when 'time'
-          error_message = "The property '#{build_fragment(fragments)}' must be a string and be a time in the format of hh:mm:ss"
-          raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
-          r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
-          if (m = r.match(data))
-            raise ValidationError.new(error_message, fragments, current_schema) if m[1].to_i > 23
-            raise ValidationError.new(error_message, fragments, current_schema) if m[2].to_i > 59
-            raise ValidationError.new(error_message, fragments, current_schema) if m[3].to_i > 59
-          else
-            raise ValidationError.new(error_message, fragments, current_schema)
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a time in the format of hh:mm:ss"
+            raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+            r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
+            if (m = r.match(data))
+              raise ValidationError.new(error_message, fragments, current_schema) if m[1].to_i > 23
+              raise ValidationError.new(error_message, fragments, current_schema) if m[2].to_i > 59
+              raise ValidationError.new(error_message, fragments, current_schema) if m[3].to_i > 59
+            else
+              raise ValidationError.new(error_message, fragments, current_schema)
+            end
           end
 
         # IPv4 in dotted-quad format
         when 'ip-address', 'ipv4'
-          error_message = "The property '#{build_fragment(fragments)}' must be a string and be a valid IPv4 address"
-          raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
-          r = Regexp.new('^(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}$')
-          if (m = r.match(data))
-            1.upto(4) do |x|
-              raise ValidationError.new(error_message, fragments, current_schema) if m[x].to_i > 255
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv4 address"
+            raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+            r = Regexp.new('^(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}$')
+            if (m = r.match(data))
+              1.upto(4) do |x|
+                raise ValidationError.new(error_message, fragments, current_schema) if m[x].to_i > 255
+              end
+            else
+              raise ValidationError.new(error_message, fragments, current_schema)
             end
-          else
-            raise ValidationError.new(error_message, fragments, current_schema)
           end
 
         # IPv6 in standard format (including abbreviations)
         when 'ipv6'
-          error_message = "The property '#{build_fragment(fragments)}' must be a string and be a valid IPv6 address"
-          raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
-          r = Regexp.new('^[a-f0-9:]+$')
-          if (m = r.match(data))
-            # All characters are valid, now validate structure
-            parts = data.split(":")
-            raise ValidationError.new(error_message, fragments, current_schema) if parts.length > 8
-            condensed_zeros = false
-            parts.each do |part|
-              if part.length == 0
-                raise ValidationError.new(error_message, fragments, current_schema) if condensed_zeros
-                condensed_zeros = true
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv6 address"
+            raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+            r = Regexp.new('^[a-f0-9:]+$')
+            if (m = r.match(data))
+              # All characters are valid, now validate structure
+              parts = data.split(":")
+              raise ValidationError.new(error_message, fragments, current_schema) if parts.length > 8
+              condensed_zeros = false
+              parts.each do |part|
+                if part.length == 0
+                  raise ValidationError.new(error_message, fragments, current_schema) if condensed_zeros
+                  condensed_zeros = true
+                end
+                raise ValidationError.new(error_message, fragments, current_schema) if part.length > 4
               end
-              raise ValidationError.new(error_message, fragments, current_schema) if part.length > 4
+            else
+              raise ValidationError.new(error_message, fragments, current_schema)
             end
-          else
-            raise ValidationError.new(error_message, fragments, current_schema)
           end
-
-        # Milliseconds since the epoch. Must be an integer or a float
-        when 'utc-millisec'
-          error_message = "The property '#{build_fragment(fragments)}' must be an integer or a float"
-          raise ValidationError.new(error_message, fragments, current_schema) if (!data.is_a?(Numeric))
-
-        # Must be a string
-        when 'regex','color','style','phone','uri','email','host-name'
-          error_message = "The property '#{build_fragment(fragments)}' must be a string"
-          raise ValidationError.new(error_message, fragments, current_schema) if (!data.is_a?(String))
         end
       end
     end

data/test/test_jsonschema_draft1.rb

@@ -687,73 +687,16 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
   end
   
   
-  def test_format_strings
+  def test_format_union
     data1 = {"a" => "boo"}
-    data2 = {"a" => 5}
+    data2 = {"a" => nil}
     
     schema = {
       "type" => "object",
-      "properties" => { "a" => {"format" => "regex"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "color"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "style"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "phone"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "uri"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "email"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "host-name"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
-  end
-  
-  
-  def test_format_numeric
-    data1 = {"a" => "boo"}
-    data2 = {"a" => 5}
-    data3 = {"a" => 5.4}
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "utc-millisec"}}
+      "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
     }
     assert(!JSON::Validator.validate(schema,data1,:version => :draft1))
     assert(JSON::Validator.validate(schema,data2,:version => :draft1))
-    assert(JSON::Validator.validate(schema,data3,:version => :draft1))
   end
   
 end

data/test/test_jsonschema_draft2.rb

@@ -759,73 +759,16 @@ class JSONSchemaDraft2Test < Test::Unit::TestCase
   end
   
   
-  def test_format_strings
+  def test_format_union
     data1 = {"a" => "boo"}
-    data2 = {"a" => 5}
+    data2 = {"a" => nil}
     
     schema = {
       "type" => "object",
-      "properties" => { "a" => {"format" => "regex"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft2))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "color"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "style"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft2))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "phone"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft2))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "uri"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft2))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "email"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft2))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft2))
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "host-name"}}
-    }
-    assert(JSON::Validator.validate(schema,data1,:version => :draft2))
-    assert(!JSON::Validator.validate(schema,data2,:version => :draft2))
-  end
-  
-  
-  def test_format_numeric
-    data1 = {"a" => "boo"}
-    data2 = {"a" => 5}
-    data3 = {"a" => 5.4}
-    
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"format" => "utc-millisec"}}
+      "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
     }
     assert(!JSON::Validator.validate(schema,data1,:version => :draft2))
     assert(JSON::Validator.validate(schema,data2,:version => :draft2))
-    assert(JSON::Validator.validate(schema,data3,:version => :draft2))
   end
   
 end

data/test/test_jsonschema_draft3.rb

@@ -902,81 +902,16 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
   end
   
   
-  def test_format_strings
+  def test_format_union
     data1 = {"a" => "boo"}
-    data2 = {"a" => 5}
+    data2 = {"a" => nil}
     
     schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "regex"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "color"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "style"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "phone"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "uri"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "email"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"format" => "host-name"}}
-    }
-    assert(JSON::Validator.validate(schema,data1))
-    assert(!JSON::Validator.validate(schema,data2))
-  end
-  
-  
-  def test_format_numeric
-    data1 = {"a" => "boo"}
-    data2 = {"a" => 5}
-    data3 = {"a" => 5.4}
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
-      "properties" => { "a" => {"format" => "utc-millisec"}}
+      "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
     }
-    assert(!JSON::Validator.validate(schema,data1))
-    assert(JSON::Validator.validate(schema,data2))
-    assert(JSON::Validator.validate(schema,data3))
+    assert(!JSON::Validator.validate(schema,data1,:version => :draft3))
+    assert(JSON::Validator.validate(schema,data2,:version => :draft3))
   end
   
   

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: json-schema
 version: !ruby/object:Gem::Version 
-  hash: 57
+  hash: 63
   prerelease: false
   segments: 
   - 0
   - 9
-  - 1
-  version: 0.9.1
+  - 2
+  version: 0.9.2
 platform: ruby
 authors: 
 - Kenny Hoxworth
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 -04:00
+date: 2011-03-30 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -57,7 +57,6 @@ files:
 - lib/json-schema/uri/file.rb
 - lib/json-schema/uri/uuid.rb
 - lib/json-schema/validator.rb
-- lib/json-schema/validator.rb.orig
 - lib/json-schema/validators/draft1.rb
 - lib/json-schema/validators/draft2.rb
 - lib/json-schema/validators/draft3.rb

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

@@ -1,391 +0,0 @@
-require 'uri'
-require 'open-uri'
-require 'pathname'
-require 'bigdecimal'
-require 'digest/sha1'
-require 'date'
-
-module JSON
-  
-  class Schema
-    class ValidationError < Exception
-      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 < Exception
-    end
-    
-    class JsonParseError < Exception
-    end
-    
-    class Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
-      end
-      
-      def self.build_fragment(fragments)
-        "#/#{fragments.join('/')}"
-      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)
-        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)
-          end
-        end
-        data
-      end
-    end
-  end
-  
-
-  class Validator
-
-    @@schemas = {}
-    @@cache_schemas = false
-    @@default_opts = {
-      :list => false,
-      :version => nil
-    }
-    @@validators = {}
-    @@default_validator = nil
-    @@available_json_backends = []
-    @@json_backend = nil
-    
-    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
-      if @options[:version]
-        @options[:version] = case @options[: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
-        u = URI.parse("http://json-schema.org/#{@options[:version]}/schema#")
-        validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
-        @options[:version] = validator
-      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
-        @base_schema.validate(@data,[])
-        Validator.clear_cache
-      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.path = (Pathname.new(parent_schema.uri.path).parent + path).cleanpath.to_s
-        end
-        uri.fragment = nil
-      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)    
-      # 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)
-      if obj['$ref']
-         load_ref_schema(parent_schema, obj['$ref'])
-       else
-         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
-    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
-      end
-      alias_method 'validate2', 'validate!'
-      
-      def clear_cache
-        @@schemas = {} if @@cache_schemas == false
-      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
-        @@json_backend
-      end
-      
-      def json_backend=(backend)
-        backend = backend.to_s
-        if @@available_json_backend.include?(backend)
-          @@json_backend = backend
-        else
-          raise JSON::Schema::JsonParseError.new("The JSON backend '#{backend}' could not be found.")
-        end
-      end
-      
-      def parse(s)
-        case @@json_backend.to_s
-        when 'json'
-          JSON.parse(s)
-        when 'yajl'
-          json = StringIO.new(s)
-          parser = Yajl::Parser.new
-          parser.parse(json)
-        else
-          raise JSON::Schema::JsonParseError.new("No supported JSON parsers found. The following parsers are suported:\n * yajl-ruby\n * json")
-        end
-      end
-    end
-  
-    if Gem.available?('json')
-      require 'json'
-      @@available_json_backends << 'json'
-      @@json_backend = 'json'
-    end
-    
-    if Gem.available?('yajl-ruby')
-      require 'yajl'
-      @@available_json_backends << 'yajl'
-      @@json_backend = 'yajl'
-    end
-    
-    
-    private
-<<<<<<< HEAD
-    
-=======
-
-    if Gem.available?('uuidtools')
-      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| UUID.create_v5(s,UUID::Nil).to_s }
-    end
-
-    def fake_uri schema
-      @@fake_uri_generator.call(schema)
-    end
-
->>>>>>> bcd72ee... added optional dependency on uuidtools gem, to resolve UUID constant overload warning
-    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(schema.inspect))
-        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