jsi 0.2.1 → 0.3.0

data/lib/jsi/schema_classes.rb

@@ -1,80 +1,96 @@
+# frozen_string_literal: true
+
 module JSI
-  # this module is just a namespace for schema classes.
-  module SchemaClasses
-    # JSI::SchemaClasses[schema_id] returns a class for the schema with the
-    # given id, the same class as returned from JSI.class_for_schema.
-    #
-    # @param schema_id [String] absolute schema id as returned by {JSI::Schema#schema_id}
-    # @return [Class subclassing JSI::Base] the class for that schema
-    def self.[](schema_id)
-      @classes_by_id[schema_id]
+  # 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
+      idfrag = schema.schema_id || schema.node_ptr.fragment
+      if name
+        "#{name} (#{idfrag})"
+      else
+        "(JSI Schema Module: #{idfrag})"
+      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
-    @classes_by_id = {}
+  end
 
+  # this module is just a namespace for schema classes.
+  module SchemaClasses
     class << self
       include Memoize
 
       # see {JSI.class_for_schema}
       def class_for_schema(schema_object)
-        memoize(:class_for_schema, JSI::Schema.from_object(schema_object)) do |schema_|
-          Class.new(Base).instance_exec(schema_) do |schema|
+        jsi_memoize(:class_for_schema, JSI::Schema.from_object(schema_object)) do |schema|
+          Class.new(Base).instance_exec(schema) do |schema|
             define_singleton_method(:schema) { schema }
             define_method(:schema) { schema }
-            include(JSI::SchemaClasses.module_for_schema(schema, conflicting_modules: [Base, BaseArray, BaseHash]))
+            include(schema.jsi_schema_module)
 
             jsi_class = self
             define_method(:jsi_class) { jsi_class }
 
-            SchemaClasses.instance_exec(self) { |klass| @classes_by_id[klass.schema_id] = klass }
-
             self
           end
         end
       end
 
-      # a module for the given schema, with accessor methods for any object
-      # property names the schema identifies. also has a singleton method
-      # called #schema to access the {JSI::Schema} this module represents.
-      #
-      # accessor methods are defined on these modules so that methods can be
-      # defined on {JSI.class_for_schema} classes without method redefinition
-      # warnings. additionally, these overriding instance methods can call
-      # `super` to invoke the normal accessor behavior.
+      # a module for the given schema, with accessor methods for any object property names the schema
+      # identifies (see {JSI::Schema#described_object_property_names}).
       #
-      # no property names that are the same as existing method names on the JSI
-      # class will be defined. users should use #[] and #[]= to access properties
-      # whose names conflict with existing methods.
-      def SchemaClasses.module_for_schema(schema_object, conflicting_modules: [])
-        schema__ = JSI::Schema.from_object(schema_object)
-        memoize(:module_for_schema, schema__, conflicting_modules) do |schema_, conflicting_modules_|
+      # 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.instance_exec(schema_) do |schema|
+            m.module_eval do
               define_singleton_method(:schema) { schema }
-              define_singleton_method(:schema_id) do
-                schema.schema_id
-              end
-              define_singleton_method(:inspect) do
-                %Q(#<Module for Schema: #{schema_id}>)
-              end
 
-              conflicting_instance_methods = (conflicting_modules_ + [m]).map do |mod|
+              extend SchemaModule
+
+              include JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [JSI::Base, JSI::BaseArray, JSI::BaseHash])
+
+              @possibly_schema_node = schema
+              extend(SchemaModulePossibly)
+              extend(JSI::SchemaClasses.accessor_module_for_schema(schema.schema, conflicting_modules: [Module, SchemaModule, SchemaModulePossibly]))
+            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: )
+        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
-                  if respond_to?(:[])
-                    self[property_name]
-                  else
-                    raise(NoMethodError, "schema instance of class #{self.class} does not respond to []; cannot call reader '#{property_name}'. instance is #{instance.pretty_inspect.chomp}")
-                  end
+                  self[property_name]
                 end
                 define_method("#{property_name}=") do |value|
-                  if respond_to?(:[]=)
-                    self[property_name] = value
-                  else
-                    raise(NoMethodError, "schema instance of class #{self.class} does not respond to []=; cannot call writer '#{property_name}='. instance is #{instance.pretty_inspect.chomp}")
-                  end
+                  self[property_name] = value
                 end
               end
             end
@@ -83,4 +99,53 @@ module JSI
       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
+      extend(JSI::SchemaClasses.accessor_module_for_schema(node.schema, conflicting_modules: [NotASchemaModule, SchemaModulePossibly]))
+    end
+
+    include SchemaModulePossibly
+  end
 end

data/lib/jsi/simple_wrap.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module JSI
-  SimpleWrap = JSI.class_for_schema({"additionalProperties": {"$ref": "#"}, "items": {"$ref": "#"}})
+  SimpleWrap = JSI::Schema.new({
+    "additionalProperties": {"$ref": "#"},
+    "items": {"$ref": "#"}
+  }).jsi_schema_module
 
-  # SimpleWrap is a JSI class which recursively wraps nested structures
-  class SimpleWrap
+  # 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
@@ -136,36 +138,31 @@ module JSI
     # @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_str = JSI.object_group_str(respond_to?(:object_group_text) ? self.object_group_text : [])
-      "\#{<#{self.class}#{object_group_str}>#{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_str = JSI.object_group_str(obj.respond_to?(:object_group_text) ? obj.object_group_text : [])
-        text "\#{<#{obj.class}#{object_group_str}>"
-        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
 
@@ -217,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_str = JSI.object_group_str(respond_to?(:object_group_text) ? object_group_text : [])
-      "\#[<#{self.class}#{object_group_str}>#{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_str = JSI.object_group_str(obj.respond_to?(:object_group_text) ? obj.object_group_text : [])
-        text "\#[<#{obj.class}#{object_group_str}>"
-        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,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   module Util
     # a proc which does nothing
@@ -17,68 +19,44 @@ module JSI
     # @param hash [#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
       end
     end
 
-    # @param object_group_text [Array<String>]
-    # @return [String]
-    def object_group_str(object_group_text)
-      object_group_text.compact.map { |t| " #{t}" }.join('')
-    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]) }
+    #      proc { |list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
     #    end
     #
     # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
@@ -92,33 +70,35 @@ module JSI
   extend Util
 
   module FingerprintHash
+    # overrides BasicObject#==
     def ==(other)
-      object_id == other.object_id || (other.respond_to?(:fingerprint) && other.fingerprint == self.fingerprint)
+      object_id == other.object_id || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == self.jsi_fingerprint)
     end
 
     alias_method :eql?, :==
 
+    # overrides Kernel#hash
     def hash
-      fingerprint.hash
+      jsi_fingerprint.hash
     end
   end
 
   module Memoize
-    def memoize(key, *args_)
-      @memos ||= {}
-      @memos[key] ||= Hash.new do |h, args|
+    def jsi_memoize(key, *args_)
+      @jsi_memos ||= {}
+      @jsi_memos[key] ||= Hash.new do |h, args|
         h[args] = yield(*args)
       end
-      @memos[key][args_]
+      @jsi_memos[key][args_]
     end
 
-    def clear_memo(key, *args)
-      @memos ||= {}
-      if @memos[key]
+    def jsi_clear_memo(key, *args)
+      @jsi_memos ||= {}
+      if @jsi_memos[key]
         if args.empty?
-          @memos[key].clear
+          @jsi_memos[key].clear
         else
-          @memos[key].delete(args)
+          @jsi_memos[key].delete(args)
         end
       end
     end