collapsium 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 380030070f1838be3f5a7955fcd6e146398653f7
+  data.tar.gz: 18862980c22abb357b61c26d867a21d397c4faef
+SHA512:
+  metadata.gz: c5be77bf133c4042d193a4f10c4dafbbc2805da3dc4497b29e11802d33a4b34726a2af79642d9f6423f9de14746a46d2a3acc7ff655d1e14d1ba11ca68ba3055
+  data.tar.gz: 55fa9036b582b1cb8f708c1d384e006b2bf822253ed213eff8204fbeae2e4a159b578ac6a1330ac380ab75b875f637e8cf4385ed8c57760ce0888e3e10d8d29c

data/.codeclimate.yml

@@ -0,0 +1,34 @@
+---
+engines:
+  bundler-audit:
+    enabled: true
+  duplication:
+    enabled: true
+    exclude_fingerprints:
+      - d85d6f12c93d79ccd43868b8315d8816
+      - a8e2b4ccb258f16eda697c5f98e21823
+      - 442a316695836b4f4693fe3786cd3396
+      - 1c24bb5da72323796b645814cc006684
+      - 4ff1112a73f7be30ecefa7bd90fdbf5a
+    config:
+      languages:
+      - ruby
+      - javascript
+      - python
+      - php
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - Gemfile.lock
+  - "**.inc"
+  - "**.js"
+  - "**.jsx"
+  - "**.module"
+  - "**.php"
+  - "**.py"
+  - "**.rb"
+exclude_paths:
+- spec/

data/.gitignore

@@ -0,0 +1,39 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Editor files
+.*.sw*

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,75 @@
+AllCops:
+  TargetRubyVersion: 2.2
+
+# Metrics
+
+Metrics/LineLength:
+  Max: 83
+  Details: >-
+    Line length of 80 is ideal for readability and compatibility; we'll accept
+    an extra 3 for minor edge cases.
+
+Metrics/MethodLength:
+  Max: 35
+
+Metrics/BlockNesting:
+  Max: 5
+
+Metrics/AbcSize:
+  Max: 50
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/ClassLength:
+  Max: 300
+
+Metrics/ModuleLength:
+  Max: 300
+
+# Style
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: false
+
+Style/Not:
+  Enabled: false
+
+Style/NegatedIf:
+  Enabled: false
+
+Style/RedundantReturn:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/TrailingCommaInLiteral:
+  Enabled: false
+
+Style/FirstParameterIndentation:
+  Enabled: false
+
+Style/TrailingUnderscoreVariable:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/SpaceAfterNot:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+addons:
+  code_climate:
+    repo_token: 56724b4322c0a98f681db40ccfa92d1a9fd4755a18daf82683f95fcaa058499d

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in collapsium.gemspec
+gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    collapsium (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.2.0)
+    codeclimate-test-reporter (0.5.0)
+      simplecov (>= 0.7.1, < 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.3)
+    parser (2.3.1.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    rainbow (2.1.0)
+    rake (11.1.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    rubocop (0.40.0)
+      parser (>= 2.3.1.0, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.0)
+    simplecov (0.11.2)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    unicode-display_width (1.0.5)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  codeclimate-test-reporter
+  collapsium!
+  rake (~> 11.1)
+  rspec (~> 3.4)
+  rubocop (~> 0.40)
+  simplecov (~> 0.11)
+  yard (~> 0.8)
+
+BUNDLED WITH
+   1.12.3

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) Jens Finkhaeuser (http://finkhaeuser.de/) and other collapsium
+contributors. All rights not covered below are reserved.
+
+The MIT +no-false-attribs License (MITNFA)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+Distributions of all or part of the Software intended to be used by the
+recipients as they would use the unmodified Software, containing modifications
+that substantially alter, remove, or disable functionality of the Software,
+outside of the documented configuration mechanisms provided by the Software,
+shall be modified such that the Original Author's bug reporting email addresses
+and urls are either replaced with the contact information of the parties
+responsible for the changes, or removed entirely.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+# collapsium
+*Provides various Hash extensions, and an UberHash class that uses them all.*
+
+Ruby's Hash is a pretty nice class, but various extensions are commonly (or not
+so commonly) used to make it even more convenient. The most notable would
+probably be [ActiveSupport::HashWithIndifferentAccess](http://apidock.com/rails/ActiveSupport/HashWithIndifferentAccess).
+
+That example, unfortunately, has all the problems of requring the kitchen sink
+that is ActiveSupport...
+
+[![Gem Version](https://badge.fury.io/rb/collapsium.svg)](https://badge.fury.io/rb/collapsium)
+[![Build status](https://travis-ci.org/jfinkhaeuser/collapsium.svg?branch=master)](https://travis-ci.org/jfinkhaeuser/collapsium)
+[![Code Climate](https://codeclimate.com/github/jfinkhaeuser/collapsium/badges/gpa.svg)](https://codeclimate.com/github/jfinkhaeuser/collapsium)
+[![Test Coverage](https://codeclimate.com/github/jfinkhaeuser/collapsium/badges/coverage.svg)](https://codeclimate.com/github/jfinkhaeuser/collapsium/coverage)
+
+# Functionality
+
+- The `IndifferentAccess` module provides support for indifferent access via a
+  `#default_proc`:
+
+  ```ruby
+  x = { foo: 42 }
+  x.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
+  x['foo'] # => 42
+  ```
+- The `RecursiveMerge` module provides a `#recursive_merge` function which merges
+  Hashes recursively:
+
+  ```ruby
+  x = { foo: { bar: 42 } }
+  x.extend(::Collapsium::RecursiveMerge)
+  x.recursive_merge(foo: { baz: 'quux' })
+  # => {
+  #   foo: {
+  #     bar: 42,
+  #     baz: 'quux',
+  #   },
+  # }
+  ```
+- The `PathedAccess` module provides a pathed access method to nested Hashes:
+
+  ```ruby
+  x = { "foo" => { "bar" => 42 } }
+  x.extend(::Collapsium::PathedAccess)
+  x["foo.bar"] # => 42
+  ```
+
+Finally, the `UberHash` class just includes all of the above.

data/Rakefile

@@ -0,0 +1,25 @@
+# Rubocop
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
+
+# Rspec
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:rspec)
+
+# Documentation
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = ['-m', 'markdown']
+  t.stats_options = ['--list-undoc']
+end
+
+# Combined test task
+desc "Test all the things!"
+task :test do
+  Rake::Task[:rubocop].invoke
+  Rake::Task[:rspec].invoke
+end
+
+# Default is the test task
+task default: :test

data/collapsium.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'collapsium/version'
+
+# rubocop:disable Style/UnneededPercentQ
+# rubocop:disable Style/SpaceAroundOperators
+Gem::Specification.new do |spec|
+  spec.name          = "collapsium"
+  spec.version       = Collapsium::VERSION
+  spec.authors       = ["Jens Finkhaeuser"]
+  spec.email         = ["jens@finkhaeuser.de"]
+  spec.description   = %q(
+    Provides IndifferentAccess, RecursiveMerge, PathedAccess, etc.
+  )
+  spec.summary       = %q(
+    Provides various Hash extensions, and an UberHash class that uses them all.
+  )
+  spec.homepage      = "https://github.com/jfinkhaeuser/collapsium"
+  spec.license       = "MITNFA"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rubocop", "~> 0.40"
+  spec.add_development_dependency "rake", "~> 11.1"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "simplecov", "~> 0.11"
+  spec.add_development_dependency "yard", "~> 0.8"
+end
+# rubocop:enable Style/SpaceAroundOperators
+# rubocop:enable Style/UnneededPercentQ

data/lib/collapsium.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+require 'collapsium/version'
+
+require 'collapsium/recursive_merge'
+require 'collapsium/indifferent_access'
+require 'collapsium/pathed_access'
+
+require 'collapsium/uber_hash'

data/lib/collapsium/indifferent_access.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+
+  ##
+  # Provides indifferent access to string/symbol keys in a Hash. That is,
+  # if your hash contains a string key, you can also access it via a symbol
+  # and vice versa.
+  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)
+      end
+    end.freeze
+
+  end # module IndifferentAccess
+
+end # module Collapsium

data/lib/collapsium/pathed_access.rb

@@ -0,0 +1,139 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+
+  ##
+  # The PathedAccess module can be used to extend Hash with pathed access
+  # on top of regular access, i.e. instead of `h["first"]["second"]` you can
+  # write `h["first.second"]`.
+  #
+  # The main benefit is much simpler code for accessing nested structured.
+  # For any given path, PathedAccess will return nil from `[]` if *any* of
+  # the path components do not exist.
+  #
+  # Similarly, intermediate nodes will be created when you write a value
+  # for a path.
+  module PathedAccess
+
+    # @return [String] the separator is the character or pattern splitting paths.
+    def separator
+      @separator ||= DEFAULT_SEPARATOR
+      return @separator
+    end
+
+    # @api private
+    # Methods redefined to support pathed read access.
+    READ_METHODS = [
+      :[], :default, :delete, :fetch, :has_key?, :include?, :key?, :member?,
+    ].freeze
+
+    # @api private
+    # Methods redefined to support pathed write access.
+    WRITE_METHODS = [
+      :[]=, :store,
+    ].freeze
+
+    # @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
+
+    (READ_METHODS + WRITE_METHODS).each do |method|
+      # Wrap all accessor functions to deal with paths
+      define_method(method) do |*args, &block|
+        # If there are no arguments, there's nothing to do with paths. Just
+        # delegate to the hash.
+        if args.empty?
+          return super(*args, &block)
+        end
+
+        # 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.
+        components = args[0].to_s.split(split_pattern)
+        loop do
+          if components.empty? or not components[0].empty?
+            break
+          end
+          components.shift
+        end
+
+        # If there are no components, return self/the root
+        if components.empty?
+          return self
+        end
+
+        # This is already the leaf-most Hash
+        if components.length == 1
+          # Weird edge case: if we didn't have to shift anything, then it's
+          # possible we inadvertently changed a symbol key into a string key,
+          # which could mean looking fails.
+          # We can detect that by comparing copy[0] to a symbolized version of
+          # components[0].
+          copy = args.dup
+          if copy[0] != components[0].to_sym
+            copy[0] = components[0]
+          end
+          return super(*copy, &block)
+        end
+
+        # Deal with other paths. The frustrating part here is that for nested
+        # hashes, only this outermost one is guaranteed to know anything about
+        # path splitting, so we'll have to recurse down to the leaf here.
+        #
+        # For write methods, we need to create intermediary hashes.
+        leaf = recursive_fetch(components, self,
+                               create: WRITE_METHODS.include?(method))
+        if leaf.is_a? Hash
+          leaf.default_proc = default_proc
+        end
+        if leaf.nil?
+          leaf = self
+        end
+
+        # If we have a leaf, we want to send the requested method to that
+        # leaf.
+        copy = args.dup
+        copy[0] = components.last
+        return leaf.send(method, *copy, &block)
+      end
+    end
+
+    private
+
+    ##
+    # Given the path components, recursively fetch any but the last key.
+    def recursive_fetch(path, data, options = {})
+      # For the leaf element, we do nothing because that's where we want to
+      # dispatch to.
+      if path.length == 1
+        return data
+      end
+
+      # Split path into head and tail; for the next iteration, we'll look use only
+      # head, and pass tail on recursively.
+      head = path[0]
+      tail = path.slice(1, path.length)
+
+      # If we're a write function, then we need to create intermediary objects,
+      # i.e. what's at head if nothing is there.
+      if options[:create] and data[head].nil?
+        data[head] = {}
+      end
+
+      # Ok, recurse.
+      return recursive_fetch(tail, data[head], options)
+    end
+  end # module PathedAccess
+end # module Collapsium

data/lib/collapsium/recursive_merge.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+module Collapsium
+  ##
+  # Provides recursive merge functions for hashes. Used in PathedHash.
+  module RecursiveMerge
+    ##
+    # Recursively merge `:other` into this Hash.
+    #
+    # This starts by merging the leaf-most Hash entries. Arrays are merged
+    # by addition.
+    #
+    # For everything that's neither Hash or Array, if the `:overwrite`
+    # parameter is true, the entry from `:other` is used. Otherwise the entry
+    # from `:self` is used.
+    #
+    # @param other [Hash] the hash to merge into `:self`
+    # @param overwrite [Boolean] see method description.
+    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 RecursiveMerge
+end # module Collapsium

data/lib/collapsium/uber_hash.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+
+require 'collapsium/recursive_merge'
+require 'collapsium/indifferent_access'
+require 'collapsium/pathed_access'
+
+module Collapsium
+
+  # A Hash that includes all the different Hash extensions in collapsium
+  class UberHash < Hash
+    include RecursiveMerge
+    include PathedAccess
+
+    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
+      end
+
+      merge!(args[0])
+    end
+  end
+
+end # module Collapsium

data/lib/collapsium/version.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+#
+# collapsium
+# https://github.com/jfinkhaeuser/collapsium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other collapsium contributors.
+# All rights reserved.
+#
+module Collapsium
+  # The current release version
+  VERSION = "0.1.0".freeze
+end

data/spec/indifferent_access_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/indifferent_access'
+
+describe ::Collapsium::IndifferentAccess do
+  before :each do
+    @tester = {}
+    @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
+  end
+
+  it "allows accessing string keys via symbol" do
+    @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
+  end
+
+  it "still works with other keys" do
+    @tester[42] = "foo"
+    expect(@tester[42]).to eql "foo"
+  end
+end

data/spec/pathed_access_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/pathed_access'
+
+describe ::Collapsium::PathedAccess do
+  before :each do
+    @tester = {}
+    @tester.extend(::Collapsium::PathedAccess)
+  end
+
+  describe "Hash-like" do
+    it "responds to Hash functions" do
+      [:invert, :delete, :fetch].each do |meth|
+        expect(@tester.respond_to?(meth)).to eql true
+      end
+    end
+
+    it "can be used like a Hash" do
+      @tester[:foo] = 42
+      inverted = @tester.invert
+      expect(inverted.empty?).to eql false
+      expect(inverted[42]).to eql :foo
+    end
+
+    it "delegates to Hash if it's nothing to do with paths" do
+      expect(@tester.default).to be_nil
+    end
+  end
+
+  describe "pathed access" do
+    it "can recursively read entries via a path" do
+      @tester["foo"] = 42
+      @tester["bar"] = {
+        "baz" => "quux",
+        "blah" => [1, 2],
+      }
+
+      expect(@tester["foo"]).to eql 42
+      expect(@tester["bar.baz"]).to eql "quux"
+      expect(@tester["bar.blah"]).to eql [1, 2]
+
+      expect(@tester["nope"]).to eql nil
+      expect(@tester["bar.nope"]).to eql nil
+    end
+
+    it "behaves consistently if in a path the first node cannot be found" do
+      @tester["foo"] = 42
+
+      expect(@tester["nope.bar"]).to eql nil
+    end
+
+    it "treats a single separator as the root" do
+      @tester["foo"] = 42
+
+      expect(@tester[@tester.separator]["foo"]).to eql 42
+    end
+
+    it "treats an empty path as the root" do
+      @tester["foo"] = 42
+
+      expect(@tester[""]["foo"]).to eql 42
+    end
+
+    it "can recursively write entries via a path" do
+      @tester["foo.bar"] = 42
+      expect(@tester["foo.bar"]).to eql 42
+    end
+
+    it "understands absolute paths (starting with separator)" do
+      @tester["foo"] = 42
+      @tester["bar"] = {
+        "baz" => "quux",
+        "blah" => [1, 2],
+      }
+
+      expect(@tester["bar.baz"]).to eql "quux"
+      expect(@tester[".bar.baz"]).to eql "quux"
+    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
+  end
+end

data/spec/recursive_merge_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/recursive_merge'
+
+describe ::Collapsium::RecursiveMerge do
+  before :each do
+    @tester = {}
+    @tester.extend(::Collapsium::RecursiveMerge)
+  end
+
+  it "handles a nil parameter well" do
+    x = @tester.recursive_merge(nil)
+
+    expect(x.is_a?(Hash)).to be_truthy
+    expect(x).to be_empty
+  end
+
+  it "merges simple values by overwriting by default" do
+    @tester[:foo] = 'old'
+    x = @tester.recursive_merge(foo: 'new')
+
+    expect(x[:foo]).to eql 'new'
+  end
+
+  it "merges simple values by using the old value if requested" do
+    @tester[:foo] = 'old'
+    x = @tester.recursive_merge({ foo: 'new' }, false)
+
+    expect(x[:foo]).to eql 'old'
+  end
+
+  it "merges arrays by concatenation" do
+    @tester[:foo] = ['old']
+    x = @tester.recursive_merge(foo: ['new'])
+
+    expect(x[:foo].length).to eql 2
+    expect(x[:foo][0]).to eql 'old'
+    expect(x[:foo][1]).to eql 'new'
+  end
+
+  it "merges objects by recursing" do
+    @tester[:foo] = {
+      bar: 42,
+      baz: ['old'],
+      quux: {
+        something: 42,
+      }
+    }
+    @tester[:bar] = [1]
+
+    to_merge = {
+      foo: {
+        bar: 123,     # should overwrite
+        baz: ['new'], # should concatenate
+        quux: {       # should merge
+          another: 123,
+        },
+      },
+      bar: [2],
+    }
+
+    x = @tester.recursive_merge(to_merge)
+
+    expect(x[:foo][:bar]).to eql 123
+    expect(x[:foo][:baz].length).to eql 2
+    expect(x[:foo][:quux][:something]).to eql 42
+    expect(x[:foo][:quux][:another]).to eql 123
+
+    expect(x[:bar].length).to eql 2
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# 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

data/spec/uber_hash_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/uber_hash'
+
+describe Collapsium::UberHash do
+  it "has recursive_merge support" do
+    x = ::Collapsium::UberHash.new(foo: [1])
+
+    # Interface expecations
+    expect(x.respond_to?(:recursive_merge)).to be_truthy
+    expect(x.respond_to?(:recursive_merge!)).to be_truthy
+
+    # Behaviour expectations
+    x.recursive_merge!(foo: [2])
+    expect(x[:foo].length).to eql 2
+  end
+
+  it "has pathed access" do
+    x = ::Collapsium::UberHash.new(
+      "foo" => {
+        "bar" => 42,
+      }
+    )
+
+    # Interface expecations
+    expect(x.respond_to?(:separator)).to be_truthy
+    expect(x.respond_to?(:split_pattern)).to be_truthy
+
+    # Behaviour expectations
+    expect(x["foo.bar"]).to eql 42
+  end
+
+  it "has indifferent access" do
+    x = ::Collapsium::UberHash.new(foo: 42)
+    expect(x['foo']).to eql 42
+
+    x = ::Collapsium::UberHash.new('foo' => 42)
+    expect(x[:foo]).to eql 42
+  end
+
+  it "can be initialized without arguments" do
+    x = ::Collapsium::UberHash.new
+    expect(x.empty?).to be_truthy
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: collapsium
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jens Finkhaeuser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.40'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: "\n    Provides IndifferentAccess, RecursiveMerge, PathedAccess, etc.\n
+  \ "
+email:
+- jens@finkhaeuser.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- collapsium.gemspec
+- lib/collapsium.rb
+- lib/collapsium/indifferent_access.rb
+- lib/collapsium/pathed_access.rb
+- lib/collapsium/recursive_merge.rb
+- lib/collapsium/uber_hash.rb
+- lib/collapsium/version.rb
+- spec/indifferent_access_spec.rb
+- spec/pathed_access_spec.rb
+- spec/recursive_merge_spec.rb
+- spec/spec_helper.rb
+- spec/uber_hash_spec.rb
+homepage: https://github.com/jfinkhaeuser/collapsium
+licenses:
+- MITNFA
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Provides various Hash extensions, and an UberHash class that uses them all.
+test_files:
+- spec/indifferent_access_spec.rb
+- spec/pathed_access_spec.rb
+- spec/recursive_merge_spec.rb
+- spec/spec_helper.rb
+- spec/uber_hash_spec.rb
+has_rdoc: