add JSON::Schema::Pointer class to abstract handling of JSON pointer, dealing with pointers in fragments or in plain pointer syntax. use this in #schema_from_fragment.

Author: notEthan

lib/json-schema/pointer.rb

@@ -0,0 +1,96 @@
+require 'addressable/uri'
+
+module JSON
+  class Schema
+    class Pointer
+      class Error < JSON::Schema::SchemaError
+      end
+      class PointerSyntaxError < Error
+      end
+      class ReferenceError < Error
+      end
+
+      def self.parse_fragment(fragment)
+        fragment = Addressable::URI.unescape(fragment)
+        match = fragment.match(/\A#/)
+        if match
+          parse_pointer(match.post_match)
+        else
+          raise(PointerSyntaxError, "Invalid fragment syntax in #{fragment.inspect}: fragment must begin with #")
+        end
+      end
+
+      def self.parse_pointer(pointer_string)
+        tokens = pointer_string.split('/', -1).map! do |piece|
+          piece.gsub('~1', '/').gsub('~0', '~')
+        end
+        if tokens[0] == ''
+          tokens[1..-1]
+        else
+          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
+        end
+      end
+
+      def initialize(type, representation)
+        @type = type
+        if type == :reference_tokens
+          reference_tokens = representation
+        elsif type == :fragment
+          reference_tokens = self.class.parse_fragment(representation)
+        elsif type == :pointer
+          reference_tokens = self.class.parse_pointer(representation)
+        else
+          raise ArgumentError, "invalid initialization type: #{type.inspect} with representation #{representation.inspect}"
+        end
+        @reference_tokens = reference_tokens.map(&:freeze).freeze
+      end
+
+      attr_reader :reference_tokens
+
+      def evaluate(document)
+        reference_tokens.each.inject(document) do |value, token|
+          if value.is_a?(Array)
+            if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
+              token = token.to_i
+            end
+            unless token.is_a?(Integer)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
+            end
+            unless (0...value.size).include?(token)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
+            end
+          elsif value.is_a?(Hash)
+            unless value.key?(token)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
+            end
+          else
+            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
+          end
+          value[token]
+        end
+      end
+
+      def to_s
+        "#<#{self.class.name} #{@type} = #{representation_s}>"
+      end
+
+      def representation_s
+        if @type == :fragment
+          fragment
+        elsif @type == :pointer
+          pointer
+        else
+          reference_tokens.inspect
+        end
+      end
+
+      def pointer
+        reference_tokens.map { |t| '/' + t.gsub('~', '~0').gsub('/', '~1') }.join('')
+      end
+
+      def fragment
+        '#' + Addressable::URI.escape(pointer)
+      end
+    end
+  end
+end

lib/json-schema/validator.rb

@@ -12,6 +12,7 @@
 require 'json-schema/errors/json_load_error'
 require 'json-schema/errors/json_parse_error'
 require 'json-schema/util/uri'
+require 'json-schema/pointer'
 
 module JSON
 
@@ -73,36 +74,10 @@ def initialize(schema_data, data, opts={})
 
     def schema_from_fragment(base_schema, fragment)
       schema_uri = base_schema.uri
-      fragments = fragment.split("/")
 
-      # ensure the first element was a hash, per the fragment spec
-      if fragments.shift != "#"
-        raise JSON::Schema::SchemaError.new("Invalid fragment syntax in :fragment option")
-      end
+      pointer = JSON::Schema::Pointer.new(:fragment, fragment)
 
-      fragments.each do |f|
-        if base_schema.is_a?(JSON::Schema) #test if fragment is a JSON:Schema instance
-          if !base_schema.schema.has_key?(f)
-            raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
-          end
-          base_schema = base_schema.schema[f]
-        elsif base_schema.is_a?(Hash)
-          if !base_schema.has_key?(f)
-            raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
-          end
-          base_schema = base_schema[f]
-        elsif base_schema.is_a?(Array)
-          if base_schema[f.to_i].nil?
-            raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
-          end
-          base_schema = base_schema[f.to_i]
-        else
-          raise JSON::Schema::SchemaError.new("Invalid schema encountered when resolving :fragment option")
-        end
-      end
-      unless base_schema.is_a?(JSON::Schema)
-        base_schema = JSON::Schema.new(base_schema,schema_uri,@options[:version])
-      end
+      base_schema = JSON::Schema.new(pointer.evaluate(base_schema.schema), schema_uri, @options[:version])
 
       if @options[:list]
         base_schema.to_array_schema