jsi 0.0.4 → 0.4.0

data/lib/jsi/schema_classes.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module JSI
+  # JSI Schema Modules are extended with JSI::SchemaModule
+  module SchemaModule
+    # @return [String] absolute schema_id of the schema this module represents.
+    #   see {Schema#schema_id}.
+    def schema_id
+      schema.schema_id
+    end
+
+    # @return [String]
+    def inspect
+      uri = schema.schema_id || schema.node_ptr.uri
+      if name
+        "#{name} (#{uri})"
+      else
+        "(JSI Schema Module: #{uri})"
+      end
+    end
+
+    # invokes {JSI::Schema#new_jsi} on this module's schema, passing the given instance.
+    # @return [JSI::Base] a JSI whose instance is the given instance
+    def new_jsi(instance, *a, &b)
+      schema.new_jsi(instance, *a, &b)
+    end
+  end
+
+  # this module is just a namespace for schema classes.
+  module SchemaClasses
+    class << self
+      include Util::Memoize
+
+      # see {JSI.class_for_schemas}
+      def class_for_schemas(schema_objects)
+        schemas = schema_objects.map { |schema_object| JSI::Schema.from_object(schema_object) }.to_set
+        jsi_memoize(:class_for_schemas, schemas) do |schemas|
+          Class.new(Base).instance_exec(schemas) do |schemas|
+            define_singleton_method(:jsi_class_schemas) { schemas }
+            define_method(:jsi_schemas) { schemas }
+            schemas.each { |schema| include(schema.jsi_schema_module) }
+            jsi_class = self
+            define_method(:jsi_class) { jsi_class }
+
+            self
+          end
+        end
+      end
+
+      # a module for the given schema, with accessor methods for any object property names the schema
+      # identifies (see {JSI::Schema#described_object_property_names}).
+      #
+      # defines a singleton method #schema to access the {JSI::Schema} this module represents, and extends
+      # the module with {JSI::SchemaModule}.
+      def module_for_schema(schema_object)
+        schema = JSI::Schema.from_object(schema_object)
+        jsi_memoize(:module_for_schema, schema) do |schema|
+          Module.new.tap do |m|
+            m.module_eval do
+              define_singleton_method(:schema) { schema }
+
+              extend SchemaModule
+
+              include JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [JSI::Base, JSI::PathedArrayNode, JSI::PathedHashNode])
+
+              @possibly_schema_node = schema
+              extend(SchemaModulePossibly)
+              schema.jsi_schemas.each do |schema_schema|
+                extend(JSI::SchemaClasses.accessor_module_for_schema(schema_schema, conflicting_modules: [Module, SchemaModule, SchemaModulePossibly]))
+              end
+            end
+          end
+        end
+      end
+
+      # @param schema [JSI::Schema] a schema for which to define accessors for any described property names
+      # @param conflicting_modules [Enumerable<Module>] an array of modules (or classes) which
+      #   may be used alongside the accessor module. methods defined by any conflicting_module
+      #   will not be defined as accessors.
+      # @return [Module] a module of accessors (setters and getters) for described property names of the given
+      #   schema
+      def accessor_module_for_schema(schema, conflicting_modules: )
+        unless schema.is_a?(JSI::Schema)
+          raise(JSI::Schema::NotASchemaError, "not a schema: #{schema.pretty_inspect.chomp}")
+        end
+        jsi_memoize(:accessor_module_for_schema, schema, conflicting_modules) do |schema, conflicting_modules|
+          Module.new.tap do |m|
+            m.module_eval do
+              conflicting_instance_methods = (conflicting_modules + [m]).map do |mod|
+                mod.instance_methods + mod.private_instance_methods
+              end.inject(Set.new, &:|)
+              accessors_to_define = schema.described_object_property_names.map(&:to_s) - conflicting_instance_methods.map(&:to_s)
+              accessors_to_define.each do |property_name|
+                define_method(property_name) do
+                  self[property_name]
+                end
+                define_method("#{property_name}=") do |value|
+                  self[property_name] = value
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # a JSI::Schema module and a JSI::NotASchemaModule are both a SchemaModulePossibly.
+  # this module provides a #[] method.
+  module SchemaModulePossibly
+    attr_reader :possibly_schema_node
+
+    # subscripting a JSI schema module or a NotASchemaModule will subscript the node, and
+    # if the result is a JSI::Schema, return a JSI::Schema class; if it is a PathedNode,
+    # return a NotASchemaModule; or if it is another value (a basic type), return that value.
+    #
+    # @param token [Object]
+    # @return [Class, NotASchemaModule, Object]
+    def [](token)
+      sub = @possibly_schema_node[token]
+      if sub.is_a?(JSI::Schema)
+        sub.jsi_schema_module
+      elsif sub.is_a?(JSI::PathedNode)
+        NotASchemaModule.new(sub)
+      else
+        sub
+      end
+    end
+  end
+
+  # a schema module is a module which represents a schema. a NotASchemaModule represents
+  # a node in a schema's document which is not a schema, such as the 'properties'
+  # node (which contains schemas but is not a schema).
+  #
+  # a NotASchemaModule is extended with the module_for_schema of the node's schema.
+  #
+  # NotASchemaModule holds a node which is not a schema. when subscripted, it subscripts
+  # its node. if the value is a JSI::Schema, its schema module is returned. if the value
+  # is another node, a NotASchemaModule for that node is returned. otherwise - when the
+  # value is a basic type - that value itself is returned.
+  class NotASchemaModule
+    # @param node [JSI::PathedNode]
+    def initialize(node)
+      unless node.is_a?(JSI::PathedNode)
+        raise(TypeError, "not JSI::PathedNode: #{node.pretty_inspect.chomp}")
+      end
+      if node.is_a?(JSI::Schema)
+        raise(TypeError, "cannot instantiate NotASchemaModule for a JSI::Schema node: #{node.pretty_inspect.chomp}")
+      end
+      @possibly_schema_node = node
+      node.jsi_schemas.each do |schema|
+        extend(JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [NotASchemaModule, SchemaModulePossibly]))
+      end
+    end
+
+    include SchemaModulePossibly
+  end
+end

data/lib/jsi/simple_wrap.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSI
+  SimpleWrap = JSI::Schema.new({
+    "additionalProperties": {"$ref": "#"},
+    "items": {"$ref": "#"}
+  }).jsi_schema_module
+
+  # SimpleWrap is a JSI schema module which recursively wraps nested structures
+  module SimpleWrap
+  end
+end

data/lib/jsi/typelike_modules.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   # a module relating to objects that act like Hash or Array instances
   module Typelike
@@ -36,7 +38,9 @@ module JSI
     # @raise [TypeError] when the object (or an object nested with a hash or
     #   array of object) cannot be expressed as json
     def self.as_json(object, *opt)
-      if object.respond_to?(:to_hash)
+      if object.is_a?(JSI::PathedNode)
+        as_json(object.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}")
@@ -72,7 +76,7 @@ module JSI
     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)
     DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift)
     # these return a modified copy
-    safe_modified_copy_methods = %w(compact merge)
+    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
@@ -82,7 +86,7 @@ module JSI
     end
     safe_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        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
@@ -90,7 +94,7 @@ module JSI
     end
     safe_kv_block_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        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) do |k, _v|
             b.call(k, self[k])
@@ -99,39 +103,66 @@ module JSI
       end
     end
 
+    # the same as Hash#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 hsh and its value in other_hash.
+    # @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
+      self_respondingto_key = self.respond_to?(:key?) ? self : to_hash
+      other.to_hash.each_pair do |key, value|
+        if block_given? && self_respondingto_key.key?(key)
+          value = yield(key, self[key], value)
+        end
+        self[key] = value
+      end
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # the same as Hash#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 hsh and its value in other_hash.
+    # @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)
+      dup.update(other, &block)
+    end
+
     # @return [String] basically the same #inspect as Hash, but has the
     #   class name and, if responsive, self's #object_group_text
     def inspect
-      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
-      "\#{<#{self.class}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
+      object_group_str = (respond_to?(:object_group_text) ? self.object_group_text : [self.class]).join(' ')
+      "\#{<#{object_group_str}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
     end
 
-    # @return [String] see #inspect
-    def to_s
-      inspect
-    end
+    alias_method :to_s, :inspect
 
     # pretty-prints a representation this node to the given printer
     # @return [void]
     def pretty_print(q)
-      q.instance_exec(self) do |obj|
-        object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
-        text "\#{<#{obj.class}#{object_group_text}>"
-        group_sub {
-          nest(2) {
-            breakable(obj.any? { true } ? ' ' : '')
-            seplist(obj, nil, :each_pair) { |k, v|
-              group {
-                pp k
-                text ' => '
-                pp v
-              }
+      object_group_str = (respond_to?(:object_group_text) ? object_group_text : [self.class]).join(' ')
+      q.text "\#{<#{object_group_str}>"
+      q.group_sub {
+        q.nest(2) {
+          q.breakable(any? { true } ? ' ' : '')
+          q.seplist(self, nil, :each_pair) { |k, v|
+            q.group {
+              q.pp k
+              q.text ' => '
+              q.pp v
             }
           }
         }
-        breakable ''
-        text '}'
-      end
+      }
+      q.breakable ''
+      q.text '}'
     end
   end
 
@@ -162,7 +193,7 @@ module JSI
     end
     safe_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        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
@@ -170,7 +201,7 @@ module JSI
     end
     safe_el_block_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        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, *a) do |_e|
@@ -183,32 +214,27 @@ module JSI
     # @return [String] basically the same #inspect as Array, but has the
     #   class name and, if responsive, self's #object_group_text
     def inspect
-      object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
-      "\#[<#{self.class}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
+      object_group_str = (respond_to?(:object_group_text) ? object_group_text : [self.class]).join(' ')
+      "\#[<#{object_group_str}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
     end
 
-    # @return [String] see #inspect
-    def to_s
-      inspect
-    end
+    alias_method :to_s, :inspect
 
     # pretty-prints a representation this node to the given printer
     # @return [void]
     def pretty_print(q)
-      q.instance_exec(self) do |obj|
-        object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
-        text "\#[<#{obj.class}#{object_group_text}>"
-        group_sub {
-          nest(2) {
-            breakable(obj.any? { true } ? ' ' : '')
-            seplist(obj, nil, :each) { |e|
-              pp e
-            }
+      object_group_str = (respond_to?(:object_group_text) ? object_group_text : [self.class]).join(' ')
+      q.text "\#[<#{object_group_str}>"
+      q.group_sub {
+        q.nest(2) {
+          q.breakable(any? { true } ? ' ' : '')
+          q.seplist(self, nil, :each) { |e|
+            q.pp e
           }
         }
-        breakable ''
-        text ']'
-      end
+      }
+      q.breakable ''
+      q.text ']'
     end
   end
 end

data/lib/jsi/util.rb

@@ -1,5 +1,12 @@
+# 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.
   module Util
+    # a proc which does nothing
+    NOOP = -> (*_) { }
+
     # returns a version of the given hash, in which any symbol keys are
     # converted to strings. behavior on collisions is undefined (but in the
     # future could take a block like
@@ -11,54 +18,36 @@ module JSI
     # the return if you need to ensure it is not the same instance as the
     # argument instance.
     #
-    # @param hash [#to_hash] the hash from which to convert symbol keys to strings
+    # @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(hash)
-      unless hash.respond_to?(:to_hash)
-        raise(ArgumentError, "expected argument to be a hash; got #{hash.class.inspect}: #{hash.pretty_inspect.chomp}")
+    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::Typelike.modified_copy(hash) do |hash_|
-        changed = false
+      JSI::Typelike.modified_copy(hashlike) do |hash|
         out = {}
-        hash_.each do |k, v|
-          if k.is_a?(Symbol)
-            changed = true
-            k = k.to_s
-          end
-          out[k] = v
+        hash.each do |k, v|
+          out[k.is_a?(Symbol) ? k.to_s : k] = v
         end
-        changed ? out : hash_
+        out
       end
     end
 
     def deep_stringify_symbol_keys(object)
       if object.respond_to?(:to_hash)
         JSI::Typelike.modified_copy(object) do |hash|
-          changed = false
           out = {}
           (hash.respond_to?(:each) ? hash : hash.to_hash).each do |k, v|
-            if k.is_a?(Symbol)
-              changed = true
-              k = k.to_s
-            end
-            out_k = deep_stringify_symbol_keys(k)
-            out_v = deep_stringify_symbol_keys(v)
-            changed = true if out_k.object_id != k.object_id
-            changed = true if out_v.object_id != v.object_id
-            out[out_k] = out_v
+            out[k.is_a?(Symbol) ? k.to_s : deep_stringify_symbol_keys(k)] = deep_stringify_symbol_keys(v)
           end
-          changed ? out : hash
+          out
         end
       elsif object.respond_to?(:to_ary)
         JSI::Typelike.modified_copy(object) do |ary|
-          changed = false
-          out = (ary.respond_to?(:each) ? ary : ary.to_ary).map do |e|
-            out_e = deep_stringify_symbol_keys(e)
-            changed = true if out_e.object_id != e.object_id
-            out_e
+          (ary.respond_to?(:each) ? ary : ary.to_ary).map do |e|
+            deep_stringify_symbol_keys(e)
           end
-          changed ? out : ary
         end
       else
         object
@@ -69,7 +58,7 @@ module JSI
     # 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]) }
+    #      proc { |list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
     #    end
     #
     # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
@@ -78,41 +67,42 @@ module JSI
       proc { |f| f.call(f) }.call(proc { |f| yield proc { |*x| f.call(f).call(*x) } })
     end
     module_function :ycomb
-  end
-  public
-  extend Util
 
-  module FingerprintHash
-    def ==(other)
-      object_id == other.object_id || (other.respond_to?(:fingerprint) && other.fingerprint == self.fingerprint)
-    end
+    module FingerprintHash
+      # overrides BasicObject#==
+      def ==(other)
+        object_id == other.object_id || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == self.jsi_fingerprint)
+      end
 
-    alias_method :eql?, :==
+      alias_method :eql?, :==
 
-    def hash
-      fingerprint.hash
+      # overrides Kernel#hash
+      def hash
+        jsi_fingerprint.hash
+      end
     end
-  end
 
-  module Memoize
-    def memoize(key, *args_)
-      @memos ||= {}
-      @memos[key] ||= Hash.new do |h, args|
-        h[args] = yield(*args)
+    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
-      @memos[key][args_]
-    end
 
-    def clear_memo(key, *args)
-      @memos ||= {}
-      if @memos[key]
-        if args.empty?
-          @memos[key].clear
-        else
-          @memos[key].delete(args)
+      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
     end
   end
-  extend Memoize
+  public
+  extend Util
 end