collapsium 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b85cef5b1becbc08cec24005e6e7c31b4e8156a
-  data.tar.gz: 1a25c135dcb2d7784dedcb04cdee7e6633e841eb
+  metadata.gz: c4eb75d59a4fd999a789ee4fb811263dea86b493
+  data.tar.gz: 15a3e7ff204d3268112e41a565d6d441d60db873
 SHA512:
-  metadata.gz: 2d54cd48ceef5cd706e662b40451f349595e88ecc7987ee54544110adff1a8493a11345e83d2ef659f825741029630d8d911b4be8325111ea28d7558fb2a7ad3
-  data.tar.gz: 24dc1841b56c2b5304d13a8977e1123aabfe196ec87f912bc4251c575ffdb9d7cfd17703a9b10d933b03a335111350ff4aa6d70099c93eeebc893d7cbb4631f2
+  metadata.gz: 31d5e290424e9e75eda116508351e2ae7ff3873ba977257140bf1112532278f4eae00590e9974b351d84afa89b1e1943d7ed4b4f74705c2ae54d6538b948b71f
+  data.tar.gz: 395b15971c754dea2eea60d7ebd601691f02214e7eeb97fa25281626b84cdaf6b4ecbb40585ebbfd8daa3914aa770f28856c81de8d7543a3e43ce15b8d4bc5a2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    collapsium (0.4.1)
+    collapsium (0.5.0)
 
 GEM
   remote: https://rubygems.org/
@@ -12,16 +12,16 @@ GEM
     diff-lcs (1.2.5)
     docile (1.1.5)
     json (2.0.2)
-    parser (2.3.1.2)
+    parser (2.3.1.4)
       ast (~> 2.2)
     powerpack (0.1.1)
     rainbow (2.1.0)
-    rake (11.2.2)
+    rake (11.3.0)
     rspec (3.5.0)
       rspec-core (~> 3.5.0)
       rspec-expectations (~> 3.5.0)
       rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.2)
+    rspec-core (3.5.4)
       rspec-support (~> 3.5.0)
     rspec-expectations (3.5.0)
       diff-lcs (>= 1.2.0, < 2.0)
@@ -30,7 +30,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.5.0)
     rspec-support (3.5.0)
-    rubocop (0.42.0)
+    rubocop (0.44.1)
       parser (>= 2.3.1.1, < 3.0)
       powerpack (~> 0.1)
       rainbow (>= 1.99.1, < 3.0)
@@ -42,7 +42,7 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
-    unicode-display_width (1.1.0)
+    unicode-display_width (1.1.1)
     yard (0.9.5)
 
 PLATFORMS
@@ -52,9 +52,9 @@ DEPENDENCIES
   bundler (~> 1.12)
   codeclimate-test-reporter
   collapsium!
-  rake (~> 11.2)
+  rake (~> 11.3)
   rspec (~> 3.5)
-  rubocop (~> 0.42)
+  rubocop (~> 0.44)
   simplecov (~> 0.12)
   yard (~> 0.9)
 

data/collapsium.gemspec

@@ -35,8 +35,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.0'
 
   spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rubocop", "~> 0.42"
-  spec.add_development_dependency "rake", "~> 11.2"
+  spec.add_development_dependency "rubocop", "~> 0.44"
+  spec.add_development_dependency "rake", "~> 11.3"
   spec.add_development_dependency "rspec", "~> 3.5"
   spec.add_development_dependency "simplecov", "~> 0.12"
   spec.add_development_dependency "yard", "~> 0.9"

data/lib/collapsium/environment_override.rb

@@ -39,6 +39,7 @@ module Collapsium
     # wrap accessor methods.
     class << self
       include ::Collapsium::Support::HashMethods
+      include ::Collapsium::Support::ArrayMethods
       include ::Collapsium::Support::Methods
 
       ##
@@ -62,6 +63,54 @@ module Collapsium
         # 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 = EnvironmentOverride.environment_variables_for_key(receiver, key)
+
+        # When we have the keys (in priority order), try to see if the
+        # environment yields something useful.
+        value = EnvironmentOverride.override_value(env_keys, receiver, key)
+
+        if not value.nil?
+          # We can't just return the value, because that doesn't respect the
+          # 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(wrapped_method.name)
+          next meth.call(*args, &block)
+        end
+
+        # Otherwise, fall back on the super method.
+        next wrapped_method.call(*args, &block)
+      end.freeze # proc
+
+      def included(base)
+        enhance(base)
+      end
+
+      def extended(base)
+        enhance(base)
+      end
+
+      def prepended(base)
+        enhance(base)
+      end
+
+      def enhance(base)
+        # Make the capabilities of classes using EnvironmentOverride viral.
+        base.extend(ViralCapabilities)
+
+        # Wrap read accessor functions to deal with paths
+        (INDEXED_READ_METHODS + KEYED_READ_METHODS).each do |method|
+          wrap_method(base, method, raise_on_missing: false, &ENV_ACCESS_READER)
+        end
+      end
+
+      def environment_variables_for_key(receiver, key)
         env_keys = []
         if receiver.respond_to?(:path_prefix)
 
@@ -92,14 +141,16 @@ module Collapsium
         else
           env_keys = [key.to_s]
         end
-        env_keys.map! { |k| receiver.key_to_env(k) }
+        env_keys.map! { |k| key_to_env(k) }
         env_keys.select! { |k| not k.empty? }
         env_keys.uniq!
 
-        # When we have the keys (in priority order), try to see if the
-        # environment yields something useful.
+        return env_keys
+      end
+
+      def override_value(variables, receiver, key)
         value = nil
-        env_keys.each do |env_key|
+        variables.each do |env_key|
           # Grab the environment value; skip if there's nothing there.
           env_value = ENV[env_key]
           if env_value.nil?
@@ -131,60 +182,22 @@ module Collapsium
           break
         end
 
-        if not value.nil?
-          # We can't just return the value, because that doesn't respect the
-          # 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(wrapped_method.name)
-          next meth.call(*args, &block)
-        end
-
-        # Otherwise, fall back on the super method.
-        next wrapped_method.call(*args, &block)
-      end.freeze # proc
-
-      def included(base)
-        enhance(base)
+        return value
       end
 
-      def extended(base)
-        enhance(base)
-      end
+      def key_to_env(key)
+        # First, convert to upper case
+        env_key = key.upcase
 
-      def prepended(base)
-        enhance(base)
-      end
+        # Next, replace non-alphanumeric characters to underscore. This also
+        # collapses them into a single undescore.
+        env_key.gsub!(/[^[:alnum:]]+/, '_')
 
-      def enhance(base)
-        # Make the capabilities of classes using EnvironmentOverride viral.
-        base.extend(ViralCapabilities)
+        # Strip leading and trailing underscores.
+        env_key.gsub!(/^_*(.*?)_*$/, '\1')
 
-        # Wrap read accessor functions to deal with paths
-        KEYED_READ_METHODS.each do |method|
-          wrap_method(base, method, &ENV_ACCESS_READER)
-        end
+        return env_key
       end
     end # class << self
-
-    def key_to_env(key)
-      # First, convert to upper case
-      env_key = key.upcase
-
-      # Next, replace non-alphanumeric characters to underscore. This also
-      # collapses them into a single undescore.
-      env_key.gsub!(/[^[:alnum:]]+/, '_')
-
-      # Strip leading and trailing underscores.
-      env_key.gsub!(/^_*(.*?)_*$/, '\1')
-
-      return env_key
-    end
   end # module EnvironmentOverride
 end # module Collapsium

data/lib/collapsium/pathed_access.rb

@@ -9,6 +9,7 @@
 
 require 'collapsium/support/hash_methods'
 require 'collapsium/support/methods'
+require 'collapsium/support/path_components'
 
 require 'collapsium/viral_capabilities'
 
@@ -27,40 +28,24 @@ module Collapsium
   # for a path.
   module PathedAccess
 
-    # @return [String] the separator is the character or pattern splitting paths.
-    def separator
-      @separator ||= DEFAULT_SEPARATOR
-      return @separator
-    end
-
-    ##
-    # Assume any pathed access has this prefix.
-    def path_prefix=(value)
-      @path_prefix = normalize_path(value)
-    end
-
-    def path_prefix
-      @path_prefix ||= ''
-      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
+    include ::Collapsium::Support::PathComponents
 
     ##
     # If the module is included, extended or prepended in a class, it'll
     # wrap accessor methods.
     class << self
-      include ::Collapsium::Support::HashMethods
       include ::Collapsium::Support::Methods
 
+      # We want to wrap methods for Arrays and Hashes alike
+      READ_METHODS = (
+        ::Collapsium::Support::HashMethods::KEYED_READ_METHODS \
+        + ::Collapsium::Support::ArrayMethods::INDEXED_READ_METHODS
+      ).uniq.freeze
+      WRITE_METHODS = (
+        ::Collapsium::Support::HashMethods::KEYED_WRITE_METHODS \
+        + ::Collapsium::Support::ArrayMethods::INDEXED_WRITE_METHODS
+      ).uniq.freeze
+
       ##
       # Returns a proc for either read or write access. Procs for write
       # access will create intermediary hashes when e.g. setting a value for
@@ -90,18 +75,10 @@ module Collapsium
           # Try to find the leaf, based on the given components.
           leaf = recursive_fetch(components, receiver, [], create: write_access)
 
-          # The tricky part is what to do with the leaf.
-          meth = nil
-          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
-            #    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(wrapped_method.name)
-          end
+          # Since Methods already contains loop prevention and we may want to
+          # call wrapped methods, let's just find the method to call from the
+          # leaf by name.
+          meth = leaf.method(wrapped_method.name)
 
           # If the first argument was a symbol key, we want to use it verbatim.
           # Otherwise we had pathed access, and only want to pass the last
@@ -112,8 +89,21 @@ module Collapsium
             the_args[0] = components.last
           end
 
+          # Array methods we're modifying here are indexed, so the first argument
+          # must be an integer. Let's make it so :)
+          if leaf.is_a? Array
+            the_args[0] = the_args[0].to_i
+          end
+
           # Then we can continue with that method.
-          next meth.call(*the_args, &block)
+          result = meth.call(*the_args, &block)
+
+          # Sadly, we can't just return the result and be done with it.
+          # We need to tell the virality function (below) what we know about the
+          # result's path prefix, so we enhance the result value explicitly here.
+          result_path = receiver.path_components(receiver.path_prefix)
+          result_path += components
+          next ViralCapabilities.enhance_value(leaf, result, result_path)
         end # proc
       end # create_proc
 
@@ -138,11 +128,11 @@ module Collapsium
         base.extend(ViralCapabilities)
 
         # Wrap all accessor functions to deal with paths
-        KEYED_READ_METHODS.each do |method|
-          wrap_method(base, method, &PATHED_ACCESS_READER)
+        READ_METHODS.each do |method|
+          wrap_method(base, method, raise_on_missing: false, &PATHED_ACCESS_READER)
         end
-        KEYED_WRITE_METHODS.each do |method|
-          wrap_method(base, method, &PATHED_ACCESS_WRITER)
+        WRITE_METHODS.each do |method|
+          wrap_method(base, method, raise_on_missing: false, &PATHED_ACCESS_WRITER)
         end
       end
 
@@ -155,14 +145,6 @@ module Collapsium
         current_path << head
         tail = path.slice(1, path.length)
 
-        # We know that the data has the current path. We also know that thanks to
-        # virality, data will respond to :path_prefix. So we might as well set the
-        # path, as long as it is more specific than what was previously there.
-        current_normalized = data.normalize_path(current_path)
-        if current_normalized.length > data.path_prefix.length
-          data.path_prefix = current_normalized
-        end
-
         # For the leaf element, we do nothing because that's where we want to
         # dispatch to.
         if path.length == 1
@@ -189,46 +171,29 @@ module Collapsium
     end # class << self
 
     ##
-    # 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
+    # Ensure that all values have their path_prefix set.
+    def virality(value, *args)
+      # Figure out what path prefix to set on the value, if any.
+      # Candidates for the prefix are:
+      explicit = args[0] || []
+      from_self = path_components(path_prefix)
+      from_value = path_components(value.path_prefix)
+
+      prefix = []
+      if not explicit.empty?
+        # If we got explicit information, we most likely want to use that.
+        prefix = explicit
+      elsif not from_self.empty?
+        # If we got information from self, that's the next best candidate.
+        prefix = from_self
+      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)
+      # However, if the value already has a better path prefix than either
+      # of the above, we want to keep that.
+      if prefix.length > from_value.length
+        value.path_prefix = normalize_path(prefix)
       end
-      return separator + join_path(components)
-    end
 
-    ##
-    # Ensure that all values have their path_prefix set.
-    def virality(value)
-      # If a value was set via a nested Hash, it may not have got its
-      # path_prefix set during storing (i.e. x[key] = { nested: some_hash }
-      # In that case, we do always know that the value's path prefix is the same
-      # as the receiver.
-      value.path_prefix = path_prefix
       return value
     end
 

data/lib/collapsium/support/array_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 Array to have.
+    module ArrayMethods
+
+      # @api private
+      # Read access methods with index parameter
+      INDEXED_READ_METHODS = [
+        :[], :at, :fetch, :include?,
+      ].freeze
+
+      # @api private
+      # All read access methods
+      READ_METHODS = INDEXED_READ_METHODS + [
+        :dup, :first, :last, :take, :drop,
+      ].freeze
+
+      # @api private
+      # Write access methods with index parameter
+      INDEXED_WRITE_METHODS = [
+        :[]=, :insert, :compact,
+      ].freeze
+
+      # All write access methods
+      WRITE_METHODS = INDEXED_WRITE_METHODS + [
+        :unshift, :pop, :shift,
+      ].freeze
+
+    end # module ArrayMethods
+
+  end # module Support
+
+end # module Collapsium