dive 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 0.0.1 (17/1/12)
+ - Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,94 @@
+# Dive: for deep hash access
+
+Dive is a gem for accessing values within nested Hashes.
+
+Why? Well, it all started when I was mapping human readable names taken from a Cucumber table to fields in a JSON response:
+
+```cucumber
+Given I have some sausages with
+  | Name          | Contents                      |
+  | Pork + Fennel | pork mince, fennel, intestine |
+  | Soylent Green | people                        |  
+```
+
+```ruby
+Given /^I have some sausages with$/ |table|
+  fields = {
+    'Name' => :name,
+    'Contents' => :ingredients
+  }
+  table.hashes.each do |row|
+    sausage = {} 
+    row.each_pair do |key, value|
+      sausage[fields[key]] = value
+    end
+    @response[:sausages] << sausage
+  end
+end
+```
+
+```ruby
+@response
+{ 
+  :sausages => [
+    {
+	  :name => 'Pork + Fennel'
+      :ingredients => 'pork mince, fennel, intestine'
+    },
+    {
+	  :name => 'Soylent Green',
+	  :ingredients => 'people'
+    }
+  ]
+}
+```
+
+All fine and dandy until I had to map to values that were nested under the first level of the response:
+
+```ruby
+@response
+{ 
+  :sausages => [
+    {
+	  :name => 'Pork + Fennel'
+      :ingredients => {
+	    :casing => 'intestine',
+	    :filling => {
+	      :meat => 'pork mince',
+	      :spices => 'fennel'
+	    }
+      }
+    }
+  ]
+}
+```
+
+I wanted to be able to do something like this:
+
+```ruby
+fields = {
+  'Name' => :sausage_name,
+  'Spices' => ':ingredients[:filling[:spices]]'
+}
+```
+
+So I did.
+
+Check out the specs for how it behaves.
+
+### Installation and usage
+
+```ruby
+gem install dive
+
+require 'dive'
+foods = { :sausages => {:pork_and_fennel => 'DELICIOUS'}}
+foods[':sausages[:pork_and_fennel]']
+```
+
+Or if you become squeamish at the idea of overriding Hash's [] method:
+
+```ruby
+require 'dive/noninvasive'
+foods.dive ':sausages[:pork_and_fennel]'
+```

data/Rakefile

@@ -0,0 +1,20 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => ['spec:invasive', 'spec:noninvasive']
+
+namespace :spec do
+  rspec_opts = '-f d'
+  
+  desc "Run all examples with invasive Hash extensions"
+  RSpec::Core::RakeTask.new('invasive') do |t|
+    t.pattern = './spec/invasive/**/*.rb'
+    t.rspec_opts = rspec_opts
+  end
+
+  desc "Run all examples with non-invasive Hash extensions"
+  RSpec::Core::RakeTask.new('noninvasive') do |t|
+    t.pattern = './spec/noninvasive/**/*.rb'
+    t.rspec_opts = rspec_opts
+  end
+end

data/dive.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dive/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dive"
+  s.version     = Dive::VERSION
+  s.authors     = ["Brent Snook"]
+  s.email       = ["brent@fuglylogic.com"]
+  s.homepage    = "http://github.com/brentsnook/dive"
+  s.summary     = %q{A gem for accessing values within nested Hashes}
+  s.description = %q{For example: {:sausages => {:pork_and_fennel => 'DELICIOUS'}}[':sausages[:pork_and_fennel]']}
+
+  s.rubyforge_project = "dive"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 2.7"
+end

data/lib/dive.rb

@@ -0,0 +1,2 @@
+require 'dive/noninvasive'
+Hash.send :include, Dive::Extensions

data/lib/dive/dive.rb

@@ -0,0 +1,73 @@
+require 'dive/version'
+
+module Dive
+  
+  def self.included clazz
+    clazz.send :include, Read
+    clazz.send :include, Write
+  end
+  
+  def symbolise key
+    is_symbol = key.respond_to?(:to_sym) && key[0] == ':'
+    is_symbol ? key[1..-1].to_sym : key
+  end
+    
+  module Read
+    
+    def self.included clazz
+      clazz.send :alias_method, :old_read, :[]
+    end
+  
+    def dive location
+      has_key?(location) ? old_read(location) : dive_read(location)
+    end
+    
+    private
+    
+    def dive_read location
+      has_key?(symbolise(location)) ? old_read(symbolise(location)) : attempt_dive(location)
+    end
+    
+    def default_value key
+      default_proc ? default_proc.call(self, key) : default
+    end 
+    
+    def attempt_dive location
+      matches = location.to_s.match /([^\[\]]*)\[(.*)\]/ #(key)[(remainder)]
+      matches ? dive_to_next_level(matches[1].strip, matches[2].strip) : default_value(location)
+    end
+    
+    def dive_to_next_level key, remainder
+      value = old_read(symbolise(key))
+      value.respond_to?(:dive) ? value.dive(remainder) : default_value(remainder)
+    end
+  end
+  
+  module Write
+    
+    def self.included clazz
+      clazz.send :alias_method, :old_store, :[]=
+    end
+    
+    def dive_store location, value
+      matches = location.to_s.match /([^\[\]]*)\[(.*)\]/
+      matches ? store_at_next_level(matches[1], matches[2], value): old_store(symbolise(location), value)
+    end
+    
+    private
+    
+    def store_at_next_level(key, remainder, value)
+      storer = has_key?(symbolise(key)) ? old_read(symbolise(key)) : {}
+      old_store symbolise(key), storer
+      storer.dive_store remainder, value
+    end
+    
+  end
+  
+  module Extensions
+    def self.included clazz
+      clazz.send :alias_method, :[], :dive
+      clazz.send :alias_method, :[]=, :dive_store
+    end
+  end
+end

data/lib/dive/noninvasive.rb

@@ -0,0 +1,2 @@
+require 'dive/dive'
+Hash.send :include, Dive

data/lib/dive/version.rb

@@ -0,0 +1,3 @@
+module Dive
+  VERSION = "0.0.1"
+end

data/spec/invasive/hash_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../lib/dive'
+
+describe Hash, 'when extended' do
+  
+  it 'performs a dive on []' do
+    hash = {'first' => {'second' => {'third' => 'deep value'}}}
+    hash['first[second[third]]'].should == 'deep value'
+  end
+  
+  it 'performs a dive store on []=' do
+    hash = {'first' => {}}
+    hash['first[second]'] = 'deep value'
+    hash['first']['second'].should == 'deep value'
+  end
+  
+  it "allows keys that aren't strings or symbols" do
+    {['array'] => 'value'}[['array']].should == 'value'
+  end
+  
+  it 'allows a nil key' do
+    hash = {:x => :y}
+    hash[nil].should == hash.default    
+  end
+end

data/spec/noninvasive/read_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Dive, 'when reading' do
+    
+  describe 'with a location that matches a normal key' do
+    it 'retrieves the normal value' do
+      hash = {'first[second]' => 'normal value', 'first' => {'second' => 'deep value'}}
+      hash.dive('first[second]').should == 'normal value'
+    end
+  end
+  
+  describe 'with a location that matches a deep key' do
+    it 'retrieves the deep value' do
+      hash = {'first' => {'second' => {'third' => 'deep value'}}}
+      hash.dive('first[second[third]]').should == 'deep value'
+    end
+  end
+  
+  it 'retrieves values that have a symbol as key' do
+    hash = {:first => {:second => 'deep value'}}
+    hash.dive(':first[:second]').should == 'deep value'
+  end
+
+  it 'ignores space around location parts' do
+    hash = {'first' => {'second' => {'third' => 'deep value'}}}
+    hash.dive('first  [  second [  third  ] ] ').should == 'deep value'
+  end
+
+  describe "when a value at any part of the location doesn't exist" do
+    it 'retrieves the default value of the hash where no key was found' do
+      hash = {'first' => {'second' => Hash.new('default')}}
+      hash.dive('first[second[idontexist]]').should == 'default'
+    end
+  end
+
+  describe 'when a hash at any part of the location can not dive' do
+    
+    before do
+      @hash = {'first' => {'second' => 'cantdive'}}
+    end
+    
+    describe 'when that hash was created with a default value' do
+      it 'retrieves the default value' do
+        @hash['first'].default = 'default'
+        @hash.dive('first[second[cantdive[fourth]]]').should == 'default'
+      end
+    end
+    
+    describe 'when that hash was created with a default proc' do
+      
+      before do
+        @hash['first'].default_proc = proc { |hash, key| "default proc: #{key}"}
+        @result = @hash.dive('first[second[cantdive[fourth]]]')
+      end
+    
+      it 'retrieves the result of evaluating the default proc' do
+        @result.should include('default proc')
+      end
+    
+      it 'uses the remainder of the location as the proc key' do
+        @result.should include('cantdive[fourth]')
+      end
+    end
+  end
+  
+  describe 'when no normal key or dive location exists' do
+    it 'retrieves the default value' do
+      hash = Hash.new 'default'
+      hash['first'] = 'value'
+      hash.dive('idontexist').should == 'default'
+    end
+  end
+  
+  it 'still attempts to dive when the default value is not nil' do
+    hash = Hash.new 'default'
+    hash['first'] = {'second' => 'deep value'}
+    hash.dive('first[second]').should == 'deep value'
+  end
+end

data/spec/noninvasive/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../../lib/dive/noninvasive'

data/spec/noninvasive/write_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Dive, 'when writing' do
+
+  describe 'with a deep location' do
+    it 'sets a deep value' do
+      nested_hash = {'third' => 'deep value'}
+      hash = {'first' => {'second' => nested_hash}}
+      
+      hash.dive_store('first[second[third]]', 'deep value')
+      
+      nested_hash['third'].should == 'deep value'
+    end
+  end
+  
+  describe 'with a normal location' do
+    it 'sets a normal value' do
+      hash = {}
+      hash.dive_store 'normal', 'normal value'
+      hash['normal'].should == 'normal value'
+    end
+  end
+  
+  describe "when parts of the location don't exist" do
+    it 'creates each part as a new Hash' do
+      hash = {}
+      hash.dive_store 'first[second[third]]', 'value'
+      hash['first']['second']['third'].should == 'value'
+    end
+  end
+  
+  describe 'when the value at the end of a location is not divable' do
+    it 'raises a NoMethodError' do
+      hash = {'first' => 'not divable'}
+      lambda { hash.dive_store 'first[second]', 'value' }.should raise_exception(NoMethodError)
+    end
+  end
+  
+  it 'recognises symbol keys' do
+    hash = {:first => {}}
+    hash.dive_store ':first[:second]', 'value'
+    hash[:first][:second].should == 'value'
+  end
+end

data/todo.txt

@@ -0,0 +1,11 @@
+
+- exploratory testing
+- test with 1.8.7
+- update change log
+- publish to gem repo
+
+-- LATER --
+
+- add can_dive? method - checks if there is a key
+- normal override overrides has_key? also
+- add support for arrays

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: dive
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brent Snook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152401600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: *2152401600
+description: ! 'For example: {:sausages => {:pork_and_fennel => ''DELICIOUS''}}['':sausages[:pork_and_fennel]'']'
+email:
+- brent@fuglylogic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- dive.gemspec
+- lib/dive.rb
+- lib/dive/dive.rb
+- lib/dive/noninvasive.rb
+- lib/dive/version.rb
+- spec/invasive/hash_spec.rb
+- spec/noninvasive/read_spec.rb
+- spec/noninvasive/spec_helper.rb
+- spec/noninvasive/write_spec.rb
+- todo.txt
+homepage: http://github.com/brentsnook/dive
+licenses: []
+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: dive
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A gem for accessing values within nested Hashes
+test_files:
+- spec/invasive/hash_spec.rb
+- spec/noninvasive/read_spec.rb
+- spec/noninvasive/spec_helper.rb
+- spec/noninvasive/write_spec.rb