jsi 0.6.0 → 0.8.0

data/lib/jsi/pathed_node.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  # this module represents a node in a document.
-  #
-  # including class MUST define
-  #
-  # - `#jsi_document` [Object] the document
-  # - `#jsi_ptr` [JSI::Ptr] a pointer to the node in the document
-  module PathedNode
-    # the content of this node
-    def jsi_node_content
-      content = jsi_ptr.evaluate(jsi_document)
-      content
-    end
-  end
-
-  # module extending a {JSI::PathedNode} object when its jsi_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.
-    #
-    # @param a arguments are passed to `#[]`
-    # @yield [Object, Object] each key and value of this hash node
-    # @return [self, Enumerator] an Enumerator if invoked without a block; otherwise self
-    def each(*a, &block)
-      return to_enum(__method__) { jsi_node_content_hash_pubsend(:size) } unless block
-      if block.arity > 1
-        jsi_node_content_hash_pubsend(:each_key) { |k| yield k, self[k, *a] }
-      else
-        jsi_node_content_hash_pubsend(:each_key) { |k| yield [k, self[k, *a]] }
-      end
-      self
-    end
-
-    # a hash in which each key is a key of the jsi_node_content hash and each value is the
-    # result of `self[key]`
-    # @param a arguments are passed to `#[]`
-    # @return [Hash]
-    def to_hash(*a)
-      {}.tap { |h| jsi_node_content_hash_pubsend(:each_key) { |k| h[k] = self[k, *a] } }
-    end
-
-    include Hashlike
-
-    # invokes the method with the given name on the jsi_node_content (if defined) or its #to_hash
-    # @param method_name [String, Symbol]
-    # @param a arguments and block are passed to the invocation of method_name
-    # @return [Object] the result of calling method method_name on the jsi_node_content or its #to_hash
-    def jsi_node_content_hash_pubsend(method_name, *a, &b)
-      if jsi_node_content.respond_to?(method_name)
-        jsi_node_content.public_send(method_name, *a, &b)
-      else
-        jsi_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|
-        jsi_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.
-    #
-    # @param a arguments are passed to `#[]`
-    # @yield [Object] each element of this array node
-    # @return [self, Enumerator] an Enumerator if invoked without a block; otherwise self
-    def each(*a, &block)
-      return to_enum(__method__) { jsi_node_content_ary_pubsend(:size) } unless block
-      jsi_node_content_ary_pubsend(:each_index) { |i| yield(self[i, *a]) }
-      self
-    end
-
-    # an array, the same size as the jsi_node_content, in which the element at each index is the
-    # result of `self[index]`
-    # @param a arguments are passed to `#[]`
-    # @return [Array]
-    def to_ary(*a)
-      to_a(*a)
-    end
-
-    include Arraylike
-
-    # invokes the method with the given name on the jsi_node_content (if defined) or its #to_ary
-    # @param method_name [String, Symbol]
-    # @param a arguments and block are passed to the invocation of method_name
-    # @return [Object] the result of calling method method_name on the jsi_node_content or its #to_ary
-    def jsi_node_content_ary_pubsend(method_name, *a, &b)
-      if jsi_node_content.respond_to?(method_name)
-        jsi_node_content.public_send(method_name, *a, &b)
-      else
-        jsi_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|
-        jsi_node_content_ary_pubsend(method_name, *a, &b)
-      end
-    end
-  end
-end

data/lib/jsi/schema/validation/core.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::Core
-    # validates the given instance against this schema
-    #
-    # @private
-    # @param instance_ptr [JSI::Ptr] a pointer to the instance to validate against the schema, in the instance_document
-    # @param instance_document [#to_hash, #to_ary, Object] document containing the instance instance_ptr pointer points to
-    # @param validate_only [Boolean] whether to return a full schema validation result or a simple, validation-only result
-    # @param visited_refs [Enumerable<JSI::Schema::Ref>]
-    # @return [JSI::Validation::Result]
-    def internal_validate_instance(instance_ptr, instance_document, validate_only: false, visited_refs: [])
-      if validate_only
-        result = JSI::Validation::VALID
-      else
-        result = JSI::Validation::FullResult.new
-      end
-      result_builder = result.builder(self, instance_ptr, instance_document, validate_only, visited_refs)
-
-      catch(:jsi_validation_result) do
-        # note: true/false are not valid as schemas in draft 4; they are only values of
-        # additionalProperties / additionalItems. since their behavior is undefined, though,
-        # it's fine for them to behave the same as boolean schemas in later drafts.
-        # I don't care about draft 4 to implement a different structuring for that.
-        if schema_content == true
-          # noop
-        elsif schema_content == false
-          result_builder.validate(false, 'instance is not valid against `false` schema')
-        elsif schema_content.respond_to?(:to_hash)
-          internal_validate_keywords(result_builder)
-        else
-          result_builder.schema_error('schema is not a boolean or a JSON object')
-        end
-        result
-      end.freeze
-    end
-  end
-end

data/lib/jsi/util/attr_struct.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Util
-    # like a Struct, but stores all the attributes in one @attributes Hash, instead of individual instance
-    # variables for each attribute.
-    # this tends to be easier to work with and more flexible. keys which are symbols are converted to strings.
-    class AttrStruct
-      class AttrStructError < StandardError
-      end
-
-      class UndefinedAttributeKey < AttrStructError
-      end
-
-      class << self
-        # creates a AttrStruct subclass with the given attribute keys.
-        # @param attribute_keys [Enumerable<String, Symbol>]
-        def [](*attribute_keys)
-          unless self == AttrStruct
-            # :nocov:
-            raise(NotImplementedError, "AttrStruct multiple inheritance not supported")
-            # :nocov:
-          end
-
-          bad = attribute_keys.reject { |key| key.respond_to?(:to_str) || key.is_a?(Symbol) }
-          unless bad.empty?
-            raise ArgumentError, "attribute keys must be String or Symbol; got keys: #{bad.map(&:inspect).join(', ')}"
-          end
-          attribute_keys = attribute_keys.map { |key| key.is_a?(Symbol) ? key.to_s : key }
-
-          Class.new(AttrStruct).tap do |klass|
-            klass.define_singleton_method(:attribute_keys) { attribute_keys }
-            klass.send(:define_method, :attribute_keys) { attribute_keys }
-            attribute_keys.each do |attribute_key|
-              # reader
-              klass.send(:define_method, attribute_key) do
-                @attributes[attribute_key]
-              end
-
-              # writer
-              klass.send(:define_method, "#{attribute_key}=") do |value|
-                @attributes[attribute_key] = value
-              end
-            end
-          end
-        end
-      end
-
-      def initialize(attributes = {})
-        unless attributes.respond_to?(:to_hash)
-          raise(TypeError, "expected attributes to be a Hash; got: #{attributes.inspect}")
-        end
-        attributes = attributes.map { |k, v| {k.is_a?(Symbol) ? k.to_s : k => v} }.inject({}, &:update)
-        bad = attributes.keys.reject { |k| self.attribute_keys.include?(k) }
-        unless bad.empty?
-          raise UndefinedAttributeKey, "undefined attribute keys: #{bad.map(&:inspect).join(', ')}"
-        end
-        @attributes = attributes
-      end
-
-      def [](key)
-        key = key.to_s if key.is_a?(Symbol)
-        @attributes[key]
-      end
-
-      def []=(key, value)
-        key = key.to_s if key.is_a?(Symbol)
-        unless self.attribute_keys.include?(key)
-          raise UndefinedAttributeKey, "undefined attribute key: #{key.inspect}"
-        end
-        @attributes[key] = value
-      end
-
-      # @return [String]
-      def inspect
-        "\#<#{self.class.name}#{@attributes.empty? ? '' : ' '}#{@attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
-      end
-
-      # pretty-prints a representation of self to the given printer
-      # @return [void]
-      def pretty_print(q)
-        q.text '#<'
-        q.text self.class.name
-        q.group_sub {
-          q.nest(2) {
-            q.breakable(@attributes.empty? ? '' : ' ')
-            q.seplist(@attributes, nil, :each_pair) { |k, v|
-              q.group {
-                q.text k
-                q.text ': '
-                q.pp v
-              }
-            }
-          }
-        }
-        q.breakable ''
-        q.text '>'
-      end
-
-      include FingerprintHash
-      def jsi_fingerprint
-        {class: self.class, attributes: @attributes}
-      end
-    end
-  end
-end