collapsium 0.3.0 → 0.4.0

data/lib/collapsium/recursive_dup.rb

@@ -7,16 +7,20 @@
 # All rights reserved.
 #
 
+require 'collapsium/viral_capabilities'
+
 module Collapsium
   ##
   # Provides recursive (deep) dup function for hashes.
   module RecursiveDup
+    # Clone Hash extensions for nested Hashes
+    extend ViralCapabilities
+
     def recursive_dup
       ret = map do |k, v|
         # Hash values, recurse into them.
         if v.is_a?(Hash)
-          n = v.dup # we duplicate v to not extend it.
-          n.extend(RecursiveDup)
+          n = ViralCapabilities.enhance_hash_value(self, v)
           next [k, n.recursive_dup]
         end
 
@@ -28,7 +32,8 @@ module Collapsium
           next [k, v]
         end
       end
-      return Hash[ret]
+      ret = Hash[ret]
+      return ViralCapabilities.enhance_hash_value(self, ret)
     end
 
     alias deep_dup recursive_dup

data/lib/collapsium/recursive_merge.rb

@@ -7,10 +7,16 @@
 # All rights reserved.
 #
 
+require 'collapsium/viral_capabilities'
+
 module Collapsium
   ##
   # Provides recursive merge functions for hashes.
   module RecursiveMerge
+
+    # Make the capabilities of classes using RecursiveMerge viral.
+    extend ViralCapabilities
+
     ##
     # Recursively merge `:other` into this Hash.
     #
@@ -31,7 +37,7 @@ module Collapsium
       merger = proc do |_, v1, v2|
         # rubocop:disable Style/GuardClause
         if v1.is_a? Hash and v2.is_a? Hash
-          next v1.merge(v2, &merger)
+          next v1.merge!(v2, &merger)
         elsif v1.is_a? Array and v2.is_a? Array
           next v1 + v2
         end
@@ -49,9 +55,7 @@ module Collapsium
     # Same as `dup.recursive_merge!`
     # @param (see #recursive_merge!)
     def recursive_merge(other, overwrite = true)
-      copy = dup
-      copy.extend(RecursiveMerge)
-      return copy.recursive_merge!(other, overwrite)
+      return dup.recursive_merge!(other, overwrite)
     end
   end # module RecursiveMerge
 end # module Collapsium

data/lib/collapsium/recursive_sort.rb

@@ -7,10 +7,16 @@
 # All rights reserved.
 #
 
+require 'collapsium/viral_capabilities'
+
 module Collapsium
   ##
   # Provides recursive sort functions for hashes.
   module RecursiveSort
+    # Virality means we don't have to rextend with RecursiveSort to sort
+    # nested values recursively.
+    extend ViralCapabilities
+
     ##
     # Recursively sort a Hash by its keys. Without a block, this function will
     # not be able to compare keys of different size.
@@ -22,7 +28,6 @@ module Collapsium
 
         # Recurse into Hash values
         if value.is_a?(Hash)
-          value.extend(RecursiveSort)
           value.recursive_sort!(&block)
         end
 
@@ -42,39 +47,7 @@ module Collapsium
       else
         ret = dup
       end
-      ret.extend(RecursiveSort)
       return ret.recursive_sort!(&block)
     end
-
-    #    def recursive_merge!(other, overwrite = true)
-    #      if other.nil?
-    #        return self
-    #      end
-    #
-    #      merger = proc do |_, v1, v2|
-    #        # rubocop:disable Style/GuardClause
-    #        if v1.is_a? Hash and v2.is_a? Hash
-    #          next v1.merge(v2, &merger)
-    #        elsif v1.is_a? Array and v2.is_a? Array
-    #          next v1 + v2
-    #        end
-    #        if overwrite
-    #          next v2
-    #        else
-    #          next v1
-    #        end
-    #        # rubocop:enable Style/GuardClause
-    #      end
-    #      merge!(other, &merger)
-    #    end
-    #
-    #    ##
-    #    # Same as `dup.recursive_merge!`
-    #    # @param (see #recursive_merge!)
-    #    def recursive_merge(other, overwrite = true)
-    #      copy = dup
-    #      copy.extend(RecursiveMerge)
-    #      return copy.recursive_merge!(other, overwrite)
-    #    end
   end # module RecursiveSort
 end # module Collapsium

data/lib/collapsium/support/hash_methods.rb

@@ -0,0 +1,48 @@
+# 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 which read and write functions we expect Hash to have.
+    module HashMethods
+
+      # @api private
+      # Read access methods with key parameter
+      KEYED_READ_METHODS = [
+        :[], :default, :fetch, :has_key?, :include?, :key?,
+      ].freeze
+
+      # @api private
+      # All read access methods
+      READ_METHODS = KEYED_READ_METHODS + [
+        :dup,
+      ].freeze
+
+      # @api private
+      # Write access methods with key parameter
+      KEYED_WRITE_METHODS = [
+        :[]=, :delete, :store,
+      ].freeze
+
+      # All write access methods
+      WRITE_METHODS = KEYED_WRITE_METHODS + [
+        :merge, :merge!,
+      ].freeze
+
+    end # module HashMethods
+
+  end # module Support
+
+end # module Collapsium

data/lib/collapsium/support/methods.rb

@@ -0,0 +1,88 @@
+# 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
+
+    ##
+    # Functionality for extending the behaviour of Hash methods
+    module Methods
+
+      ##
+      # Given the base module, wraps the given method name in the given block.
+      # The block must accept the super_method as the first parameter, followed
+      # by any arguments and blocks the super method might accept.
+      #
+      # The canonical usage example is of a module that when prepended wraps
+      # some methods with extra functionality:
+      #
+      # ```ruby
+      #   module MyModule
+      #     class << self
+      #       include ::Collapsium::Support::Methods
+      #
+      #       def prepended(base)
+      #         wrap_method(base, :method_to_wrap) do |super_method, *args, &block|
+      #           # modify args, if desired
+      #           result = super_method.call(*args, &block)
+      #           # do something with the result, if desired
+      #           next result
+      #         end
+      #       end
+      #     end
+      #   end
+      # ```
+      def wrap_method(base, method_name, raise_on_missing = true, &wrapper_block)
+        # The base class must define an instance method of method_name, otherwise
+        # this will NameError. That's also a good check that sensible things are
+        # being done.
+        base_method = nil
+        def_method = nil
+        if base.is_a? Module
+          # Modules *may* not be fully defined when this is called, so in some
+          # cases it's best to ignore NameErrors.
+          begin
+            base_method = base.instance_method(method_name.to_sym)
+          rescue NameError
+            if raise_on_missing
+              raise
+            end
+            return
+          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
+          # 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)
+        end
+
+        # Hack for calling the private method "define_method"
+        def_method.call(method_name) do |*args, &method_block|
+          # Prepend the old method to the argument list; but bind it to the current
+          # instance.
+          super_method = base_method.bind(self)
+          args.unshift(super_method)
+
+          # Then yield to the given wrapper block. The wrapper should decide
+          # whether to call the old method or not.
+          next wrapper_block.call(*args, &method_block)
+        end
+      end
+
+    end # module Methods
+
+  end # module Support
+
+end # module Collapsium

data/lib/collapsium/uber_hash.rb

@@ -13,17 +13,23 @@ require 'collapsium/recursive_sort'
 require 'collapsium/indifferent_access'
 require 'collapsium/pathed_access'
 require 'collapsium/prototype_match'
+require 'collapsium/viral_capabilities'
+
+require 'collapsium/support/hash_methods'
 
 module Collapsium
 
   # A Hash that includes all the different Hash extensions in collapsium
   class UberHash < Hash
+    include ViralCapabilities
     include RecursiveMerge
     include RecursiveDup
     include RecursiveSort
     include PathedAccess
     include PrototypeMatch
 
+    include Support::HashMethods
+
     def initialize(*args)
       super
 
@@ -35,7 +41,7 @@ module Collapsium
         return
       end
 
-      merge!(args[0])
+      recursive_merge!(args[0])
     end
   end
 

data/lib/collapsium/version.rb

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

data/lib/collapsium/viral_capabilities.rb

@@ -0,0 +1,151 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+require 'collapsium/support/hash_methods'
+require 'collapsium/support/methods'
+
+module Collapsium
+  ##
+  # Tries to make extended Hash capabilities viral, i.e. provides the same
+  # features to nested Hash structures as the Hash that includes this module.
+  #
+  # 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.
+  #
+  # 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
+
+    include ::Collapsium::Support::HashMethods
+    include ::Collapsium::Support::Methods
+
+    ##
+    # When prepended, included or extended, enhance the base.
+    def prepended(base)
+      ViralCapabilities.enhance(base)
+    end
+
+    def included(base)
+      ViralCapabilities.enhance(base)
+    end
+
+    def extended(base)
+      ViralCapabilities.enhance(base)
+    end
+
+    class << self
+      include ::Collapsium::Support::HashMethods
+      include ::Collapsium::Support::Methods
+
+      ##
+      # When prepended, included or extended, enhance the base.
+      def prepended(base)
+        enhance(base)
+      end
+
+      def included(base)
+        enhance(base)
+      end
+
+      def extended(base)
+        enhance(base)
+      end
+
+      ##
+      # Enhance the base by wrapping all READ_METHODS and WRITE_METHODS in
+      # a wrapper that uses enhance_hash_value to, well, enhance Hash results.
+      def enhance(base)
+        # rubocop:disable Style/ClassVars
+        @@write_block ||= proc do |super_method, *args, &block|
+          arg_copy = args.map do |arg|
+            enhance_hash_value(super_method.receiver, arg)
+          end
+          result = super_method.call(*arg_copy, &block)
+          next enhance_hash_value(super_method.receiver, result)
+        end
+        @@read_block ||= proc do |super_method, *args, &block|
+          result = super_method.call(*args, &block)
+          next enhance_hash_value(super_method.receiver, result)
+        end
+        # rubocop:enable Style/ClassVars
+
+        READ_METHODS.each do |method_name|
+          wrap_method(base, method_name, false, &@@read_block)
+        end
+
+        WRITE_METHODS.each do |method_name|
+          wrap_method(base, method_name, false, &@@write_block)
+        end
+      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.
+        # 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
+
+          value.each do |key, inner_val|
+            if not inner_val.is_a? Hash
+              new_value[key] = inner_val
+              next
+            end
+
+            if inner_val.class == outer_hash.class
+              new_value[key] = inner_val
+              next
+            end
+
+            new_inner_value = outer_hash.class.new
+            new_inner_value.merge!(inner_val)
+            new_value[key] = new_inner_value
+          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
+
+        # 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
+
+        # Finally, the class can define its own virality function.
+        if outer_hash.respond_to?(:virality)
+          value = outer_hash.virality(value)
+        end
+
+        return value
+      end
+    end
+
+  end # module ViralCapabilities
+end # module Collapsium