hash_tools 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c49be4b67ede742b42848405b4ac0226266a345
+  data.tar.gz: e4d2509e181d2466bd4a2f42bbdd328c2f9bad4e
+SHA512:
+  metadata.gz: 5e96a94e34f64344db9236a10bd12af7e8e726a00b9ba0b597be36c2ed7cdb15d1e7e62669eadf49ab91a250382fa2ac5d03981faa8a04f4a5bbc467dbc32046
+  data.tar.gz: 2a1e88310651ce839db9e14c116b9df405917a347f2a3ceb8c2ace9ac3309c26ce35224625fa6bc1ea4a3fd8e56d5debcb4f2e89346d22d57f024096b7deb865

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec", "~> 3.2.0", '< 3.3'
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Julik Tarkhanov
+
+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.
+
+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,52 @@
+# hash_tools
+
+Do things to Hashes, without injecting methods into them or extending core classes of the language.
+And mostly without being too smart. Does not require ActiveSupport.
+
+Transforming the keys of a hash:
+
+    HashTools::Transform.transform_keys_of({'foo' => 1}, &:upcase) #=> {'FOO' => 1}, works recursively
+
+Fetching multiple values from a Hash:
+
+    h = {
+      'foo' => {
+        'bar' => 2
+        'baz' => 1
+      }
+    }
+    HashTools.deep_fetch(h, 'foo/bar') #=> 2
+    HashTools.deep_fetch_multi(h, 'foo/bar', 'foo/baz') #=> [2, 1]
+
+Fetching multiple values from arrays of Hashes
+
+    records = [
+      {'name': 'Jake'},
+      {'name': 'Barbara'},
+    ]
+    
+    HashTools.deep_map_value(records, 'name') #=> ['Jake', 'Barbara']
+
+A simple indifferent access proxy:
+
+    h = {'foo'=>{bar: 2}}
+    w = HashTools.indifferent(h)
+    w[:foo][:bar] #=> 2
+
+Check the documentation for the separate modules for more.
+
+## Contributing to hash_tools
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2015 Julik Tarkhanov. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require_relative 'lib/hash_tools'
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.version = HashTools::VERSION
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "hash_tools"
+  gem.homepage = "http://github.com/julik/hash_tools"
+  gem.license = "MIT"
+  gem.description = %Q{Do useful things to Ruby Hashes}
+  gem.summary = %Q{Do useful things to Ruby Hashes}
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hash_tools #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/hash_tools.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: hash_tools 1.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "hash_tools"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2015-10-17"
+  s.description = "Do useful things to Ruby Hashes"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".yardopts",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "hash_tools.gemspec",
+    "lib/hash_tools.rb",
+    "lib/hash_tools/indifferent.rb",
+    "spec/hash_tools/indifferent_spec.rb",
+    "spec/hash_tools_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/julik/hash_tools"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Do useful things to Ruby Hashes"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["< 3.3", "~> 3.2.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+    else
+      s.add_dependency(%q<rspec>, ["< 3.3", "~> 3.2.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["< 3.3", "~> 3.2.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+  end
+end
+

data/lib/hash_tools/indifferent.rb

@@ -0,0 +1,103 @@
+require 'delegate'
+
+# A tiny version of HashWithIndifferentAccess. Works like a wrapper proxy around a Ruby Hash.
+# Does not support all of the methods for a Ruby Hash object, but nevertheless can be useful
+# for checking params and for working with parsed JSON.
+class HashTools::Indifferent < SimpleDelegator
+  # Create a new Indifferent by supplying a Ruby Hash object to wrap. The Hash being
+  # wrapped is not going to be altered or copied.
+  #
+  # @param naked_hash [Hash] the Hash object to wrap with an Indifferent
+  def initialize(naked_hash)
+    __setobj__(naked_hash)
+  end
+  
+  # Get a value from the Hash, bu supplying a Symbol or a String
+  # Key presence is verified by first trying a Symbol, and then a String.
+  #
+  # @param k the key to fetch
+  # @return the value, wrapped in {Indifferent} if it is a Hash
+  def [](k)
+    v = __getobj__[__transform_key__(k)]
+    __rewrap__(v)
+  end
+  
+  # Set a value in the Hash, bu supplying a Symbol or a String as a key.
+  # Key presence is verified by first trying a Symbol, and then a String.
+  #
+  # @param k the key to set
+  # @param v the value to set
+  # @return v
+  def []=(k, v)
+    __getobj__[ __transform_key__(k) ] = v
+  end 
+  
+  # Fetch a value, by supplying a Symbol or a String as a key.
+  # Key presence is verified by first trying a Symbol, and then a String.
+  #
+  # @param k the key to set
+  # @param blk the block for no value
+  # @return v
+  def fetch(k, &blk)
+    v = __getobj__.fetch( __transform_key__(k) , &blk)
+    __rewrap__(v)
+  end
+  
+  # Get the keys of the Hash. The keys are returned as-is (both Symbols and Strings).
+  #
+  # @return [Array] an array of keys
+  def keys
+    __getobj__.keys.map{|k| __transform_key__(k) }
+  end
+  
+  # Checks for key presence whether the key is a String or a Symbol
+  #
+  # @param k[String,Symbol] the key to check
+  def key?(k)
+    __getobj__.has_key?( __transform_key__(k))
+  end
+  
+  # Yields each key - value pair of the indifferent.
+  # If the value is a Hash as well, that hash will be wrapped in an Indifferent before returning
+  def each(&blk)
+    __getobj__.each do |k, v|
+      blk.call([__transform_key__(k), __rewrap__(v)])
+    end
+  end
+  
+  # Yields each key - value pair of the indifferent.
+  # If the value is a Hash as well, that hash will be wrapped in an Indifferent before returning
+  def each_pair
+    o = __getobj__
+    keys.each do | k |
+      value = o[__transform_key__(k)]
+      yield(k, __rewrap__(value))
+    end
+  end
+  
+  def map(&blk)
+    keys.map do |k| 
+      tk = __transform_key__(k)
+      yield [tk, __rewrap__(__getobj__[tk])]
+    end
+  end
+  
+  alias_method :has_key?, :key?
+  
+  private
+  
+  def __transform_key__(k)
+    if __getobj__.has_key?(k.to_sym)
+      k.to_sym
+    else
+      k.to_s
+    end
+  end 
+  
+  def __rewrap__(v)
+    return v if v.is_a?(self.class)
+    return self.class.new(v) if v.is_a?(Hash)
+    return v.map{|e| __rewrap__(e)} if v.is_a?(Array)
+    v
+  end
+end

data/lib/hash_tools.rb

@@ -0,0 +1,135 @@
+module HashTools
+  VERSION = '1.0.0'
+  
+  require_relative 'hash_tools/indifferent'
+  
+  FWD_SLASH = '/' # Used as the default separator for deep_fetch
+  INT_KEY_RE = /^\-?\d+$/ # Regular expression to detect array indices in the path ("phones/0/code")
+  
+  # Fetch a deeply-nested hash key from a hash, using a String representing a path
+  #
+  #     deep_fetch({
+  #       'a' => {
+  #         'b' => {
+  #           'c' => value}}
+  #     }, 'a/b/c') #=> value
+  #
+  # @param hash [Hash] the (potentially deep) string-keyed Hash to fetch the value from
+  # @param path [String] the path to the item in `hash`. The path may contain numbers for deeply nested arrays ('foo/0/bar')
+  # @param separator [String] the path separator, defaults to '/'
+  # @param default_blk The default value block for when there is no value.
+  # @return the fetched value or the value of the default_block
+  def deep_fetch(hash, path, separator: FWD_SLASH, &default_blk)
+    keys = path.split(separator)
+    keys.inject(hash) do |hash_or_array, k|
+      if !hash_or_array.respond_to?(:fetch)
+        raise "#{hash_or_array.inspect} does not respond to #fetch"
+      elsif hash_or_array.is_a?(Array) && k =~ INT_KEY_RE
+        hash_or_array.fetch(k.to_i, &default_blk)
+      else
+        hash_or_array.fetch(k, &default_blk)
+      end
+    end
+  end
+  
+  # Fetches multiple keys from a deep hash, using a Strings representing paths
+  #
+  #     deep_fetch({
+  #       'z' => 1,
+  #       'a' => {
+  #         'b' => {
+  #           'c' => value}}
+  #     }, 'a/b', 'z') #=> [value, 1]
+  #
+  # @param hash [Hash] the (potentially deep) string-keyed Hash to fetch the value from
+  # @param key_paths [String] the paths to the items in `hash`. The paths may contain numbers for deeply nested arrays ('foo/0/bar')
+  # @param separator [String] the path separator, defaults to '/'
+  # @return [Array] the fetched values
+  def deep_fetch_multi(hash, *key_paths, separator: FWD_SLASH)
+    key_paths.map{|k| deep_fetch(hash, k, separator: separator) }
+  end
+  
+  # Fetches a deeply nested key from each of the Hashes in a given Array.
+  #
+  #     arr = [
+  #       {'age' => 12, 'name' => 'Jack'},
+  #       {'age' => 25, 'name' => 'Joe'},
+  #     ]
+  #     deep_map_value(arr, 'age') => [12, 25]
+  #
+  # @param enum_of_hashes [Enumerable] a list of Hash objects to fetch the values from
+  # @param path [String] the paths to the value. Paths may contain numbers for deeply nested arrays ('foo/0/bar')
+  # @param separator [String] the path separator, defaults to '/'
+  # @return [Array] the fetched values
+  def deep_map_value(enum_of_hashes, path, separator: FWD_SLASH)
+    enum_of_hashes.map{|h| deep_fetch(h, path, separator: separator)}
+  end
+  
+  # Recursively transform string keys and values of a passed
+  # Hash or Array using the passed transformer
+  #
+  # @param any [Hash,String,Array] the value to transform the contained items in
+  # @param transformer The block applied to each string key and value, recursively
+  # @return the transformed value
+  def transform_string_keys_and_values_of(any, &transformer)
+    transform_string_values_of(transform_keys_of(any, &transformer), &transformer)
+  end
+  
+  # Recursively convert string values in nested hashes and
+  # arrays using a passed block. The block will receive the String
+  # to transform and should return a transformed string.
+  #
+  # @param any [Hash,String,Array] the value to transform the contained items in
+  # @param transformer The block applied to each string value, recursively
+  # @return the transformed value
+  def transform_string_values_of(any, &transformer)
+    if any.is_a?(String)
+      transformer.call(any)
+    elsif any.is_a?(Array)
+      any.map{|e| transform_string_values_of(e, &transformer) }
+    elsif any.is_a?(Hash)
+      h = {}
+      any.each_pair do |k, v|
+        h[k] = transform_string_values_of(v, &transformer)
+      end
+      h
+    else
+      any
+    end
+  end
+  
+  # Recursively convert hash keys using a block.
+  # using a passed block. The block will receive a hash key
+  # to be transformed and should return a transformed key
+  # For example, to go from uderscored notation to camelized:
+  #
+  #      h = {'foo_bar' => 1}
+  #      transform_keys_of(h) {|k| k.to_s.camelize(:lower) } # => {'fooBar' => 1}
+  #
+  # @param any [Hash] the Hash to transform
+  # @param transformer the block to apply to each key, recursively
+  # @return [Hash] the transformed Hash
+  def transform_keys_of(any, &transformer)
+    if any.is_a?(Array)
+      return any.map{|e| transform_keys_of(e, &transformer) }
+    elsif any.is_a?(Hash)
+      h = {}
+      any.each_pair do |k, v|
+        h[transformer.call(k.to_s)] = transform_keys_of(v, &transformer)
+      end
+      h
+    else
+      any
+    end
+  end
+  
+  # Returns an {HashTools::Indifferent} wrapper for the given Hash.
+  #
+  # @param hash [Hash] the Hash to wrap
+  # @return [Indifferent] the wrapper for the hash
+  def indifferent(hash)
+    Indifferent.new(hash)
+  end
+  
+  extend self
+end

data/spec/hash_tools/indifferent_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../spec_helper'
+
+describe HashTools::Indifferent do
+  it 'supports indifferent access' do
+    h_syms = {a: 1, 'b' => 2}
+    wrapper = described_class.new(h_syms)
+    
+    expect(wrapper['a']).to eq(1)
+    expect(wrapper[:a]).to eq(1)
+    expect(wrapper.fetch('a')).to eq(1)
+    expect(wrapper.fetch(:a)).to eq(1)
+    
+    expect(wrapper['b']).to eq(2)
+    expect(wrapper[:b]).to eq(2)
+    expect(wrapper.fetch('b')).to eq(2)
+    expect(wrapper.fetch(:b)).to eq(2)
+    
+    expect(wrapper.keys).to eq(h_syms.keys)
+  end
+  
+  it 'supports indifferent access to deeply nested hashes' do
+    h_deep = {a: {:b => 1, 'c' => 2}}
+    
+    wrapper = described_class.new(h_deep)
+    expect(wrapper[:a][:b]).to eq(1)
+    expect(wrapper['a']['b']).to eq(1)
+    
+    expect(wrapper[:a][:c]).to eq(2)
+    expect(wrapper['a']['c']).to eq(2)
+    
+    expect(wrapper.keys).to eq(h_deep.keys)
+  end
+  
+  it 'supports map' do
+    h_deep = {:a => {:b => 1}, 'b' => {'b' => 2}}
+    wrapper = described_class.new(h_deep)
+    
+    wrapper.map do |(k, v)|
+      expect(v['b']).not_to be_nil
+      expect(v[:b]).not_to be_nil
+    end
+  end
+  
+  it 'supports indifferent access to inner arrays' do
+    h_deep = {:a => [{:b => 1}]}
+    wrapper = described_class.new(h_deep)
+    
+    expect(wrapper[:a][0][:b]).to eq(1)
+    expect(wrapper['a'][0]['b']).to eq(1)
+  end
+end

data/spec/hash_tools_spec.rb

@@ -0,0 +1,171 @@
+require_relative 'spec_helper'
+
+describe HashTools do
+  let(:t) do
+    Class.new do
+      include HashTools
+    end.new
+  end
+  let(:uppercase) { ->(k){ k.upcase } }
+  
+  describe '.indifferent' do
+    it 'returns an indifferent wrapper' do
+      h = {'foo' => {bar: 1}}
+      ind = t.indifferent(h)
+      expect(ind[:foo][:bar]).to eq(1)
+    end
+  end
+  
+  it 'transforms hash keys' do
+    s = {"set" => 10}
+    ref =  {"SET" => 10}
+    expect(t.transform_keys_of(s, &uppercase)).to eq(ref)
+  end
+  
+  it 'transforms nested hash keys' do
+    s = {"set" => {"two"=>123}}
+    ref =  {"SET"=>{"TWO"=>123}}
+    expect(t.transform_keys_of(s, &uppercase)).to eq(ref)
+  end
+  
+  it 'does nothing to the array' do
+    a = %w( a b c d)
+    expect(t.transform_keys_of(a, &uppercase)).to eq(a)
+  end
+  
+  it 'transforms hashes embedded in arrays' do
+    a = [{"me"=>"Julik"}]
+    ref = [{"ME"=>"Julik"}]
+    expect(t.transform_keys_of(a, &uppercase)).to eq(ref)
+  end
+  
+  it 'transforms nested hashes in an array' do
+    a = {"foo" => [{"me"=>"Julik"}]}
+    ref = {"FOO"=>[{"ME"=>"Julik"}]}
+    expect(t.transform_keys_of(a, &uppercase)).to eq(ref)
+  end
+  
+  it 'exposes methods on the module itself' do
+    expect(HashTools).to respond_to(:transform_keys_of)
+  end
+  
+  describe '.transform_string_values_of' do
+    it 'transforms the string value' do
+      x = "foo"
+      expect(t.transform_string_values_of(x, &uppercase)).to eq('FOO')
+    end
+    
+    it 'transforms strings in array' do
+      x = %w( foo bar baz)
+      ref = %w( FOO BAR BAZ )
+      expect(t.transform_string_values_of(x, &uppercase)).to eq(ref)
+    end
+    
+    it 'transforms string values in a Hash' do
+      x = {"foo" => "bar"}
+      ref = {"foo" => "BAR"}
+      expect(t.transform_string_values_of(x, &uppercase)).to eq(ref)
+    end
+  end
+  
+  describe '.transform_string_keys_and_values_of' do
+    it 'transforms both keys and values' do
+      x = {"foo" => "bar"}
+      ref = {"FOO" => "BAR"}
+      expect(t.transform_string_keys_and_values_of(x, &uppercase)).to eq(ref)
+    end
+  end
+  
+  describe '.deep_fetch' do
+    let(:deep) {
+      {
+        'foo' =>1,
+        'bar' => {
+          'baz' => 2
+        },
+        'array' => [1,2,3],
+        'array-with-hashes' => [{'name' => 'Joe'}, {'name' => 'Jane'}]
+      }
+    }
+    
+    it 'accepts a block for a default value' do
+      v = described_class.deep_fetch(deep, 'bar/nonexistent') { :default}
+      expect(v).to eq(:default)
+    end
+    
+    it 'fetches deep keys from a hash keyed by strings' do
+      expect(described_class.deep_fetch(deep, 'foo')).to eq(deep.fetch('foo'))
+      expect(described_class.deep_fetch(deep, 'bar/baz')).to eq(deep.fetch('bar').fetch('baz'))
+    end
+    
+    it 'fetches deep keys with a custom separator' do
+      expect(described_class.deep_fetch(deep, 'bar.baz', separator: '.')).to eq(deep.fetch('bar').fetch('baz'))
+    end
+    
+    it 'causes a KeyError to be raised for missing keys' do
+      expect {
+        described_class.deep_fetch(deep, 'bar/nonexistent')
+      }.to raise_error(KeyError, 'key not found: "nonexistent"')
+    end
+    
+    it 'allows fetches from arrays' do
+      expect(described_class.deep_fetch(deep, 'array/0')).to eq(1)
+      expect(described_class.deep_fetch(deep, 'array/-1')).to eq(3)
+    end
+    
+    it 'allows fetches from hashes within arrays' do
+      expect(described_class.deep_fetch(deep, 'array-with-hashes/0/name')).to eq('Joe')
+      expect {
+        described_class.deep_fetch(deep, 'array-with-hashes/10/name')
+      }.to raise_error(IndexError, /index 10 outside of array bounds/)
+      
+      default_value = described_class.deep_fetch(deep, 'array-with-hashes/0/jake') { :default }
+      expect(default_value).to eq(:default)
+    end
+  end
+  
+  describe '.deep_fetch_multi' do
+    let(:deep) {
+      {
+        'foo' =>1,
+        'bar' => {
+          'baz' => 2
+        },
+        'array' => [1,2,3],
+        'array-with-hashes' => [{'name' => 'Joe'}, {'name' => 'Jane'}]
+      }
+    }
+    
+    it 'fetches mutiple keys' do
+      expect(described_class.deep_fetch_multi(deep, 'foo', 'bar/baz')).to eq([1,2])
+    end
+    
+    it 'fetches deep keys with a custom separator' do
+      expect(described_class.deep_fetch_multi(deep, 'foo', 'bar.baz', separator: '.')).to eq([1,2])
+    end
+    
+    it 'causes a KeyError to be raised for missing keys' do
+      expect {
+        described_class.deep_fetch_multi(deep, 'foo', 'nonexistent')
+      }.to raise_error(KeyError)
+    end
+  end
+    
+  describe '.deep_map_value' do
+    it 'deep maps the values' do
+      v = [
+        {'foo' => 5},
+        {'foo' => 6},
+      ]
+      expect(described_class.deep_map_value(v, "foo")).to eq([5,6])
+    end
+    
+    it 'deep maps the values with a custom separator' do
+      v = [
+        {'foo' => {'bar' => 1}},
+        {'foo' => {'bar' => 2}},
+      ]
+      expect(described_class.deep_map_value(v, "foo-bar", separator: '-')).to eq([1,2])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'hash_tools'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: hash_tools
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+description: Do useful things to Ruby Hashes
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hash_tools.gemspec
+- lib/hash_tools.rb
+- lib/hash_tools/indifferent.rb
+- spec/hash_tools/indifferent_spec.rb
+- spec/hash_tools_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/julik/hash_tools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Do useful things to Ruby Hashes
+test_files: []