collapsium 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63b5ae2bec3820d536814099c538f53f32ce3d14
-  data.tar.gz: d18f3d4bd528f98cf7b92a31a94da97211efb5d2
+  metadata.gz: a0237b4fe627fff71b5c02f5e3f77f9d9713e849
+  data.tar.gz: fd48fd69e118edfba70a91ee7920495008a140ad
 SHA512:
-  metadata.gz: 1bc5ee36f8b47a7a7e1acffa6d80ef1d4dc400e4459418542e7dfaf99fed4d9fb76493ade6e37f5b50faecaad99a6c641ec7f6f78ece791f225269750ba4e16a
-  data.tar.gz: 7c5dc2d3f39681cfb909bc4259ca577707c90884e8bd3a80819ad5b84e79689d57fb1850856b25cf7bc18245a350f24b1037d324ce13e3ea63a090fbef848088
+  metadata.gz: 69e87ad355d708944ef6bda61139a63028a666cf9165b2438c2b47da3edc92fdaa4b581435528ef31754b09cd265e2908dc3205c049e9ea1424b4d7b93536cfe
+  data.tar.gz: f85612ff08aeaf56ca7699a68ef171709905aa838eabf26c7196002b95529cb79eeff998a5a546a70cf46d64485842cc913449e4d073a51e441ba1d50102dec2

data/.travis.yml

@@ -3,6 +3,9 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
+script:
+  - bundle exec rake
+  - bundle exec codeclimate-test-reporter
 addons:
   code_climate:
     repo_token: 56724b4322c0a98f681db40ccfa92d1a9fd4755a18daf82683f95fcaa058499d

data/Gemfile.lock

@@ -1,18 +1,18 @@
 PATH
   remote: .
   specs:
-    collapsium (0.6.1)
+    collapsium (0.7.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.3.0)
-    codeclimate-test-reporter (0.6.0)
-      simplecov (>= 0.7.1, < 1.0.0)
+    codeclimate-test-reporter (1.0.3)
+      simplecov
     diff-lcs (1.2.5)
     docile (1.1.5)
     json (2.0.2)
-    parser (2.3.1.4)
+    parser (2.3.2.0)
       ast (~> 2.2)
     powerpack (0.1.1)
     rainbow (2.1.0)

data/lib/collapsium/indifferent_access.rb

@@ -7,6 +7,11 @@
 # All rights reserved.
 #
 
+require 'collapsium/support/hash_methods'
+require 'collapsium/support/methods'
+
+require 'collapsium/viral_capabilities'
+
 module Collapsium
 
   ##
@@ -16,18 +21,111 @@ module Collapsium
   module IndifferentAccess
 
     ##
-    # Set your Hash's #default_proc to DEFAULT_PROC, and you've got indifferent
-    # access.
-    DEFAULT_PROC = proc do |hash, key|
-      case key
-      when String
-        sym = key.to_sym
-        hash[sym] if hash.key?(sym)
-      when Symbol
-        str = key.to_s
-        hash[str] if hash.key?(str)
+    # If the module is included, extended or prepended in a class, it'll
+    # wrap accessor methods.
+    class << self
+      include ::Collapsium::Support::Methods
+
+      ##
+      # Given a key, returns all indifferent permutations to try.
+      def key_permutations(key)
+        tries = [key]
+        if key.is_a? Symbol
+          key_s = key.to_s
+          tries << key_s
+          if key_s =~ /^[0-9]/
+            tries << key_s.to_i
+          end
+        elsif key.is_a? String
+          tries << key.to_sym
+          if key =~ /^[0-9]/
+            tries << key.to_i
+          end
+        elsif key.is_a? Integer
+          tries += [key.to_s, key.to_s.to_sym]
+        end
+
+        return tries
+      end
+
+      ##
+      # Make the given keys unique according to the logic of this module.
+      def unique_keys(keys)
+        # The simplest way is to stringify all keys before making them
+        # unique. That works for Integer as well as Symbol.
+        return keys.map(&:to_s).uniq
+      end
+
+      ##
+      # Sort the given keys indifferently. This will sort Integers first,
+      # Symbols second and Strings third. Everything else comes last. This
+      # is done because that's the order in which comparsion time increases.
+      def sorted_keys(keys, &block)
+        # Sorting sucks because we can't compare Strings and Symbols. So in
+        # order to get this right, we'll have to sort each type individually,
+        # then concatenate the results.
+        sorted = []
+        [Integer, Symbol, String].each do |klass|
+          sorted += keys.select { |key| key.is_a?(klass) }.sort(&block)
+        end
+        return sorted
+      end
+
+      READ_METHODS = ::Collapsium::Support::HashMethods::KEYED_READ_METHODS.freeze
+
+      INDIFFERENT_ACCESS_READER = proc do |wrapped_method, *args, &block|
+        # Bail out early if the receiver is not a Hash. Do the same if we have
+        # no key.
+        receiver = wrapped_method.receiver
+        if not receiver.is_a? Hash or args.empty?
+          next wrapped_method.call(*args, &block)
+        end
+
+        # Definitely try the key as given first. Then, depending on the key's
+        # type and value, we want to try it as a Symbol, String and/or Integer
+        key = args.shift
+        tries = IndifferentAccess.key_permutations(key)
+
+        # With the variations to try assembled, go through them one by one
+        result = nil
+        tries.each do |try|
+          if receiver.keys.include?(try)
+            result = wrapped_method.call(try, *args, &block)
+            break
+          end
+        end
+
+        # If any of the above yielded a result, great, return that. Otherwise
+        # yield to the default implementation (i.e. wrapped_method).
+        if not result.nil?
+          next result
+        end
+        next wrapped_method.call(key, *args, &block)
+      end.freeze
+
+      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 IndifferentAccess viral.
+        base.extend(ViralCapabilities)
+
+        # Wrap all accessor functions to deal with paths
+        READ_METHODS.each do |method|
+          wrap_method(base, method, raise_on_missing: false,
+                      &INDIFFERENT_ACCESS_READER)
+        end
       end
-    end.freeze
+    end # class << self
 
   end # module IndifferentAccess
 

data/lib/collapsium/pathed_access.rb

@@ -84,7 +84,7 @@ module Collapsium
           # Otherwise we had pathed access, and only want to pass the last
           # component to whatever method we're calling.
           the_args = args
-          if not args[0].is_a?(Symbol)
+          if not args[0].is_a?(Symbol) and args[0] != components.last
             the_args = args.dup
             the_args[0] = components.last
           end
@@ -92,7 +92,8 @@ module Collapsium
           # 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 and the_args[0][0] =~ /[0-9]/
-            the_args[0] = the_args[0].to_i
+            the_args = the_args.dup
+            the_args[0] = the_args[0].to_s.to_i
           end
 
           # Then we can continue with that method.

data/lib/collapsium/recursive_merge.rb

@@ -34,21 +34,11 @@ module Collapsium
         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)
+      # We can't call merge! because that will only be invoked for keys that
+      # are missing, and default_proc doesn't seem to be used there. So we need
+      # to call a custom merge function.
+      new_self = RecursiveMerge.merger(self, self, other, overwrite)
+      replace(new_self)
     end
 
     ##
@@ -57,5 +47,46 @@ module Collapsium
     def recursive_merge(other, overwrite = true)
       return dup.recursive_merge!(other, overwrite)
     end
+
+    class << self
+      def merger(the_self, v1, v2, overwrite)
+        if v1.is_a? Hash and v2.is_a? Hash
+          v1 = ViralCapabilities.enhance_value(the_self, v1)
+          v2 = ViralCapabilities.enhance_value(the_self, v2)
+
+          # IndifferentAccess has its own idea of which keys are unique, so if
+          # we use it, we must consult it.
+          keys = (v1.keys + v2.keys).uniq
+          if the_self.singleton_class.ancestors.include?(IndifferentAccess)
+            keys = IndifferentAccess.unique_keys(keys)
+          end
+          new_val = ViralCapabilities.enhance_value(the_self, {})
+          keys.each do |key|
+            v1_inner = v1[key]
+            v2_inner = v2[key]
+            if not v1_inner.nil? and not v2_inner.nil?
+              new_val[key] = RecursiveMerge.merger(the_self, v1_inner, v2_inner,
+                                                   overwrite)
+            elsif not v1_inner.nil?
+              # Nothing to do, we have v1[key]
+              new_val[key] = v1_inner
+            else
+              # v2.key?(key) is true
+              new_val[key] = v2_inner
+            end
+          end
+
+          v1.replace(new_val)
+          return v1
+        elsif v1.is_a? Array and v2.is_a? Array
+          return v1 + v2
+        end
+
+        if overwrite
+          return v2
+        end
+        return v1
+      end
+    end # class << self
   end # module RecursiveMerge
 end # module Collapsium

data/lib/collapsium/recursive_sort.rb

@@ -8,6 +8,7 @@
 #
 
 require 'collapsium/viral_capabilities'
+require 'collapsium/indifferent_access'
 
 module Collapsium
   ##
@@ -21,7 +22,15 @@ module Collapsium
     # Recursively sort a Hash by its keys. Without a block, this function will
     # not be able to compare keys of different size.
     def recursive_sort!(&block)
-      return keys.sort(&block).reduce(self) do |seed, key|
+      # If we have IndifferentAccess, we need to sort keys appropriately.
+      the_keys = nil
+      if singleton_class.ancestors.include?(IndifferentAccess)
+        the_keys = IndifferentAccess.sorted_keys(keys, &block)
+      else
+        the_keys = keys.sort(&block)
+      end
+
+      return the_keys.reduce(self) do |seed, key|
         # Delete (and later re-insert) value for ordering
         value = self[key]
         delete(key)

data/lib/collapsium/support/methods.rb

@@ -7,6 +7,8 @@
 # All rights reserved.
 #
 
+require 'zlib'
+
 module Collapsium
 
   ##
@@ -18,6 +20,53 @@ module Collapsium
     module Methods
       WRAPPER_HASH = "@__collapsium_methods_wrappers".freeze
 
+      # Try to determine built-in Classes and Modules early on, so we
+      # can ignore them in our wrappers search.
+      class << self
+        ##
+        # Return built-in symbols. It's called to initialize the BUILTINS
+        # constant early on. It also caches its result, so should be safe to
+        # call later, too.
+        def builtins
+          @builtins ||= nil
+          if not @builtins.nil?
+            return @builtins
+          end
+
+          # Object's constants contain all Module and Class definitions to date.
+          # We need to get the constant values, though, not just their names.
+          builtins = Object.constants.sort.map do |const_name|
+            Object.const_get(const_name)
+          end
+
+          # If JSON was required, there will be some generator methods that
+          # override the above generators. We want to filter those out as well.
+          # If, however, JSON was not required, we'll get a NameError and won't
+          # add anything new.
+          # rubocop:disable Lint/HandleExceptions
+          begin
+            json_builtins = JSON::Ext::Generator::GeneratorMethods.constants.sort
+            json_builtins.map! do |const_name|
+              JSON::Ext::Generator::GeneratorMethods.const_get(const_name)
+            end
+            builtins += json_builtins
+          rescue NameError
+            # We just ignore this; if JSON is automatically required, there will
+            # be some mixin Modules here, otherwise we will just process them.
+          end
+          # rubocop:enable Lint/HandleExceptions
+
+          # Last, we want to filter, so only Class and Module items are kept.
+          builtins.select! do |item|
+            item.is_a?(Module) or item.is_a?(Class)
+          end
+
+          @builtins = builtins
+          return @builtins
+        end
+      end # class << self
+      BUILTINS = Methods.builtins.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
@@ -63,7 +112,6 @@ 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(args.to_s)
           the_binding = [wrapper_block.object_id, self.class.object_id, signature]
 
@@ -145,7 +193,7 @@ module Collapsium
         # 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)
+        def wrappers(base, method_name, visited = nil)
           # 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|
@@ -155,10 +203,6 @@ module Collapsium
             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
@@ -167,7 +211,21 @@ module Collapsium
           rescue NoMethodError
             ancestors = base.class.ancestors
           end
-          ancestors = ancestors - Object.ancestors - [Object, Class, Module]
+          ancestors = ancestors - Object.ancestors - BUILTINS
+
+          # Bail out if there are no ancestors to process.
+          if ancestors.empty?
+            return []
+          end
+
+          # We add the base and its class to the set of visited items. Note
+          # that we're doing it late, so we only have to do it when we have
+          # ancestors to visit.
+          if visited.nil?
+            visited = Set.new
+          end
+          visited.add(base)
+          visited.add(base.class)
 
           ancestors.each do |ancestor|
             # Skip an visited item...

data/lib/collapsium/uber_hash.rb

@@ -28,6 +28,7 @@ module Collapsium
     include RecursiveSort
     include RecursiveFetch
     include PathedAccess
+    include IndifferentAccess
     include PrototypeMatch
 
     include Support::HashMethods
@@ -35,9 +36,6 @@ module Collapsium
     def initialize(*args)
       super
 
-      # Activate IndifferentAccess
-      self.default_proc = IndifferentAccess::DEFAULT_PROC
-
       # Extra functionality: allow being initialized by a Hash
       if args.empty? or not args[0].is_a?(Hash)
         return

data/lib/collapsium/version.rb

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

data/lib/collapsium/viral_capabilities.rb

@@ -35,6 +35,8 @@ module Collapsium
       array_ancestor: Array,
     }.freeze
 
+    ENHANCED_MARKER = "@__collapsium_viral_capabilities_marker".freeze
+
     ##
     # Any Object (Class, Module) that's enhanced with ViralCapabilities will at
     # least be extended with a module defining its Hash and Array ancestors.
@@ -138,22 +140,14 @@ module Collapsium
         # 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
+        # Turns out that that's quite expensive at run-time, though, so instead
+        # we resort to flagging enhanced values.
+        if value.is_a? Array or value.is_a? Hash
+          needs_wrapping = !value.instance_variable_get(ENHANCED_MARKER)
+          if needs_wrapping
+            enhance(value)
+            value.instance_variable_set(ENHANCED_MARKER, true)
           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

data/spec/indifferent_access_spec.rb

@@ -1,26 +1,121 @@
 require 'spec_helper'
 require_relative '../lib/collapsium/indifferent_access'
 
+class IncludedIndifferentHash < Hash
+  include ::Collapsium::IndifferentAccess
+end
+
+class PrependedIndifferentHash < Hash
+  prepend ::Collapsium::IndifferentAccess
+end
+
+class ExtendedIndifferentHash < Hash
+  extend ::Collapsium::IndifferentAccess
+end
+
 describe ::Collapsium::IndifferentAccess do
-  before :each do
-    @tester = {}
-    @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
+  let(:tester) do
+    tester = {}
+    tester.extend(::Collapsium::IndifferentAccess)
+    tester
   end
 
   it "allows accessing string keys via symbol" do
-    @tester["foo"] = 42
-    expect(@tester["foo"]).to eql 42
-    expect(@tester[:foo]).to eql 42
+    expect(tester).to be_empty
+
+    tester["foo"] = 42
+    expect(tester["foo"]).to eql 42
+    expect(tester[:foo]).to eql 42
   end
 
   it "allows accessing symbol keys via strings" do
-    @tester[:foo] = 42
-    expect(@tester[:foo]).to eql 42
-    expect(@tester["foo"]).to eql 42
+    expect(tester).to be_empty
+
+    tester[:foo] = 42
+    expect(tester[:foo]).to eql 42
+    expect(tester["foo"]).to eql 42
+  end
+
+  it "allows accessing integer keys with strings or symbols" do
+    expect(tester).to be_empty
+
+    tester[42] = 123
+    expect(tester[:"42"]).to eql 123
+    expect(tester["42"]).to eql 123
+  end
+
+  it "allows accessing string keys with integers" do
+    expect(tester).to be_empty
+
+    tester["42"] = 123
+    expect(tester[:"42"]).to eql 123
+    expect(tester[42]).to eql 123
   end
 
   it "still works with other keys" do
-    @tester[42] = "foo"
-    expect(@tester[42]).to eql "foo"
+    expect(tester).to be_empty
+
+    tester[42] = "foo"
+
+    expect(tester[nil]).to be_nil
+    expect(tester[3.14]).to be_nil
+  end
+
+  it "makes keys unique" do
+    test = [
+      "foo", :foo,
+      "42", :"42", 42,
+    ]
+    expect(::Collapsium::IndifferentAccess.unique_keys(test)).to eql %w(foo 42)
+  end
+
+  it "can sort keys" do
+    test = [
+      "foo", :foo,
+      "bar", :bar,
+      "42", :"42", 42,
+    ]
+    expecation = [
+      42,
+      :"42", :bar, :foo,
+      "42", "bar", "foo",
+    ]
+    expect(::Collapsium::IndifferentAccess.sorted_keys(test)).to eql expecation
+  end
+
+  it "does nothing for Arrays" do
+    test = [42]
+    test.extend(::Collapsium::IndifferentAccess)
+
+    result = nil
+    expect { result = test.include?(42) }.not_to raise_error
+    expect(result).to be_truthy
+  end
+
+  context IncludedIndifferentHash do
+    let(:tester) { IncludedIndifferentHash.new }
+
+    it "can be accessed indifferently" do
+      tester["foo"] = 42
+      expect(tester[:foo]).to eql 42
+    end
+  end
+
+  context ExtendedIndifferentHash do
+    let(:tester) { ExtendedIndifferentHash.new }
+
+    it "can be accessed indifferently" do
+      tester["foo"] = 42
+      expect(tester[:foo]).to eql 42
+    end
+  end
+
+  context PrependedIndifferentHash do
+    let(:tester) { PrependedIndifferentHash.new }
+
+    it "can be accessed indifferently" do
+      tester["foo"] = 42
+      expect(tester[:foo]).to eql 42
+    end
   end
 end

data/spec/pathed_access_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require_relative '../lib/collapsium/pathed_access'
+require_relative '../lib/collapsium/indifferent_access'
 
 class PathedHash < Hash
   prepend ::Collapsium::PathedAccess
@@ -34,7 +35,7 @@ describe ::Collapsium::PathedAccess do
     end
   end
 
-  describe "pathed access" do
+  describe "PathedAccess" do
     context ":path_prefix" do
       it "can be read" do
         expect { @tester.path_prefix }.not_to raise_error
@@ -145,6 +146,22 @@ describe ::Collapsium::PathedAccess do
       # "foo.bar" also exists at the top level.
       expect(@tester["foo.bar"]).to be_nil
     end
+
+    context "keys with spaces" do
+      it "accepts spaces in top-level keys" do
+        @tester['foo bar'] = 42
+        expect(@tester['foo bar']).to eql 42
+        expect(@tester['.foo bar']).to eql 42
+      end
+
+      it "accepts spaces in nested keys" do
+        @tester['spaces'] = {
+          'foo bar' => 42,
+        }
+        expect(@tester['spaces']['foo bar']).to eql 42
+        expect(@tester['spaces.foo bar']).to eql 42
+      end
+    end
   end
 
   describe "nested inherit capabilities" do
@@ -156,7 +173,7 @@ describe ::Collapsium::PathedAccess do
       }
     end
 
-    it "can still perform pathed access" do
+    it "can still perform PathedAccess" do
       foo = @tester['foo']
       expect(foo['bar.baz']).to eql 42
     end
@@ -167,41 +184,6 @@ describe ::Collapsium::PathedAccess do
     end
   end
 
-  describe "with indifferent access" do
-    before do
-      require_relative '../lib/collapsium/indifferent_access'
-    end
-
-    it "can write with indifferent access without overwriting" do
-      @tester[:foo] = {
-        bar: 42,
-        baz: 'quux',
-      }
-      @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
-
-      expect(@tester['foo.bar']).to eql 42
-      expect(@tester['foo.baz']).to eql 'quux'
-
-      @tester['foo.bar'] = 123
-      expect(@tester['foo.bar']).to eql 123
-      expect(@tester['foo.baz']).to eql 'quux'
-    end
-
-    it "doesn't break #path_prefix" do
-      @tester[:foo] = {
-        bar: {
-          baz: 123,
-        }
-      }
-      @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
-
-      expect(@tester[:foo].path_prefix).to eql ".foo"
-      expect(@tester["foo"].path_prefix).to eql ".foo"
-      expect(@tester[:foo][:bar].path_prefix).to eql ".foo.bar"
-      expect(@tester["foo.bar"].path_prefix).to eql ".foo.bar"
-    end
-  end
-
   context PathedHash do
     let(:test_hash) { PathedHash.new }
 
@@ -230,26 +212,100 @@ describe ::Collapsium::PathedAccess do
       }
     end
 
-    it "resolved with pathed access" do
+    it "resolved with PathedAccess" do
       expect(@tester['foo.bar.0.baz1']).to eql 'quux1'
       expect(@tester['foo.bar.1.baz2']).to eql 'quux2'
     end
   end
 
-  context "nested symbol keys" do
-    before do
-      @tester['foo'] = {
-        bar: { 'baz' => 'quux' },
+  context "with IndifferentAccess" do
+    it "resolves with a created Hash and :[]" do
+      tester = { foo: { 'bar' => 42 } }
+      tester.extend(::Collapsium::PathedAccess)
+      tester.extend(::Collapsium::IndifferentAccess)
+
+      res = tester['.foo']
+
+      expect(res.length).to eql 1
+      expect(res.key?('bar')).to be_truthy
+      expect(res.fetch('bar')).to eql 42
+      expect(res['bar']).to eql 42
+    end
+
+    it "resolves with a created Hash and :fetch" do
+      tester = { foo: { 'bar' => 42 } }
+      tester.extend(::Collapsium::PathedAccess)
+      tester.extend(::Collapsium::IndifferentAccess)
+
+      res = tester.fetch('.foo')
+
+      expect(res.length).to eql 1
+      expect(res.key?('bar')).to be_truthy
+      expect(res.fetch('bar')).to eql 42
+      expect(res['bar']).to eql 42
+    end
+
+    it "resolves with a replaced Hash and :[]" do
+      tester = {}
+      tester.extend(::Collapsium::PathedAccess)
+      tester.extend(::Collapsium::IndifferentAccess)
+      tester.replace(foo: { 'bar' => 42 })
+
+      res = tester['.foo']
+
+      expect(res.length).to eql 1
+      expect(res.key?('bar')).to be_truthy
+      expect(res.fetch('bar')).to eql 42
+      expect(res['bar']).to eql 42
+    end
+
+    it "resolves with a replaced Hash and :fetch" do
+      tester = {}
+      tester.extend(::Collapsium::PathedAccess)
+      tester.extend(::Collapsium::IndifferentAccess)
+      tester.replace(foo: { 'bar' => 42 })
+
+      res = tester.fetch('.foo')
+
+      expect(res.length).to eql 1
+      expect(res.key?('bar')).to be_truthy
+      expect(res.fetch('bar')).to eql 42
+      expect(res['bar']).to eql 42
+    end
+
+    it "can write without overwriting" do
+      tester = {
+        foo: {
+          bar: 42,
+          baz: 'quux',
+        }
       }
+      tester.extend(::Collapsium::PathedAccess)
+      tester.extend(::Collapsium::IndifferentAccess)
+
+      expect(tester['foo.bar']).to eql 42
+      expect(tester['foo.baz']).to eql 'quux'
+
+      tester['foo.bar'] = 123
+      expect(tester['foo.bar']).to eql 123
+      expect(tester['foo.baz']).to eql 'quux'
     end
 
-    it "resolve with pathed access & indifferent access" do
-      # This should be nil - we don't use indifferent access yet.
-      expect(@tester['foo.bar.baz']).to be_nil
+    it "doesn't break #path_prefix" do
+      tester = {
+        foo: {
+          bar: {
+            baz: 123,
+          }
+        }
+      }
+      tester.extend(::Collapsium::PathedAccess)
+      tester.extend(::Collapsium::IndifferentAccess)
 
-      # With indifferent access, pathed access must work
-      @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
-      expect(@tester['foo.bar.baz']).to eql 'quux'
+      expect(tester[:foo].path_prefix).to eql ".foo"
+      expect(tester["foo"].path_prefix).to eql ".foo"
+      expect(tester[:foo][:bar].path_prefix).to eql ".foo.bar"
+      expect(tester["foo.bar"].path_prefix).to eql ".foo.bar"
     end
   end
 end

data/spec/recursive_merge_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 require_relative '../lib/collapsium/recursive_merge'
+require_relative '../lib/collapsium/indifferent_access'
+require_relative '../lib/collapsium/pathed_access'
 
 describe ::Collapsium::RecursiveMerge do
   before :each do
@@ -84,4 +86,119 @@ describe ::Collapsium::RecursiveMerge do
     expect(@tester[:foo].respond_to?(:recursive_merge)).to be_truthy
     expect(x[:foo].respond_to?(:recursive_merge)).to be_truthy
   end
+
+  it "does not offer indifferent access by itself" do
+    tester = {
+      foo: 42
+    }
+    tester.extend(::Collapsium::RecursiveMerge)
+
+    expect(tester[:foo]).to eql 42
+    expect(tester['foo']).to be_nil
+  end
+
+  context "with IndifferentAccess" do
+    let(:tester) do
+      tester = {}
+      tester.extend(::Collapsium::IndifferentAccess)
+      tester.extend(::Collapsium::RecursiveMerge)
+    end
+
+    it "merges string and symbol keys" do
+      tester[:foo] = {
+        bar: 123,
+      }
+      tester[:arr] = [2]
+      other = {
+        "foo" => {
+          "baz asdf" => "quux",
+          "bar" => 42
+        },
+        "arr" => [1],
+      }
+      x = tester.recursive_merge(other)
+
+      expect(x.length).to eql 2
+      expect(x[:foo].length).to eql 2
+      expect(x[:foo]['baz asdf']).to eql 'quux'
+      expect(x[:foo][:bar]).to eql 42 # overwrite
+      expect(x[:arr].length).to eql 2
+      expect(x[:arr]).to eql [2, 1]
+    end
+
+    it "merges string and symbol keys without overwriting" do
+      tester[:foo] = {
+        bar: 123,
+      }
+      tester[:arr] = [2]
+      other = {
+        "foo" => {
+          "baz asdf" => "quux",
+          "bar" => 42
+        },
+        "arr" => [1],
+      }
+      x = tester.recursive_merge(other, false)
+
+      expect(x.length).to eql 2
+      expect(x[:foo].length).to eql 2
+      expect(x[:foo]['baz asdf']).to eql 'quux'
+      expect(x[:foo][:bar]).to eql 123 # no overwrite
+      expect(x[:arr].length).to eql 2
+      expect(x[:arr]).to eql [2, 1]
+    end
+  end
+
+  context "with IndifferentAccess and PathedAccess" do
+    let(:tester) do
+      tester = {}
+      tester.extend(::Collapsium::IndifferentAccess)
+      tester.extend(::Collapsium::RecursiveMerge)
+      tester.extend(::Collapsium::PathedAccess)
+    end
+
+    it "merges string and symbol keys" do
+      tester[:foo] = {
+        bar: 123,
+      }
+      tester[:arr] = [2]
+      other = {
+        "foo" => {
+          "baz asdf" => "quux",
+          "bar" => 42
+        },
+        "arr" => [1],
+      }
+      x = tester.recursive_merge(other)
+
+      expect(x.length).to eql 2
+      expect(x['foo'].length).to eql 2
+      expect(x['foo.baz asdf']).to eql 'quux'
+      expect(x['foo.bar']).to eql 42 # overwrite
+      expect(x['arr'].length).to eql 2
+      expect(x['arr']).to eql [2, 1]
+    end
+
+    it "merges string and symbol keys without overwriting" do
+      tester[:foo] = {
+        bar: 123,
+      }
+      tester[:arr] = [2]
+      other = {
+        "foo" => {
+          "baz asdf" => "quux",
+          "bar" => 42
+        },
+        "arr" => [1],
+      }
+      x = tester.recursive_merge(other, false)
+
+      expect(x.length).to eql 2
+      expect(x['foo'].length).to eql 2
+      expect(x['foo.baz asdf']).to eql 'quux'
+      expect(x['foo.bar']).to eql 123 # no overwrite
+      expect(x['arr'].length).to eql 2
+      expect(x['arr']).to eql [2, 1]
+    end
+  end
 end

data/spec/recursive_sort_spec.rb

@@ -2,11 +2,6 @@ require 'spec_helper'
 require_relative '../lib/collapsium/recursive_sort'
 
 describe ::Collapsium::RecursiveSort do
-  before :each do
-    @tester = {}
-    @tester.extend(::Collapsium::RecursiveSort)
-  end
-
   it "sorts a nested hash with string keys in place" do
     h = {
       'a' => 1,
@@ -80,4 +75,18 @@ describe ::Collapsium::RecursiveSort do
     expect(h.object_id).not_to eql h2.object_id
     expect(h['c'].object_id).not_to eql h2['c'].object_id
   end
+
+  it "works with IndifferentAccess" do
+    require_relative '../lib/collapsium/indifferent_access'
+    tester = {
+      "foo" => 42,
+      "bar" => 123,
+      :foo => "foo from symbol",
+      :bar => "bar from symbol",
+    }
+    tester.extend(::Collapsium::RecursiveSort)
+    tester.extend(::Collapsium::IndifferentAccess)
+
+    expect { tester.recursive_sort! }.not_to raise_error
+  end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,3 @@
-# Only start CodeClimate from travis
-if ENV['CODECLIMATE_REPO_TOKEN']
-  require 'codeclimate-test-reporter'
-  CodeClimate::TestReporter.start
-end
-
 # Always start SimpleCov
 require 'simplecov'
 SimpleCov.start do

data/spec/uber_hash_spec.rb

@@ -74,4 +74,9 @@ describe Collapsium::UberHash do
     x = ::Collapsium::UberHash.new(data)
     expect(x[:some].is_a?(::Collapsium::UberHash)).to be_truthy
   end
+
+  it "behaves like a Hash" do
+    tester = ::Collapsium::UberHash.new
+    expect { tester[] }.to raise_error(ArgumentError)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: collapsium
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Jens Finkhaeuser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-04 00:00:00.000000000 Z
+date: 2016-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -139,7 +139,7 @@ files:
 - spec/recursive_sort_spec.rb
 - spec/spec_helper.rb
 - spec/support_methods_spec.rb
-- spec/support_path_components.rb
+- spec/support_path_components_spec.rb
 - spec/uber_hash_spec.rb
 - spec/viral_capabilities_spec.rb
 homepage: https://github.com/jfinkhaeuser/collapsium
@@ -177,6 +177,6 @@ test_files:
 - spec/recursive_sort_spec.rb
 - spec/spec_helper.rb
 - spec/support_methods_spec.rb
-- spec/support_path_components.rb
+- spec/support_path_components_spec.rb
 - spec/uber_hash_spec.rb
 - spec/viral_capabilities_spec.rb