sparsify 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing
+
+`Sparsify` is [Apache-liennsed](LICENSE.txt).
+
+## Git-Flow
+
+`Sparsify` follows the [git-flow][] branching model, which means that every
+commit on `master` is a release. The default working branch is `develop`, so
+in general please keep feature pull-requests based against the current
+`develop`.
+
+ - fork sparsify
+ - use the git-flow model to start your feature or hotfix
+ - make some commits (please include specs)
+ - submit a pull-request
+
+## Bug Reporting
+
+Please include clear steps-to-reproduce. Spec files are especially welcome;
+a failing spec can be contributed as a pull-request against `develop`.
+
+## Documentation
+
+`Sparsify` uses YARDOC, and so must your pull-requests.
+
+## Ruby Appraiser
+
+`Sparsify` uses the [ruby-appraiser][] gem via [pre-commit][] hook, which can be
+activated by installing [icefox/git-hooks][] and running `git-hooks --install`.
+Reek and Rubocop are strong guidelines; use them to reduce defects as much as
+you can, but if you believe clarity will be sacrificed they can be bypassed
+with the `--no-verify` flag.
+
+[git-flow]: http://nvie.com/posts/a-successful-git-branching-model/
+[pre-commit]: .githooks/pre-commit/ruby-appraiser
+[ruby-appraiser]: https://github.com/simplymeasured/ruby-appraiser
+[icefox/git-hooks]: https://github.com/icefox/git-hooks
+[pull-request-hack]: http://felixge.de/2013/03/11/the-pull-request-hack.html

data/Gemfile

@@ -0,0 +1,6 @@
+# encoding: utf-8
+source 'http://gems.production.int.simplymeasured.com:9292'
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sparsify.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2013 Simply Measured
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,55 @@
+# Sparsify
+
+Convert a deeply-nested hash into a shallow sparse hash. Useful for tools that
+either can't handle deeply-nested hashes or that allow partial updates via
+sparse hashes.
+
+This gem is our internal implementation of our [Sparisfy Challenge][].
+
+[Sparsify Challenge]: https://github.com/simplymeasured/sparsify-challenge
+
+## Usage
+
+```ruby
+require 'sparsify'
+
+Sparsify({'foo' => { 'bar' => {'baz' => 'bingo'}}})
+#=> {'foo.bar.baz' => 'bingo'}
+
+Unsparsify({'foo.bar.baz' => 'bingo'})
+#=> {'foo' => { 'bar' => {'baz' => 'bingo'}}}
+```
+
+## Advanced Usage
+
+### Custom Separator
+
+```ruby
+require 'sparsify'
+
+Sparsify({'foo' => { 'bar.bar' => {'baz' => 'bingo'}}}, separator: '|')
+#=> {'foo|bar.bar|baz' => 'bingo'}
+
+Unsparsify({'foo|bar.bar|baz' => 'bingo'}, separator: '|')
+#=> {'foo' => { 'bar.bar' => {'baz' => 'bingo'}}}
+```
+
+### Sparse Arrays
+
+``` ruby
+require 'sparsify'
+
+Sparsify({'foo' => ['bar','baz','buz']}, sparse_array: true)
+#=> {'foo.0'=>'bar','foo.1'=>'baz','foo.2'=>'buz'}
+
+Unsparsify({'foo.0'=>'bar','foo.1'=>'baz','foo.2'=>'buz'}, sparse_array: true)
+#=> {'foo' => ['bar','baz','buz']}
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.verbose = true
+end

data/git_hooks/pre-commit/ruby-appraiser

@@ -0,0 +1,17 @@
+#!/bin/bash
+echo -e "\033[0;36mRuby Appraiser: running\033[0m"
+bundle exec ruby-appraiser --mode=authored rubocop --verbose
+result_code=$?
+if [ $result_code -gt "0" ]; then
+  echo -en "\033[0;31m" # RED
+  echo "[✘] Ruby Appraiser found newly-created defects and "
+  echo "    has blocked your commit."
+  echo "    Fix the defects and commit again."
+  echo "    To bypass, commit again with --no-verify."
+  echo -en "\033[0m" # RESET
+  exit $result_code
+else
+  echo -en "\033[0;32m" # GREEN
+  echo "[✔] Ruby Appraiser ok"
+  echo -en "\033[0m" #RESET
+fi

data/lib/sparsify.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+require 'sparsify/version'
+require 'sparsify/utility_methods'
+require 'sparsify/helper_methods'
+require 'sparsify/guard_methods'
+
+# Provides sparse-key access to a Hash.
+#
+# {'foo'=>{'bar'=>'bingo'}}.sparse #=> {'foo.bar'=>'bingo'}
+# {'foo.bar'=>'bingo'}.unsparse => {'foo'=>{'bar'=>'bingo'}}
+#
+module Sparsify
+  # The default separator, used if not specified in command's
+  # options hash.
+  DEFAULT_SEPARATOR = '.'.freeze
+
+  # Returns a sparse version of self using the options provided.
+  #
+  # @param options [Hash<Symbol,Object>]
+  # @option options [String] :separator
+  # @option options [String] :prefix
+  # @option options [Boolean,:zero_pad] :sparse_array (false)
+  #   truthy values will cause arrays to be sparsed by index and decended into.
+  #   :zero_pad causes indexes to be zero-padded to make them sort lexically.
+  # @return [Hash<String,Object>]
+  def sparse(options = {})
+    Sparsify.sparse(self, options)
+  end
+
+  # Replaces self with sparse version of itself.
+  #
+  # @param options (see #sparse)
+  # @return [Hash<String,Object>]
+  def sparse!(options = {})
+    self.replace(sparse, options)
+  end
+
+  # Used internally by both Sparsify::Utility#sparse and
+  # Sparsify::Utility#unsparse
+  #
+  # @overload sparse_eachrm (options = {}, &block)
+  #   Yields once per key in sparse version of itself.
+  #   @param options (see #sparse)
+  #   @yieldparam [(sparse_key,value)]
+  #   @return [void]
+  # @overload sparse_each(options = {})
+  #   @param options (see #sparse)
+  #   @return [Enumerator<(sparse_key,value)>]
+  def sparse_each(options = {}, &block)
+    Sparsify.sparse_each(self, options, &block)
+  end
+
+  # Follows semantics of Hash#fetch
+  #
+  # @overload sparse_fetch(sparse_key, options = {})
+  #   @param options (see #sparse)
+  #   @raise [KeyError] if sparse_key not found 
+  #   @return [Object]
+  # @overload sparse_fetch(sparse_key, default, options = {})
+  #   @param options (see #sparse)
+  #   @param default [Object] the default object
+  #   @return [default]
+  # @overload sparse_fetch(sparse_key, options = {}, &block)
+  #   @param options (see #sparse)
+  #   @yield if sparse_key not founs
+  #   @return [Object] that which was returned by the given block.
+  def sparse_fetch(*args, &block)
+    Sparsify.sparse_fetch(self, *args, &block)
+  end
+
+  # Follows semantics of Hash#[] without support for Hash#default_proc
+  #
+  # @overload sparse_get(sparse_key, options = {})
+  #   @param options (see #sparse)
+  #   @return [Object] at that address or nil if none found
+  def sparse_fetch(*args, &block)
+    Sparsify.sparse_fetch(self, *args, &block)
+  end
+
+  # Returns a deeply-nested hash version of self.
+  #
+  # @param options (see #sparse)
+  # @return [Hash<String,Object>]
+  def unsparse(options = {})
+    Sparsify.unsparse(self, options)
+  end
+
+  # Replaces self with deeply-nested version of self.
+  #
+  # @param options (see #sparse)
+  # @return [Hash<String,Object>]
+  def unsparse!(options = {})
+    self.replace(unsparse, options)
+  end
+end

data/lib/sparsify/guard_methods.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Sparsify
+  # Methods to ensure Sparsify isn't mixed into nonsensical things
+  module GuardMethods
+    # Sparsify can be *extended* into instances of Hash
+    # @param base [Hash]
+    def extended(base)
+      unless base.is_a? Hash
+        raise ArgumentError, "<#{base.inspect}> is not a Hash!"
+      end
+    end
+
+    # Sparsigy can be *included* into implementations of Hash
+    # @param base [Hash.class]
+    def included(base)
+      unless base <= Hash
+        raise ArgumentError, "<#{base.inspect} does not inherit Hash"
+      end
+    end
+  end
+
+  extend GuardMethods
+end

data/lib/sparsify/helper_methods.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Sparsify
+  module HelperMethods
+    def Sparsify(hsh, options = {})
+      Sparsify.sparse(hsh, options)
+    end
+
+    def Unsparsify(hsh, options = {})
+      Sparsify.unsparse(hsh, options)
+    end
+  end
+
+  extend HelperMethods
+end
+
+include Sparsify::HelperMethods

data/lib/sparsify/utility_methods.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+module Sparsify
+  # The Utility Methods provide a significant (~4x) performance increase
+  # over extend-ing instance methods everywhere we need them.
+  module UtilityMethods
+
+    # Provides a way to iterate through a deeply-nested hash as if it were
+    # a sparse-hash. Used internally for generating and deconstructing sparse
+    # hashes.
+    #
+    # @overload sparse_each(hsh, options = {}, &block)
+    #   Yields once per key in sparse version of itself.
+    #   @param hsh [Hash<#to_s,Object>]
+    #   @param options (see Sparsify::UtilityMethods#sparse)
+    #   @yieldparam [(sparse_key,value)]
+    #   @return [void]
+    # @overload sparse_each(hsh, options = {})
+    #   @param hsh [Hash<#to_s,Object>]
+    #   @param options (see Sparsify::UtilityMethods#sparse)
+    #   @return [Enumerator<(sparse_key,value)>]
+    def sparse_each(hsh, options = {}, &block)
+      return enum_for(:sparse_each, hsh, options) unless block_given?
+
+      inherited_prefix = options.fetch(:prefix, nil)
+      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+      sparse_array = options.fetch(:sparse_array, false)
+
+      hsh.each do |partial_key, value|
+        key = escaped_join(inherited_prefix, partial_key.to_s, separator)
+        if value.kind_of?(Hash) && !value.empty?
+          sparse_each(value, options.merge(prefix: key), &block)
+        elsif sparse_array && value.kind_of?(Array) && !value.empty?
+          zps = (sparse_array == :zero_pad ? "%0#{value.count.to_s.size}d" : '%d')# zero-pad string
+          sparse_each(value.count.times.map(&zps.method(:%)).zip(value), options.merge(prefix: key), &block)
+        else
+          yield key, value
+        end
+      end
+    end
+
+    # Returns a sparse version of the given hash
+    #
+    # @param hsh [Hash<#to_s,Object>]
+    # @param options (see Sparsify::UtilityMethods#sparse)
+    # @return [Hash<String,Object>]
+    def sparse(hsh, options = {})
+      enum = sparse_each(hsh, options)
+      enum.each_with_object(Hash.new) do |(key, value), memo|
+        memo[key] = value
+      end
+    end
+
+    # Returns a deeply-nested version of the given sparse hash
+    # @param hsh [Hash<#to_s,Object>]
+    # @param options (see Sparsify::UtilityMethods#sparse)
+    # @return [Hash<String,Object>]
+    def unsparse(hsh, options = {})
+      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+      hsh.each_with_object({}) do |(k, v), memo|
+        current = memo
+        key = escaped_split(k, separator)
+        up_next = partial = key.shift
+        until key.size.zero?
+          up_next = key.shift
+          up_next = up_next.to_i if (up_next =~ /\A[0-9]+\Z/)
+          current = (current[partial] ||= (up_next.kind_of?(Integer) ? [] : {}))
+          case up_next
+          when Integer then raise KeyError unless current.kind_of?(Array)
+          else              raise KeyError unless current.kind_of?(Hash)
+          end
+          partial = up_next
+        end
+        current[up_next] = v
+      end
+    end
+
+    # Fetch a sparse key from the given deeply-nested hash.
+    #
+    # @overload sparse_fetch(hsh, sparse_key, default, options = {})
+    #   @param hsh [Hash<#to_s,Object>]
+    #   @param sparse_key [#to_s]
+    #   @param default [Object] returned if sparse key not found
+    #   @param options (see Sparsify::UtilityMethods#sparse)
+    #   @return [Object]
+    # @overload sparse_fetch(hsh, sparse_key, options = {}, &block)
+    #   @param hsh [Hash<#to_s,Object>]
+    #   @param sparse_key [#to_s]
+    #   @param options (see Sparsify::UtilityMethods#sparse)
+    #   @yieldreturn is returned if key not found
+    #   @return [Object]
+    # @overload sparse_fetch(hsh, sparse_key, options = {})
+    #   @param hsh [Hash<#to_s,Object>]
+    #   @param sparse_key [#to_s]
+    #   @param options (see Sparsify::UtilityMethods#sparse)
+    #   @raise KeyError if key not found
+    #   @return [Object]
+    def sparse_fetch(hsh, sparse_key, *args, &block)
+      options = ( args.last.kind_of?(Hash) ? args.pop : {})
+      default = args.pop
+
+      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+
+      escaped_split(sparse_key, separator).reduce(hsh) do |memo, kp|
+        if memo.kind_of?(Hash) and memo.has_key?(kp)
+          memo.fetch(kp)
+        elsif default
+          return default
+        elsif block_given?
+          return yield
+        else
+          raise KeyError, sparse_key
+        end
+      end
+    end
+
+    # Get a sparse key from the given deeply-nested hash, or return nil
+    # if key not found.
+    #
+    # Worth noting is that Hash#default_proc is *not* used, as the intricacies
+    # of implementation would lead to all sorts of terrible surprises.
+    #
+    # @param hsh [Hash<#to_s,Object>]
+    # @param sparse_key [#to_s]
+    # @param options (see Sparsify::UtilityMethods#sparse)
+    # @return [Object]
+    def sparse_get(hsh, sparse_key, options = {})
+      sparse_fetch(hsh, sparse_key, options) { nil }
+    end
+
+    private
+
+    # Utility method for backslash-escaping a string
+    # @param str [String]
+    # @param separator [String] single-character string
+    # @return [String]
+    def escape(str, separator)
+      pattern = /(\\|#{Regexp.escape(separator)})/
+      str.gsub(pattern, '\\\\\1')
+    end
+
+    # Utility method for removing backslash-escaping from a string
+    # @param str [String]
+    # @param separator [String] single-character string
+    # @return [String]
+    def unescape(str, separator)
+      pattern = /\\(\\|#{Regexp.escape(separator)})/
+      str.gsub(pattern, '\1')
+    end
+
+    # Utility method for splitting a string by a separator into
+    # non-escaped parts
+    # @param str [String]
+    # @param separator [String] single-character string
+    # @return [Array<String>]
+    def escaped_split(str, separator)
+      unescaped_separator = /(?<!\\)(#{Regexp.escape(separator)})/
+      # String#split(<Regexp>) on non zero-width matches yields the match
+      # as the even entries in the array.
+      parts = str.split(unescaped_separator).each_slice(2).map(&:first)
+      parts.map do |part|
+        unescape(part, separator)
+      end
+    end
+
+    # Utility method for joining a pre-escaped string with a not-yet escaped
+    # string on a given separator, escaping the new part before joining.
+    # @param pre_escaped_prefix [String]
+    # @param new_part [String] - will be escaped before joining
+    # @param separator [String] single-character string
+    # @return [String]
+    def escaped_join(pre_escaped_prefix, new_part, separator)
+      [pre_escaped_prefix, escape(new_part, separator)].compact.join(separator)
+    end
+  end
+
+  extend UtilityMethods
+end

data/lib/sparsify/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Sparsify
+  VERSION = '1.0.0'
+end

data/sparsify.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sparsify/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sparsify'
+  spec.version       = Sparsify::VERSION
+  spec.authors       = ['Ryan Biesemeyer']
+  spec.email         = ['ryan@simplymeasured.com']
+  spec.description   = 'Flattens deeply-nested hashes into sparse hashes'
+  spec.summary       = 'Flattens deeply-nested hashes into sparse hashes'
+  spec.homepage      = 'https://www.github.com/simplymeasured/sparsify'
+  spec.license       = 'Apache 2'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'ruby-appraiser-rubocop'
+end

data/spec/sparsify_spec.rb

@@ -0,0 +1,197 @@
+# encoding: utf-8
+require 'sparsify'
+
+describe 'Sparsify' do
+  let(:source_hash) do
+    {'foo' => { 'bar' => {'baz'=>'bingo', 'whee'=> {}}},'asdf'=>'qwer'}
+  end
+
+  let(:intended_result) do
+    {
+      'foo.bar.baz' => 'bingo',
+      'foo.bar.whee' => {},
+      'asdf' => 'qwer',
+    }
+  end
+
+  it 'should sparsify' do
+    Sparsify(source_hash).should == intended_result
+  end
+
+  context 'round-trip' do
+    subject do
+      Unsparsify(Sparsify(source_hash, separator: '|'), separator: '|')
+    end
+    it { should == source_hash }
+  end
+
+  context 'escaping separator in keys' do
+    let(:nested_hash) do
+      {
+        'foo.foo' => 'foo',
+        'foo' => {'bar.bar' => 'bar'}
+      }
+    end
+    let(:sparse_hash) do
+      {
+        'foo\.foo' => 'foo',
+        'foo.bar\.bar' => 'bar'
+      }
+    end
+    context '#sparse' do
+      subject do
+        Sparsify(nested_hash)
+      end
+      it { should eq sparse_hash }
+    end
+    context '#unsparse' do
+      subject do
+        Unsparsify(sparse_hash)
+      end
+      it { should eq nested_hash }
+    end
+  end
+
+  context 'sparse_array' do
+    let(:source_hash) do
+      {'foo' => ['bar','baz',{'bingo'=>'baby'}]}
+    end
+    let(:intended_result) do
+      {
+        'foo.0' => 'bar',
+        'foo.1' => 'baz',
+        'foo.2.bingo' => 'baby'
+      }
+    end
+    it 'should sparsify' do
+      Sparsify(source_hash, sparse_array: true).should == intended_result
+    end
+    context 'round-trip' do
+      subject do
+        Unsparsify(Sparsify(source_hash, sparse_array: true), sparse_array: true)
+      end
+      it { should == source_hash }
+    end
+    context 'zero-pad' do
+      let(:source_hash) do
+        {'foo' => ['bar','baz',{'bingo'=>'baby'},'blip','blip','blip','blip','blip','blip','blip','blip']}
+      end
+      let(:intended_result) do
+        {
+          'foo.00' => 'bar',
+          'foo.01' => 'baz',
+          'foo.02.bingo' => 'baby',
+          'foo.03' => 'blip',
+          'foo.04' => 'blip',
+          'foo.05' => 'blip',
+          'foo.06' => 'blip',
+          'foo.07' => 'blip',
+          'foo.08' => 'blip',
+          'foo.09' => 'blip',
+          'foo.10' => 'blip',
+        }
+      end
+      it 'should sparsify' do
+        Sparsify(source_hash, sparse_array: :zero_pad).should == intended_result
+      end
+    end
+  end
+
+  context '.sparse_each' do
+    context 'when no block given' do
+      let(:sparse_each_result) { Sparsify.sparse_each(source_hash) }
+      context 'the result' do
+        subject { sparse_each_result }
+        it { should be_an_instance_of Enumerator }
+      end
+    end
+
+    context 'with block given' do
+      it 'should yield all entries from the sparse hash' do
+        expect do |b|
+          Sparsify.sparse_each(source_hash, &b)
+        end.to yield_successive_args(*intended_result.to_a)
+      end
+    end
+  end
+
+  context '.sparse_fetch' do
+    let(:fetch_args) { [source_hash, search_key] }
+    let(:the_intended_result) { intended_result[search_key] }
+    let(:the_fetcher) do
+      proc { |block| Sparsify.sparse_fetch(*fetch_args, &block) }
+    end
+    let(:the_result) { the_fetcher.call }
+    let(:fetch_block) { nil }
+    context 'when fetching an existing key' do
+      let(:search_key) { 'foo.bar.baz' }
+      context 'the result' do
+        subject { the_result }
+        it { should == the_intended_result }
+      end
+    end
+    context 'when fetching an existing partial key' do
+      context 'the result' do
+        let(:search_key) { 'foo.bar' }
+        let(:the_intended_result) { source_hash['foo']['bar'] }
+        subject { the_result }
+        it { should eq the_intended_result }
+      end
+    end
+    context 'when fetching a missing key' do
+      let(:search_key) { 'fiddle.foodle' }
+      context 'with default supplied' do
+        let(:fetch_args) { [source_hash, search_key, default_value] }
+        let(:default_value) { :some_default }
+        it 'should return the default' do
+          the_result.should eq default_value
+        end
+      end
+      context 'with alternate block supplied' do
+        it 'should yield the block' do
+          expect { |b| the_fetcher.call(b) }.to yield_with_no_args
+        end
+        context 'the return value' do
+          let(:default_value) { :some_default }
+          let(:default_proc) { proc { default_value } }
+          subject { the_fetcher.call(default_proc)}
+          it { should eq default_value }
+        end
+      end
+      specify { expect { the_result }.to raise_exception KeyError }
+    end
+  end
+
+  context '.sparse_get' do
+    let(:get_args) { [source_hash, search_key] }
+    let(:the_getter) do
+      proc { |block| Sparsify.sparse_fetch(*get_args, &block) }
+    end
+    let(:the_result) { the_getter.call }
+
+    context 'when getting an existing key' do
+      let(:the_intended_result) { intended_result[search_key] }
+      let(:search_key) { 'foo.bar.baz' }
+      context 'the result' do
+        subject { the_result }
+        it { should == the_intended_result }
+      end
+    end
+
+    context 'when getting an existing partial key' do
+      context 'the result' do
+        let(:search_key) { 'foo.bar' }
+        let(:the_intended_result) { source_hash['foo']['bar'] }
+        subject { the_result }
+        it { should eq the_intended_result }
+      end
+    end
+
+    context 'when getting a missing key' do
+      let(:search_key) { 'fiddle.foodle' }
+      context 'the result' do
+        subject { the_result }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: sparsify
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Biesemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-appraiser-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Flattens deeply-nested hashes into sparse hashes
+email:
+- ryan@simplymeasured.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- git_hooks/pre-commit/ruby-appraiser
+- lib/sparsify.rb
+- lib/sparsify/guard_methods.rb
+- lib/sparsify/helper_methods.rb
+- lib/sparsify/utility_methods.rb
+- lib/sparsify/version.rb
+- sparsify.gemspec
+- spec/sparsify_spec.rb
+homepage: https://www.github.com/simplymeasured/sparsify
+licenses:
+- Apache 2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Flattens deeply-nested hashes into sparse hashes
+test_files:
+- spec/sparsify_spec.rb
+has_rdoc: