RubyGems - json-schema - Versions diffs - 0.9.1 → 0.9.2 - Mend

json-schema 0.9.1 → 0.9.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

data/lib/json-schema/attributes/format.rb +68 -68
data/test/test_jsonschema_draft1.rb +3 -60
data/test/test_jsonschema_draft2.rb +3 -60
data/test/test_jsonschema_draft3.rb +5 -70
metadata +4 -5
data/lib/json-schema/validator.rb.orig +0 -391

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 DELETED Viewed

@@ -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