collapsium 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0565523a24719d83a3a81ec99005231cb86155df
-  data.tar.gz: eb817e05d8dec93788ecc51337579315a6719c70
+  metadata.gz: 1b85cef5b1becbc08cec24005e6e7c31b4e8156a
+  data.tar.gz: 1a25c135dcb2d7784dedcb04cdee7e6633e841eb
 SHA512:
-  metadata.gz: c3e20a3f37be0496fd1ac6c6f653e845aaf57d7dd8b149347bddef882ac2ddf7b414b656370e65c49070fb8a638c4beb9ba139fc18bd485765f7fe695ea738da
-  data.tar.gz: 45ed48ecbc31111ac87689f7ffc84cdb5769d6a19bde8368e6cf5e0f60902af1c1753894d011f059b286e989db398f50e65984b8cd336e132a9a09b4b0197ca3
+  metadata.gz: 2d54cd48ceef5cd706e662b40451f349595e88ecc7987ee54544110adff1a8493a11345e83d2ef659f825741029630d8d911b4be8325111ea28d7558fb2a7ad3
+  data.tar.gz: 24dc1841b56c2b5304d13a8977e1123aabfe196ec87f912bc4251c575ffdb9d7cfd17703a9b10d933b03a335111350ff4aa6d70099c93eeebc893d7cbb4631f2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    collapsium (0.4.0)
+    collapsium (0.4.1)
 
 GEM
   remote: https://rubygems.org/

data/lib/collapsium/environment_override.rb

@@ -10,6 +10,7 @@
 require 'collapsium/support/hash_methods'
 require 'collapsium/support/methods'
 
+require 'collapsium/recursive_dup'
 require 'collapsium/viral_capabilities'
 
 module Collapsium
@@ -27,8 +28,12 @@ module Collapsium
   # For example, the key "some!@email.org" will become "SOME_EMAIL_ORG".
   #
   # If PathedAccess is also used, the :path_prefix of nested hashes will
-  # be consulted after converting it in the same manner.
+  # be consulted after converting it in the same manner. NOTE:
+  # include EnvironmentOverride *after* PathedAccess for both to work well
+  # together.
   module EnvironmentOverride
+    include ::Collapsium::RecursiveDup
+
     ##
     # If the module is included, extended or prepended in a class, it'll
     # wrap accessor methods.
@@ -38,33 +43,54 @@ module Collapsium
 
       ##
       # Returns a proc read access.
-      ENV_ACCESS_READER = proc do |super_method, *args, &block|
+      ENV_ACCESS_READER = proc do |wrapped_method, *args, &block|
         # If there are no arguments, there's nothing to do with paths. Just
         # delegate to the hash.
         if args.empty?
-          next super_method.call(*args, &block)
+          next wrapped_method.call(*args, &block)
         end
 
-        # The method's receiver is encapsulated in the super_method; we'll
+        # The method's receiver is encapsulated in the wrapped_method; we'll
         # use it a few times so let's reduce typing. This is essentially the
         # equivalent of `self`.
-        receiver = super_method.receiver
+        receiver = wrapped_method.receiver
 
         # All KEYED_READ_METHODS have a key as the first argument.
         key = args[0]
 
-        # Grab matching environment variable names. We consider first a pathed
-        # name, if pathed access is supported, followed by the unpathed name.
-        env_keys = [key.to_s]
-        if receiver.respond_to?(:path_prefix) and not
-            (receiver.path_prefix.nil? or receiver.path_prefix.empty?)
-          prefix_components = receiver.path_components(receiver.path_prefix)
-
-          if prefix_components.last == key
-            env_keys.unshift(receiver.path_prefix)
-          else
-            env_keys.unshift(receiver.path_prefix + receiver.separator + key.to_s)
+        # Grab matching environment variable names. If PathedAccess is
+        # supported, we'll try environment variables of the path, starting
+        # with the full qualified path and ending with just the last key
+        # component.
+        env_keys = []
+        if receiver.respond_to?(:path_prefix)
+
+          # If we have a prefix, use it.
+          components = []
+          if not receiver.path_prefix.nil?
+            components += receiver.path_components(receiver.path_prefix)
+          end
+
+          # The key has its own components. If the key components and prefix
+          # components overlap (it happens), ignore the duplication.
+          key_comps = receiver.path_components(key.to_s)
+          if key_comps.first == components.last
+            components.pop
+          end
+          components += key_comps
+
+          # Start with most qualified, shifting off the first component
+          # until we reach just the last component.
+          loop do
+            path = receiver.normalize_path(components)
+            env_keys << path
+            components.shift
+            if components.empty?
+              break
+            end
           end
+        else
+          env_keys = [key.to_s]
         end
         env_keys.map! { |k| receiver.key_to_env(k) }
         env_keys.select! { |k| not k.empty? }
@@ -84,47 +110,44 @@ module Collapsium
           # the parsed result. Otherwise use it as a string.
           require 'json'
           # rubocop:disable Lint/HandleExceptions
+          parsed = env_value
           begin
-            env_value = JSON.parse(env_value)
+            parsed = JSON.parse(env_value)
           rescue JSON::ParserError
             # Do nothing. We just use the env_value verbatim.
           end
           # rubocop:enable Lint/HandleExceptions
 
-          # For the given key, retrieve the current value. We'll need it later.
-          # Note that we deliberately do not use any of KEYED_READ_METHODS,
-          # because that would recurse infinitely.
-          old_value = nil
-          receiver.each do |k, v|
-            if k == key
-              old_value = v
-              break
-            end
-          end
+          # Excellent, we've got an environment variable. Only use it if it
+          # changes something, though. We'll temporarily unset the environment
+          # variable while fetching the old value.
+          ENV.delete(env_key)
+          old_value = receiver[key]
+          ENV[env_key] = env_value # not the parsed value!
 
-          # Note that we re-assign the value only if it's changed, but we
-          # break either way. If env_value exists, it must be used, but
-          # changing it always will lead to an infinite recursion.
-          # The double's super_method will never be called, but rather
-          # always this wrapper.
-          if env_value != old_value
-            value = env_value
+          if parsed != old_value
+            value = parsed
           end
           break
         end
+
         if not value.nil?
           # We can't just return the value, because that doesn't respect the
-          # method being called. We can deal with this by duplicating the
-          # receiver, writing the value we found into the appropriate key,
-          # and then sending the super_method to the duplicate.
-          double = receiver.dup
+          # method being called. We also can't store the value, because that
+          # would not reset the Hash after the environment variable was
+          # cleared.
+          #
+          # We can deal with this by duplicating the receiver, writing the value
+          # we found into the appropriate key, and then sending the
+          # wrapped_method to the duplicate.
+          double = receiver.recursive_dup
           double[key] = value
-          meth = double.method(super_method.name)
+          meth = double.method(wrapped_method.name)
           next meth.call(*args, &block)
         end
 
         # Otherwise, fall back on the super method.
-        next super_method.call(*args, &block)
+        next wrapped_method.call(*args, &block)
       end.freeze # proc
 
       def included(base)
@@ -140,7 +163,7 @@ module Collapsium
       end
 
       def enhance(base)
-        # Make the capabilities of classes using PathedAccess viral.
+        # Make the capabilities of classes using EnvironmentOverride viral.
         base.extend(ViralCapabilities)
 
         # Wrap read accessor functions to deal with paths

data/lib/collapsium/pathed_access.rb

@@ -66,17 +66,17 @@ module Collapsium
       # access will create intermediary hashes when e.g. setting a value for
       # `foo.bar.baz`, and the `bar` Hash doesn't exist yet.
       def create_proc(write_access)
-        return proc do |super_method, *args, &block|
+        return proc do |wrapped_method, *args, &block|
           # If there are no arguments, there's nothing to do with paths. Just
           # delegate to the hash.
           if args.empty?
-            next super_method.call(*args, &block)
+            next wrapped_method.call(*args, &block)
           end
 
-          # The method's receiver is encapsulated in the super_method; we'll
+          # The method's receiver is encapsulated in the wrapped_method; we'll
           # use it a few times so let's reduce typing. This is essentially the
           # equivalent of `self`.
-          receiver = super_method.receiver
+          receiver = wrapped_method.receiver
 
           # With any of the dispatch methods, we know that the first argument has
           # to be a key. We'll try to split it by the path separator.
@@ -95,12 +95,12 @@ module Collapsium
           if receiver.object_id == leaf.object_id
             # a) if the leaf and the receiver are identical, then the receiver
             #    itself was requested, and we really just need to delegate to its
-            #    super_method.
-            meth = super_method
+            #    wrapped_method.
+            meth = wrapped_method
           else
             # b) if the leaf is different from the receiver, we want to delegate
             #    to the leaf.
-            meth = leaf.method(super_method.name)
+            meth = leaf.method(wrapped_method.name)
           end
 
           # If the first argument was a symbol key, we want to use it verbatim.

data/lib/collapsium/support/methods.rb

@@ -16,10 +16,9 @@ module Collapsium
     ##
     # 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
+      # The block must accept the wrapped_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
@@ -31,9 +30,9 @@ module Collapsium
       #       include ::Collapsium::Support::Methods
       #
       #       def prepended(base)
-      #         wrap_method(base, :method_to_wrap) do |super_method, *args, &block|
+      #         wrap_method(base, :method_name) do |wrapped_method, *args, &block|
       #           # modify args, if desired
-      #           result = super_method.call(*args, &block)
+      #           result = wrapped_method.call(*args, &block)
       #           # do something with the result, if desired
       #           next result
       #         end
@@ -41,7 +40,59 @@ module Collapsium
       #     end
       #   end
       # ```
-      def wrap_method(base, method_name, raise_on_missing = true, &wrapper_block)
+      def wrap_method(base, method_name, options = {}, &wrapper_block)
+        # Option defaults (need to check for nil if we default to true)
+        if options[:raise_on_missing].nil?
+          options[:raise_on_missing] = true
+        end
+
+        # Grab helper methods
+        base_method, def_method = resolve_helpers(base, method_name,
+                                                  options[:raise_on_missing])
+        if base_method.nil?
+          # Indicates that we're not done building a Module yet
+          return
+        end
+
+        # Hack for calling the private method "define_method"
+        def_method.call(method_name) do |*args, &method_block|
+          # We're trying to prevent loops by maintaining a stack of wrapped
+          # method invocations.
+          @__collapsium_methods_callstack ||= []
+
+          # 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))
+          the_binding = [wrapper_block.object_id, self.class.object_id, signature]
+
+          # We'll either pass the wrapped method to the wrapper block, or invoke
+          # it ourselves.
+          wrapped_method = base_method.bind(self)
+
+          # If we do find a loop with the current binding involved, we'll just
+          # call the wrapped method.
+          if Methods.loop_detected?(the_binding, @__collapsium_methods_callstack)
+            next wrapped_method.call(*args, &method_block)
+          end
+
+          # If there is no loop, call the wrapper block and pass along the
+          # wrapped method as the first argument.
+          args.unshift(wrapped_method)
+
+          # Then yield to the given wrapper block. The wrapper should decide
+          # whether to call the old method or not. But by modifying our stack
+          # before/after the invocation, we allow the loop detection above to
+          # work.
+          @__collapsium_methods_callstack << the_binding
+          result = wrapper_block.call(*args, &method_block)
+          @__collapsium_methods_callstack.pop
+
+          next result
+        end
+      end
+
+      def resolve_helpers(base, method_name, raise_on_missing)
         # 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.
@@ -56,7 +107,7 @@ module Collapsium
             if raise_on_missing
               raise
             end
-            return
+            return base_method, def_method
           end
           def_method = base.method(:define_method)
         else
@@ -68,18 +119,31 @@ module Collapsium
           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)
+        return base_method, def_method
+      end
 
-          # 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)
+      class << self
+        # Given an input array, return repeated sequences from the array. It's
+        # used in loop detection.
+        def repeated(array)
+          counts = Hash.new(0)
+          array.each { |val| counts[val] += 1 }
+          return counts.reject { |_, count| count == 1 }.keys
         end
-      end
+
+        # Given a call stack and a binding, returns true if there seems to be a
+        # loop in the call stack with the binding causing it, false otherwise.
+        def loop_detected?(the_binding, stack)
+          # Make a temporary stack with the binding pushed
+          tmp_stack = stack.dup
+          tmp_stack << the_binding
+          loops = Methods.repeated(tmp_stack)
+
+          # If we do find a loop with the current binding involved, we'll just
+          # call the wrapped method.
+          return loops.include?(the_binding)
+        end
+      end # class << self
 
     end # module Methods
 

data/lib/collapsium/version.rb

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

data/lib/collapsium/viral_capabilities.rb

@@ -67,25 +67,25 @@ module Collapsium
       # 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|
+        @@write_block ||= proc do |wrapped_method, *args, &block|
           arg_copy = args.map do |arg|
-            enhance_hash_value(super_method.receiver, arg)
+            enhance_hash_value(wrapped_method.receiver, arg)
           end
-          result = super_method.call(*arg_copy, &block)
-          next enhance_hash_value(super_method.receiver, result)
+          result = wrapped_method.call(*arg_copy, &block)
+          next enhance_hash_value(wrapped_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)
+        @@read_block ||= proc do |wrapped_method, *args, &block|
+          result = wrapped_method.call(*args, &block)
+          next enhance_hash_value(wrapped_method.receiver, result)
         end
         # rubocop:enable Style/ClassVars
 
         READ_METHODS.each do |method_name|
-          wrap_method(base, method_name, false, &@@read_block)
+          wrap_method(base, method_name, raise_on_missing: false, &@@read_block)
         end
 
         WRITE_METHODS.each do |method_name|
-          wrap_method(base, method_name, false, &@@write_block)
+          wrap_method(base, method_name, raise_on_missing: false, &@@write_block)
         end
       end
 

data/spec/environment_override_spec.rb

@@ -37,7 +37,7 @@ describe ::Collapsium::EnvironmentOverride do
     end
   end
 
-  context "without pathed access" do
+  context "without PathedAccess" do
     it "overrides first-order keys" do
       expect(@tester["foo"].is_a?(Hash)).to be_truthy
       ENV["FOO"] = "test"
@@ -56,16 +56,30 @@ describe ::Collapsium::EnvironmentOverride do
       @tester.store("foo", 42)
       expect(@tester["foo"]).to eql 42
     end
+
+    it "changes with every env change" do
+      ENV["BAR"] = "test1"
+      expect(@tester["foo"]["bar"]).to eql "test1"
+      ENV["BAR"] = "test2"
+      expect(@tester["foo"]["bar"]).to eql "test2"
+    end
+
+    it "resets when the env resets" do
+      ENV["BAR"] = "test"
+      expect(@tester["foo"]["bar"]).to eql "test"
+      ENV.delete("BAR")
+      expect(@tester["foo"]["bar"]).to eql 42
+    end
   end
 
-  context "with pathed access" do
+  context "with PathedAccess" do
     before :each do
       @tester = { "foo" => { "bar" => 42 } }
-      @tester.extend(::Collapsium::EnvironmentOverride)
       @tester.extend(::Collapsium::PathedAccess)
-      ENV["FOO"] = nil
-      ENV["BAR"] = nil
-      ENV["FOO_BAR"] = nil
+      @tester.extend(::Collapsium::EnvironmentOverride)
+      ENV.delete("FOO")
+      ENV.delete("BAR")
+      ENV.delete("FOO_BAR")
     end
 
     it "overrides first-order keys" do
@@ -76,10 +90,10 @@ describe ::Collapsium::EnvironmentOverride do
     end
 
     it "inherits environment override" do
-      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_truthy
+      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_truthy
       ENV["BAR"] = "test"
-      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_falsy
-      expect(@tester["foo"]["bar"]).to eql "test"
+      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo.bar"]).to eql "test"
     end
 
     it "write still works" do
@@ -87,6 +101,20 @@ describe ::Collapsium::EnvironmentOverride do
       expect(@tester["foo"]).to eql 42
     end
 
+    it "changes with every env change" do
+      ENV["BAR"] = "test1"
+      expect(@tester["foo.bar"]).to eql "test1"
+      ENV["BAR"] = "test2"
+      expect(@tester["foo.bar"]).to eql "test2"
+    end
+
+    it "resets when the env resets" do
+      ENV["BAR"] = "test"
+      expect(@tester["foo.bar"]).to eql "test"
+      ENV.delete("BAR")
+      expect(@tester["foo.bar"]).to eql 42
+    end
+
     it "overrides from pathed key" do
       expect(@tester["foo.bar"].is_a?(Fixnum)).to be_truthy
       ENV["FOO_BAR"] = "test"
@@ -144,11 +172,22 @@ describe ::Collapsium::EnvironmentOverride do
       expect(@tester["foo"].is_a?(Hash)).to be_truthy
       expect(@tester["foo"]["json_key"]).to eql "json_value"
     end
+
+    it "respects PathedAccess" do
+      @tester = { "foo" => { "bar" => 42 } }
+      @tester.extend(::Collapsium::PathedAccess)
+      @tester.extend(::Collapsium::EnvironmentOverride)
+
+      ENV["FOO_BAR"] = '{ "json_key": "json_value" }'
+      expect(@tester["foo.bar"].is_a?(Hash)).to be_truthy
+      expect(@tester["foo.bar"]["json_key"]).to eql "json_value"
+      expect(@tester["foo"]["bar.json_key"]).to eql "json_value"
+    end
   end
 
   context "coverage" do
     it "raises when not passing arguments" do
-      expect { @tester.fetch }.to raise_error
+      expect { @tester.fetch }.to raise_error(ArgumentError)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: collapsium
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Jens Finkhaeuser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-17 00:00:00.000000000 Z
+date: 2016-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler