key_path 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5bc45e3830cd4c5a9bbf20765cf382874a890927
+  data.tar.gz: fa82506141b7515dbc9b6f19cbf99f1dffb9f272
+SHA512:
+  metadata.gz: 5f1817be54a72fce97109507cb259f1a19392efb7adc6dc4e492ee6c986126c869c6a387ac753b80ef3b604f8051813c19f372592f4c93f6f2827778d8daeeeb
+  data.tar.gz: 4d1aa2f3f87fb7973c6ac2f3296516d70bc38d6ddbbd9436d45a3e4dff60bccceed8c0f84af2e4e88121bdfe64e5998ca2c228bcfa5ac2300aa91c01422a2d31

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

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/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+    - 2.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in keypath.gemspec
+gemspec
+
+gem 'rake'
+gem 'coveralls', require: false
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nick Charlton
+
+MIT License
+
+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,85 @@
+# keypath-based collection access extensions for Ruby.
+
+[![Build Status](https://secure.travis-ci.org/nickcharlton/keypath-ruby.png?branch=master)](http://travis-ci.org/nickcharlton/keypath-ruby) [![Code Climate](https://codeclimate.com/github/nickcharlton/keypath-ruby.png)](https://codeclimate.com/github/nickcharlton/keypath-ruby) [![Test Coverage](https://coveralls.io/repos/nickcharlton/keypath-ruby/badge.png?branch=master)](https://coveralls.io/r/nickcharlton/keypath-ruby)
+
+This gem allows you to access nested Ruby collections (`Hash`, `Array`, etc) using 
+keypaths.
+
+For example, say you had a nested data structure like:
+
+```ruby
+data = {
+    :item_one => {:id => 1, :url => 'http://nickcharlton.net/'},
+    :something_else => [
+        {
+            :id => 1,
+            :url => 'https://github.com/'
+        }
+    ]
+}
+```
+
+You could access "https://github.com/" through: `something_else.0.url`. Basically, 
+this is intended to allow you to manipulate/transform large nested structures that 
+you might get back from a JSON document.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'keypath'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install keypath
+
+## Usage
+
+`KeyPath` is at least two things. First, it's a class (actually, `KeyPath::Path`)
+which represents a path (this is just a string, and has methods to go back and
+forth from it) and secondly a set of class extensions for `Enumerable`, `Hash` and 
+`String` which allow you to use the native collection classes with keypaths.
+
+```ruby
+require 'key_path'
+
+data = {
+    :item => {
+        :url => 'http://nickcharlton.net'
+    }
+}
+
+# fetching a path
+path = KeyPath::Path.new 'item.url'
+data.value_at_keypath(path) #=> 'http://nickcharlton.net'
+
+# finding all `:url` paths in a collection
+data.keypaths_for_nested_key(:url) #=> {item.url => 'http://nickcharlton.net'}
+
+# going back and forth from a string
+path.to_s #=> 'item.url'
+'item.url'.to_keypath #=> #<KeyPath:70096895112220 path=item.url>
+
+# get the parent of a keypath (or nil, if there isn't one)
+path.parent #=> #<KeyPath:70096895221110 path=item>
+
+# setting a path
+data.set_keypath(path, 'http://github.com/')
+```
+
+## 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
+
+## Author
+
+Copyright (c) 2013 Nick Charlton (<nick@nickcharlton.net>)
+

data/Rakefile

@@ -0,0 +1,28 @@
+##
+# Initialise Bundler, catch errors.
+##
+require 'bundler'
+require 'bundler/gem_tasks'
+
+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
+
+##
+# Configure the test suite.
+##
+require 'rake/testtask'
+
+Rake::TestTask.new :spec do |t|
+  t.test_files = Dir['spec/*_spec.rb']
+end
+
+##
+# By default, just run the tests.
+##
+task :default => :spec
+

data/key_path.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'key_path/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'key_path'
+  spec.version       = KeyPath::VERSION
+  spec.authors       = ['Nick Charlton']
+  spec.email         = ['nick@nickcharlton.net']
+  spec.description   = %q{Keypath-based collection access extensions for Ruby.}
+  spec.summary       = %q{This gem allows you to access nested Ruby collections 
+                          (Hash, Array, etc) using keypaths. E.g.: 'something.item.0'}
+  spec.homepage      = 'https://github.com/nickcharlton/keypath-ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  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.add_dependency 'activesupport', '~> 4.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry'
+end

data/lib/key_path/enumerable/extensions.rb

@@ -0,0 +1,52 @@
+module Enumerable
+  # see: http://stackoverflow.com/a/7139631/83386
+  def value_at_keypath(keypath)
+    if keypath.is_a?(KeyPath::Path)
+      keypath = keypath.to_s
+    end
+
+    parts = keypath.split '.', 2
+    
+    # if it's an array, call the index
+    if self[parts[0].to_i]
+      match = self[parts[0].to_i]
+    else
+      match = self[parts[0]] || self[parts[0].to_sym]
+    end
+    
+    if !parts[1] or match.nil?
+      return match
+    else
+      return match.value_at_keypath(parts[1])
+    end
+  end
+
+  def set_keypath(keypath, value)
+    # handle both string and KeyPath::Path forms
+    if keypath.is_a?(String)
+      keypath = keypath.to_keypath
+    end
+
+    # create a collection at the keypath
+    collection = keypath.to_collection
+    
+    # set the value in the collection
+    depth = ''
+    keypath.to_a.each do |e|
+      # walk down set and make up the right place to assign
+      if e.is_number?
+        key = "#{e}"
+      else
+        key = ":#{e}"
+      end
+      depth << "[#{key}]"
+    end
+
+    # assign it
+    eval "collection#{depth} = #{value}"
+    
+    # merge the new collection into self
+    self.deep_merge!(collection)
+  end
+end
+

data/lib/key_path/hash/deep_merge.rb

@@ -0,0 +1,73 @@
+# 
+# = Hash Deep Merge
+# 
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+# 
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      https://gist.github.com/weppos/6391
+#
+module KeyPath
+  module HashDeepMerge
+    #
+    # Recursive version of Hash#merge!
+    # 
+    # Adds the contents of +other_hash+ to +hsh+, 
+    # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+    # 
+    # Compared with Hash#merge!, this method supports nested hashes.
+    # When both +hsh+ and +other_hash+ contains an entry with the same key,
+    # it merges and returns the values from both arrays.
+    # 
+    #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+    #    h2 = {"b" => 254, "c" => 300, "c" => {"c1" => 16, "c3" => 94}}
+    #    h1.rmerge!(h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+    #    
+    # Simply using Hash#merge! would return
+    # 
+    #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+    # 
+    def deep_merge!(other_hash)
+      merge!(other_hash) do |key, oldval, newval| 
+          oldval.class == self.class ? oldval.deep_merge!(newval) : newval
+      end
+    end
+ 
+    #
+    # Recursive version of Hash#merge
+    # 
+    # Compared with Hash#merge!, this method supports nested hashes.
+    # When both +hsh+ and +other_hash+ contains an entry with the same key,
+    # it merges and returns the values from both arrays.
+    # 
+    # Compared with Hash#merge, this method provides a different approch
+    # for merging nasted hashes.
+    # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+    # includes the same key, the value is merged instead replaced with
+    # +other_hash+ value.
+    # 
+    #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+    #    h2 = {"b" => 254, "c" => 300, "c" => {"c1" => 16, "c3" => 94}}
+    #    h1.rmerge(h2)    #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+    #    
+    # Simply using Hash#merge would return
+    # 
+    #    h1.merge(h2)     #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+    # 
+    def deep_merge(other_hash)
+      r = {}
+      merge(other_hash)  do |key, oldval, newval| 
+        r[key] = oldval.class == self.class ? oldval.deep_merge(newval) : newval
+      end
+    end
+  end
+end
+
+class Hash
+  include KeyPath::HashDeepMerge
+end

data/lib/key_path/hash/extensions.rb

@@ -0,0 +1,30 @@
+module KeyPath
+  module HashExtensions
+    def keypaths_for_nested_key(nested_key = '', nested_hash=self, path=[], all_values={})
+      nested_hash.each do |k, v|
+        path << k.to_s # assemble the path from the key
+        case v
+        when Array then
+          v.each_with_index do |item, i|
+            path << "#{i}" # add the array key
+            keypaths_for_nested_key(nested_key, item, path, all_values)
+          end
+          path.pop # remove the array key
+        when Hash then keypaths_for_nested_key(nested_key, v, path, all_values)
+        else
+          if k == nested_key
+            all_values.merge!({"#{path.join('.')}" => "#{v}"})
+          end
+          path.pop
+        end
+      end
+      path.pop
+   
+      return all_values
+    end
+  end
+end
+
+class Hash
+  include KeyPath::HashExtensions
+end

data/lib/key_path/path.rb

@@ -0,0 +1,59 @@
+module KeyPath
+  class Path
+    def initialize(path='')
+      @path = path
+    end
+
+    def parent
+      s = self.to_a
+      s.pop
+
+      # there's no parent if it's empty
+      if s == []
+        return nil
+      end
+
+      # otherwise, join them back together and pass back a path
+      s.join('.').to_keypath
+    end
+
+    def to_s
+      @path
+    end
+
+    def to_a
+      @path.split('.')
+    end
+
+    def to_collection
+      collection = {}
+      s = self.to_a
+      depth = ''
+
+      s.each_with_index do |e, i|
+        # assemble the key
+        if e.is_number?
+          key = "#{e}"
+        else
+          key = ":#{e}"
+        end
+        depth << "[#{key}]"
+
+        # figure out the correct type to push
+        type = {}
+        if e.is_plural?
+          type = []
+        end
+
+        # evaluate this stage
+        eval "collection#{depth} = #{type}"
+      end
+
+      collection
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{self.object_id} path=#{@path}>"
+    end
+  end
+end

data/lib/key_path/string/extensions.rb

@@ -0,0 +1,25 @@
+require 'active_support/inflector'
+
+module KeyPath
+  module StringExtensions
+    def to_keypath
+      KeyPath::Path.new self
+    end
+
+    def is_singular?
+      self.pluralize != self and self.singularize == self
+    end
+
+    def is_plural?
+      self.singularize != self and self.pluralize == self
+    end
+
+    def is_number?
+      true if Float(self) rescue false
+    end
+  end
+end
+
+class String
+  include KeyPath::StringExtensions
+end

data/lib/key_path/version.rb

@@ -0,0 +1,3 @@
+module KeyPath
+  VERSION = '1.0.0'
+end

data/lib/key_path.rb

@@ -0,0 +1,14 @@
+# gem bits
+require 'key_path/version'
+require 'key_path/path'
+
+# extensions
+require 'key_path/hash/deep_merge'
+require 'key_path/hash/extensions'
+require 'key_path/enumerable/extensions'
+require 'key_path/string/extensions'
+
+
+module KeyPath
+  # Your code goes here...
+end

data/spec/enumerable_extensions_spec.rb

@@ -0,0 +1,88 @@
+# test helpers
+require File.expand_path 'spec_helper.rb', __dir__
+
+describe 'EnumerableExtensions' do
+  it 'adds methods to collections' do
+    hash = {:id => 1}
+
+    hash.must_respond_to 'value_at_keypath'
+    hash.must_respond_to 'set_keypath'
+  end
+
+  it 'can fetch simple path values' do
+    hash = {:id => 1}
+
+    hash.value_at_keypath('id').must_equal 1
+  end
+
+  it 'can accept KeyPath::Path objects for keypaths' do
+    hash = {:id => 1}
+    keypath = KeyPath::Path.new('id')
+
+    hash.value_at_keypath(keypath).must_equal 1
+  end
+
+
+  it 'can fetch with a nested hash key path' do
+    hash = {:item => {:id => 1}}
+
+    hash.value_at_keypath('item.id').must_equal 1
+  end
+
+  it 'can fetch a nested array object' do
+    hash = {:items => [{:id => 1}]}
+
+    hash.value_at_keypath('items.0').must_equal({:id => 1})
+  end
+
+  it 'can set a simple value using a keypath string' do
+    source = {:item => {:id => {}}}
+    keypath = 'item.id'
+    value = 1
+
+    source.set_keypath(keypath, value)
+
+    source.value_at_keypath(keypath).must_equal(value)
+  end
+
+  it 'can set a simple value using a KeyPath::Path object' do
+    source = {:item => {:id => {}}}
+    keypath = KeyPath::Path.new('item.id')
+    value = 1
+
+    source.set_keypath(keypath, value)
+
+    source.value_at_keypath(keypath).must_equal(value)
+  end
+
+  it 'can set a string value using a KeyPath::Path object' do
+    source = {:item => {:id => {}}}
+    keypath = KeyPath::Path.new('item.id')
+    value = 'value'
+
+    source.set_keypath(keypath, value)
+
+    source.value_at_keypath(keypath).must_equal(value)
+  end
+
+
+  it 'can set a hash for a path' do
+    source = {:item => {:id => {}}}
+    keypath = KeyPath::Path.new('item')
+    value = {:id => 1}
+
+    source.set_keypath(keypath, value)
+
+    source.value_at_keypath(keypath).must_equal(value)
+  end
+
+  it 'can set a value in a nested array' do
+    source = {:items => [{:id => 1}]}
+    keypath = KeyPath::Path.new('items.1')
+    value = {:id => 2}
+
+    source.set_keypath(keypath, value)
+
+    source.value_at_keypath(keypath).must_equal(value)
+  end
+end

data/spec/hash_deep_merge_spec.rb

@@ -0,0 +1,58 @@
+# test helpers
+require File.expand_path 'spec_helper.rb', __dir__
+
+describe 'HashDeepMerge' do
+  it 'adds methods to the Hash class' do
+    hash = {:id => 1}
+
+    hash.must_respond_to 'deep_merge'
+    hash.must_respond_to 'deep_merge!'
+  end
+
+  it 'recursively adds two hashes' do
+    one = {:one => {:id => 1}}
+    two = {:one => {:url => 'http://nickcharlton.net'}}
+    three = {:one => {:id => 1, :url => 'http://nickcharlton.net'}}
+
+    output = one.deep_merge(two)
+
+    output.must_be_kind_of Hash
+    output.must_equal three
+  end
+
+  it 'recursively adds two hashes in place' do
+    one = {:one => {:id => 1}}
+    two = {:one => {:url => 'http://nickcharlton.net'}}
+    three = {:one => {:id => 1, :url => 'http://nickcharlton.net'}}
+
+    one.deep_merge!(two)
+
+    one.must_be_kind_of Hash
+    one.must_equal three
+  end
+end
+
+describe 'HashNormalMerge' do
+  it 'combines nested hashes without decending into them' do
+    one = {'a' => 100, 'b' => 200, 'c' => {'c1' => 12, 'c2' => 14}}
+    two = {'b' => 254, 'c' => 300, 'c' => {'c1' => 16, 'c3' => 94}}
+    expected = {'a' => 100, 'b' => 254, 'c' => {'c1' => 16, 'c3' => 94}}
+
+    output = one.merge(two)
+
+    output.must_be_kind_of Hash
+    output.must_equal expected
+  end
+
+  it 'combines nested hashes without decending into them in place' do
+    one = {'a' => 100, 'b' => 200, 'c' => {'c1' => 12, 'c2' => 14}}
+    two = {'b' => 254, 'c' => 300, 'c' => {'c1' => 16, 'c3' => 94}}
+    expected = {'a' => 100, 'b' => 254, 'c' => {'c1' => 16, 'c3' => 94}}
+
+    one.merge!(two)
+
+    one.must_be_kind_of Hash
+    one.must_equal expected
+  end
+
+end

data/spec/hash_extensions_spec.rb

@@ -0,0 +1,64 @@
+# test helpers
+require File.expand_path 'spec_helper.rb', __dir__
+
+describe 'HashExtensions' do
+  it 'adds methods to the Hash class' do
+    hash = {:id => 1}
+
+    hash.must_respond_to 'keypaths_for_nested_key'
+  end
+
+  it 'can find keys in a nested hash' do
+    data = {
+      :id => 1,
+      :item => {
+        :id => 2,
+        :name => 'an item'
+      }
+    }
+    
+    keypaths = data.keypaths_for_nested_key(:id)
+
+    keypaths.wont_be_nil
+    keypaths.must_include 'id'
+    keypaths.must_include 'item.id'
+  end
+
+  it 'can find keys in nested array' do
+    data = {
+      :id => 1,
+      :items => [{
+        :id => 2,
+        :name => 'an item'
+      },
+      {
+        :id => 3,
+        :name => 'another item'
+      }]
+    }
+
+    keypaths = data.keypaths_for_nested_key(:id)
+
+    keypaths.wont_be_nil
+    keypaths.must_include 'id'
+    keypaths.must_include 'items.0.id'
+    keypaths.must_include 'items.1.id'
+  end
+
+  it 'can handle walking into an otherwise unknown object' do
+    class ExampleClass
+      def initialize
+        @name = 'Example Class'
+      end
+
+      example = ExampleClass.new
+
+      data = {:items => example}
+
+      keypaths = data.keypaths_for_nested_key(:items)
+
+      keypaths.wont_be_nil
+      keypaths.must_include 'items'
+    end
+  end
+end

data/spec/key_path_spec.rb

@@ -0,0 +1,3 @@
+# test helpers
+require File.expand_path 'spec_helper.rb', __dir__
+

data/spec/path_spec.rb

@@ -0,0 +1,67 @@
+# test helpers
+require File.expand_path 'spec_helper.rb', __dir__
+
+describe 'KeyPath::Path main methods' do
+  it 'creates a KeyPath instance from a string' do
+    path = KeyPath::Path.new('item.url')
+
+    path.wont_be_nil
+    path.to_s.must_be_kind_of String
+    path.to_s.must_equal 'item.url'
+  end
+
+  it 'outputs an array of items in the path' do
+    path = KeyPath::Path.new('item.url')
+
+    path.to_a.must_be_kind_of Array
+    path.to_a.must_equal ['item', 'url']
+  end
+
+  it 'spits out a useful inspect string' do
+    path = KeyPath::Path.new('item.url')
+
+    path.inspect.must_be_kind_of String
+    path.inspect.wont_be_nil
+  end
+
+  it 'returns a parent if one exists' do
+    path = KeyPath::Path.new('item.url')
+
+    path.parent.wont_be_nil
+    path.parent.must_be_kind_of KeyPath::Path
+  end
+
+  it 'returns nil if a parent doesnt exist' do
+    path = KeyPath::Path.new('item')
+
+    path.parent.must_be_nil
+  end
+end
+
+describe 'KeyPath::Path collections generation' do
+  it 'returns an empty hash with an empty path' do
+    path = KeyPath::Path.new('')
+    path.to_collection.must_equal({})
+  end
+
+  it 'returns a nested hash for a single path unit' do
+    path = KeyPath::Path.new('item')
+    path.to_collection.must_equal({:item => {}})
+  end
+
+  it 'returns a nested array when the key is plural' do
+    path = KeyPath::Path.new('items')
+    path.to_collection.must_equal({:items => []})
+  end
+
+  it 'returns a double nested array with a two set keypath' do
+    path = KeyPath::Path.new('item.id')
+    path.to_collection.must_equal({:item => {:id => {}}})
+  end
+
+  it 'returns a nested array with an item' do
+    path = KeyPath::Path.new('items.0.id')
+    path.to_collection.must_equal({:items => [{:id => {}}]})
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+# test coverage
+require 'coveralls'
+
+# enable coveralls
+Coveralls.wear!
+
+# test framework
+require 'minitest/autorun'
+require 'minitest/pride'
+
+# pull in the library
+require File.expand_path '../lib/key_path.rb', __dir__
+

data/spec/string_extensions_spec.rb

@@ -0,0 +1,41 @@
+# test helpers
+require File.expand_path 'spec_helper.rb', __dir__
+
+describe 'StringExtensions' do
+  it 'can create a KeyPath instance from itself' do
+    example_string = 'item.url'
+
+    example_string.to_keypath.wont_be_nil
+    example_string.to_keypath.must_be_kind_of KeyPath::Path
+
+    # around and around we go
+    example_string.to_keypath.to_s.must_equal example_string
+  end
+
+  it 'can make a set of strings plural' do 
+    %w(word rail dress business).each do |v|
+      v.is_plural?.must_equal false
+    end
+
+    %w(words rails dresses businesses).each do |v|
+      v.is_plural?.must_equal true
+    end
+  end
+
+  it 'can make a set of string singular' do
+    %w(word rail dress business).each do |v|
+      v.is_singular?.must_equal true
+    end
+
+    %w(words rails dresses businesses).each do |v|
+      v.is_singular?.must_equal false
+    end
+  end
+
+  it 'can test if a string is actually a number' do
+    '0'.is_number?.must_equal true
+    '1234567890'.is_number?.must_equal true
+
+    'item'.is_number?.must_equal false
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: key_path
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nick Charlton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Keypath-based collection access extensions for Ruby.
+email:
+- nick@nickcharlton.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- key_path.gemspec
+- lib/key_path.rb
+- lib/key_path/enumerable/extensions.rb
+- lib/key_path/hash/deep_merge.rb
+- lib/key_path/hash/extensions.rb
+- lib/key_path/path.rb
+- lib/key_path/string/extensions.rb
+- lib/key_path/version.rb
+- spec/enumerable_extensions_spec.rb
+- spec/hash_deep_merge_spec.rb
+- spec/hash_extensions_spec.rb
+- spec/key_path_spec.rb
+- spec/path_spec.rb
+- spec/spec_helper.rb
+- spec/string_extensions_spec.rb
+homepage: https://github.com/nickcharlton/keypath-ruby
+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.0.14
+signing_key: 
+specification_version: 4
+summary: 'This gem allows you to access nested Ruby collections  (Hash, Array, etc)
+  using keypaths. E.g.: ''something.item.0'''
+test_files:
+- spec/enumerable_extensions_spec.rb
+- spec/hash_deep_merge_spec.rb
+- spec/hash_extensions_spec.rb
+- spec/key_path_spec.rb
+- spec/path_spec.rb
+- spec/spec_helper.rb
+- spec/string_extensions_spec.rb
+has_rdoc: