json_schemer 0.2.24 → 1.0.0

data/lib/json_schemer/schema/base.rb

@@ -4,40 +4,27 @@ module JSONSchemer
     class Base
       include Format
 
-      Instance = Struct.new(:data, :data_pointer, :schema, :schema_pointer, :parent_uri, :before_property_validation, :after_property_validation) do
+      Instance = Struct.new(:data, :data_pointer, :schema, :schema_pointer, :base_uri, :before_property_validation, :after_property_validation) do
         def merge(
           data: self.data,
           data_pointer: self.data_pointer,
           schema: self.schema,
           schema_pointer: self.schema_pointer,
-          parent_uri: self.parent_uri,
+          base_uri: self.base_uri,
           before_property_validation: self.before_property_validation,
           after_property_validation: self.after_property_validation
         )
-          self.class.new(data, data_pointer, schema, schema_pointer, parent_uri, before_property_validation, after_property_validation)
+          self.class.new(data, data_pointer, schema, schema_pointer, base_uri, before_property_validation, after_property_validation)
         end
       end
 
       ID_KEYWORD = '$id'
       DEFAULT_REF_RESOLVER = proc { |uri| raise UnknownRef, uri.to_s }
       NET_HTTP_REF_RESOLVER = proc { |uri| JSON.parse(Net::HTTP.get(uri)) }
+      RUBY_REGEXP_RESOLVER = proc { |pattern| Regexp.new(pattern) }
+      ECMA_REGEXP_RESOLVER = proc { |pattern| Regexp.new(EcmaRegexp.ruby_equivalent(pattern)) }
       BOOLEANS = Set[true, false].freeze
 
-      RUBY_REGEX_ANCHORS_TO_ECMA_262 = {
-        :bos => 'A',
-        :eos => 'z',
-        :bol => '\A',
-        :eol => '\z'
-      }.freeze
-
-      ECMA_262_REGEXP_RESOLVER = proc do |pattern|
-        Regexp.new(
-          Regexp::Scanner.scan(pattern).map do |type, token, text|
-            type == :anchor ? RUBY_REGEX_ANCHORS_TO_ECMA_262.fetch(token, text) : text
-          end.join
-        )
-      end
-
       INSERT_DEFAULT_PROPERTY = proc do |data, property, property_schema, _parent|
         if !data.key?(property) && property_schema.is_a?(Hash) && property_schema.key?('default')
           data[property] = property_schema.fetch('default').clone
@@ -47,8 +34,23 @@ module JSONSchemer
       JSON_POINTER_TOKEN_ESCAPE_CHARS = { '~' => '~0', '/' => '~1' }
       JSON_POINTER_TOKEN_ESCAPE_REGEXP = Regexp.union(JSON_POINTER_TOKEN_ESCAPE_CHARS.keys)
 
+      class << self
+        def draft_name
+          name.split('::').last.downcase
+        end
+
+        def meta_schema
+          @meta_schema ||= JSON.parse(Pathname.new(__dir__).join("#{draft_name}.json").read).freeze
+        end
+
+        def meta_schemer
+          @meta_schemer ||= JSONSchemer.schema(meta_schema)
+        end
+      end
+
       def initialize(
         schema,
+        base_uri: nil,
         format: true,
         insert_property_defaults: false,
         before_property_validation: nil,
@@ -56,10 +58,11 @@ module JSONSchemer
         formats: nil,
         keywords: nil,
         ref_resolver: DEFAULT_REF_RESOLVER,
-        regexp_resolver: 'ecma'
+        regexp_resolver: 'ruby'
       )
         raise InvalidSymbolKey, 'schemas must use string keys' if schema.is_a?(Hash) && !schema.empty? && !schema.first.first.is_a?(String)
         @root = schema
+        @base_uri = base_uri
         @format = format
         @before_property_validation = [*before_property_validation]
         @before_property_validation.unshift(INSERT_DEFAULT_PROPERTY) if insert_property_defaults
@@ -69,24 +72,34 @@ module JSONSchemer
         @ref_resolver = ref_resolver == 'net/http' ? CachedResolver.new(&NET_HTTP_REF_RESOLVER) : ref_resolver
         @regexp_resolver = case regexp_resolver
         when 'ecma'
-          CachedResolver.new(&ECMA_262_REGEXP_RESOLVER)
+          CachedResolver.new(&ECMA_REGEXP_RESOLVER)
         when 'ruby'
-          CachedResolver.new(&Regexp.method(:new))
+          CachedResolver.new(&RUBY_REGEXP_RESOLVER)
         else
           regexp_resolver
         end
       end
 
       def valid?(data)
-        valid_instance?(Instance.new(data, '', root, '', nil, @before_property_validation, @after_property_validation))
+        valid_instance?(Instance.new(data, '', root, '', @base_uri, @before_property_validation, @after_property_validation))
       end
 
       def validate(data)
-        validate_instance(Instance.new(data, '', root, '', nil, @before_property_validation, @after_property_validation))
+        validate_instance(Instance.new(data, '', root, '', @base_uri, @before_property_validation, @after_property_validation))
+      end
+
+      def valid_schema?
+        self.class.meta_schemer.valid?(root)
+      end
+
+      def validate_schema
+        self.class.meta_schemer.validate(root)
       end
 
     protected
 
+      attr_reader :root
+
       def valid_instance?(instance)
         validate_instance(instance).none?
       end
@@ -116,13 +129,13 @@ module JSONSchemer
         ref = schema['$ref']
         id = schema[id_keyword]
 
-        instance.parent_uri = join_uri(instance.parent_uri, id)
-
         if ref
           validate_ref(instance, ref, &block)
           return
         end
 
+        instance.base_uri = join_uri(instance.base_uri, id)
+
         if format? && custom_format?(format)
           validate_custom_format(instance, formats.fetch(format), &block)
         end
@@ -200,7 +213,7 @@ module JSONSchemer
 
         if if_schema && valid_instance?(instance.merge(schema: if_schema, before_property_validation: false, after_property_validation: false))
           validate_instance(instance.merge(schema: then_schema, schema_pointer: "#{instance.schema_pointer}/then"), &block) unless then_schema.nil?
-        elsif if_schema
+        elsif schema.key?('if')
           validate_instance(instance.merge(schema: else_schema, schema_pointer: "#{instance.schema_pointer}/else"), &block) unless else_schema.nil?
         end
 
@@ -224,7 +237,7 @@ module JSONSchemer
 
     private
 
-      attr_reader :root, :formats, :keywords, :ref_resolver, :regexp_resolver
+      attr_reader :formats, :keywords, :ref_resolver, :regexp_resolver
 
       def id_keyword
         ID_KEYWORD
@@ -242,9 +255,11 @@ module JSONSchemer
         !custom_format?(format) && supported_format?(format)
       end
 
-      def child(schema)
+      def child(schema, base_uri:)
         JSONSchemer.schema(
           schema,
+          default_schema_class: self.class,
+          base_uri: base_uri,
           format: format?,
           formats: formats,
           keywords: keywords,
@@ -301,50 +316,38 @@ module JSONSchemer
       end
 
       def validate_ref(instance, ref, &block)
-        if ref.start_with?('#')
-          schema_pointer = ref.slice(1..-1)
-          if valid_json_pointer?(schema_pointer)
-            ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(schema_pointer))
-            subinstance = instance.merge(
-              schema: ref_pointer.eval(root),
-              schema_pointer: schema_pointer,
-              parent_uri: (pointer_uri(root, ref_pointer) || instance.parent_uri)
-            )
-            validate_instance(subinstance, &block)
-            return
-          end
-        end
-
-        ref_uri = join_uri(instance.parent_uri, ref)
+        ref_uri = join_uri(instance.base_uri, ref)
 
+        ref_uri_pointer = ''
         if valid_json_pointer?(ref_uri.fragment)
-          ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(ref_uri.fragment))
-          ref_root = resolve_ref(ref_uri)
-          ref_object = child(ref_root)
-          subinstance = instance.merge(
-            schema: ref_pointer.eval(ref_root),
-            schema_pointer: ref_uri.fragment,
-            parent_uri: (pointer_uri(ref_root, ref_pointer) || ref_uri)
-          )
-          ref_object.validate_instance(subinstance, &block)
-        elsif id = ids[ref_uri.to_s]
-          subinstance = instance.merge(
-            schema: id.fetch(:schema),
-            schema_pointer: id.fetch(:pointer),
-            parent_uri: ref_uri
-          )
-          validate_instance(subinstance, &block)
+          ref_uri_pointer = ref_uri.fragment
+          ref_uri.fragment = nil
+        end
+
+        ref_object = if ids.key?(ref_uri) || ref_uri.to_s == @base_uri.to_s
+          self
         else
-          ref_root = resolve_ref(ref_uri)
-          ref_object = child(ref_root)
-          id = ref_object.ids[ref_uri.to_s] || { schema: ref_root, pointer: '' }
-          subinstance = instance.merge(
-            schema: id.fetch(:schema),
-            schema_pointer: id.fetch(:pointer),
-            parent_uri: ref_uri
-          )
-          ref_object.validate_instance(subinstance, &block)
+          child(resolve_ref(ref_uri), base_uri: ref_uri)
+        end
+
+        ref_schema, ref_schema_pointer = ref_object.ids[ref_uri] || [ref_object.root, '']
+
+        ref_uri_pointer_parts = Hana::Pointer.parse(URI.decode_www_form_component(ref_uri_pointer))
+        schema, base_uri = ref_uri_pointer_parts.reduce([ref_schema, ref_uri]) do |(obj, uri), token|
+          if obj.is_a?(Array)
+            [obj.fetch(token.to_i), uri]
+          else
+            [obj.fetch(token), join_uri(uri, obj[id_keyword])]
+          end
         end
+
+        subinstance = instance.merge(
+          schema: schema,
+          schema_pointer: "#{ref_schema_pointer}#{ref_uri_pointer}",
+          base_uri: base_uri
+        )
+
+        ref_object.validate_instance(subinstance, &block)
       end
 
       def validate_custom_format(instance, custom_format)
@@ -616,8 +619,7 @@ module JSONSchemer
 
       def safe_strict_decode64(data)
         Base64.strict_decode64(data)
-      rescue ArgumentError => e
-        raise e unless e.message == 'invalid base64'
+      rescue ArgumentError
         nil
       end
 
@@ -627,7 +629,7 @@ module JSONSchemer
 
       def join_uri(a, b)
         b = URI.parse(b) if b
-        if a && b && a.relative? && b.relative?
+        uri = if a && b && a.relative? && b.relative?
           b
         elsif a && b
           URI.join(a, b)
@@ -636,34 +638,26 @@ module JSONSchemer
         else
           a
         end
+        uri.fragment = nil if uri.is_a?(URI) && uri.fragment == ''
+        uri
       end
 
-      def pointer_uri(schema, pointer)
-        uri_parts = nil
-        pointer.reduce(schema) do |obj, token|
-          next obj.fetch(token.to_i) if obj.is_a?(Array)
-          if obj_id = obj[id_keyword]
-            uri_parts ||= []
-            uri_parts << obj_id
-          end
-          obj.fetch(token)
-        end
-        uri_parts ? URI.join(*uri_parts) : nil
-      end
-
-      def resolve_ids(schema, ids = {}, parent_uri = nil, pointer = '')
+      def resolve_ids(schema, ids = {}, base_uri = @base_uri, pointer = '')
         if schema.is_a?(Array)
-          schema.each_with_index { |subschema, index| resolve_ids(subschema, ids, parent_uri, "#{pointer}/#{index}") }
+          schema.each_with_index { |subschema, index| resolve_ids(subschema, ids, base_uri, "#{pointer}/#{index}") }
         elsif schema.is_a?(Hash)
-          uri = join_uri(parent_uri, schema[id_keyword])
+          uri = join_uri(base_uri, schema[id_keyword])
           schema.each do |key, value|
-            if key == id_keyword && uri != parent_uri
-              ids[uri.to_s] = {
-                schema: schema,
-                pointer: pointer
-              }
+            case key
+            when id_keyword
+              ids[uri] ||= [schema, pointer]
+            when 'items', 'allOf', 'anyOf', 'oneOf', 'additionalItems', 'contains', 'additionalProperties', 'propertyNames', 'if', 'then', 'else', 'not'
+              resolve_ids(value, ids, uri, "#{pointer}/#{key}")
+            when 'properties', 'patternProperties', 'definitions', 'dependencies'
+              value.each do |subkey, subvalue|
+                resolve_ids(subvalue, ids, uri, "#{pointer}/#{key}/#{subkey}")
+              end
             end
-            resolve_ids(value, ids, uri, "#{pointer}/#{key}")
           end
         end
         ids

data/lib/json_schemer/schema/draft4.json

@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

data/lib/json_schemer/schema/draft6.json

@@ -0,0 +1,155 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}