jsi 0.6.0 → 0.8.0

data/lib/jsi/util.rb

@@ -1,11 +1,96 @@
 # frozen_string_literal: true
 
 module JSI
-  # JSI::Util classes, modules, constants, and methods are internal, and will be added and removed without warning.
-  #
-  # @api private
+  # JSI::Util contains public utilities
   module Util
-    autoload :AttrStruct, 'jsi/util/attr_struct'
+    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
@@ -25,7 +110,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
@@ -35,16 +120,16 @@ module JSI
     end
 
     def deep_stringify_symbol_keys(object)
-      if object.respond_to?(:to_hash)
-        JSI::Typelike.modified_copy(object) do |hash|
+      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 : deep_stringify_symbol_keys(k)] = deep_stringify_symbol_keys(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::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,9 +139,69 @@ module JSI
       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.
     #
+    # @api private
     # @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
@@ -64,8 +209,10 @@ module JSI
     def ensure_module_set(modules)
       if modules.is_a?(Set) && modules.frozen?
         set = modules
-      else
+      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?
@@ -77,148 +224,5 @@ module JSI
 
       set
     end
-
-    # is the given name ok to use as a ruby method name?
-    def ok_ruby_method_name?(name)
-      # must be a string
-      return false unless name.respond_to?(:to_str)
-      # must not begin with a digit
-      return false if name =~ /\A[0-9]/
-      # must not contain characters special to ruby syntax
-      return false if name =~ /[\\\s\#;\.,\(\)\[\]\{\}'"`%\+\-\/\*\^\|&=<>\?:!@\$~]/
-
-      return true
-    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
-    #
-    #     length.call([0])
-    #     # => 1
-    #
-    # see https://en.wikipedia.org/wiki/Fixed-point_combinator#Y_combinator
-    # and chapter 9 of the little schemer, available as the sample chapter at
-    # https://felleisen.org/matthias/BTLS-index.html
-    def ycomb
-      proc { |f| f.call(f) }.call(proc { |f| yield proc { |*x| f.call(f).call(*x) } })
-    end
-
-    module FingerprintHash
-      # overrides BasicObject#==
-      def ==(other)
-        __id__ == other.__id__ || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == self.jsi_fingerprint)
-      end
-
-      alias_method :eql?, :==
-
-      # overrides Kernel#hash
-      def hash
-        jsi_fingerprint.hash
-      end
-    end
-
-    class MemoMap
-      Result = Util::AttrStruct[*%w(
-        value
-        inputs
-        inputs_hash
-      )]
-
-      class Result
-      end
-
-      def initialize(key_by: nil, &block)
-        @key_by = key_by
-        @block = block
-
-        # each result has its own mutex to update its memoized value thread-safely
-        @result_mutexes = {}
-        # another mutex to thread-safely initialize each result mutex
-        @result_mutexes_mutex = Mutex.new
-
-        @results = {}
-      end
-
-      def [](*inputs)
-        if @key_by
-          key = @key_by.call(*inputs)
-        else
-          key = inputs
-        end
-        result_mutex = @result_mutexes_mutex.synchronize do
-          @result_mutexes[key] ||= Mutex.new
-        end
-
-        result_mutex.synchronize do
-          inputs_hash = inputs.hash
-          if @results.key?(key) && inputs_hash == @results[key].inputs_hash && inputs == @results[key].inputs
-            @results[key].value
-          else
-            value = @block.call(*inputs)
-            @results[key] = Result.new(value: value, inputs: inputs, inputs_hash: inputs_hash)
-            value
-          end
-        end
-      end
-    end
-
-    module Memoize
-      def self.extended(object)
-        object.send(:jsi_initialize_memos)
-      end
-
-      private
-
-      def jsi_initialize_memos
-        @jsi_memomaps_mutex = Mutex.new
-        @jsi_memomaps = {}
-      end
-
-      # @return [Util::MemoMap]
-      def jsi_memomap(name, **options, &block)
-        raise(Bug, 'must jsi_initialize_memos') unless @jsi_memomaps
-        unless @jsi_memomaps.key?(name)
-          @jsi_memomaps_mutex.synchronize do
-            # note: this ||= appears redundant with `unless @jsi_memomaps.key?(name)`,
-            # but that check is not thread safe. this check is.
-            @jsi_memomaps[name] ||= Util::MemoMap.new(**options, &block)
-          end
-        end
-        @jsi_memomaps[name]
-      end
-
-      def jsi_memoize(name, *inputs, &block)
-        jsi_memomap(name, &block)[*inputs]
-      end
-    end
-
-    module Virtual
-      class InstantiationError < StandardError
-      end
-
-      # this virtual class is not intended to be instantiated except by its subclasses, which override #initialize
-      def initialize
-        # :nocov:
-        raise(InstantiationError, "cannot instantiate virtual class #{self.class}")
-        # :nocov:
-      end
-
-      # virtual_method is used to indicate that the method calling it must be implemented on the (non-virtual) subclass
-      def virtual_method
-        # :nocov:
-        raise(Bug, "class #{self.class} must implement #{caller_locations.first.label}")
-        # :nocov:
-      end
-    end
-
-    public
-
-    extend self
   end
-  public
-  extend Util
 end

data/lib/jsi/validation/error.rb

@@ -29,6 +29,10 @@ module JSI
     #   document containing the instance at instance_ptr
     #   @return [Object]
     class Error
+      def initialize(attributes = {})
+        super
+        freeze
+      end
     end
   end
 end

data/lib/jsi/validation/result.rb

@@ -3,10 +3,7 @@
 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
@@ -24,7 +21,6 @@ module JSI
         end
 
         def schema_issue(*_)
-          virtual_method
         end
 
         def schema_error(message, keyword = nil)
@@ -48,12 +44,12 @@ module JSI
           subresult
         end
 
+        # @param instance_child_token [String, Integer]
         # @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)
+        def child_subschema_validate(instance_child_token, subschema_ptr)
           subresult = schema.subschema(subschema_ptr).internal_validate_instance(
-            instance_ptr + subinstance_ptr,
+            instance_ptr[instance_child_token],
             instance_document,
             validate_only: validate_only,
           )
@@ -71,24 +67,13 @@ module JSI
           nil
         end
       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
-
+    class Result
       # is the instance valid against its schemas?
       # @return [Boolean]
       def valid?
-        # :nocov:
-        virtual_method
-        # :nocov:
+        #chkbug raise(NotImplementedError)
       end
 
       include Util::FingerprintHash
@@ -102,7 +87,7 @@ module JSI
             valid,
             message,
             keyword: nil,
-            results: []
+            results: Util::EMPTY_ARY
         )
           results.each { |res| result.schema_issues.merge(res.schema_issues) }
           if !valid
@@ -126,7 +111,9 @@ module JSI
           })
         end
       end
+    end
 
+    class FullResult
       def initialize
         @validation_errors = Set.new
         @schema_issues = Set.new
@@ -140,7 +127,6 @@ module JSI
       end
 
       def freeze
-        @validation_errors.each(&:freeze)
         @schema_issues.each(&:freeze)
         @validation_errors.freeze
         @schema_issues.freeze
@@ -156,17 +142,14 @@ module JSI
         self
       end
 
-      def +(result)
-        FullResult.new.merge(self).merge(result)
-      end
-
-      # @private
+      # see {Util::Private::FingerprintHash}
+      # @api private
       def jsi_fingerprint
         {
           class: self.class,
           validation_errors: validation_errors,
           schema_issues: schema_issues,
-        }
+        }.freeze
       end
     end
 
@@ -178,7 +161,7 @@ module JSI
             valid,
             message,
             keyword: nil,
-            results: []
+            results: Util::EMPTY_ARY
         )
           if !valid
             throw(:jsi_validation_result, INVALID)
@@ -189,7 +172,9 @@ module JSI
           # noop
         end
       end
+    end
 
+    class ValidityResult
       def initialize(valid)
         @valid = valid
       end
@@ -198,12 +183,13 @@ module JSI
         @valid
       end
 
-      # @private
+      # see {Util::Private::FingerprintHash}
+      # @api private
       def jsi_fingerprint
         {
           class: self.class,
           valid: valid?,
-        }
+        }.freeze
       end
     end
   end

data/lib/jsi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSI
-  VERSION = "0.6.0".freeze
+  VERSION = "0.8.0".freeze
 end

data/lib/jsi.rb

@@ -8,9 +8,6 @@ require "pathname"
 require "bigdecimal"
 require "addressable/uri"
 
-require "jsi/util"
-require "jsi/typelike_modules"
-
 module JSI
   # generally put in code paths that are not expected to be valid control flow paths.
   # rather a NotImplementedCorrectlyError. but that's too long.
@@ -20,6 +17,9 @@ module JSI
   class Bug < NotImplementedError
   end
 
+  # @private TODO remove, any ruby without this is already long EOL
+  FrozenError = Object.const_defined?(:FrozenError) ? ::FrozenError : Class.new(StandardError)
+
   # @private
   ROOT_PATH = Pathname.new(__FILE__).dirname.parent.expand_path
 
@@ -29,68 +29,94 @@ module JSI
   # @private
   SCHEMAS_PATH = RESOURCES_PATH.join('schemas')
 
-  autoload :Ptr, 'jsi/ptr'
-
-  # @private
-  # @deprecated
-  module JSON
-    Pointer = Ptr
+  DEFAULT_CONTENT_TO_IMMUTABLE = proc do |content|
+    Util.deep_to_frozen(content, not_implemented: proc do |instance|
+      raise(ArgumentError, [
+        "JSI does not know how to make the given instance immutable.",
+        "See new_jsi / new_schema params `mutable` and `to_immutable` documentation for options.",
+        "https://www.rubydoc.info/gems/jsi/#{VERSION}/JSI/SchemaSet#new_jsi-instance_method",
+        "Given instance: #{instance.pretty_inspect.chomp}",
+      ].join("\n"))
+    end)
   end
 
-  autoload :PathedNode, 'jsi/pathed_node'
-  autoload :Typelike, 'jsi/typelike_modules'
-  autoload :Hashlike, 'jsi/typelike_modules'
-  autoload :Arraylike, 'jsi/typelike_modules'
+  autoload :Util, 'jsi/util'
+  autoload :Ptr, 'jsi/ptr'
   autoload :Schema, 'jsi/schema'
   autoload :SchemaSet, 'jsi/schema_set'
   autoload :Base, 'jsi/base'
-  autoload :Metaschema, 'jsi/metaschema'
-  autoload :MetaschemaNode, 'jsi/metaschema_node'
+  autoload(:MetaSchemaNode, 'jsi/metaschema_node')
+  autoload :SchemaModule, 'jsi/schema_classes'
   autoload :SchemaClasses, 'jsi/schema_classes'
   autoload :SchemaRegistry, 'jsi/schema_registry'
   autoload :Validation, 'jsi/validation'
   autoload :JSICoder, 'jsi/jsi_coder'
 
+  autoload :JSONSchemaDraft04, 'schemas/json-schema.org/draft-04/schema'
+  autoload :JSONSchemaDraft06, 'schemas/json-schema.org/draft-06/schema'
+  autoload :JSONSchemaDraft07, 'schemas/json-schema.org/draft-07/schema'
   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'
 
-  # instantiates a given schema object as a JSI Schema.
+  # Instantiates the given schema content as a JSI Schema, passing all params to
+  # {JSI.new_schema}, and returns its {Schema#jsi_schema_module JSI Schema Module}.
   #
-  # 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)
+  # @return (see JSI::Schema::MetaSchema#new_schema_module)
+  def self.new_schema_module(schema_content, **kw, &block)
+    new_schema(schema_content, **kw, &block).jsi_schema_module
   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}.
+  # @private pending dialect/vocabularies
+  # Instantiates the given document as a JSI Meta-Schema.
   #
-  # @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
+  # @param metaschema_document an object to be instantiated as a JSI Meta-Schema
+  # @param schema_implementation_modules (see MetaSchemaNode#initialize)
+  # @param to_immutable (see SchemaSet#new_jsi)
+  # @return [JSI::MetaSchemaNode + JSI::Schema::MetaSchema + JSI::Schema]
+  def self.new_metaschema(metaschema_document,
+      schema_implementation_modules: ,
+      to_immutable: DEFAULT_CONTENT_TO_IMMUTABLE
+  )
+    metaschema_document = to_immutable.call(metaschema_document) if to_immutable
+
+    MetaSchemaNode.new(metaschema_document,
+      schema_implementation_modules: schema_implementation_modules,
+      jsi_content_to_immutable: to_immutable,
+    )
   end
 
-  # @private @deprecated
-  def self.class_for_schemas(schemas)
-    SchemaClasses.class_for_schemas(schemas.map { |schema| JSI.new_schema(schema) })
+  # @private pending dialect/vocabularies
+  # Instantiates the given document as a JSI Meta-Schema, passing all params to
+  # {new_metaschema}, and returns its {Schema#jsi_schema_module JSI Schema Module}.
+  #
+  # @return [JSI::SchemaModule + JSI::SchemaModule::MetaSchemaModule]
+  def self.new_metaschema_module(metaschema_document, **kw)
+    new_metaschema(metaschema_document, **kw).jsi_schema_module
   end
 
-  # `JSI.schema_registry` is the {JSI::SchemaRegistry} in which schemas are registered.
+  # `JSI.schema_registry` is the default {JSI::SchemaRegistry} in which schemas are registered and from
+  # which they resolve references.
   #
   # @return [JSI::SchemaRegistry]
   def self.schema_registry
-    return @schema_registry if instance_variable_defined?(:@schema_registry)
-    @schema_registry = SchemaRegistry.new
+    @schema_registry
+  end
+
+  # @param schema_registry [JSI::SchemaRegistry]
+  def self.schema_registry=(schema_registry)
+    @schema_registry = schema_registry
   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 }
+  DEFAULT_SCHEMA_REGISTRY = SchemaRegistry.new.tap do |schema_registry|
+    schema_registry.autoload_uri("http://json-schema.org/draft-04/schema") { JSI::JSONSchemaDraft04.schema }
+    schema_registry.autoload_uri("http://json-schema.org/draft-06/schema") { JSI::JSONSchemaDraft06.schema }
+    schema_registry.autoload_uri("http://json-schema.org/draft-07/schema") { JSI::JSONSchemaDraft07.schema }
+  end.freeze
+
+  self.schema_registry = DEFAULT_SCHEMA_REGISTRY.dup
+
+  Schema # trigger autoload, ensure JSI methods (new_schema etc) defined in schema.rb load
+end