collapsium 0.4.1 → 0.5.0

data/lib/collapsium/support/methods.rb

@@ -16,6 +16,8 @@ module Collapsium
     ##
     # Functionality for extending the behaviour of Hash methods
     module Methods
+      WRAPPER_HASH = "@__collapsium_methods_wrappers".freeze
+
       ##
       # Given the base module, wraps the given method name in the given block.
       # The block must accept the wrapped_method as the first parameter, followed
@@ -54,8 +56,7 @@ module Collapsium
           return
         end
 
-        # Hack for calling the private method "define_method"
-        def_method.call(method_name) do |*args, &method_block|
+        wrap_method_block = proc do |*args, &method_block|
           # We're trying to prevent loops by maintaining a stack of wrapped
           # method invocations.
           @__collapsium_methods_callstack ||= []
@@ -63,7 +64,7 @@ module Collapsium
           # Our current binding is based on the wrapper block and our own class,
           # as well as the arguments (CRC32).
           require 'zlib'
-          signature = Zlib::crc32(JSON::dump(args))
+          signature = Zlib.crc32(args.to_s)
           the_binding = [wrapper_block.object_id, self.class.object_id, signature]
 
           # We'll either pass the wrapped method to the wrapper block, or invoke
@@ -90,6 +91,16 @@ module Collapsium
 
           next result
         end
+
+        # Hack for calling the private method "define_method"
+        def_method.call(method_name, &wrap_method_block)
+
+        # Register this wrapper with the base
+        base_wrappers = base.instance_variable_get(WRAPPER_HASH)
+        base_wrappers ||= {}
+        base_wrappers[method_name] ||= []
+        base_wrappers[method_name] << wrapper_block
+        base.instance_variable_set(WRAPPER_HASH, base_wrappers)
       end
 
       def resolve_helpers(base, method_name, raise_on_missing)
@@ -107,13 +118,20 @@ module Collapsium
             if raise_on_missing
               raise
             end
-            return base_method, def_method
+            return nil, nil, nil
           end
           def_method = base.method(:define_method)
         else
           # For Objects and Classes, the unbound method will later be bound to
           # the object or class to define the method on.
-          base_method = base.method(method_name.to_s).unbind
+          begin
+            base_method = base.method(method_name.to_s).unbind
+          rescue NameError
+            if raise_on_missing
+              raise
+            end
+            return nil, nil, nil
+          end
           # With regards to method defintion, we only want to define methods
           # for the specific instance (i.e. use :define_singleton_method).
           def_method = base.method(:define_singleton_method)
@@ -123,6 +141,52 @@ module Collapsium
       end
 
       class << self
+        ##
+        # Given any base (value, class, module) and a method name, returns the
+        # wrappers defined for the base, in order of definition. If no wrappers
+        # are defined, an empty Array is returned.
+        def wrappers(base, method_name, visited = Set.new)
+          # First, check the instance, then its class for a wrapper. If either of
+          # them succeeds, exit with a result.
+          [base, base.class].each do |item|
+            item_wrappers = item.instance_variable_get(WRAPPER_HASH)
+            if not item_wrappers.nil? and item_wrappers.include?(method_name)
+              return item_wrappers[method_name]
+            end
+          end
+
+          # We add the base and its class to the set of visited items.
+          visited.add(base)
+          visited.add(base.class)
+
+          # If neither of the above contained a wrapper, look at ancestors
+          # recursively.
+          ancestors = nil
+          begin
+            ancestors = base.ancestors
+          rescue NoMethodError
+            ancestors = base.class.ancestors
+          end
+          ancestors = ancestors - Object.ancestors - [Object, Class, Module]
+
+          ancestors.each do |ancestor|
+            # Skip an visited item...
+            if visited.include?(ancestor)
+              next
+            end
+            visited.add(ancestor)
+
+            # ... and recurse into unvisited ones
+            anc_wrappers = wrappers(ancestor, method_name, visited)
+            if not anc_wrappers.empty?
+              return anc_wrappers
+            end
+          end
+
+          # Return an empty list if we couldn't find anything.
+          return []
+        end
+
         # Given an input array, return repeated sequences from the array. It's
         # used in loop detection.
         def repeated(array)

data/lib/collapsium/support/path_components.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+
+  ##
+  # Support functionality for Collapsium
+  module Support
+
+    ##
+    # @api private
+    # Defines functions for path prefixes and components. This is mainly used
+    # by PathedAccess, but it helps keeping everything separate so that
+    # ViralCapabilities can also apply it to Arrays.
+    module PathComponents
+
+      ##
+      # Assume any pathed access has this prefix.
+      def path_prefix=(value)
+        @path_prefix = normalize_path(value)
+      end
+
+      def path_prefix
+        @path_prefix ||= separator
+        return @path_prefix
+      end
+
+      # @api private
+      # Default path separator
+      DEFAULT_SEPARATOR = '.'.freeze
+
+      ##
+      # @return [RegExp] the pattern to split paths at; based on `separator`
+      def split_pattern
+        /(?<!\\)#{Regexp.escape(separator)}/
+      end
+
+      # @return [String] the separator is the character or pattern splitting paths.
+      def separator
+        @separator ||= DEFAULT_SEPARATOR
+        return @separator
+      end
+      attr_writer :separator
+
+      ##
+      # Break path into components. Expects a String path separated by the
+      # `#separator`, and returns the path split into components (an Array of
+      # String).
+      def path_components(path)
+        return filter_components(path.split(split_pattern))
+      end
+
+      ##
+      # Given path components, filters out unnecessary ones.
+      def filter_components(components)
+        return components.select { |c| not c.nil? and not c.empty? }
+      end
+
+      ##
+      # Join path components with the `#separator`.
+      def join_path(components)
+        return components.join(separator)
+      end
+
+      ##
+      # Get the parent path of the given path.
+      def parent_path(path)
+        components = path_components(normalize_path(path))
+        return normalize_path(components.slice(0, components.length - 1))
+      end
+
+      ##
+      # Normalizes a String path so that there are no empty components, and it
+      # starts with a separator.
+      def normalize_path(path)
+        components = []
+        if path.respond_to?(:split) # likely a String
+          components = path_components(path)
+        elsif path.respond_to?(:join) # likely an Array
+          components = filter_components(path)
+        end
+        return separator + join_path(components)
+      end
+
+    end # module PathComponents
+
+  end # module Support
+
+end # module Collapsium

data/lib/collapsium/version.rb

@@ -8,5 +8,5 @@
 #
 module Collapsium
   # The current release version
-  VERSION = "0.4.1".freeze
+  VERSION = "0.5.0".freeze
 end

data/lib/collapsium/viral_capabilities.rb

@@ -8,6 +8,7 @@
 #
 
 require 'collapsium/support/hash_methods'
+require 'collapsium/support/array_methods'
 require 'collapsium/support/methods'
 
 module Collapsium
@@ -18,16 +19,37 @@ module Collapsium
   # Virality is ensured by changing the return value of various methods; if it
   # is derived from Hash, it is attempted to convert it to the including class.
   #
-  # The module uses HashMethods to decide which methods to make viral in this
-  # manner.
+  # The module uses HashMethods and ArrayMethods to decide which methods to make
+  # viral in this manner.
   #
   # There are two ways for using this module:
   # a) in a `Class`, either include, prepend or extend it.
   # b) in a `Module`, *extend* this module. The resulting module can be included,
   #    prepended or extended in a `Class` again.
   module ViralCapabilities
+    # The default ancestor values for the accessors in ViralAncestorTypes
+    # are defined here. They're also used for generating functions that should
+    # provide the best ancestor class.
+    DEFAULT_ANCESTORS = {
+      hash_ancestor: Hash,
+      array_ancestor: Array,
+    }.freeze
+
+    ##
+    # Any Object (Class, Module) that's enhanced with ViralCapabilities will at
+    # least be extended with a module defining its Hash and Array ancestors.
+    module ViralAncestorTypes
+      def hash_ancestor
+        return @hash_ancestor || DEFAULT_ANCESTORS[:hash_ancestor]
+      end
+      attr_writer :hash_ancestor
+
+      def array_ancestor
+        return @array_ancestor || DEFAULT_ANCESTORS[:array_ancestor]
+      end
+      attr_writer :array_ancestor
+    end
 
-    include ::Collapsium::Support::HashMethods
     include ::Collapsium::Support::Methods
 
     ##
@@ -45,7 +67,6 @@ module Collapsium
     end
 
     class << self
-      include ::Collapsium::Support::HashMethods
       include ::Collapsium::Support::Methods
 
       ##
@@ -62,24 +83,40 @@ module Collapsium
         enhance(base)
       end
 
+      # We want to wrap methods for Arrays and Hashes alike
+      READ_METHODS = (
+        ::Collapsium::Support::HashMethods::READ_METHODS \
+        + ::Collapsium::Support::ArrayMethods::READ_METHODS
+      ).uniq.freeze
+      WRITE_METHODS = (
+        ::Collapsium::Support::HashMethods::WRITE_METHODS \
+        + ::Collapsium::Support::ArrayMethods::WRITE_METHODS
+      ).uniq.freeze
+
       ##
       # Enhance the base by wrapping all READ_METHODS and WRITE_METHODS in
-      # a wrapper that uses enhance_hash_value to, well, enhance Hash results.
+      # a wrapper that uses enhance_value to, well, enhance Hash and Array
+      # results.
       def enhance(base)
         # rubocop:disable Style/ClassVars
         @@write_block ||= proc do |wrapped_method, *args, &block|
           arg_copy = args.map do |arg|
-            enhance_hash_value(wrapped_method.receiver, arg)
+            enhance_value(wrapped_method.receiver, arg)
           end
           result = wrapped_method.call(*arg_copy, &block)
-          next enhance_hash_value(wrapped_method.receiver, result)
+          next enhance_value(wrapped_method.receiver, result)
         end
         @@read_block ||= proc do |wrapped_method, *args, &block|
           result = wrapped_method.call(*args, &block)
-          next enhance_hash_value(wrapped_method.receiver, result)
+          next enhance_value(wrapped_method.receiver, result)
         end
         # rubocop:enable Style/ClassVars
 
+        # Minimally: add the ancestor functions to classes
+        if base.is_a? Class
+          base.extend(ViralAncestorTypes)
+        end
+
         READ_METHODS.each do |method_name|
           wrap_method(base, method_name, raise_on_missing: false, &@@read_block)
         end
@@ -89,63 +126,192 @@ module Collapsium
         end
       end
 
+      ##
+      # Enhance Hash or Array value
+      def enhance_value(parent, value, *args)
+        if value.is_a? Hash
+          value = enhance_hash_value(parent, value, *args)
+        elsif value.is_a? Array
+          value = enhance_array_value(parent, value, *args)
+        end
+
+        # It's possible that the value is a Hash or an Array, but there's no
+        # ancestor from which capabilities can be copied. We can find out by
+        # checking whether any wrappers are defined for it.
+        needs_wrapping = true
+        READ_METHODS.each do |method_name|
+          wrappers = ::Collapsium::Support::Methods.wrappers(value, method_name)
+          # rubocop:disable Style/Next
+          if wrappers.include?(@@read_block)
+            # all done
+            needs_wrapping = false
+            break
+          end
+          # rubocop:enable Style/Next
+        end
+
+        # If we have a Hash or Array value that needs enhancing still, let's
+        # do that.
+        if needs_wrapping and (value.is_a? Array or value.is_a? Hash)
+          enhance(value)
+        end
+
+        return value
+      end
+
+      def enhance_array_value(parent, value, *args)
+        # If the value is not of the best ancestor type, make sure it becomes
+        # that type.
+        # XXX: DO NOT replace the loop with a simpler function - it could lead
+        #      to infinite recursion!
+        enc_class = array_ancestor(parent, value)
+        if value.class != enc_class
+          new_value = enc_class.new
+          value.each do |item|
+            if not item.is_a? Hash and not item.is_a? Array
+              new_value << item
+              next
+            end
+
+            new_item = enhance_value(value, item)
+            new_value << new_item
+          end
+          value = new_value
+        end
+
+        # Copy all modules from the parent to the value
+        copy_mods(parent, value)
+
+        # Set appropriate ancestors on the value
+        set_ancestors(parent, value)
+
+        return call_virality(parent, value, *args)
+      end
+
       ##
       # Given an outer Hash and a value, enhance Hash values so that they have
       # the same capabilities as the outer Hash. Non-Hash values are returned
       # unchanged.
-      def enhance_hash_value(outer_hash, value)
-        # If the value is not a Hash, we don't do anything.
-        if not value.is_a? Hash
-          return value
-        end
-
-        # If the value is a different type of Hash from ourself, we want to
-        # create an instance of our own type with the same values.
+      def enhance_hash_value(parent, value, *args)
+        # If the value is not of the best ancestor type, make sure it becomes
+        # that type.
         # XXX: DO NOT replace the loop with :merge! or :merge - those are
         #      potentially wrapped write functions, leading to an infinite
         #      recursion.
-        if value.class != outer_hash.class
-          new_value = outer_hash.class.new
+        enc_class = hash_ancestor(parent, value)
 
-          value.each do |key, inner_val|
-            if not inner_val.is_a? Hash
-              new_value[key] = inner_val
-              next
-            end
+        if value.class != enc_class
+          new_value = enc_class.new
 
-            if inner_val.class == outer_hash.class
-              new_value[key] = inner_val
+          value.each do |key, item|
+            if not item.is_a? Hash and not item.is_a? Array
+              new_value[key] = item
               next
             end
 
-            new_inner_value = outer_hash.class.new
-            new_inner_value.merge!(inner_val)
-            new_value[key] = new_inner_value
+            new_item = enhance_value(value, item)
+            new_value[key] = new_item
           end
           value = new_value
         end
 
-        # Next, we want to extend all the modules in self. That might be a
-        # no-op due to the above block, but not necessarily so.
-        value_mods = (class << value; self end).included_modules
-        own_mods = (class << outer_hash; self end).included_modules
-        (own_mods - value_mods).each do |mod|
-          value.extend(mod)
-        end
+        # Copy all modules from the parent to the value
+        copy_mods(parent, value)
 
         # If we have a default_proc and the value doesn't, we want to use our
         # own. This *can* override a perfectly fine default_proc with our own,
         # which might suck.
-        value.default_proc ||= outer_hash.default_proc
+        if parent.respond_to?(:default_proc)
+          # FIXME: need to inherit this for arrays, too?
+          value.default_proc ||= parent.default_proc
+        end
+
+        # Set appropriate ancestors on the value
+        set_ancestors(parent, value)
+
+        return call_virality(parent, value, *args)
+      end
+
+      def copy_mods(parent, value)
+        # We want to extend all the modules in self. That might be a
+        # no-op due to the above block, but not necessarily so.
+        value_mods = (class << value; self end).included_modules
+        parent_mods = (class << parent; self end).included_modules
+        parent_mods << ViralAncestorTypes
+        mods_to_copy = (parent_mods - value_mods).uniq
+
+        # Small fixup for JSON; this doesn't technically belong here, but let's
+        # play nice.
+        if value.is_a? Array
+          mods_to_copy.delete(::JSON::Ext::Generator::GeneratorMethods::Hash)
+        elsif value.is_a? Hash
+          mods_to_copy.delete(::JSON::Ext::Generator::GeneratorMethods::Array)
+        end
+
+        # Copy mods.
+        mods_to_copy.each do |mod|
+          value.extend(mod)
+        end
+      end
 
-        # Finally, the class can define its own virality function.
-        if outer_hash.respond_to?(:virality)
-          value = outer_hash.virality(value)
+      def call_virality(parent, value, *args)
+        # The parent class can define its own virality function.
+        if parent.respond_to?(:virality)
+          value = parent.virality(value, *args)
         end
 
         return value
       end
-    end
+
+      DEFAULT_ANCESTORS.each do |getter, default|
+        define_method(getter) do |parent, value|
+          # We value (haha) the value's stored ancestor over the parent's...
+          [value, parent].each do |receiver|
+            # rubocop:disable Lint/HandleExceptions
+            begin
+              klass = receiver.send(getter)
+              if klass != default
+                return klass
+              end
+            rescue NoMethodError
+            end
+            # rubocop:enable Lint/HandleExceptions
+          end
+
+          # ... but if neither yield satisfying results, we value the parent's
+          # class over the value's. This way parents can propagate their class.
+          [parent, value].each do |receiver|
+            if receiver.is_a? default
+              return receiver.class
+            end
+          end
+
+          # The default shouldn't really be reached, because it only applies
+          # if neither parent nor value are derived from default, and then
+          # this functions shouldn't even be called.
+          # :nocov:
+          return default
+          # :nocov:
+        end
+      end
+
+      def set_ancestors(parent, value)
+        DEFAULT_ANCESTORS.each do |getter, default|
+          setter = "#{getter}=".to_sym
+
+          ancestor = nil
+          if parent.is_a? default
+            ancestor = parent.class
+          elsif parent.respond_to?(getter)
+            ancestor = parent.send(getter)
+          else
+            ancestor = default
+          end
+
+          value.send(setter, ancestor)
+        end
+      end
+    end # class << self
 
   end # module ViralCapabilities
 end # module Collapsium