jsi-dev 0.0.0.pre.maruku

data/lib/jsi/util/typelike.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module JSI
+  # a module of methods for objects which behave like Hash but are not Hash.
+  #
+  # this module is intended to be internal to JSI. no guarantees or API promises
+  # are made for non-JSI classes including this module.
+  module Util::Hashlike
+    # safe methods which can be delegated to #to_hash (which the includer is assumed to have defined).
+    # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
+
+    # methods which do not need to access the value.
+    SAFE_KEY_ONLY_METHODS = %w(each_key empty? has_key? include? key? keys length member? size).map(&:freeze).freeze
+    SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at).map(&:freeze).freeze
+    DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift).map(&:freeze).freeze
+    # these return a modified copy
+    safe_modified_copy_methods = %w(compact)
+    # select and reject will return a modified copy but need the yielded block variable value from #[]
+    safe_kv_block_modified_copy_methods = %w(select reject)
+    SAFE_METHODS = SAFE_KEY_ONLY_METHODS | SAFE_KEY_VALUE_METHODS
+    custom_methods = %w(merge) # defined below
+    safe_to_hash_methods = SAFE_METHODS -
+      safe_modified_copy_methods -
+      safe_kv_block_modified_copy_methods -
+      custom_methods
+    safe_to_hash_methods.each do |method_name|
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
+      else
+        define_method(method_name) { |*a, **kw, &b| to_hash.public_send(method_name, *a, **kw, &b) }
+      end
+    end
+    safe_modified_copy_methods.each do |method_name|
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) do |*a, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+            responsive_object.public_send(method_name, *a, &b)
+          end
+        end
+      else
+        define_method(method_name) do |*a, **kw, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+            responsive_object.public_send(method_name, *a, **kw, &b)
+          end
+        end
+      end
+    end
+    safe_kv_block_modified_copy_methods.each do |method_name|
+      define_method(method_name) do |**kw, &b|
+        jsi_modified_copy do |object_to_modify|
+          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+          responsive_object.public_send(method_name) do |k, _v|
+            b.call(k, self[k, **kw])
+          end
+        end
+      end
+    end
+
+    # like [Hash#update](https://ruby-doc.org/core/Hash.html#method-i-update)
+    # @param other [#to_hash] the other hash to update this hash from
+    # @yield [key, oldval, newval] for entries with duplicate keys, the value of each duplicate key
+    #   is determined by calling the block with the key, its value in self and its value in other.
+    # @return self, updated with other
+    # @raise [TypeError] when `other` does not respond to #to_hash
+    def update(other, &block)
+      unless other.respond_to?(:to_hash)
+        raise(TypeError, "cannot update with argument that does not respond to #to_hash: #{other.pretty_inspect.chomp}")
+      end
+      other.to_hash.each_pair do |key, value|
+        if block && key?(key)
+          value = yield(key, self[key], value)
+        end
+        self[key] = value
+      end
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # like [Hash#merge](https://ruby-doc.org/core/Hash.html#method-i-merge)
+    # @param other [#to_hash] the other hash to merge into this
+    # @yield [key, oldval, newval] for entries with duplicate keys, the value of each duplicate key
+    #   is determined by calling the block with the key, its value in self and its value in other.
+    # @return duplicate of this hash with the other hash merged in
+    # @raise [TypeError] when `other` does not respond to #to_hash
+    def merge(other, &block)
+      jsi_modified_copy do |instance|
+        instance.merge(other.is_a?(Base) ? other.jsi_node_content : other, &block)
+      end
+    end
+
+    # basically the same #inspect as Hash, but has the class name and, if responsive,
+    # self's #jsi_object_group_text
+    # @return [String]
+    def inspect
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
+      -"\#{<#{object_group_str}>#{map { |k, v| " #{k.inspect} => #{v.inspect}" }.join(',')}}"
+    end
+
+    alias_method :to_s, :inspect
+
+    # pretty-prints a representation of this hashlike to the given printer
+    # @return [void]
+    def pretty_print(q)
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
+      q.text "\#{<#{object_group_str}>"
+      q.group_sub {
+        q.nest(2) {
+          q.breakable ' ' if !empty?
+          q.seplist(self, nil, :each_pair) { |k, v|
+            q.group {
+              q.pp k
+              q.text ' => '
+              q.pp v
+            }
+          }
+        }
+      }
+      q.breakable '' if !empty?
+      q.text '}'
+    end
+  end
+
+  # a module of methods for objects which behave like Array but are not Array.
+  #
+  # this module is intended to be internal to JSI. no guarantees or API promises
+  # are made for non-JSI classes including this module.
+  module Util::Arraylike
+    # safe methods which can be delegated to #to_ary (which the includer is assumed to have defined).
+    # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
+
+    # methods which do not need to access the element.
+    SAFE_INDEX_ONLY_METHODS = %w(each_index empty? length size).map(&:freeze).freeze
+    # there are some ambiguous ones that are omitted, like #sort, #map / #collect.
+    SAFE_INDEX_ELEMENT_METHODS = %w(| & * + - <=> abbrev at bsearch bsearch_index combination compact count cycle dig drop drop_while fetch find_index first include? index join last pack permutation product reject repeated_combination repeated_permutation reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip).map(&:freeze).freeze
+    DESTRUCTIVE_METHODS = %w(<< clear collect! compact! concat delete delete_at delete_if fill flatten! insert keep_if map! pop push reject! replace reverse! rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift).map(&:freeze).freeze
+
+    # methods (well, method) that returns a modified copy and doesn't need any handling of block variable(s)
+    safe_modified_copy_methods = %w(compact)
+
+    # methods that return a modified copy and do need handling of block variables
+    safe_el_block_methods = %w(reject select)
+
+    SAFE_METHODS = SAFE_INDEX_ONLY_METHODS | SAFE_INDEX_ELEMENT_METHODS
+    safe_to_ary_methods = SAFE_METHODS - safe_modified_copy_methods - safe_el_block_methods
+    safe_to_ary_methods.each do |method_name|
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) { |*a, &b| to_ary.public_send(method_name, *a, &b) }
+      else
+        define_method(method_name) { |*a, **kw, &b| to_ary.public_send(method_name, *a, **kw, &b) }
+      end
+    end
+    safe_modified_copy_methods.each do |method_name|
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) do |*a, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+            responsive_object.public_send(method_name, *a, &b)
+          end
+        end
+      else
+        define_method(method_name) do |*a, **kw, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+            responsive_object.public_send(method_name, *a, **kw, &b)
+          end
+        end
+      end
+    end
+    safe_el_block_methods.each do |method_name|
+      define_method(method_name) do |**kw, &b|
+        jsi_modified_copy do |object_to_modify|
+          i = 0
+          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+          responsive_object.public_send(method_name) do |_e|
+            b.call(self[i, **kw]).tap { i += 1 }
+          end
+        end
+      end
+    end
+
+    # see [Array#assoc](https://ruby-doc.org/core/Array.html#method-i-assoc)
+    def assoc(obj)
+      # note: assoc implemented here (instead of delegated) due to inconsistencies in whether
+      # other implementations expect each element to be an Array or to respond to #to_ary
+      detect { |e| e.respond_to?(:to_ary) and e[0] == obj }
+    end
+
+    # see [Array#rassoc](https://ruby-doc.org/core/Array.html#method-i-rassoc)
+    def rassoc(obj)
+      # note: rassoc implemented here (instead of delegated) due to inconsistencies in whether
+      # other implementations expect each element to be an Array or to respond to #to_ary
+      detect { |e| e.respond_to?(:to_ary) and e[1] == obj }
+    end
+
+    # basically the same #inspect as Array, but has the class name and, if responsive,
+    # self's #jsi_object_group_text
+    # @return [String]
+    def inspect
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
+      -"\#[<#{object_group_str}>#{map { |e| ' ' + e.inspect }.join(',')}]"
+    end
+
+    alias_method :to_s, :inspect
+
+    # pretty-prints a representation of this arraylike to the given printer
+    # @return [void]
+    def pretty_print(q)
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
+      q.text "\#[<#{object_group_str}>"
+      q.group_sub {
+        q.nest(2) {
+          q.breakable ' ' if !empty?
+          q.seplist(self, nil, :each) { |e|
+            q.pp e
+          }
+        }
+      }
+      q.breakable '' if !empty?
+      q.text ']'
+    end
+  end
+end

data/lib/jsi/util.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module JSI
+  # JSI::Util contains public utilities
+  module Util
+    autoload :Private, 'jsi/util/private'
+
+    include Private
+
+    extend self
+
+    autoload :Arraylike, 'jsi/util/typelike'
+    autoload :Hashlike, 'jsi/util/typelike'
+
+    # yields the content of the given param `object`. for objects which have a #jsi_modified_copy
+    # method of their own (JSI::Base, JSI::MetaschemaNode) that method is invoked with the given
+    # block. otherwise the given object itself is yielded.
+    #
+    # the given block must result in a modified copy of its block parameter
+    # (not destructively modifying the yielded content).
+    #
+    # @yield [Object] the content of the given object. the block should result
+    #   in a (nondestructively) modified copy of this.
+    # @return [object.class] modified copy of the given object
+    def modified_copy(object, &block)
+      if object.respond_to?(:jsi_modified_copy)
+        object.jsi_modified_copy(&block)
+      else
+        yield(object)
+      end
+    end
+
+    # A structure like the given `object`, recursively coerced to JSON-compatible types.
+    #
+    # - Structures of Hash, Array, and basic types of String/number/boolean/nil are returned as-is.
+    # - If the object responds to `#as_json`, that method is used, passing any given options.
+    # - If the object supports [implicit conversion](https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html)
+    #   with `#to_hash`, `#to_ary`, `#to_str`, or `#to_int`, that is used.
+    # - Set becomes Array; Symbol becomes String.
+    # - Types with no known coersion to JSON-compatible raise TypeError.
+    #
+    # @param object [Object]
+    # @return [Array, Hash, String, Integer, Float, Boolean, NilClass] a JSON-compatible structure like the given `object`
+    # @raise [TypeError] If the object cannot be coerced to a JSON-compatible structure
+    def as_json(object, options = {})
+      type_err = proc { raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}") }
+      if object.respond_to?(:as_json)
+        options.empty? ? object.as_json : object.as_json(**options) # TODO remove eventually (keyword argument compatibility)
+      elsif object.is_a?(Addressable::URI)
+        object.to_s
+      elsif object.respond_to?(:to_hash) && (object_to_hash = object.to_hash).is_a?(Hash)
+        result = {}
+        object_to_hash.each_pair do |k, v|
+          ks = k.is_a?(String) ? k :
+            k.is_a?(Symbol) ? k.to_s :
+            k.respond_to?(:to_str) && (kstr = k.to_str).is_a?(String) ? kstr :
+            raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
+          result[ks] = as_json(v, **options)
+        end
+        result
+      elsif object.respond_to?(:to_ary) && (object_to_ary = object.to_ary).is_a?(Array)
+        object_to_ary.map { |e| as_json(e, **options) }
+      elsif [String, Integer, TrueClass, FalseClass, NilClass].any? { |c| object.is_a?(c) }
+        object
+      elsif object.is_a?(Float)
+        type_err.call unless object.finite?
+        object
+      elsif object.is_a?(Symbol)
+        object.to_s
+      elsif object.is_a?(Set)
+        as_json(object.to_a, **options)
+      elsif object.respond_to?(:to_str) && (object_to_str = object.to_str).is_a?(String)
+        object_to_str
+      elsif object.respond_to?(:to_int) && (object_to_int = object.to_int).is_a?(Integer)
+        object_to_int
+      else
+        type_err.call
+      end
+    end
+
+    # A JSON encoded string of the given object.
+    #
+    # - If the object has a `#to_json` method that isn't defined by the stdlib `json` gem,
+    #   that method is used, passing any given options.
+    # - Otherwise, JSON is generated using {as_json} to coerce to compatible types.
+    # @return [String]
+    def to_json(object, options = {})
+      if USE_TO_JSON_METHOD[object.class]
+        options.empty? ? object.to_json : object.to_json(**options) # TODO remove eventually (keyword argument compatibility)
+      else
+        JSON.generate(as_json(object, **options))
+      end
+    end
+
+    # a hash copied from the given hashlike, in which any symbol keys are
+    # converted to strings. behavior on collisions is undefined (but in the
+    # future could take a block like
+    # ActiveSupport::HashWithIndifferentAccess#update)
+    #
+    # at the moment it is undefined whether the returned hash is the same
+    # instance as the `hash` param. if `hash` is already a hash  which contains
+    # no symbol keys, this method MAY return that same instance. use #dup on
+    # the return if you need to ensure it is not the same instance as the
+    # argument instance.
+    #
+    # @param hashlike [#to_hash] the hash from which to convert symbol keys to strings
+    # @return [same class as the param `hash`, or Hash if the former cannot be done] a
+    #    hash(-like) instance containing no symbol keys
+    def stringify_symbol_keys(hashlike)
+      unless hashlike.respond_to?(:to_hash)
+        raise(ArgumentError, "expected argument to be a hash; got #{hashlike.class.inspect}: #{hashlike.pretty_inspect.chomp}")
+      end
+      JSI::Util.modified_copy(hashlike) do |hash|
+        out = {}
+        hash.each do |k, v|
+          out[k.is_a?(Symbol) ? k.to_s : k] = v
+        end
+        out
+      end
+    end
+
+    def deep_stringify_symbol_keys(object)
+      if object.respond_to?(:to_hash) && !object.is_a?(Addressable::URI)
+        JSI::Util.modified_copy(object) do |hash|
+          out = {}
+          (hash.respond_to?(:each) ? hash : hash.to_hash).each do |k, v|
+            out[k.is_a?(Symbol) ? k.to_s.freeze : deep_stringify_symbol_keys(k)] = deep_stringify_symbol_keys(v)
+          end
+          out
+        end
+      elsif object.respond_to?(:to_ary)
+        JSI::Util.modified_copy(object) do |ary|
+          (ary.respond_to?(:each) ? ary : ary.to_ary).map do |e|
+            deep_stringify_symbol_keys(e)
+          end
+        end
+      else
+        object
+      end
+    end
+
+    # returns an object which is equal to the param object, and is recursively frozen.
+    # the given object is not modified.
+    def deep_to_frozen(object, not_implemented: nil)
+      dtf = proc { |o| deep_to_frozen(o, not_implemented: not_implemented) }
+      if object.instance_of?(Hash)
+        out = {}
+        identical = object.frozen?
+        object.each do |k, v|
+          fk = dtf[k]
+          fv = dtf[v]
+          identical &&= fk.__id__ == k.__id__
+          identical &&= fv.__id__ == v.__id__
+          out[fk] = fv
+        end
+        if !object.default.nil?
+          out.default = dtf[object.default]
+          identical &&= out.default.__id__ == object.default.__id__
+        end
+        if object.default_proc
+          raise(ArgumentError, "cannot make immutable copy of a Hash with default_proc")
+        end
+        if identical
+          object
+        else
+          out.freeze
+        end
+      elsif object.instance_of?(Array)
+        identical = object.frozen?
+        out = Array.new(object.size)
+        object.each_with_index do |e, i|
+          fe = dtf[e]
+          identical &&= fe.__id__ == e.__id__
+          out[i] = fe
+        end
+        if identical
+          object
+        else
+          out.freeze
+        end
+      elsif object.instance_of?(String)
+        if object.frozen?
+          object
+        else
+          object.dup.freeze
+        end
+      elsif CLASSES_ALWAYS_FROZEN.any? { |c| object.is_a?(c) } # note: `is_a?`, not `instance_of?`, here because instance_of?(Integer) is false until Fixnum/Bignum is gone. this is fine here; there is no concern of subclasses of CLASSES_ALWAYS_FROZEN duping/freezing differently (as with e.g. ActiveSupport::HashWithIndifferentAccess)
+        object
+      else
+        if not_implemented
+          not_implemented.call(object)
+        else
+          raise(NotImplementedError, [
+            "deep_to_frozen not implemented for class: #{object.class}",
+            "object: #{object.pretty_inspect.chomp}",
+          ].join("\n"))
+        end
+      end
+    end
+
+    # ensures the given param becomes a frozen Set of Modules.
+    # returns the param if it is already that, otherwise initializes and freezes such a Set.
+    #
+    # @param modules [Set, Enumerable] the object to ensure becomes a frozen Set of Modules
+    # @return [Set] frozen Set containing the given modules
+    # @raise [ArgumentError] when the modules param is not an Enumerable
+    # @raise [Schema::NotASchemaError] when the modules param contains objects which are not Schemas
+    def ensure_module_set(modules)
+      if modules.is_a?(Set) && modules.frozen?
+        set = modules
+      elsif modules.is_a?(Enumerable)
+        set = Set.new(modules).freeze
+      else
+        raise(TypeError, "not given an Enumerable of Modules")
+      end
+      not_modules = set.reject { |s| s.is_a?(Module) }
+      if !not_modules.empty?
+        raise(TypeError, [
+          "ensure_module_set given non-Module objects:",
+          *not_modules.map { |ns| ns.pretty_inspect.chomp },
+        ].join("\n"))
+      end
+
+      set
+    end
+  end
+end

data/lib/jsi/validation/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSI
+  module Validation
+    Error = Util::AttrStruct[*%w(
+      message
+      keyword
+      schema
+      instance_ptr
+      instance_document
+    )]
+
+    # a validation error of a schema instance against a schema
+    #
+    # @!attribute message
+    #   a message describing the error
+    #   @return [String]
+    # @!attribute keyword
+    #   the keyword of the schema which failed to validate.
+    #   this may be absent if the error is not from a schema keyword (i.e, `false` schema).
+    #   @return [String]
+    # @!attribute schema
+    #   the schema against which the instance failed to validate
+    #   @return [JSI::Schema]
+    # @!attribute instance_ptr
+    #   pointer to the instance in instance_document
+    #   @return [JSI::Ptr]
+    # @!attribute instance_document
+    #   document containing the instance at instance_ptr
+    #   @return [Object]
+    class Error
+    end
+  end
+end

data/lib/jsi/validation/result.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module JSI
+  module Validation
+    # a result of validating an instance against schemas which describe it.
+    # virtual base class.
+    class Result
+      include Util::Virtual
+
+      Builder = Util::AttrStruct[*%w(
+        result
+        schema
+        instance_ptr
+        instance_document
+        validate_only
+        visited_refs
+      )]
+
+      # @private
+      # a structure used to build a Result. virtual base class.
+      class Builder
+        def instance
+          instance_ptr.evaluate(instance_document)
+        end
+
+        def schema_issue(*_)
+          virtual_method
+        end
+
+        def schema_error(message, keyword = nil)
+          schema_issue(:error, message, keyword)
+        end
+
+        def schema_warning(message, keyword = nil)
+          schema_issue(:warning, message, keyword)
+        end
+
+        # @param subschema_ptr [JSI::Ptr, #to_ary]
+        # @return [JSI::Validation::Result]
+        def inplace_subschema_validate(subschema_ptr)
+          subresult = schema.subschema(subschema_ptr).internal_validate_instance(
+            instance_ptr,
+            instance_document,
+            validate_only: validate_only,
+            visited_refs: visited_refs,
+          )
+          merge_schema_issues(subresult)
+          subresult
+        end
+
+        # @param instance_child_token [String, Integer]
+        # @param subschema_ptr [JSI::Ptr, #to_ary]
+        # @return [JSI::Validation::Result]
+        def child_subschema_validate(instance_child_token, subschema_ptr)
+          subresult = schema.subschema(subschema_ptr).internal_validate_instance(
+            instance_ptr[instance_child_token],
+            instance_document,
+            validate_only: validate_only,
+          )
+          merge_schema_issues(subresult)
+          subresult
+        end
+
+        # @param other_result [JSI::Validation::Result]
+        # @return [void]
+        def merge_schema_issues(other_result)
+          unless validate_only
+            # schema_issues are always merged from subschema results (not depending on validation results)
+            result.schema_issues.merge(other_result.schema_issues)
+          end
+          nil
+        end
+      end
+
+      def builder(schema, instance_ptr, instance_document, validate_only, visited_refs)
+        self.class::Builder.new(
+          result: self,
+          schema: schema,
+          instance_ptr: instance_ptr,
+          instance_document: instance_document,
+          validate_only: validate_only,
+          visited_refs: visited_refs,
+        )
+      end
+
+      # is the instance valid against its schemas?
+      # @return [Boolean]
+      def valid?
+        # :nocov:
+        virtual_method
+        # :nocov:
+      end
+
+      include Util::FingerprintHash
+    end
+
+    # a full result of validating an instance against its schemas, with each validation error
+    class FullResult < Result
+      # @private
+      class Builder < Result::Builder
+        def validate(
+            valid,
+            message,
+            keyword: nil,
+            results: []
+        )
+          results.each { |res| result.schema_issues.merge(res.schema_issues) }
+          if !valid
+            results.each { |res| result.validation_errors.merge(res.validation_errors) }
+            result.validation_errors << Validation::Error.new({
+              message: message,
+              keyword: keyword,
+              schema: schema,
+              instance_ptr: instance_ptr,
+              instance_document: instance_document,
+            })
+          end
+        end
+
+        def schema_issue(level, message, keyword = nil)
+          result.schema_issues << Schema::Issue.new({
+            level: level,
+            message: message,
+            keyword: keyword,
+            schema: schema,
+          })
+        end
+      end
+
+      def initialize
+        @validation_errors = Set.new
+        @schema_issues = Set.new
+      end
+
+      attr_reader :validation_errors
+      attr_reader :schema_issues
+
+      def valid?
+        validation_errors.empty?
+      end
+
+      def freeze
+        @validation_errors.each(&:freeze)
+        @schema_issues.each(&:freeze)
+        @validation_errors.freeze
+        @schema_issues.freeze
+        super
+      end
+
+      def merge(result)
+        unless result.is_a?(FullResult)
+          raise(TypeError, "not a #{FullResult.name}: #{result.pretty_inspect.chomp}")
+        end
+        validation_errors.merge(result.validation_errors)
+        schema_issues.merge(result.schema_issues)
+        self
+      end
+
+      def +(result)
+        FullResult.new.merge(self).merge(result)
+      end
+
+      # see {Util::Private::FingerprintHash}
+      # @api private
+      def jsi_fingerprint
+        {
+          class: self.class,
+          validation_errors: validation_errors,
+          schema_issues: schema_issues,
+        }
+      end
+    end
+
+    # a result indicating only whether an instance is valid against its schemas
+    class ValidityResult < Result
+      # @private
+      class Builder < Result::Builder
+        def validate(
+            valid,
+            message,
+            keyword: nil,
+            results: []
+        )
+          if !valid
+            throw(:jsi_validation_result, INVALID)
+          end
+        end
+
+        def schema_issue(*_)
+          # noop
+        end
+      end
+
+      def initialize(valid)
+        @valid = valid
+      end
+
+      def valid?
+        @valid
+      end
+
+      # see {Util::Private::FingerprintHash}
+      # @api private
+      def jsi_fingerprint
+        {
+          class: self.class,
+          valid: valid?,
+        }
+      end
+    end
+  end
+end