fat-rb 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bdcab4d41d15436be2044afe9bfca50b7b0a5bc8
-  data.tar.gz: a8511fdb9a72033f2177c3a5e02883f5f793f8b9
+  metadata.gz: 12f093f4b8df095cdd3b0b4eb0ba1a2acdcc81b5
+  data.tar.gz: ccfd4bd0e8c7903d67142d00ffa2446adc12542d
 SHA512:
-  metadata.gz: 237740a7a6614dc056f41be23c46762f8aff6ceeb1ebcc1cb7373ef05ef02184d033821f43742ad8724dac581ca2080cbfe4beb91c84808714ef331b1c771005
-  data.tar.gz: f08e8bb9f6ed4c6cbddd29208974a38927cc1055d8b7c70f7084d080142ddd16e8b14ed9f5db4b62ca359897984edd01fde3a37dbc781bfe65407d1171502d90
+  metadata.gz: cc9f4281017434079d02f9c42a332e0f83fef95f7e6f01e5fd13cba110d18dd2296e871d482ff32ad5e361be6947ae2405f936f8c3b93d16c49d9692e9747a7e
+  data.tar.gz: 20de6a4911dff4a50f9c727b4869057bffe77672ba7695c2b0b645d17c86f1befe8016ebd2c1ce7889dbb050ab1e234b62105e2c8cbf97de15d3d71c1a61f41f

data/README.md

@@ -3,89 +3,7 @@ fat
 
 Ruby implementation for [Fat](https://github.com/tonchis/fat), to support non-MRI.
 
-The name is an acronym for "find at". It helps you avoid that nasty `undefined method [] for nil` when looking for values in a hash.
-
-# Use
-
-Say you have the following hash
-
-```ruby
-hash = {
-  "foo" => {
-    "bar" => {
-      "baz" => :value
-    }
-  }
-}
-```
-
-To get your `:value` you usually do `hash["foo"]["bar"]["baz"]`. But what happens if `"bar"` doesn't exist? Yeap, BOOM!
-
-I find more comfortable to ask if I can walk to `:value` using the keys `"foo"`, `"bar"`, `"baz"`. If I can't, tell me where the path ends.
-
-```ruby
-require "fat-rb"
-
-Fat.at(hash, "foo", "bar", "baz")
-# => :value
-
-Fat.at(hash, "foo", "not", "here")
-# => Fat::FatError: No hash found at foo.not
-```
-
-The `Fat::FatError` let's you know that a `Hash` was expected as a value for the key `"not"`. Way more explicit than guessing from a `undefined method [] for nil`.
-
-It's the same with Symbols
-
-```ruby
-hash = {
-  "foo" => {
-    :bar => {
-      "baz" => :value
-    }
-  }
-}
-
-Fat.at(hash, "foo", :bar, "baz")
-# => :value
-```
-
-If you prefer to call `hash.at` you only need to include `Fat` into `Hash`.
-
-```ruby
-Hash.include(Fat)
-
-hash.at("foo", "bar", "baz")
-# => :value
-```
-
-You can also *namespace* the keys with dots `.` or colons `:` if they are all Strings or Symbols, respectively.
-
-```ruby
-Hash.include(Fat)
-
-hash = {
-  "foo" => {
-    "bar" => {
-      "baz" => :value
-    }
-  }
-}
-
-hash.at("foo.bar.baz")
-# => :value
-
-hash = {
-  foo: {
-    bar: {
-      baz: :value
-    }
-  }
-}
-
-hash.at("foo:bar:baz")
-# => :value
-```
+Please look at the [README](https://github.com/tonchis/fat/blob/master/README.md) in that repository to learn about `Fat`.
 
 # Install
 

data/fat-rb.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "fat-rb"
-  s.version = "1.0.0"
+  s.version = "2.0.0"
   s.summary = "Ruby implementation of the Fat gem"
   s.description = s.summary
   s.authors = ["Lucas Tolchinsky"]

data/lib/fat.rb

@@ -1,39 +1,25 @@
 module Fat
   FatError = Class.new(StandardError)
 
-  def self.at(hash, *args)
-    fields = parse_args(*args)
-
-    fields[0..-1].each_with_index do |field, index|
-      hash = hash[field]
-      if index != fields.length - 1 && !hash.kind_of?(Hash)
-        raise Fat::FatError, "No hash found at #{fields[0..index].join(".")}"
+  def self.at(hash, *args, **keywords)
+    value = hash
+
+    args.each_with_index do |field, index|
+      value = value[field]
+      if value.nil?
+        if !keywords.empty?
+          return keywords[:default]
+        else
+          raise Fat::FatError, "#{args[0..index].join(".")} is nil"
+        end
       end
     end
 
-    hash
-  end
-
-  def self.parse_args(*args)
-    return args if args.length > 1
-
-    fields = args.first.split(".")
-
-    if fields.length == 1
-      fields = args.first.split(":")
-
-      if fields.length == 1
-        raise FatError, "Single argument expected to be a namespace with dots (.) or colons (:)"
-      else
-        fields.map(&:to_sym)
-      end
-    else
-      fields
-    end
+    value
   end
 
-  def at(*args)
-    Fat.at(self, *args)
+  def at(*args, **keywords)
+    Fat.at(self, *args, keywords)
   end
 end
 

data/test/fat_test.rb

@@ -4,87 +4,60 @@ require_relative "../lib/fat"
 scope do
   setup do
     {
-      foo: {
+      "foo" => {
         "bar" => {
-          baz: :found
+          "baz" => :found
         }
       }
     }
   end
 
-  test "honor key type" do |hash|
-    exception = assert_raise(Fat::FatError) { Fat.at(hash, :foo, :bar, :found) }
-    assert_equal "No hash found at foo.bar", exception.message
-
-    assert_equal :found, Fat.at(hash, :foo, "bar", :baz)
+  test "find value" do |hash|
+    assert_equal :found, Fat.at(hash, "foo", "bar", "baz")
   end
-end
 
-scope do
-  test "single argument must be a namespace" do
-    exception = assert_raise(Fat::FatError) { Fat.at({"foo" => "bar"}, "foo") }
-    assert_equal "Single argument expected to be a namespace with dots (.) or colons (:)", exception.message
-  end
-end
+  test "don't find value" do |hash|
+    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo", "bar", "wat") }
+    assert_equal "foo.bar.wat is nil", exception.message
 
-scope do
-  setup do
-    {
-      "foo" => {
-        "bar" => {
-          "baz" => :found
-        }
-      }
-    }
+    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo", "wat", "baz") }
+    assert_equal "foo.wat is nil", exception.message
   end
 
-  test "namespaced strings" do |hash|
-    assert_equal :found, Fat.at(hash, "foo.bar.baz")
-
-    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo.not.baz") }
-    assert_equal "No hash found at foo.not", exception.message
+  test "return default value" do |hash|
+    assert_equal "default", Fat.at(hash, "foo", "wat", "baz", default: "default")
+    assert_equal nil, Fat.at(hash, "foo", "bar", "wat", default: nil)
   end
-end
 
-scope do
-  setup do
-    {
-      foo: {
-        bar: {
-          baz: :found
-        }
-      }
-    }
-  end
+  test "include the module" do |hash|
+    Hash.include(Fat)
+
+    assert hash.respond_to?(:at)
+    assert_equal :found, hash.at("foo", "bar", "baz")
 
-  test "namespaced symbols" do |hash|
-    assert_equal :found, Fat.at(hash, "foo:bar:baz")
+    exception = assert_raise(Fat::FatError) { hash.at("foo", "wat", "baz") }
+    assert_equal "foo.wat is nil", exception.message
 
-    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo:not:baz") }
-    assert_equal "No hash found at foo.not", exception.message
+    assert_equal nil, hash.at("foo", "bar", "wat", default: nil)
   end
 end
 
 scope do
   setup do
-    Hash.include(Fat)
-
     {
-      "foo" => {
+      foo: {
         "bar" => {
-          "baz" => :found
+          baz: :found
         }
       }
     }
   end
 
-  test "include the module" do |hash|
-    assert hash.respond_to?(:at)
-  end
+  test "honor key type" do |hash|
+    exception = assert_raise(Fat::FatError) { Fat.at(hash, :foo, :bar, :found) }
+    assert_equal "foo.bar is nil", exception.message
 
-  test "honor Fat interface" do |hash|
-    assert_equal :found, hash.at("foo", "bar", "baz")
-    assert_equal :found, hash.at("foo.bar.baz")
+    assert_equal :found, Fat.at(hash, :foo, "bar", :baz)
   end
 end
 
@@ -93,9 +66,13 @@ scope do
     Hash.include(Fat)
   end
 
-  test "corner case" do
+  test "corner case: empty hashes" do
     assert_raise(Fat::FatError) { {}.at(:foo, :bar) }
     assert_raise(Fat::FatError) { Fat.at({}, :foo, :bar) }
   end
+
+  test "corner case: lookup a single key" do
+    assert_equal :found, {"foo" => :found}.at("foo")
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Lucas Tolchinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2015-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest