jsi 0.4.0 → 0.7.0

data/lib/jsi/json/pointer.rb

@@ -1,419 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module JSON
-    # a JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
-    class Pointer
-      class Error < StandardError
-      end
-      class PointerSyntaxError < Error
-      end
-      class ReferenceError < Error
-      end
-
-      # instantiates a Pointer from any given reference tokens.
-      #
-      #     >> JSI::JSON::Pointer[]
-      #     => #<JSI::JSON::Pointer reference_tokens: []>
-      #     >> JSI::JSON::Pointer['a', 'b']
-      #     => #<JSI::JSON::Pointer reference_tokens: ["a", "b"]>
-      #     >> JSI::JSON::Pointer['a']['b']
-      #     => #<JSI::JSON::Pointer reference_tokens: ["a", "b"]>
-      #
-      # note in the last example that you can conveniently chain the class .[] method
-      # with the instance #[] method.
-      #
-      # @param *reference_tokens any number of reference tokens
-      # @return [JSI::JSON::Pointer]
-      def self.[](*reference_tokens)
-        new(reference_tokens)
-      end
-
-      # parse a URI-escaped fragment and instantiate as a JSI::JSON::Pointer
-      #
-      #     ptr = JSI::JSON::Pointer.from_fragment('/foo/bar')
-      #     => #<JSI::JSON::Pointer fragment: /foo/bar>
-      #     ptr.reference_tokens
-      #     => ["foo", "bar"]
-      #
-      # with URI escaping:
-      #
-      #     ptr = JSI::JSON::Pointer.from_fragment('/foo%20bar')
-      #     => #<JSI::JSON::Pointer fragment: /foo%20bar>
-      #     ptr.reference_tokens
-      #     => ["foo bar"]
-      #
-      # @param fragment [String] a fragment containing a pointer (starting with #)
-      # @return [JSI::JSON::Pointer]
-      # @raise [JSI::JSON::Pointer::PointerSyntaxError] when the fragment does not contain a pointer with valid pointer syntax
-      def self.from_fragment(fragment)
-        from_pointer(Addressable::URI.unescape(fragment), type: 'fragment')
-      end
-
-      # parse a pointer string and instantiate as a JSI::JSON::Pointer
-      #
-      #     ptr1 = JSI::JSON::Pointer.from_pointer('/foo')
-      #     => #<JSI::JSON::Pointer pointer: /foo>
-      #     ptr1.reference_tokens
-      #     => ["foo"]
-      #
-      #     ptr2 = JSI::JSON::Pointer.from_pointer('/foo~0bar/baz~1qux')
-      #     => #<JSI::JSON::Pointer pointer: /foo~0bar/baz~1qux>
-      #     ptr2.reference_tokens
-      #     => ["foo~bar", "baz/qux"]
-      #
-      # @param pointer_string [String] a pointer string
-      # @param type (for internal use) indicates the original representation of the pointer
-      # @return [JSI::JSON::Pointer]
-      # @raise [JSI::JSON::Pointer::PointerSyntaxError] when the pointer_string does not have valid pointer syntax
-      def self.from_pointer(pointer_string, type: 'pointer')
-        tokens = pointer_string.split('/', -1).map! do |piece|
-          piece.gsub('~1', '/').gsub('~0', '~')
-        end
-        if tokens[0] == ''
-          new(tokens[1..-1], type: type)
-        elsif tokens.empty?
-          new(tokens, type: type)
-        else
-          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
-        end
-      end
-
-      # initializes a JSI::JSON::Pointer from the given reference_tokens.
-      #
-      # @param reference_tokens [Array<Object>]
-      # @param type [String, Symbol] one of 'pointer' or 'fragment'
-      def initialize(reference_tokens, type: nil)
-        unless reference_tokens.respond_to?(:to_ary)
-          raise(TypeError, "reference_tokens must be an array. got: #{reference_tokens.inspect}")
-        end
-        @reference_tokens = reference_tokens.to_ary.map(&:freeze).freeze
-        @type = type.is_a?(Symbol) ? type.to_s : type
-      end
-
-      attr_reader :reference_tokens
-
-      # takes a root json document and evaluates this pointer through the document, returning the value
-      # pointed to by this pointer.
-      #
-      # @param document [#to_ary, #to_hash] the document against which we will evaluate this pointer
-      # @return [Object] the content of the document pointed to by this pointer
-      # @raise [JSI::JSON::Pointer::ReferenceError] the document does not contain the path this pointer references
-      def evaluate(document)
-        res = reference_tokens.inject(document) do |value, token|
-          if value.respond_to?(:to_ary)
-            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.respond_to?(:size) ? value : value.to_ary).size).include?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
-            end
-            (value.respond_to?(:[]) ? value : value.to_ary)[token]
-          elsif value.respond_to?(:to_hash)
-            unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
-            end
-            (value.respond_to?(:[]) ? value : value.to_hash)[token]
-          else
-            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
-          end
-        end
-        res
-      end
-
-      # @return [String] the pointer string representation of this Pointer
-      def pointer
-        reference_tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
-      end
-
-      # @return [String] the fragment string representation of this Pointer
-      def fragment
-        Addressable::URI.escape(pointer)
-      end
-
-      # @return [Addressable::URI] a URI consisting only of a pointer fragment
-      def uri
-        Addressable::URI.new(fragment: fragment)
-      end
-
-      # @return [Boolean] whether this pointer points to the root (has an empty array of reference_tokens)
-      def root?
-        reference_tokens.empty?
-      end
-
-      # @return [JSI::JSON::Pointer] pointer to the parent of where this pointer points
-      # @raise [JSI::JSON::Pointer::ReferenceError] if this pointer has no parent (points to the root)
-      def parent
-        if root?
-          raise(ReferenceError, "cannot access parent of root pointer: #{pretty_inspect.chomp}")
-        else
-          Pointer.new(reference_tokens[0...-1], type: @type)
-        end
-      end
-
-      # @return [Boolean] does this pointer contain the other_ptr - that is, is this pointer an
-      #   ancestor of other_ptr, a child pointer. contains? is inclusive; a pointer does contain itself.
-      def contains?(other_ptr)
-        self.reference_tokens == other_ptr.reference_tokens[0...self.reference_tokens.size]
-      end
-
-      # @return [JSI::JSON::Pointer] returns this pointer relative to the given ancestor_ptr
-      # @raise [JSI::JSON::Pointer::ReferenceError] if the given ancestor_ptr is not an ancestor of this pointer
-      def ptr_relative_to(ancestor_ptr)
-        unless ancestor_ptr.contains?(self)
-          raise(ReferenceError, "ancestor_ptr #{ancestor_ptr.inspect} is not ancestor of #{inspect}")
-        end
-        Pointer.new(reference_tokens[ancestor_ptr.reference_tokens.size..-1], type: @type)
-      end
-
-      # @param ptr [JSI::JSON::Pointer]
-      # @return [JSI::JSON::Pointer] a pointer with the reference tokens of this one plus the given ptr's.
-      def +(ptr)
-        unless ptr.is_a?(JSI::JSON::Pointer)
-          raise(TypeError, "ptr must be a JSI::JSON::Pointer; got: #{ptr.inspect}")
-        end
-        Pointer.new(reference_tokens + ptr.reference_tokens, type: @type)
-      end
-
-      # @param n [Integer]
-      # @return [JSI::JSON::Pointer] a Pointer consisting of the first n of our reference_tokens
-      # @raise [ArgumentError] if n is not between 0 and the size of our reference_tokens
-      def take(n)
-        unless (0..reference_tokens.size).include?(n)
-          raise(ArgumentError, "n not in range (0..#{reference_tokens.size}): #{n.inspect}")
-        end
-        Pointer.new(reference_tokens.take(n), type: @type)
-      end
-
-      # appends the given token to this Pointer's reference tokens and returns the result
-      #
-      # @param token [Object]
-      # @return [JSI::JSON::Pointer] pointer to a child node of this pointer with the given token
-      def [](token)
-        Pointer.new(reference_tokens + [token], type: @type)
-      end
-
-      # given this Pointer points to a schema in the given document, returns a set of pointers
-      # to subschemas of that schema for the given property name.
-      #
-      # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
-      # @param property_name [Object] the property name for which to find a subschema
-      # @return [Set<JSI::JSON::Pointer>] pointers to subschemas
-      def schema_subschema_ptrs_for_property_name(document, property_name)
-        ptr = self
-        schema = ptr.evaluate(document)
-        Set.new.tap do |ptrs|
-          if schema.respond_to?(:to_hash)
-            apply_additional = true
-            if schema.key?('properties') && schema['properties'].respond_to?(:to_hash) && schema['properties'].key?(property_name)
-              apply_additional = false
-              ptrs << ptr['properties'][property_name]
-            end
-            if schema['patternProperties'].respond_to?(:to_hash)
-              schema['patternProperties'].each_key do |pattern|
-                if property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
-                  apply_additional = false
-                  ptrs << ptr['patternProperties'][pattern]
-                end
-              end
-            end
-            if apply_additional && schema.key?('additionalProperties')
-              ptrs << ptr['additionalProperties']
-            end
-          end
-        end
-      end
-
-      # given this Pointer points to a schema in the given document, returns a set of pointers
-      # to subschemas of that schema for the given array index.
-      #
-      # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
-      # @param idx [Object] the array index for which to find subschemas
-      # @return [Set<JSI::JSON::Pointer>] pointers to subschemas
-      def schema_subschema_ptrs_for_index(document, idx)
-        ptr = self
-        schema = ptr.evaluate(document)
-        Set.new.tap do |ptrs|
-          if schema.respond_to?(:to_hash)
-            if schema['items'].respond_to?(:to_ary)
-              if schema['items'].each_index.to_a.include?(idx)
-                ptrs << ptr['items'][idx]
-              elsif schema.key?('additionalItems')
-                ptrs << ptr['additionalItems']
-              end
-            elsif schema.key?('items')
-              ptrs << ptr['items']
-            end
-          end
-        end
-      end
-
-      # given this Pointer points to a schema in the given document, this matches any
-      # applicators of the schema (oneOf, anyOf, allOf, $ref) which should be applied
-      # and returns them as a set of pointers.
-      #
-      # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
-      # @param instance [Object] the instance to check any applicators against
-      # @return [JSI::JSON::Pointer] either a pointer to a *Of subschema in the document,
-      #   or self if no other subschema was matched
-      def schema_match_ptrs_to_instance(document, instance)
-        ptr = self
-        schema = ptr.evaluate(document)
-
-        Set.new.tap do |ptrs|
-          if schema.respond_to?(:to_hash)
-            if schema['$ref'].respond_to?(:to_str)
-              ptr.deref(document) do |deref_ptr|
-                ptrs.merge(deref_ptr.schema_match_ptrs_to_instance(document, instance))
-              end
-            else
-              ptrs << ptr
-            end
-            if schema['allOf'].respond_to?(:to_ary)
-              schema['allOf'].each_index do |i|
-                ptrs.merge(ptr['allOf'][i].schema_match_ptrs_to_instance(document, instance))
-              end
-            end
-            if schema['anyOf'].respond_to?(:to_ary)
-              schema['anyOf'].each_index do |i|
-                valid = ::JSON::Validator.validate(JSI::Typelike.as_json(document), JSI::Typelike.as_json(instance), fragment: ptr['anyOf'][i].fragment)
-                if valid
-                  ptrs.merge(ptr['anyOf'][i].schema_match_ptrs_to_instance(document, instance))
-                end
-              end
-            end
-            if schema['oneOf'].respond_to?(:to_ary)
-              one_i = schema['oneOf'].each_index.detect do |i|
-                ::JSON::Validator.validate(JSI::Typelike.as_json(document), JSI::Typelike.as_json(instance), fragment: ptr['oneOf'][i].fragment)
-              end
-              if one_i
-                ptrs.merge(ptr['oneOf'][one_i].schema_match_ptrs_to_instance(document, instance))
-              end
-            end
-            # TODO dependencies
-          else
-            ptrs << ptr
-          end
-        end
-      end
-
-      # takes a document and a block. the block is yielded the content of the given document at this
-      # pointer's location. the block must result a modified copy of that content (and MUST NOT modify
-      # the object it is given). this modified copy of that content is incorporated into a modified copy
-      # of the given document, which is then returned. the structure and contents of the document outside
-      # the path pointed to by this pointer is not modified.
-      #
-      # @param document [Object] the document to apply this pointer to
-      # @yield [Object] the content this pointer applies to in the given document
-      #   the block must result in the new content which will be placed in the modified document copy.
-      # @return [Object] a copy of the given document, with the content this pointer applies to
-      #   replaced by the result of the block
-      def modified_document_copy(document, &block)
-        # we need to preserve the rest of the document, but modify the content at our path.
-        #
-        # this is actually a bit tricky. we can't modify the original document, obviously.
-        # we could do a deep copy, but that's expensive. instead, we make a copy of each array
-        # or hash in the path above this node. this node's content is modified by the caller, and
-        # that is recursively merged up to the document root. the recursion is done with a
-        # y combinator, for no other reason than that was a fun way to implement it.
-        modified_document = JSI::Util.ycomb do |rec|
-          proc do |subdocument, subpath|
-            if subpath == []
-              Typelike.modified_copy(subdocument, &block)
-            else
-              car = subpath[0]
-              cdr = subpath[1..-1]
-              if subdocument.respond_to?(:to_hash)
-                subdocument_car = (subdocument.respond_to?(:[]) ? subdocument : subdocument.to_hash)[car]
-                car_object = rec.call(subdocument_car, cdr)
-                if car_object.object_id == subdocument_car.object_id
-                  subdocument
-                else
-                  (subdocument.respond_to?(:merge) ? subdocument : subdocument.to_hash).merge({car => car_object})
-                end
-              elsif subdocument.respond_to?(:to_ary)
-                if car.is_a?(String) && car =~ /\A\d+\z/
-                  car = car.to_i
-                end
-                unless car.is_a?(Integer)
-                  raise(TypeError, "bad subscript #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for array: #{subdocument.pretty_inspect.chomp}")
-                end
-                subdocument_car = (subdocument.respond_to?(:[]) ? subdocument : subdocument.to_ary)[car]
-                car_object = rec.call(subdocument_car, cdr)
-                if car_object.object_id == subdocument_car.object_id
-                  subdocument
-                else
-                  (subdocument.respond_to?(:[]=) ? subdocument : subdocument.to_ary).dup.tap do |arr|
-                    arr[car] = car_object
-                  end
-                end
-              else
-                raise(TypeError, "bad subscript: #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for content: #{subdocument.pretty_inspect.chomp}")
-              end
-            end
-          end
-        end.call(document, reference_tokens)
-        modified_document
-      end
-
-      # if this Pointer points at a $ref node within the given document, #deref attempts
-      # to follow that $ref and return a Pointer to the referenced location. otherwise,
-      # this Pointer is returned.
-      #
-      # if the content this Pointer points to in the document is not hash-like, does not
-      # have a $ref property, its $ref cannot be found, or its $ref points outside the document,
-      # this pointer is returned.
-      #
-      # @param document [Object] the document this pointer applies to
-      # @yield [Pointer] if a block is given (optional), this will yield a deref'd pointer. if this
-      #   pointer does not point to a $ref object in the given document, the block is not called.
-      #   if we point to a $ref which cannot be followed (e.g. a $ref to an external
-      #   document, which is not yet supported), the block is not called.
-      # @return [Pointer] dereferenced pointer, or this pointer
-      def deref(document, &block)
-        block ||= Util::NOOP
-        content = evaluate(document)
-
-        if content.respond_to?(:to_hash)
-          ref = (content.respond_to?(:[]) ? content : content.to_hash)['$ref']
-        end
-        return self unless ref.is_a?(String)
-
-        if ref[/\A#/]
-          return Pointer.from_fragment(Addressable::URI.parse(ref).fragment).tap(&block)
-        end
-
-        # HAX for how google does refs and ids
-        if document['schemas'].respond_to?(:to_hash)
-          if document['schemas'][ref]
-            return Pointer.new(['schemas', ref], type: 'hax').tap(&block)
-          end
-          document['schemas'].each do |k, schema|
-            if schema['id'] == ref
-              return Pointer.new(['schemas', k], type: 'hax').tap(&block)
-            end
-          end
-        end
-
-        #raise(NotImplementedError, "cannot dereference #{ref}") # TODO
-        return self
-      end
-
-      # @return [String] string representation of this Pointer
-      def inspect
-        "#{self.class.name}[#{reference_tokens.map(&:inspect).join(", ")}]"
-      end
-
-      alias_method :to_s, :inspect
-
-      # pointers are equal if the reference_tokens are equal, regardless of @type
-      def jsi_fingerprint
-        {class: JSI::JSON::Pointer, reference_tokens: reference_tokens}
-      end
-      include Util::FingerprintHash
-    end
-  end
-end

data/lib/jsi/json-schema-fragments.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "json-schema"
-
-# apply the changes from https://github.com/ruby-json-schema/json-schema/pull/382 
-
-# json-schema/validator.rb
-
-module JSON
-  class Validator
-    def initialize(schema_data, data, opts={})
-      @options = @@default_opts.clone.merge(opts)
-      @errors = []
-
-      validator = self.class.validator_for_name(@options[:version])
-      @options[:version] = validator
-      @options[:schema_reader] ||= self.class.schema_reader
-
-      @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
-      @validation_options[:insert_defaults] = true if @options[:insert_defaults]
-      @validation_options[:strict] = true if @options[:strict] == true
-      @validation_options[:clear_cache] = true if !@@cache_schemas || @options[:clear_cache]
-
-      @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
-      @original_data = data
-      @data = initialize_data(data)
-      @@mutex.synchronize { build_schemas(@base_schema) }
-
-      # If the :fragment option is set, try and validate against the fragment
-      if opts[:fragment]
-        @base_schema = schema_from_fragment(@base_schema, opts[:fragment])
-      end
-
-      # validate the schema, if requested
-      if @options[:validate_schema]
-        if @base_schema.schema["$schema"]
-          base_validator = self.class.validator_for_name(@base_schema.schema["$schema"])
-        end
-        metaschema = base_validator ? base_validator.metaschema : validator.metaschema
-        # Don't clear the cache during metaschema validation!
-        self.class.validate!(metaschema, @base_schema.schema, {:clear_cache => false})
-      end
-    end
-
-    def schema_from_fragment(base_schema, fragment)
-      schema_uri = base_schema.uri
-
-      pointer = JSI::JSON::Pointer.from_fragment(fragment)
-
-      base_schema = JSON::Schema.new(pointer.evaluate(base_schema.schema), schema_uri, @options[:version])
-
-      if @options[:list]
-        base_schema.to_array_schema
-      elsif base_schema.is_a?(Hash)
-        JSON::Schema.new(base_schema, schema_uri, @options[:version])
-      else
-        base_schema
-      end
-    end
-  end
-end

data/lib/jsi/json.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module JSON
-    autoload :Node, 'jsi/json/node'
-    autoload :ArrayNode, 'jsi/json/node'
-    autoload :HashNode, 'jsi/json/node'
-    autoload :Pointer, 'jsi/json/pointer'
-  end
-end

data/lib/jsi/pathed_node.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  # including class MUST define
-  # - #node_document [Object] returning the document
-  # - #node_ptr [JSI::JSON::Pointer] returning a pointer for the node path in the document
-  # - #document_root_node [JSI::PathedNode] returning a PathedNode pointing at the document root
-  # - #parent_node [JSI::PathedNode] returning the parent node of this PathedNode
-  # - #deref [JSI::PathedNode] following a $ref
-  #
-  # given these, this module represents the node in the document at the path.
-  #
-  # the node content (#node_content) is the result of evaluating the node document at the path.
-  module PathedNode
-    # @return [Object] the content of this node
-    def node_content
-      content = node_ptr.evaluate(node_document)
-      content
-    end
-
-    # @yield [JSI::JSON::Pointer] if a block is given (optional), this will yield a deref'd pointer
-    # @return [JSI::JSON::Pointer] our node_ptr, derefed against our node_document
-    def node_ptr_deref(&block)
-      node_ptr.deref(node_document, &block)
-    end
-  end
-
-  # module extending a {JSI::PathedNode} object when its node_content is Hash-like (responds to #to_hash)
-  module PathedHashNode
-    # yields each hash key and value of this node.
-    #
-    # each yielded key is the same as a key of the node content hash,
-    # and each yielded value is the result of self[key] (see #[]).
-    #
-    # returns an Enumerator if no block is given.
-    #
-    # @yield [Object, Object] each key and value of this hash node
-    # @return [self, Enumerator]
-    def each(&block)
-      return to_enum(__method__) { node_content_hash_pubsend(:size) } unless block_given?
-      if block.arity > 1
-        node_content_hash_pubsend(:each_key) { |k| yield k, self[k] }
-      else
-        node_content_hash_pubsend(:each_key) { |k| yield [k, self[k]] }
-      end
-      self
-    end
-
-    # @return [Hash] a hash in which each key is a key of the node_content hash and
-    #   each value is the result of self[key] (see #[]).
-    def to_hash
-      {}.tap { |h| each_key { |k| h[k] = self[k] } }
-    end
-
-    include Hashlike
-
-    # @param method_name [String, Symbol]
-    # @param *a, &b are passed to the invocation of method_name
-    # @return [Object] the result of calling method method_name on the node_content or its #to_hash
-    def node_content_hash_pubsend(method_name, *a, &b)
-      if node_content.respond_to?(method_name)
-        node_content.public_send(method_name, *a, &b)
-      else
-        node_content.to_hash.public_send(method_name, *a, &b)
-      end
-    end
-
-    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
-    SAFE_KEY_ONLY_METHODS.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        node_content_hash_pubsend(method_name, *a, &b)
-      end
-    end
-  end
-
-  module PathedArrayNode
-    # yields each array element of this node.
-    #
-    # each yielded element is the result of self[index] for each index of our array (see #[]).
-    #
-    # returns an Enumerator if no block is given.
-    #
-    # @yield [Object] each element of this array node
-    # @return [self, Enumerator]
-    def each
-      return to_enum(__method__) { node_content_ary_pubsend(:size) } unless block_given?
-      node_content_ary_pubsend(:each_index) { |i| yield(self[i]) }
-      self
-    end
-
-    # @return [Array] an array, the same size as the node_content, in which the
-    #   element at each index is the result of self[index] (see #[])
-    def to_ary
-      to_a
-    end
-
-    include Arraylike
-
-    # @param method_name [String, Symbol]
-    # @param *a, &b are passed to the invocation of method_name
-    # @return [Object] the result of calling method method_name on the node_content or its #to_ary
-    def node_content_ary_pubsend(method_name, *a, &b)
-      if node_content.respond_to?(method_name)
-        node_content.public_send(method_name, *a, &b)
-      else
-        node_content.to_ary.public_send(method_name, *a, &b)
-      end
-    end
-
-    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a).
-    # we override these methods from Arraylike
-    SAFE_INDEX_ONLY_METHODS.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        node_content_ary_pubsend(method_name, *a, &b)
-      end
-    end
-  end
-end