jsi 0.4.0 → 0.7.0

data/lib/jsi/util.rb

@@ -1,13 +1,74 @@
 # frozen_string_literal: true
 
 module JSI
-  # JSI::Util classes, modules, constants, and methods are INTERNAL and will be added and removed without warning.
-  # do not rely on them.
+  # JSI::Util contains public utilities
   module Util
-    # a proc which does nothing
-    NOOP = -> (*_) { }
+    autoload :Private, 'jsi/util/private'
 
-    # returns a version of the given hash, in which any symbol keys are
+    include Private
+
+    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
+        return yield(object)
+      end
+    end
+
+    # recursive method to express the given argument object in json-compatible
+    # types of Hash, Array, and basic types of String/boolean/numeric/nil. this
+    # will raise TypeError if an object is given that is not a type that seems
+    # to be expressable as json.
+    #
+    # similar effect could be achieved by requiring 'json/add/core' and using #as_json,
+    # but I don't much care for how it represents classes that are
+    # not naturally expressable in JSON, and prefer not to load its
+    # monkey-patching.
+    #
+    # @param object [Object] the object to be converted to jsonifiability
+    # @return [Array, Hash, String, Boolean, NilClass, Numeric] jsonifiable
+    #   expression of param object
+    # @raise [TypeError] when the object (or an object nested with a hash or
+    #   array of object) cannot be expressed as json
+    def as_json(object, *opt)
+      if object.is_a?(JSI::Base)
+        as_json(object.jsi_node_content, *opt)
+      elsif object.respond_to?(:to_hash)
+        (object.respond_to?(:map) ? object : object.to_hash).map do |k, v|
+          unless k.is_a?(Symbol) || k.respond_to?(:to_str)
+            raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
+          end
+          {k.to_s => as_json(v, *opt)}
+        end.inject({}, &:update)
+      elsif object.respond_to?(:to_ary)
+        (object.respond_to?(:map) ? object : object.to_ary).map { |e| as_json(e, *opt) }
+      elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| object.is_a?(c) }
+        object
+      elsif object.is_a?(Symbol)
+        object.to_s
+      elsif object.is_a?(Set)
+        as_json(object.to_a, *opt)
+      elsif object.respond_to?(:as_json)
+        as_json(object.as_json(*opt), *opt)
+      else
+        raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}")
+      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)
@@ -25,7 +86,7 @@ module JSI
       unless hashlike.respond_to?(:to_hash)
         raise(ArgumentError, "expected argument to be a hash; got #{hashlike.class.inspect}: #{hashlike.pretty_inspect.chomp}")
       end
-      JSI::Typelike.modified_copy(hashlike) do |hash|
+      JSI::Util.modified_copy(hashlike) do |hash|
         out = {}
         hash.each do |k, v|
           out[k.is_a?(Symbol) ? k.to_s : k] = v
@@ -36,7 +97,7 @@ module JSI
 
     def deep_stringify_symbol_keys(object)
       if object.respond_to?(:to_hash)
-        JSI::Typelike.modified_copy(object) do |hash|
+        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 : deep_stringify_symbol_keys(k)] = deep_stringify_symbol_keys(v)
@@ -44,7 +105,7 @@ module JSI
           out
         end
       elsif object.respond_to?(:to_ary)
-        JSI::Typelike.modified_copy(object) do |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
@@ -54,55 +115,30 @@ module JSI
       end
     end
 
-    # this is the Y-combinator, which allows anonymous recursive functions. for a simple example,
-    # to define a recursive function to return the length of an array:
-    #
-    #    length = ycomb do |len|
-    #      proc { |list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
-    #    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.
     #
-    # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
-    # and chapter 9 of the little schemer, available as the sample chapter at http://www.ccs.neu.edu/home/matthias/BTLS/
-    def ycomb
-      proc { |f| f.call(f) }.call(proc { |f| yield proc { |*x| f.call(f).call(*x) } })
-    end
-    module_function :ycomb
-
-    module FingerprintHash
-      # overrides BasicObject#==
-      def ==(other)
-        object_id == other.object_id || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == self.jsi_fingerprint)
+    # @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
+      else
+        set = Set.new(modules).freeze
       end
-
-      alias_method :eql?, :==
-
-      # overrides Kernel#hash
-      def hash
-        jsi_fingerprint.hash
+      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
-    end
 
-    module Memoize
-      def jsi_memoize(key, *args_)
-        @jsi_memos ||= {}
-        @jsi_memos[key] ||= Hash.new do |h, args|
-          h[args] = yield(*args)
-        end
-        @jsi_memos[key][args_]
-      end
-
-      def jsi_clear_memo(key, *args)
-        @jsi_memos ||= {}
-        if @jsi_memos[key]
-          if args.empty?
-            @jsi_memos[key].clear
-          else
-            @jsi_memos[key].delete(args)
-          end
-        end
-      end
+      set
     end
+
+    extend self
   end
-  public
-  extend Util
 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,210 @@
+# 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 subschema_ptr [JSI::Ptr, #to_ary]
+        # @param subinstance_ptr [JSI::Ptr, #to_ary]
+        # @return [JSI::Validation::Result]
+        def child_subschema_validate(subschema_ptr, subinstance_ptr)
+          subresult = schema.subschema(subschema_ptr).internal_validate_instance(
+            instance_ptr + subinstance_ptr,
+            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
+
+      # @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
+
+      # @private
+      def jsi_fingerprint
+        {
+          class: self.class,
+          valid: valid?,
+        }
+      end
+    end
+  end
+end

data/lib/jsi/validation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JSI
+  module Validation
+    autoload :Error, 'jsi/validation/error'
+
+    autoload :Result, 'jsi/validation/result'
+    autoload :FullResult, 'jsi/validation/result'
+    autoload :ValidityResult, 'jsi/validation/result'
+
+    VALID = ValidityResult.new(true).freeze
+
+    INVALID = ValidityResult.new(false).freeze
+  end
+end

data/lib/jsi/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
-  VERSION = "0.4.0".freeze
+  VERSION = "0.7.0".freeze
 end

data/lib/jsi.rb

@@ -5,12 +5,10 @@ require "pp"
 require "set"
 require "json"
 require "pathname"
+require "bigdecimal"
 require "addressable/uri"
 
-require "jsi/json-schema-fragments"
-
 require "jsi/util"
-require "jsi/typelike_modules"
 
 module JSI
   # generally put in code paths that are not expected to be valid control flow paths.
@@ -21,30 +19,62 @@ module JSI
   class Bug < NotImplementedError
   end
 
+  # @private
   ROOT_PATH = Pathname.new(__FILE__).dirname.parent.expand_path
-  RESOURCES_PATH = ROOT_PATH.join('resources')
 
-  autoload :JSON, 'jsi/json'
-  autoload :PathedNode, 'jsi/pathed_node'
-  autoload :Typelike, 'jsi/typelike_modules'
-  autoload :Hashlike, 'jsi/typelike_modules'
-  autoload :Arraylike, 'jsi/typelike_modules'
+  # @private
+  RESOURCES_PATH = ROOT_PATH.join('{resources}')
+
+  # @private
+  SCHEMAS_PATH = RESOURCES_PATH.join('schemas')
+
+  autoload :Ptr, 'jsi/ptr'
+  autoload :Typelike, 'jsi/util/typelike'
   autoload :Schema, 'jsi/schema'
+  autoload :SchemaSet, 'jsi/schema_set'
   autoload :Base, 'jsi/base'
   autoload :Metaschema, 'jsi/metaschema'
   autoload :MetaschemaNode, 'jsi/metaschema_node'
   autoload :SchemaClasses, 'jsi/schema_classes'
+  autoload :SchemaRegistry, 'jsi/schema_registry'
+  autoload :Validation, 'jsi/validation'
   autoload :JSICoder, 'jsi/jsi_coder'
 
   autoload :JSONSchemaOrgDraft04, 'schemas/json-schema.org/draft-04/schema'
   autoload :JSONSchemaOrgDraft06, 'schemas/json-schema.org/draft-06/schema'
+  autoload :JSONSchemaOrgDraft07, 'schemas/json-schema.org/draft-07/schema'
 
   autoload :SimpleWrap, 'jsi/simple_wrap'
 
-  # @param schemas [Enumerable<JSI::Schema, #to_hash, Boolean>] schemas to represent with the class
-  # @return [Class subclassing JSI::Base] a JSI class which represents the given schemas.
-  #   an instance of the class represents a JSON Schema instance described by all of the given schemas.
-  def self.class_for_schemas(*schemas)
-    SchemaClasses.class_for_schemas(*schemas)
+  # instantiates a given schema object as a JSI Schema.
+  #
+  # see {JSI::Schema.new_schema}
+  #
+  # @param (see JSI::Schema.new_schema)
+  # @return (see JSI::Schema.new_schema)
+  def self.new_schema(schema_object, **kw)
+    JSI::Schema.new_schema(schema_object, **kw)
+  end
+
+  # instantiates a given schema object as a JSI Schema and returns its JSI Schema Module.
+  #
+  # shortcut to chain {JSI::Schema.new_schema} + {Schema#jsi_schema_module}.
+  #
+  # @param (see JSI::Schema.new_schema)
+  # @return [Module, JSI::SchemaModule] the JSI Schema Module of the schema
+  def self.new_schema_module(schema_object, **kw)
+    JSI::Schema.new_schema(schema_object, **kw).jsi_schema_module
+  end
+
+  # `JSI.schema_registry` is the {JSI::SchemaRegistry} in which schemas are registered.
+  #
+  # @return [JSI::SchemaRegistry]
+  def self.schema_registry
+    return @schema_registry if instance_variable_defined?(:@schema_registry)
+    @schema_registry = SchemaRegistry.new
   end
 end
+
+JSI.schema_registry.autoload_uri("http://json-schema.org/draft-04/schema") { JSI::JSONSchemaOrgDraft04.schema }
+JSI.schema_registry.autoload_uri("http://json-schema.org/draft-06/schema") { JSI::JSONSchemaOrgDraft06.schema }
+JSI.schema_registry.autoload_uri("http://json-schema.org/draft-07/schema") { JSI::JSONSchemaOrgDraft07.schema }

data/lib/schemas/json-schema.org/draft-04/schema.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
 module JSI
-  schema_id = 'http://json-schema.org/draft-04/schema'
-  schema_content = ::JSON.parse(File.read(::JSON::Validator.validators[schema_id].metaschema))
-  JSONSchemaOrgDraft04 = MetaschemaNode.new(schema_content).jsi_schema_module
+  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-04/schema.json').read)
+  JSONSchemaOrgDraft04 = MetaschemaNode.new(metaschema_document,
+    schema_implementation_modules: [JSI::Schema::Draft04],
+  ).jsi_schema_module
+
+  # the JSI schema module for `http://json-schema.org/draft-04/schema`
+  module JSONSchemaOrgDraft04
+    # @!parse extend JSI::DescribesSchemaModule
+    # @!parse include JSI::Schema::Draft04
+  end
 end

data/lib/schemas/json-schema.org/draft-06/schema.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
 module JSI
-  schema_id = 'http://json-schema.org/draft/schema' # I don't know why this is not http://json-schema.org/draft-06/schema
-  schema_content = ::JSON.parse(File.read(::JSON::Validator.validators[schema_id].metaschema))
-  JSONSchemaOrgDraft06 = MetaschemaNode.new(schema_content).jsi_schema_module
+  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-06/schema.json').read)
+  JSONSchemaOrgDraft06 = MetaschemaNode.new(metaschema_document,
+    schema_implementation_modules: [JSI::Schema::Draft06],
+  ).jsi_schema_module
+
+  # the JSI schema module for `http://json-schema.org/draft-06/schema`
+  module JSONSchemaOrgDraft06
+    # @!parse extend JSI::DescribesSchemaModule
+    # @!parse include JSI::Schema::Draft06
+  end
 end

data/lib/schemas/json-schema.org/draft-07/schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JSI
+  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-07/schema.json').read)
+  JSONSchemaOrgDraft07 = MetaschemaNode.new(metaschema_document,
+    schema_implementation_modules: [JSI::Schema::Draft07],
+  ).jsi_schema_module
+
+  # the JSI schema module for `http://json-schema.org/draft-07/schema`
+  module JSONSchemaOrgDraft07
+    # @!parse extend JSI::DescribesSchemaModule
+    # @!parse include JSI::Schema::Draft07
+  end
+end