jsi 0.6.0 → 0.7.0

data/lib/jsi/util.rb

@@ -1,11 +1,72 @@
 # 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
+
+    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
@@ -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
@@ -78,147 +139,6 @@ 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/version.rb

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

data/lib/jsi.rb

@@ -9,7 +9,6 @@ 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.
@@ -30,17 +29,7 @@ module JSI
   SCHEMAS_PATH = RESOURCES_PATH.join('schemas')
 
   autoload :Ptr, 'jsi/ptr'
-
-  # @private
-  # @deprecated
-  module JSON
-    Pointer = Ptr
-  end
-
-  autoload :PathedNode, 'jsi/pathed_node'
-  autoload :Typelike, 'jsi/typelike_modules'
-  autoload :Hashlike, 'jsi/typelike_modules'
-  autoload :Arraylike, 'jsi/typelike_modules'
+  autoload :Typelike, 'jsi/util/typelike'
   autoload :Schema, 'jsi/schema'
   autoload :SchemaSet, 'jsi/schema_set'
   autoload :Base, 'jsi/base'
@@ -77,11 +66,6 @@ module JSI
     JSI::Schema.new_schema(schema_object, **kw).jsi_schema_module
   end
 
-  # @private @deprecated
-  def self.class_for_schemas(schemas)
-    SchemaClasses.class_for_schemas(schemas.map { |schema| JSI.new_schema(schema) })
-  end
-
   # `JSI.schema_registry` is the {JSI::SchemaRegistry} in which schemas are registered.
   #
   # @return [JSI::SchemaRegistry]

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

@@ -3,10 +3,12 @@
 module JSI
   metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-04/schema.json').read)
   JSONSchemaOrgDraft04 = MetaschemaNode.new(metaschema_document,
-    metaschema_instance_modules: [JSI::Schema::Draft04],
+    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

@@ -3,10 +3,12 @@
 module JSI
   metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-06/schema.json').read)
   JSONSchemaOrgDraft06 = MetaschemaNode.new(metaschema_document,
-    metaschema_instance_modules: [JSI::Schema::Draft06],
+    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

@@ -3,10 +3,12 @@
 module JSI
   metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-07/schema.json').read)
   JSONSchemaOrgDraft07 = MetaschemaNode.new(metaschema_document,
-    metaschema_instance_modules: [JSI::Schema::Draft07],
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsi
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Ethan
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2023-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -36,13 +36,14 @@ files:
 - CHANGELOG.md
 - LICENSE.md
 - README.md
+- jsi.gemspec
 - lib/jsi.rb
 - lib/jsi/base.rb
+- lib/jsi/base/node.rb
 - lib/jsi/jsi_coder.rb
 - lib/jsi/metaschema.rb
 - lib/jsi/metaschema_node.rb
 - lib/jsi/metaschema_node/bootstrap_schema.rb
-- lib/jsi/pathed_node.rb
 - lib/jsi/ptr.rb
 - lib/jsi/schema.rb
 - lib/jsi/schema/application.rb
@@ -98,9 +99,10 @@ files:
 - lib/jsi/schema_registry.rb
 - lib/jsi/schema_set.rb
 - lib/jsi/simple_wrap.rb
-- lib/jsi/typelike_modules.rb
 - lib/jsi/util.rb
-- lib/jsi/util/attr_struct.rb
+- lib/jsi/util/private.rb
+- lib/jsi/util/private/attr_struct.rb
+- lib/jsi/util/typelike.rb
 - lib/jsi/validation.rb
 - lib/jsi/validation/error.rb
 - lib/jsi/validation/result.rb
@@ -116,7 +118,7 @@ homepage: https://github.com/notEthan/jsi
 licenses:
 - AGPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -131,8 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: 'JSI: JSON Schema Instantiation'
 test_files: []

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