json_schemer 0.2.25 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd29a78d2cbd45dc0409c551d0e3c11e39a801204bab75e22ded249c4ef8edf8
-  data.tar.gz: 9d0556d1f4723ae50b9a038595f44ffdc9c0dcc8d05d9b9771f58248fc88a764
+  metadata.gz: 460e70448c0b37c65fd4e51f046036336b17121cc716c197fe80f2e2517f45e7
+  data.tar.gz: f06d11eab9bb88c45a018c8913d6a5d2e33162064c9f995e5772beb811e68ed6
 SHA512:
-  metadata.gz: d3bb75eb37c9ad70776fbf8d7fc5c1d7cc4a79bf7c68e2430dbf30f256fb0a3e1cddf718fa1799486814058d98455ef47b62baa514b1b49beafe0c7fc6a489dc
-  data.tar.gz: eea979521c2d65afef0325f94513ecf64bf604c562af41afae2ec258a4449b70a28aee927be925681ceecc434ba716271d7bbc6a713f8413b0f22710b7ed7c9c
+  metadata.gz: 83549b328ba3067ed206a8bdea448e34ba274c7c5a7857d38793d74f0691339f845b0e39fdbb0ff8c3869dfbaf0dcd13380c458c80397b100a848f96443bf691
+  data.tar.gz: 106314824f1805e7d2306c10c696d4503b54b4d9203321e37816242c30598c3870ec40ade53dc08692ec3b2a35f18360c96211f0b8af44fd4414931da4e5b1e5

data/.github/workflows/ci.yml

@@ -6,12 +6,8 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        ruby: [2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, head, jruby, jruby-head, truffleruby, truffleruby-head]
+        ruby: [2.5, 2.6, 2.7, 3.0, 3.1, 3.2, head, jruby, jruby-head, truffleruby, truffleruby-head]
         exclude:
-          - os: windows-latest
-            ruby: jruby
-          - os: windows-latest
-            ruby: jruby-head
           - os: windows-latest
             ruby: truffleruby
           - os: windows-latest

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [1.0.0] - 2023-05-26
+
+### Breaking Changes
+
+- Ruby 2.4 is no longer supported.
+- The default `regexp_resolver` is now `ruby`, which passes patterns directly to `Regexp`. The previous default, `ecma`, rewrites patterns to behave more like Javascript (ECMA-262) regular expressions:
+  - Beginning of string: `^` -> `\A`
+  - End of string: `$` -> `\z`
+  - Space: `\s` -> `[\t\r\n\f\v\uFEFF\u2029\p{Zs}]`
+  - Non-space: `\S` -> `[^\t\r\n\f\v\uFEFF\u2029\p{Zs}]`
+- Invalid ECMA-262 regular expressions raise `JSONSchemer::InvalidEcmaRegexp` when `regexp_resolver` is set to `ecma`.
+- Embedded subschemas (ie, subschemas referenced by `$id`) can only be found under "known" keywords (eg, `definitions`). Previously, the entire schema object was scanned for `$id`.
+- Empty fragments are now removed from `$ref` URIs before calling `ref_resolver`.
+- Refs that are fragment-only JSON pointers with special characters must use the proper encoding (eg, `"$ref": "#/definitions/some-%7Bid%7D"`).
+
+[1.0.0]: https://github.com/davishmcclurg/json_schemer/releases/tag/v1.0.0

data/Gemfile.lock

@@ -1,19 +1,15 @@
 PATH
   remote: .
   specs:
-    json_schemer (0.2.25)
-      ecma-re-validator (~> 0.3)
+    json_schemer (1.0.1)
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       simpleidn (~> 0.2)
-      uri_template (~> 0.7)
 
 GEM
   remote: https://rubygems.org/
   specs:
     docile (1.4.0)
-    ecma-re-validator (0.3.0)
-      regexp_parser (~> 2.0)
     hana (1.3.7)
     minitest (5.15.0)
     rake (13.0.6)
@@ -30,7 +26,6 @@ GEM
       unf_ext
     unf (0.1.4-java)
     unf_ext (0.0.8.2)
-    uri_template (0.7.0)
 
 PLATFORMS
   java

data/README.md

@@ -45,7 +45,12 @@ schemer.valid?({ 'abc' => 10 })
 # error validation (`validate` returns an enumerator)
 
 schemer.validate({ 'abc' => 10 }).to_a
-# => [{"data"=>10, "schema"=>{"type"=>"integer", "minimum"=>11}, "pointer"=>"#/abc", "type"=>"minimum"}]
+# => [{"data"=>10,
+#      "data_pointer"=>"/abc",
+#      "schema"=>{"type"=>"integer", "minimum"=>11},
+#      "schema_pointer"=>"/properties/abc",
+#      "root_schema"=>{"type"=>"object", "properties"=>{"abc"=>{"type"=>"integer", "minimum"=>11}}},
+#      "type"=>"minimum"}]
 
 # default property values
 
@@ -74,6 +79,30 @@ schemer = JSONSchemer.schema(schema)
 
 schema = '{ "type": "integer" }'
 schemer = JSONSchemer.schema(schema)
+
+# schema validation
+
+JSONSchemer.valid_schema?({ '$id' => '#valid' })
+# => true
+
+JSONSchemer.validate_schema({ '$id' => nil }).to_a
+# => [{"data"=>nil,
+#      "data_pointer"=>"/$id",
+#      "schema"=>{"type"=>"string", "format"=>"uri-reference"},
+#      "schema_pointer"=>"/properties/$id",
+#      "root_schema"=>{...meta schema},
+#      "type"=>"string"}]
+
+JSONSchemer.schema({ '$id' => '#valid' }).valid_schema?
+# => true
+
+JSONSchemer.schema({ '$id' => nil }).validate_schema.to_a
+# => [{"data"=>nil,
+#      "data_pointer"=>"/$id",
+#      "schema"=>{"type"=>"string", "format"=>"uri-reference"},
+#      "schema_pointer"=>"/properties/$id",
+#      "root_schema"=>{...meta schema},
+#      "type"=>"string"}]
 ```
 
 ## Options
@@ -113,8 +142,9 @@ JSONSchemer.schema(
   ref_resolver: 'net/http',
   
   # use different method to match regexes
-  # 'ecma'/'ruby'/proc/lambda/respond_to?(:call)
-  # default: 'ecma'
+  # 'ruby'/'ecma'/proc/lambda/respond_to?(:call)
+  # 'ruby': proc { |pattern| Regexp.new(pattern) }
+  # default: 'ruby'
   regexp_resolver: proc do |pattern|
     RE2::Regexp.new(pattern)
   end

data/json_schemer.gemspec

@@ -20,16 +20,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.4'
+  spec.required_ruby_version = '>= 2.5'
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "simplecov", "~> 0.22"
 
-  spec.add_runtime_dependency "ecma-re-validator", "~> 0.3"
   spec.add_runtime_dependency "hana", "~> 1.3"
   spec.add_runtime_dependency "regexp_parser", "~> 2.0"
   spec.add_runtime_dependency "simpleidn", "~> 0.2"
-  spec.add_runtime_dependency "uri_template", "~> 0.7"
 end

data/lib/json_schemer/ecma_regexp.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module JSONSchemer
+  class EcmaRegexp
+    class Syntax < Regexp::Syntax::Base
+      # regexp_parser >= 2.3.0 uses syntax classes directly instead of instances
+      # :nocov:
+      SYNTAX = respond_to?(:implements) ? self : new
+      # :nocov:
+      SYNTAX.implements :anchor, Anchor::Extended
+      SYNTAX.implements :assertion, Assertion::All
+      # literal %i[number] to support regexp_parser < 2.2.0 (Backreference::Plain)
+      SYNTAX.implements :backref, %i[number] + Backreference::Name
+      # :meta_sequence, :bell, and :escape are not supported in ecma
+      SYNTAX.implements :escape, Escape::Basic + (Escape::Control - %i[meta_sequence]) + (Escape::ASCII - %i[bell escape]) + Escape::Unicode + Escape::Meta + Escape::Hex + Escape::Octal
+      SYNTAX.implements :property, UnicodeProperty::All
+      SYNTAX.implements :nonproperty, UnicodeProperty::All
+      # :comment is not supported in ecma
+      SYNTAX.implements :free_space, (FreeSpace::All - %i[comment])
+      SYNTAX.implements :group, Group::Basic + Group::Named + Group::Passive
+      SYNTAX.implements :literal, Literal::All
+      SYNTAX.implements :meta, Meta::Extended
+      SYNTAX.implements :quantifier, Quantifier::Greedy + Quantifier::Reluctant + Quantifier::Interval + Quantifier::IntervalReluctant
+      SYNTAX.implements :set, CharacterSet::Basic
+      SYNTAX.implements :type, CharacterType::Extended
+    end
+
+    RUBY_EQUIVALENTS = {
+      :anchor => {
+        :bol => '\A',
+        :eol => '\z'
+      },
+      :type => {
+        :space => '[\t\r\n\f\v\uFEFF\u2029\p{Zs}]',
+        :nonspace => '[^\t\r\n\f\v\uFEFF\u2029\p{Zs}]'
+      }
+    }.freeze
+
+    class << self
+      def ruby_equivalent(pattern)
+        Regexp::Scanner.scan(pattern).map do |type, token, text|
+          Syntax::SYNTAX.check!(*Syntax::SYNTAX.normalize(type, token))
+          RUBY_EQUIVALENTS.dig(type, token) || text
+        rescue Regexp::Syntax::NotImplementedError
+          raise InvalidEcmaRegexp, "invalid token #{text.inspect} (#{type}:#{token}) in #{pattern.inspect}"
+        end.join
+      rescue Regexp::Scanner::ScannerError
+        raise InvalidEcmaRegexp, "invalid pattern #{pattern.inspect}"
+      end
+    end
+  end
+end

data/lib/json_schemer/format/uri_template.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Format
+    module URITemplate
+      # https://datatracker.ietf.org/doc/html/rfc6570
+      PCT_ENCODED = '%\h{2}'                                         # pct-encoded     =  "%" HEXDIG HEXDIG
+      EXPLODE = '\*'                                                 # explode         =  "*"
+      MAX_LENGTH = '[1-9]\d{0,3}'                                    # max-length      =  %x31-39 0*3DIGIT   ; positive integer < 10000
+      PREFIX = ":#{MAX_LENGTH}"                                      # prefix          =  ":" max-length
+      MODIFIER_LEVEL4 = "#{PREFIX}|#{EXPLODE}"                       # modifier-level4 =  prefix / explode
+      VARCHAR = "(\\w|#{PCT_ENCODED})"                               # varchar         =  ALPHA / DIGIT / "_" / pct-encoded
+      VARNAME = "#{VARCHAR}(\\.?#{VARCHAR})*"                        # varname         =  varchar *( ["."] varchar )
+      VARSPEC = "#{VARNAME}(#{MODIFIER_LEVEL4})?"                    # varspec         =  varname [ modifier-level4 ]
+      VARIABLE_LIST = "#{VARSPEC}(,#{VARSPEC})*"                     # variable-list   =  varspec *( "," varspec )
+      OPERATOR = '[+#./;?&=,!@|]'                                    # operator        =  op-level2 / op-level3 / op-reserve
+                                                                     # op-level2       =  "+" / "#"
+                                                                     # op-level3       =  "." / "/" / ";" / "?" / "&"
+                                                                     # op-reserve      =  "=" / "," / "!" / "@" / "|"
+      EXPRESSION = "{#{OPERATOR}?#{VARIABLE_LIST}}"                  # expression      =  "{" [ operator ] variable-list "}"
+      LITERALS = "[^\\x00-\\x20\\x7F\"%'<>\\\\^`{|}]|#{PCT_ENCODED}" # literals        =  %x21 / %x23-24 / %x26 / %x28-3B / %x3D / %x3F-5B
+                                                                     #                 /  %x5D / %x5F / %x61-7A / %x7E / ucschar / iprivate
+                                                                     #                 /  pct-encoded
+                                                                     #                      ; any Unicode character except: CTL, SP,
+                                                                     #                      ;  DQUOTE, "'", "%" (aside from pct-encoded),
+                                                                     #                      ;  "<", ">", "\", "^", "`", "{", "|", "}"
+      URI_TEMPLATE = "(#{LITERALS}|#{EXPRESSION})*"                  # URI-Template    = *( literals / expression )
+      URI_TEMPLATE_REGEX = /\A#{URI_TEMPLATE}\z/
+
+      def valid_uri_template?(data)
+        URI_TEMPLATE_REGEX.match?(data)
+      end
+    end
+  end
+end

data/lib/json_schemer/format.rb

@@ -2,6 +2,7 @@
 module JSONSchemer
   module Format
     include Hostname
+    include URITemplate
 
     # this is no good
     EMAIL_REGEX = /\A[^@\s]+@([\p{L}\d-]+\.)+[\p{L}\d\-]{2,}\z/i.freeze
@@ -49,7 +50,7 @@ module JSONSchemer
       when 'relative-json-pointer'
         valid_relative_json_pointer?(data)
       when 'regex'
-        EcmaReValidator.valid?(data)
+        valid_regex?(data)
       else
         raise UnknownFormat, format
       end
@@ -115,13 +116,6 @@ module JSONSchemer
       end.force_encoding(Encoding::US_ASCII)
     end
 
-    def valid_uri_template?(data)
-      URITemplate.new(data)
-      true
-    rescue URITemplate::Invalid
-      false
-    end
-
     def valid_json_pointer?(data)
       JSON_POINTER_REGEX.match?(data)
     end
@@ -129,5 +123,11 @@ module JSONSchemer
     def valid_relative_json_pointer?(data)
       RELATIVE_JSON_POINTER_REGEX.match?(data)
     end
+
+    def valid_regex?(data)
+      !!EcmaRegexp.ruby_equivalent(data)
+    rescue InvalidEcmaRegexp
+      false
+    end
   end
 end

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
@@ -45,10 +32,25 @@ module JSONSchemer
       end
 
       JSON_POINTER_TOKEN_ESCAPE_CHARS = { '~' => '~0', '/' => '~1' }
-      JSON_POINTER_TOKEN_ESCAPE_REGEXP = Regexp.union(JSON_POINTER_TOKEN_ESCAPE_CHARS.keys)
+      JSON_POINTER_TOKEN_ESCAPE_REGEX = 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
@@ -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,10 +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,
@@ -302,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)
@@ -622,12 +624,12 @@ module JSONSchemer
       end
 
       def escape_json_pointer_token(token)
-        token.gsub(JSON_POINTER_TOKEN_ESCAPE_REGEXP, JSON_POINTER_TOKEN_ESCAPE_CHARS)
+        token.gsub(JSON_POINTER_TOKEN_ESCAPE_REGEX, JSON_POINTER_TOKEN_ESCAPE_CHARS)
       end
 
       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": {}
+}

data/lib/json_schemer/schema/draft7.json

@@ -0,0 +1,172 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/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"
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        },
+        "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": true
+        },
+        "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": true,
+        "enum": {
+            "type": "array",
+            "items": true,
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "if": { "$ref": "#" },
+        "then": { "$ref": "#" },
+        "else": { "$ref": "#" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": true
+}

data/lib/json_schemer/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module JSONSchemer
-  VERSION = '0.2.25'
+  VERSION = '1.0.1'
 end

data/lib/json_schemer.rb

@@ -9,17 +9,17 @@ require 'set'
 require 'time'
 require 'uri'
 
-require 'ecma-re-validator'
 require 'hana'
 require 'regexp_parser'
 require 'simpleidn'
-require 'uri_template'
 
 require 'json_schemer/version'
 require 'json_schemer/format/hostname'
+require 'json_schemer/format/uri_template'
 require 'json_schemer/format'
 require 'json_schemer/errors'
 require 'json_schemer/cached_resolver'
+require 'json_schemer/ecma_regexp'
 require 'json_schemer/schema/base'
 require 'json_schemer/schema/draft4'
 require 'json_schemer/schema/draft6'
@@ -33,7 +33,9 @@ module JSONSchemer
   class InvalidRegexpResolution < StandardError; end
   class InvalidFileURI < StandardError; end
   class InvalidSymbolKey < StandardError; end
+  class InvalidEcmaRegexp < StandardError; end
 
+  DEFAULT_SCHEMA_CLASS = Schema::Draft7
   SCHEMA_CLASS_BY_META_SCHEMA = {
     'http://json-schema.org/schema#' => Schema::Draft4, # Version-less $schema deprecated after Draft 4
     'http://json-schema.org/draft-04/schema#' => Schema::Draft4,
@@ -52,33 +54,38 @@ module JSONSchemer
   end
 
   class << self
-    def schema(schema, default_schema_class: Schema::Draft7, **options)
+    def schema(schema, default_schema_class: DEFAULT_SCHEMA_CLASS, **options)
       case schema
       when String
         schema = JSON.parse(schema)
       when Pathname
-        uri = URI.parse(File.join('file:', URI::DEFAULT_PARSER.escape(schema.realpath.to_s)))
-        if options.key?(:ref_resolver)
-          schema = FILE_URI_REF_RESOLVER.call(uri)
+        base_uri = URI.parse(File.join('file:', URI::DEFAULT_PARSER.escape(schema.realpath.to_s)))
+        options[:base_uri] = base_uri
+        schema = if options.key?(:ref_resolver)
+          FILE_URI_REF_RESOLVER.call(base_uri)
         else
           ref_resolver = CachedResolver.new(&FILE_URI_REF_RESOLVER)
-          schema = ref_resolver.call(uri)
           options[:ref_resolver] = ref_resolver
+          ref_resolver.call(base_uri)
         end
-        schema[draft_class(schema, default_schema_class)::ID_KEYWORD] ||= uri.to_s
       end
-      draft_class(schema, default_schema_class).new(schema, **options)
-    end
-
-  private
 
-    def draft_class(schema, default_schema_class)
-      if schema.is_a?(Hash) && schema.key?('$schema')
+      schema_class = if schema.is_a?(Hash) && schema.key?('$schema')
         meta_schema = schema.fetch('$schema')
         SCHEMA_CLASS_BY_META_SCHEMA[meta_schema] || raise(UnsupportedMetaSchema, meta_schema)
       else
         default_schema_class
       end
+
+      schema_class.new(schema, **options)
+    end
+
+    def valid_schema?(schema, default_schema_class: DEFAULT_SCHEMA_CLASS)
+      schema(schema, default_schema_class: default_schema_class).valid_schema?
+    end
+
+    def validate_schema(schema, default_schema_class: DEFAULT_SCHEMA_CLASS)
+      schema(schema, default_schema_class: default_schema_class).validate_schema
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schemer
 version: !ruby/object:Gem::Version
-  version: 0.2.25
+  version: 1.0.1
 platform: ruby
 authors:
 - David Harsha
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-26 00:00:00.000000000 Z
+date: 2023-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.22'
-- !ruby/object:Gem::Dependency
-  name: ecma-re-validator
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: hana
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +108,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: uri_template
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.7'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.7'
 description:
 email:
 - davishmcclurg@gmail.com
@@ -146,6 +118,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -159,12 +132,17 @@ files:
 - json_schemer.gemspec
 - lib/json_schemer.rb
 - lib/json_schemer/cached_resolver.rb
+- lib/json_schemer/ecma_regexp.rb
 - lib/json_schemer/errors.rb
 - lib/json_schemer/format.rb
 - lib/json_schemer/format/hostname.rb
+- lib/json_schemer/format/uri_template.rb
 - lib/json_schemer/schema/base.rb
+- lib/json_schemer/schema/draft4.json
 - lib/json_schemer/schema/draft4.rb
+- lib/json_schemer/schema/draft6.json
 - lib/json_schemer/schema/draft6.rb
+- lib/json_schemer/schema/draft7.json
 - lib/json_schemer/schema/draft7.rb
 - lib/json_schemer/version.rb
 homepage: https://github.com/davishmcclurg/json_schemer
@@ -179,7 +157,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="