navigable_hash 0.0.1 → 1.0.0

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: 0r24ERdqRyaWZ5GjVaqJXl2K9vnXsgTia

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+.rbenv-gemsets
 .bundle
 .config
 .yardoc

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  # Rubies 2.0.0
+  - 2.0.0
+
+  # Rubies 1.9.x
+  - 1.9.3
+  - 1.9.2
+  - jruby-19mode
+  - rbx-19mode
+
+  # Rubies 1.8.7
+  - 1.8.7
+  - rbx-18mode
+  - jruby-18mode

data/README.md

@@ -1,6 +1,11 @@
 # NavigableHash
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/jwaldrip/navigable_hash.png?branch=master)](https://travis-ci.org/jwaldrip/navigable_hash)
+[![Coverage Status](https://coveralls.io/repos/jwaldrip/navigable_hash/badge.png?branch=master)](https://coveralls.io/r/jwaldrip/navigable_hash)
+[![Code Climate](https://codeclimate.com/github/jwaldrip/navigable_hash.png)](https://codeclimate.com/github/jwaldrip/navigable_hash)
+[![Dependency Status](https://gemnasium.com/jwaldrip/navigable_hash.png)](https://gemnasium.com/jwaldrip/navigable_hash)
+
+NavigableHash was built as lightweight and quick way to navigate through a hash or array object using the familiar ruby dot notation.  See 'Usage' below for examples.  Keys as strings or symbols don't matter, its all included.
 
 ## Installation
 
@@ -18,7 +23,41 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+(Check out the rspec tests for coverage examples)
+
+Most basic usage:
+```ruby
+test_hash = { :example_key => 'example value' }
+navigable_hash = NavigableHash.new(test_hash)
+
+navigable_hash.example_key
+# => 'example_value'
+```
+
+
+More:
+```ruby
+new_hash = { :second_key => { :inner_key => true }, :array_item => [{}, "string", :symbol] }
+navigable_hash = NavigableHash.new(new_hash)
+
+navigable_hash.second_key.inner_key
+# => true
+
+navigable_hash.array_item.last
+# => :symbol
+```
+
+
+Call Agnostic (key as a string, symbol or dot notation):
+```ruby
+new_hash = { "first_key" => "value 1" }
+navigable_hash = NavigableHash.new(new_hash)
+
+navigable_hash.first_key
+navigable_hash[:first_key]
+navigable_hash["first_key"]
+# => "value 1"
+```
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,5 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/navigable_hash.rb

@@ -1,29 +1,152 @@
-require "navigable_hash/version"
-require 'active_support/core_ext/hash'
-require "active_support/hash_with_indifferent_access"
+class NavigableHash < Hash
 
-class NavigableHash < HashWithIndifferentAccess
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  alias_method :get_value, :[] unless method_defined?(:get_value)
+  alias_method :set_value, :[]= unless method_defined?(:set_value)
+
+  def ==(other_hash)
+    to_hash == self.class.new(other_hash).to_hash
+  end
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = NavigableHash.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    set_value convert_key(key), navigate(value)
+  end
+
+  alias :store :[]=
 
   def [](key)
-    navigate super(key)
+    get_value convert_key(key)
   end
 
-  def method_missing(m, *args, &block)
-    self[m]
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    self.class.new to_hash
+  end
+
+  # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+  # either a string or a symbol:
+  #
+  #   counters = HashWithIndifferentAccess.new
+  #   counters[:foo] = 1
+  #
+  #   counters.fetch("foo")          # => 1
+  #   counters.fetch(:bar, 0)        # => 0
+  #   counters.fetch(:bar) {|key| 0} # => 0
+  #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
+  #
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
   end
 
-  def respond_to_missing?(m, include_private = false)
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Merges the instantiated and the specified hashes together, giving precedence to the values from the second hash.
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  def respond_to?(m, include_private = false)
     true
   end
 
-  def ==(other_hash)
-    to_hash == self.class.new(other_hash).to_hash
+  def to_hash
+    reduce({}) do |hash, (key, value)|
+      hash.merge key => convert_for_to_hash(value)
+    end
   end
 
-  private
+  # Updates the instantized hash with values from the second:
+  #
+  #   hash_1 = NavigableHash.new
+  #   hash_1[:key] = "value"
+  #
+  #   hash_2 = NavigableHash.new
+  #   hash_2[:key] = "New Value!"
+  #
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  #
+  def update(other_hash)
+    other_hash.reduce(self) { |hash, (k, v)| hash[k] = navigate(v) ; hash }
+  end
+
+  alias_method :merge!, :update
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  protected :get_value, :set_value
+
+  def convert_for_to_hash(value)
+    case value
+    when NavigableHash
+      convert_navigable_hash_for_to_hash value
+    when Array
+      convert_array_for_to_hash value
+    else
+      convert_value_for_to_hash value
+    end
+  end
+
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  def convert_navigable_hash_for_to_hash(value)
+    value.to_hash
+  end
+
+  def convert_array_for_to_hash(value)
+    value.map { |item| convert_for_to_hash item }
+  end
+
+  def convert_value_for_to_hash(value)
+    value
+  end
 
   def navigate value
     case value
+    when NavigableHash
+      value
     when Hash
       navigate_hash value
     when Array
@@ -45,4 +168,17 @@ class NavigableHash < HashWithIndifferentAccess
     value
   end
 
+  private
+
+  def method_missing(m, *args, &block)
+    m = m.to_s
+    if args.size == 1 && m.gsub!(/(.+)=$/, '\1')
+      self.send :[]=, m, args.first
+    elsif args.size == 0
+      self.send :[], m
+    else
+      raise ArgumentError, "wrong number of arguments(#{args.size} for 0)"
+    end
+  end
+
 end

data/navigable_hash.gemspec

@@ -1,15 +1,14 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'navigable_hash/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "navigable_hash"
-  spec.version       = NavigableHash::VERSION
+  spec.version       = "1.0.0"
   spec.authors       = ["Jason Waldrip", "Kevin Wanek"]
   spec.email         = ["jason@waldrip.net", "k@dmcy.us"]
-  spec.description   = %q{Allows a hash to be navigated with dot notation or indifferent access}
-  spec.summary       = %q{Allows a hash to be navigated with dot notation or indifferent access}
+  spec.description   = %q{Allows a hash to be navigated with dot notation or indifferent access.}
+  spec.summary       = %q{Allows a hash to be navigated with dot notation or indifferent access.}
   spec.homepage      = "http://github.com/jwaldrip/navigable_hash"
   spec.license       = "MIT"
 
@@ -18,12 +17,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport"
-
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "simplecov-multi"
 
 end

data/spec/helpers/helper_methods.rb

@@ -0,0 +1,54 @@
+module NavigableHash::HelperMethods
+
+  def test_key_with_dot_notation(key, hash)
+    case (value = hash[key])
+    when Hash
+      value.keys.each { |key| test_key_with_dot_notation key, hash }
+    end
+    describe "##{key}" do
+      it "should call navigate" do
+        navigable.should_receive(:navigate).any_number_of_times
+        navigable.send(key)
+      end
+
+      it "should have a valid value" do
+        navigable.send(key).should == hash[key]
+      end
+    end
+  end
+
+  def test_key_with_symbol_notation(key, hash)
+    case (value = hash[key])
+    when Hash
+      value.keys.each { |key| test_key_with_dot_notation key, hash }
+    end
+    describe "##{key}" do
+      it "should call navigate" do
+        navigable.should_receive(:navigate).any_number_of_times
+        navigable[key.to_sym]
+      end
+
+      it "should have a valid value" do
+        navigable[key.to_sym].should == hash[key]
+      end
+    end
+  end
+
+  def test_key_with_string_notation(key, hash)
+    case (value = hash[key])
+    when Hash
+      value.keys.each { |key| test_key_with_dot_notation key, hash }
+    end
+    describe "##{key}" do
+      it "should call navigate" do
+        navigable.should_receive(:navigate).any_number_of_times
+        navigable[key.to_s]
+      end
+
+      it "should have a valid value" do
+        navigable[key.to_s].should == hash[key]
+      end
+    end
+  end
+
+end

data/spec/lib/navigable_hash_spec.rb

@@ -1,57 +1,237 @@
 require 'spec_helper'
 require 'pry'
+require 'helpers/helper_methods'
+
+RSpec.configure do |c|
+  c.extend NavigableHash::HelperMethods
+end
 
 describe NavigableHash do
 
-  TEST_HASH = { symbol_key: 'symbol_key_value', 'string_key' => 'string_key_value', hash_item: { inner_value: true }, array: [ {}, 'string', :symbol ] , nil_value: nil, object: Object.new }
+  TEST_HASH = { :symbol_key => 'symbol_key_value', 'string_key' => 'string_key_value', :hash_item => { :inner_value => true }, :array => [ {}, 'string', :symbol ] , :nil_value => nil, :object => Object.new }
+
+  describe ".new" do
+    context "given an array" do
+      it "should not raise an error" do
+        expect { NavigableHash.new([:a, 1]) }.to_not raise_error
+      end
+    end
+
+    context "given a hash" do
+      it "should not raise an error" do
+        expect { NavigableHash.new({:a => 1}) }.to_not raise_error
+      end
+    end
+  end
+
+  describe ".new(TEST_HASH)" do
+    context "with dot notation" do
+      TEST_HASH.keys.each do |key_name|
+        test_key_with_dot_notation(key_name, TEST_HASH)
+      end
+    end
+
+    context "with symbol notation" do
+      TEST_HASH.keys.each do |key_name|
+        test_key_with_symbol_notation(key_name, TEST_HASH)
+      end
+    end
+
+    context "with string notation" do
+      TEST_HASH.keys.each do |key_name|
+        test_key_with_string_notation(key_name, TEST_HASH)
+      end
+    end
+  end
 
   let(:hash){ TEST_HASH }
   let(:navigable){ NavigableHash.new(hash) }
 
+  context "with a deep setter" do
+    let(:hash){ {} }
+    it "should be able to set and get a deep value" do
+      value = "world"
+      navigable.foo = {}
+      navigable.foo.bar = {}
+      navigable.foo.bar.baz = value
+      navigable.foo.bar.baz.should == value
+    end
+  end
+
+  describe "#__any_method__" do
+    it "should not raise an error" do
+      expect { navigable.__any_method__ }.to_not raise_error
+    end
+
+    it "should get a value" do
+      navigable.__any_method__ = "foo"
+      navigable.__any_method__.should == "foo"
+    end
+
+    it "should raise an error with arguments" do
+      expect { navigable.__any_method__ :foo }.to raise_error
+    end
+  end
+
+  describe "#__any_method__=" do
+    it "should not raise an error" do
+      expect { navigable.__any_method__ = 'value' }.to_not raise_error
+    end
+
+    it "should set a value" do
+      expect { navigable.__any_method__ = 'value' }.to change { navigable.__any_method__ }
+    end
+
+    it "should raise an error with more than one argument" do
+      expect { navigable.send :__any_method__, :foo, :bar }.to raise_error
+    end
+  end
+
   describe "#[]" do
 
     context "given a hash" do
       it "should return a new instance of navigable hash" do
-        navigable[:hash_item].should be_a NavigableHash
+        navigable[:hash_item].should be_an_instance_of NavigableHash
       end
     end
 
     context "given an array" do
       it "should call #navigate with each value" do
-        size = hash[:array].size
-        navigable.should_receive(:navigate_array).with(hash[:array])
-        navigable[:array]
+        navigable[:array].should be_a Array
       end
     end
 
     context "given any object" do
       it "should return a value" do
-        navigable.should_receive(:navigate_value).with(hash[:object]).any_number_of_times.and_call_original
-        navigable[:object].should == hash[:object]
+        navigable[:object].should be_an_instance_of Object
       end
     end
 
     context "given nil" do
       it "should return a value" do
-        navigable.should_receive(:navigate_value).with(hash[:nil_value]).any_number_of_times.and_call_original
-        navigable[:nil_value].should == hash[:nil_value]
         navigable[:nil_value].should be_nil
       end
     end
 
   end
 
+  describe "#[]=" do
+    it "should set a value" do
+      expect { navigable[:new_key] = 'value' }.to change { navigable[:new_key] }
+    end
+
+    context "given a hash" do
+      it "should return a new instance of navigable hash" do
+        hash = {:a => 1, :b => 2, :c => 3}
+        navigable.should_receive(:navigate_hash).with(hash)
+        navigable[:hash] = hash
+      end
+    end
+
+    context "given an array" do
+      it "should call #navigate with each value" do
+        array = [1, 2, 3]
+        navigable.should_receive(:navigate_array).with(array)
+        navigable[:array] = array
+      end
+    end
+
+    context "given any object" do
+      it "should return a value" do
+        object = Object.new
+        navigable.should_receive(:navigate_value).with(object)
+        navigable[:object] = object
+      end
+    end
+
+    context "given nil" do
+      it "should return a value" do
+        navigable.should_receive(:navigate_value).with(nil)
+        navigable[:nil_value] = nil
+      end
+    end
+  end
+
   describe "#==" do
     it "should be equal to a hash" do
       navigable.should == hash
     end
   end
 
-  TEST_HASH.keys.each do |key_name|
-    describe "##{key_name}" do
-      it "should call navigate" do
-        navigable.should_receive(:navigate).any_number_of_times.and_call_original
-        navigable.send(key_name).should == TEST_HASH[key_name]
+  describe "#delete" do
+    context "given a string as the key" do
+      it "should delete a value" do
+        expect { navigable.delete('hash_item') }.to change { navigable[:hash_item] }.to(nil)
+      end
+    end
+
+    context "given a symbol as the key" do
+      it "should delete a value" do
+        expect { navigable.delete(:hash_item) }.to change { navigable[:hash_item] }.to(nil)
+      end
+    end
+  end
+
+
+  describe "#dup" do
+    it "should return a copy of navigable hash" do
+      navigable.dup.should be_an_instance_of NavigableHash
+    end
+
+    it "should be equal to its original" do
+      navigable.dup.should == navigable
+    end
+  end
+
+  describe "#key?" do
+    context "if a key exists" do
+      it "should be true" do
+        navigable[:present_key] = 'value'
+        navigable.key?(:present_key).should be_true
+      end
+    end
+
+    context "if a key does not exist" do
+      it "should be false" do
+        navigable.key?(:no_key).should be_false
+      end
+    end
+  end
+
+  describe "#fetch" do
+    context "given a hash" do
+      let(:hash){ { :hash => {} } }
+      it "should return an instance of NavigableHash" do
+        navigable.fetch(:hash).should be_an_instance_of NavigableHash
+      end
+    end
+  end
+
+  describe "#merge" do
+    context "given a hash" do
+      it "should have a navigable hash" do
+        merged = navigable.merge({ :some_hash => {}})
+        merged[:some_hash].should be_an_instance_of NavigableHash
+      end
+    end
+  end
+
+  describe "#to_hash" do
+    it "should be an instance of Hash" do
+      navigable.to_hash.should be_an_instance_of Hash
+    end
+
+    it "inner hash should be an instance of hash" do
+      navigable[:hash_item].should be_an_instance_of NavigableHash
+      navigable.to_hash['hash_item'].should be_an_instance_of Hash
+    end
+  end
+
+  describe "#update" do
+    context "given a hash" do
+      it "should have a navigable hash" do
+        navigable.update({ :some_hash => {}})
+        navigable[:some_hash].should be_an_instance_of NavigableHash
       end
     end
   end
@@ -62,6 +242,13 @@ describe NavigableHash do
     end
   end
 
+  describe "#values_at" do
+    let (:hash){ { :foo => "foo_value", :bar => "bar_value", :baz => "baz_value" } }
+    it "should have the correct values" do
+      navigable.values_at(:foo, :bar).should == [hash[:foo], hash[:bar]]
+    end
+  end
+
   describe "#method_missing" do
     it "should return nil" do
       navigable.this_is_not_a_method.should be_nil

data/spec/spec_helper.rb

@@ -5,7 +5,14 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
 SimpleCov.start
+
 require 'navigable_hash'
 
 RSpec.configure do |config|
@@ -17,5 +24,5 @@ RSpec.configure do |config|
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
-  config.order = 'random'
+  # config.order = 'random'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: navigable_hash
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,42 +10,42 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2013-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+        version: '1.3'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -61,7 +61,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -77,7 +77,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -93,7 +93,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: simplecov-multi
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -108,7 +108,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Allows a hash to be navigated with dot notation or indifferent access
+description: Allows a hash to be navigated with dot notation or indifferent access.
 email:
 - jason@waldrip.net
 - k@dmcy.us
@@ -116,15 +116,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/navigable_hash.rb
-- lib/navigable_hash/version.rb
 - navigable_hash.gemspec
+- spec/helpers/helper_methods.rb
 - spec/lib/navigable_hash_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/jwaldrip/navigable_hash
@@ -148,10 +150,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Allows a hash to be navigated with dot notation or indifferent access
+summary: Allows a hash to be navigated with dot notation or indifferent access.
 test_files:
+- spec/helpers/helper_methods.rb
 - spec/lib/navigable_hash_spec.rb
 - spec/spec_helper.rb

data/lib/navigable_hash/version.rb

@@ -1,5 +0,0 @@
-require 'active_support/hash_with_indifferent_access'
-
-class NavigableHash < HashWithIndifferentAccess
-  VERSION = "0.0.1"
-end