tonsser_hash_utils 1.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21216e909e28b7232940d8f26b5cf3f6d446ad60
-  data.tar.gz: d1abc94b1c4648912a2cd6c7a454b7fbf121a8df
+  metadata.gz: a07a24d08bf8a7ce458efb446458126f97961994
+  data.tar.gz: 169432513c2a5ba66f8435897922032daec6d267
 SHA512:
-  metadata.gz: 755fe94450976b16c5d2dd99f3191e6929ef6d7f0b734132fa0876afcb78e5a5f8a6de5b94da3dafb9d0dd85fa4586bb44a9eeb66266932f1e543e32b7ba09b1
-  data.tar.gz: 68a2949f62b74399490ee90880c55212bd4c758116bc7c83b416d0dad52ed00c37d9dfc3b32b78e19fac007d6225457803e4d4e78356a08d2678fcbe7b6d449b
+  metadata.gz: 4ffaabc26f0bc621f20c0f0b64c544537f970f6d5563329189e2420024e168b63d1a78323866723469a38228709bb717d6eba966a057a461f7b5a24334cfc2b6
+  data.tar.gz: 8f75d7cf18ef1710a901419e9174ec2d13b081fdc43b2587196616942befa0aff126140924cd5c01571614135c7709c0e359d07c901e0933dd81777f37233da2

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in tonsser_hash_utils.gemspec
+# Specify your gem"s dependencies in tonsser_hash_utils.gemspec
 gemspec

data/README.md

@@ -1,26 +1,123 @@
-# TonsserHashUtils
+# Tonsser Hash Utils
 
-TODO: Write a gem description
+A collection of classes for dealing with hashes. We've found them to be useful when manipulating a lot of JSON.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tonsser_hash_utils'
+gem "tonsser_hash_utils", "~> 1.0"
 ```
 
 And then execute:
 
-    $ bundle
+```
+bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install tonsser_hash_utils
+```
+gem install tonsser_hash_utils
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+The gem contains the following classes
+
+- `HashWithQuickAccess`
+- `DeepHash`
+- `HashMerger`
+- `HashBuilder`
+
+### HashWithQuickAccess
+
+`HashWithQuickAccess` makes it easy to access lots of properties within deeply nested hashes. Useful when dealing with hashes that are serialized from JSON.
+
+Example:
+
+```ruby
+# This
+json[:foo][:bar][:baz][:qux]
+
+# Becomes this
+hash = HashWithQuickAccess.new(json)
+hash.foo.bar.baz.qux
+```
+
+It also supports arrays within the hashes, so you can do stuff like
+
+```ruby
+hash = HashWithQuickAccess.new(json)
+hash.foo.bar[4].baz.qux
+```
+
+### DeepHash
+
+`DeepHash` is useful for checking if some deeply nested value is present.
+
+Example:
+
+```ruby
+# This
+params[:foo] && params[:foo][:bar] && params[:foo][:bar][:baz]
+
+# Becomes this
+DeepHash.new(params).dig(:foo, :bar, :baz)
+```
+
+### HashMerger
+
+`HashMerger` is useful for recursively deep merging hashes that can contains arrays, which should also be merged.
+
+Example:
+
+```ruby
+one = {
+  foo: {
+    bar: [1,2,3]
+  }
+}
+
+two = {
+  foo: {
+    bar: [4,5]
+    qux: "Yo!"
+  }
+}
+
+HashMerger.new(one).merge_with(two) # => {
+                                    #      foo: {
+                                    #        bar: [1,2,3,4,5],
+                                    #        qux: "Yo!"
+                                    #      }
+                                    #    }
+```
+
+**NOTE**: The merging is done using recursion, which might overflow the stack in Ruby due to the lack of tail call optimization. This shouldn't be a problem unless you have giant hashes, but be aware!
+
+### HashBuilder
+
+`HashBuilder` is useful for building a hash that might contain deep nesting.
+
+```ruby
+# This
+json = {
+  one: {
+    two: {
+      three: {
+        four: :foo
+      }
+    }
+  }
+}
+
+# Becomes this
+builder = HashBuilder.new
+builder.one.two.three.four = :foo
+json = builder.as_json
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,8 @@
 require "bundler/gem_tasks"
 
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+end

data/lib/deep_hash.rb

@@ -14,11 +14,7 @@ class DeepHash
 
   def dig(*keys)
     keys.inject(@hash) do |location, key|
-      if location.nil?
-        nil
-      else
-        location[key]
-      end
+      location[key] unless location.nil?
     end
   end
 end

data/lib/hash_builder.rb

@@ -30,7 +30,9 @@ class HashBuilder
   end
 
   def method_missing(name, *args)
-    if match = name.to_s.match(/(?<key>.*?)=$/)
+    match = name.to_s.match(/(?<key>.*?)=$/)
+
+    if match.present?
       @hash[match[:key].to_sym] = args.first
     else
       @hash[name] = HashBuilder.new if @hash[name].blank?

data/lib/hash_merger.rb

@@ -20,7 +20,7 @@ class HashMerger
   private
 
   def do_merge(hash, acc)
-    hash.inject(acc) do |acc, (key, value)|
+    hash.each_with_object(acc) do |(key, value), _acc|
       acc[key] = if value.is_a?(Hash)
                    do_merge(value, acc[key].dup || {})
                  elsif value.is_a?(Array)
@@ -28,8 +28,6 @@ class HashMerger
                  else
                    value
                  end
-
-      acc
     end
   end
 end

data/lib/hash_with_quick_access.rb

@@ -4,15 +4,15 @@ class HashWithQuickAccess
   end
 
   def method_missing(key)
-    if has_key(key)
+    if key?(key)
       fetch_possibly_decorated_value(key)
     else
-      raise KeyError.new("key :#{key} was not found")
+      fail KeyError, "key :#{key} was not found"
     end
   end
 
   def respond_to?(method_name, include_private = false)
-    has_key(method_name) || super
+    key?(method_name) || super
   end
 
   def keys
@@ -47,7 +47,7 @@ class HashWithQuickAccess
     end
   end
 
-  def has_key(key)
+  def key?(key)
     all_keys.include?(key)
   end
 

data/lib/tonsser_hash_utils/version.rb

@@ -1,3 +1,3 @@
 module TonsserHashUtils
-  VERSION = "1.0"
+  VERSION = "1.0.2"
 end

data/spec/lib/deep_hash_spec.rb

@@ -2,17 +2,17 @@ require "deep_hash"
 
 describe DeepHash, "#dig" do
   it "returns the value if its there" do
-    hash = DeepHash.new({
+    hash = DeepHash.new(
       foo: {
         bar: {
           baz: {
-            qux: "value"
-          }
-        }
-      }
-    })
+            qux: "value",
+          },
+        },
+      },
+    )
 
-    expect(hash.dig(:foo, :bar, :baz)).to eq({ qux: "value" })
+    expect(hash.dig(:foo, :bar, :baz)).to eq(qux: "value")
     expect(hash.dig(:foo, :bar, :baz, :qux)).to eq "value"
   end
 

data/spec/lib/hash_builder_spec.rb

@@ -16,7 +16,7 @@ describe HashBuilder do
     hash.foo = :foo
     hash.bar = :bar
 
-    expect(hash.as_json).to eq({"foo"=>"foo", "bar"=>"bar"})
+    expect(hash.as_json).to eq("foo" => "foo", "bar" => "bar")
   end
 
   it "allows easy creation of nested hashes" do
@@ -24,6 +24,8 @@ describe HashBuilder do
     hash.one.two.three.four = :foo
 
     expect(hash.one.two.three.four).to eq :foo
-    expect(hash.as_json).to eq({"one"=>{"two"=>{"three"=>{"four"=>"foo"}}}})
+    expect(hash.as_json).to eq(
+      "one" => { "two" => { "three" => { "four" => "foo" } } },
+    )
   end
 end

data/spec/lib/hash_merger_spec.rb

@@ -5,142 +5,132 @@ describe HashMerger do
     a = {
       foo: {
         bar: {
-          baz: "one"
+          baz: "one",
         },
-        yo: "yo"
+        yo: "yo",
       },
-      yo: "yo"
+      yo: "yo",
     }
 
     b = {
       foo: {
         bar: {
-          qux: "two"
-        }
+          qux: "two",
+        },
       },
-      dog: "dog"
+      dog: "dog",
     }
 
     merged = HashMerger.new(a).merge_with(b)
 
-    expect(merged).to eq({
+    expect(merged).to eq(
       foo: {
         bar: {
           baz: "one",
           qux: "two",
         },
-        yo: "yo"
+        yo: "yo",
       },
       yo: "yo",
       dog: "dog",
-    })
+    )
 
-    expect(a).to eq({
+    expect(a).to eq(
       foo: {
         bar: {
-          baz: "one"
+          baz: "one",
         },
-        yo: "yo"
+        yo: "yo",
       },
-      yo: "yo"
-    })
+      yo: "yo",
+    )
 
-    expect(b).to eq({
+    expect(b).to eq(
       foo: {
         bar: {
-          qux: "two"
-        }
+          qux: "two",
+        },
       },
-      dog: "dog"
-    })
+      dog: "dog",
+    )
   end
 
   it "deep merges arrays" do
     a = {
       foo: {
-        bar: ["one"]
-      }
+        bar: ["one"],
+      },
     }
 
     b = {
       foo: {
-        bar: ["two"]
-      }
+        bar: ["two"],
+      },
     }
 
     merged = HashMerger.new(a).merge_with(b)
 
-    expect(merged).to eq({
-      foo: {
-        bar: ["one", "two"]
-      }
-    })
-
-    expect(a).to eq({
-      foo: { bar: ["one"] }
-    })
-
-    expect(b).to eq({
-      foo: { bar: ["two"] }
-    })
+    expect(merged).to eq(foo: { bar: ["one", "two"] })
+    expect(a).to eq(foo: { bar: ["one"] })
+    expect(b).to eq(foo: { bar: ["two"] })
   end
 
   it "merges hashes with mixed types" do
     a = {
       foo: {
         bar: {
-          baz: "one"
+          baz: "one",
         },
-        array: [1,2],
-        yo: "yo"
+        array: [1, 2],
+        yo: "yo",
       },
-      yo: "yo"
+      yo: "yo",
     }
 
     b = {
       foo: {
         bar: {
-          qux: "two"
+          qux: "two",
         },
-        array: [3,4]
+        array: [3, 4],
       },
-      dog: "dog"
+      dog: "dog",
     }
 
     merged = HashMerger.new(a).merge_with(b)
 
-    expect(merged).to eq({
+    expect(merged).to eq(
       foo: {
         bar: {
           baz: "one",
           qux: "two",
         },
-        array: [1,2,3,4],
-        yo: "yo"
+        array: [1, 2, 3, 4],
+        yo: "yo",
       },
       yo: "yo",
       dog: "dog",
-    })
+    )
 
-    expect(a).to eq({
+    expect(a).to eq(
       foo: {
         bar: {
-          baz: "one"
+          baz: "one",
         },
-        array: [1,2],
-        yo: "yo"
+        array: [1, 2],
+        yo: "yo",
       },
-      yo: "yo"
-    })
+      yo: "yo",
+    )
 
-    expect(b).to eq({
+    expect(b).to eq(
       foo: {
         bar: {
-          qux: "two"
+          qux: "two",
         },
-        array: [3,4]
+        array: [3, 4],
       },
-      dog: "dog"
-    })
+      dog: "dog",
+    )
   end
 end

data/spec/lib/hash_with_quick_access_spec.rb

@@ -2,7 +2,7 @@ require "hash_with_quick_access"
 
 describe HashWithQuickAccess do
   it "gives you quick access to hashes or arrays nested in other hashes" do
-    hash = HashWithQuickAccess.new({
+    hash = HashWithQuickAccess.new(
       name: "Mikkel Hansen",
       books: [
         { name: "Fight Club" },
@@ -10,7 +10,7 @@ describe HashWithQuickAccess do
       job: {
         title: "Programmer",
       },
-    })
+    )
 
     expect(hash.name).to eq "Mikkel Hansen"
     expect(hash.books.first.name).to eq "Fight Club"
@@ -18,11 +18,11 @@ describe HashWithQuickAccess do
   end
 
   it "only wraps values if they are hashes" do
-    hash = HashWithQuickAccess.new({
+    hash = HashWithQuickAccess.new(
       books: [
-        "Fight Club"
+        "Fight Club",
       ],
-    })
+    )
 
     expect(hash.books.first).to eq "Fight Club"
   end
@@ -30,32 +30,28 @@ describe HashWithQuickAccess do
   it "gives a useful error when asking for key that doesn't exist" do
     hash = HashWithQuickAccess.new({})
 
-    expect {
+    expect do
       hash.foo.bar.baz
-    }.to raise_error(KeyError, "key :foo was not found")
+    end.to raise_error(KeyError, "key :foo was not found")
   end
 
   it "lets you get at the keys" do
-    hash = HashWithQuickAccess.new({
+    hash = HashWithQuickAccess.new(
       name: "Mikkel Hansen",
       books: [],
-    })
+    )
 
     expect(hash.keys).to eq [:name, :books]
   end
 
   it "allows lookups when the keys are strings" do
-    hash = HashWithQuickAccess.new({ "name" => 1 })
+    hash = HashWithQuickAccess.new("name" => 1)
 
     expect(hash.name).to eq 1
   end
 
   it "lets you use the standard hash #[] method" do
-    hash = HashWithQuickAccess.new({
-      job: {
-        title: "Programmer",
-      },
-    })
+    hash = HashWithQuickAccess.new(job: { title: "Programmer" })
 
     expect(hash[:job][:title]).to eq "Programmer"
   end

data/spec/spec_helper.rb

@@ -1,91 +1,11 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
   config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
   config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
     mocks.verify_partial_doubles = true
   end
 
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # 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
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
 end

data/tonsser_hash_utils.gemspec

@@ -1,21 +1,21 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'tonsser_hash_utils/version'
+require "tonsser_hash_utils/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "tonsser_hash_utils"
   spec.version       = TonsserHashUtils::VERSION
   spec.authors       = ["David Pedersen"]
   spec.email         = ["david@tonsser.com"]
-  spec.summary       = %q{A collection of classes for dealing with hashes}
-  spec.description   = %q{}
+  spec.summary       = "A collection of classes for dealing with hashes"
+  spec.description   = ""
   spec.homepage      = "http://github.com/tonsser/tonsser_hash_utils"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  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.7"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tonsser_hash_utils
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: 1.0.2
 platform: ruby
 authors:
 - David Pedersen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-12 00:00:00.000000000 Z
+date: 2015-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - Gemfile
 - LICENSE.txt
 - README.md