fat 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e695c0dfe4c5034dc2977e30ba13260f4359fcc
-  data.tar.gz: 92c736aa2db12b4f06926cf5d3065c56720b317d
+  metadata.gz: 64e614f67b483c476550fd7b144dbb8e03ae010c
+  data.tar.gz: 0f4ace7f1c241251e27eaa37eccba1d9e29cdef6
 SHA512:
-  metadata.gz: a8595a6a2bf6701c6b9477d79eb875cbe05c70b2db92ce76a1b1f0475da22bfb93dd8f904a7944f35e30015c3a93edfb51677ee9be4ef9c194ccef53c78bd495
-  data.tar.gz: b2cc74a7a6015d67b172ca55a3eaf25beda14b4129309e8a9dfe88b5c5f69f29330aa5848576a2a786b39e24490c8ca79bd5d146a43e9ed0c7fa6f5fa0794d91
+  metadata.gz: 3e5bee3db122f8470ec1403273f72274192affdb2479d129798447d4535420f555f49e7fe6997830e59828686f5f4922913e83803fef0e89aeb680cbfdf55156
+  data.tar.gz: 8e0241de729d4daa1f03711c519b73929dfdbcf14dafef0d282a10b2ead4181509081dd34de380e9a4eb8db6f589fef18fbe0fd4974b4f9a9d552d532a59f936

data/README.md

@@ -19,9 +19,9 @@ hash = {
 }
 ```
 
-To get your `:value` you usually do `hash["foo"]["bar"]["baz"]`. But what happens if `"bar"` doesn't exist? Yeap, BOOM!
+To get your `:value` you usually do `hash["foo"]["bar"]["baz"]`. But what happens if `"bar"` doesn't exist? Yeap, BOOM! You will get an `undefined method [] for nil` error.
 
-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.
+Using `Fat` you can walk the hash up to the `:value`, but it'll raise an exception if it finds `nil` at any point.
 
 ```ruby
 require "fat"
@@ -30,10 +30,22 @@ Fat.at(hash, "foo", "bar", "baz")
 # => :value
 
 Fat.at(hash, "foo", "not", "here")
-# => Fat::FatError: No hash found at foo.not
+# => Fat::FatError: foo.not is nil
+
+Fat.at(hash, "foo", "bar", "nope")
+# => Fat::FatError: foo.bar.nope is nil
+```
+
+You can specify a default return value with the `default:` keyword if you don't want an exception raised.
+
+```ruby
+require "fat"
+
+Fat.at(hash, "foo", "not", "here", default: "whoops")
+# => "whoops"
 ```
 
-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`.
+If you set `default: nil` this method behaves exactly like [Hash#dig](http://ruby-doc.org/core-2.3.0/Hash.html#method-i-dig), available from Ruby 2.3.0.
 
 It's the same with Symbols
 
@@ -59,15 +71,6 @@ hash.at("foo", "bar", "baz")
 # => :value
 ```
 
-If all your keys are Strings you can *namespace* them with dots.
-
-```ruby
-Hash.include(Fat)
-
-hash.at("foo.bar.baz")
-# => :value
-```
-
 # Install
 
 ```bash

data/ext/fat/fat.c

@@ -9,17 +9,14 @@ void Init_fat();
 static VALUE singleton_method_at(int argc, VALUE *argv, VALUE self);
 static VALUE method_at(int argc, VALUE *argv, VALUE hash);
 
-static VALUE fat(VALUE hash, VALUE fields);
+static VALUE fat(VALUE hash, VALUE fields, VALUE default_value);
 
 // Helpers
-static inline void parse_fields(VALUE args, VALUE *fields);
 static inline VALUE fields_upto_index(VALUE fields, long index);
-static inline void parse_singleton_args(int argc, VALUE *argv, VALUE *hash, VALUE *fields);
-static inline void parse_method_args(int argc, VALUE *argv, VALUE *fields);
 static inline long compute_error_message_length(VALUE fields, long index);
 static inline void copy_error_message(VALUE fields, long index, char* error_message_pointer);
-static inline VALUE str_to_sym(VALUE str);
 static inline VALUE sym_to_str(VALUE sym);
+static inline VALUE extract_default(VALUE keywords);
 
 void Init_fat(void) {
   Fat = rb_define_module("Fat");
@@ -32,52 +29,38 @@ void Init_fat(void) {
 static VALUE singleton_method_at(int argc, VALUE *argv, VALUE self) {
   VALUE hash;
   VALUE fields;
+  VALUE keywords;
 
-  parse_singleton_args(argc, argv, &hash, &fields);
+  rb_scan_args(argc, argv, "1*:", &hash, &fields, &keywords);
 
-  return fat(hash, fields);
+  return fat(hash, fields, extract_default(keywords));
 }
 
 static VALUE method_at(int argc, VALUE *argv, VALUE hash) {
   VALUE fields;
+  VALUE keywords;
 
-  parse_method_args(argc, argv, &fields);
+  rb_scan_args(argc, argv, "*:", &fields, &keywords);
 
-  return fat(hash, fields);
+  return fat(hash, fields, extract_default(keywords));
 }
 
-static VALUE fat(VALUE hash, VALUE fields) {
+static VALUE fat(VALUE hash, VALUE fields, VALUE default_value) {
   VALUE value = hash;
 
   for (long i = 0; i < RARRAY_LEN(fields); i++) {
     value = rb_hash_aref(value, RARRAY_AREF(fields, i));
 
-    if (i < RARRAY_LEN(fields) - 1 && TYPE(value) != T_HASH) {
-      rb_raise(rb_eFatError, "No hash found at %s", RSTRING_PTR(fields_upto_index(fields, i)));
-    }
-  }
-
-  return value;
-}
-
-static inline void parse_fields(VALUE args, VALUE *fields) {
-  if (RARRAY_LEN(args) == 1) {
-    *fields = rb_str_split(RARRAY_PTR(args)[0], ".");
-
-    if (RARRAY_LEN(*fields) == 1) {
-      VALUE split = rb_str_split(RARRAY_PTR(args)[0], ":");
-
-      if (RARRAY_LEN(split) == 1) {
-        rb_raise(rb_eFatError, "Single argument expected to be a namespace with dots (.) or colons (:)");
+    if (NIL_P(value)) {
+      if (!NIL_P(default_value)) {
+        return default_value;
       } else {
-        for (long i = 0; i < RARRAY_LEN(split); i++) {
-          rb_ary_store(*fields, i, str_to_sym(RARRAY_AREF(split, i)));
-        }
+        rb_raise(rb_eFatError, "%s is nil", RSTRING_PTR(fields_upto_index(fields, i)));
       }
     }
-  } else {
-    *fields = args;
   }
+
+  return value;
 }
 
 static inline VALUE fields_upto_index(VALUE fields, long index) {
@@ -88,18 +71,6 @@ static inline VALUE fields_upto_index(VALUE fields, long index) {
   return rb_str_new2(error_message_pointer);
 }
 
-static inline void parse_singleton_args(int argc, VALUE *argv, VALUE *hash, VALUE *fields) {
-  VALUE args;
-  rb_scan_args(argc, argv, "1*", hash, &args);
-  parse_fields(args, fields);
-}
-
-static inline void parse_method_args(int argc, VALUE *argv, VALUE *fields) {
-  VALUE args;
-  rb_scan_args(argc, argv, "*", &args);
-  parse_fields(args, fields);
-}
-
 static inline long compute_error_message_length(VALUE fields, long index) {
   long error_length = 0;
 
@@ -150,10 +121,16 @@ static inline void copy_error_message(VALUE fields, long index, char* error_mess
   *current_char_pointer++ = '\0';
 }
 
-static inline VALUE str_to_sym(VALUE str) {
-  return ID2SYM(rb_intern(RSTRING_PTR(str)));
-}
-
 static inline VALUE sym_to_str(VALUE sym) {
   return rb_id2str(SYM2ID(sym));
 }
+
+static inline VALUE extract_default(VALUE keywords) {
+  VALUE result = Qnil;
+
+  if (!NIL_P(keywords)) {
+    result = rb_hash_aref(keywords, ID2SYM(rb_intern("default")));
+  }
+
+  return result;
+}

data/fat.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "fat"
-  s.version = "1.0.0"
+  s.version = "2.0.0"
   s.summary = "C extension to find values in nested hashes without pain"
   s.description = s.summary
   s.authors = ["Lucas Tolchinsky"]

data/test/fat_test.rb

@@ -1,32 +1,6 @@
 require "cutest"
 require_relative "../lib/fat"
 
-scope do
-  setup do
-    {
-      foo: {
-        "bar" => {
-          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)
-  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
-
 scope do
   setup do
     {
@@ -38,53 +12,47 @@ scope do
     }
   end
 
-  test "namespaced strings" do |hash|
-    assert_equal :found, Fat.at(hash, "foo.bar.baz")
+  test "find value" do |hash|
+    assert_equal :found, Fat.at(hash, "foo", "bar", "baz")
+  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
 
-    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo.not.baz") }
-    assert_equal "No hash found at foo.not", exception.message
+    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo", "wat", "baz") }
+    assert_equal "foo.wat is nil", exception.message
   end
-end
 
-scope do
-  setup do
-    {
-      foo: {
-        bar: {
-          baz: :found
-        }
-      }
-    }
+  test "return default value" do |hash|
+    assert_equal "default", Fat.at(hash, "foo", "wat", "baz", default: "default")
+    assert_equal "default", Fat.at(hash, "foo", "bar", "wat", default: "default")
   end
 
-  test "namespaced symbols" do |hash|
-    assert_equal :found, Fat.at(hash, "foo:bar:baz")
+  test "include the module" do |hash|
+    Hash.include(Fat)
 
-    exception = assert_raise(Fat::FatError) { Fat.at(hash, "foo:not:baz") }
-    assert_equal "No hash found at foo.not", exception.message
+    assert hash.respond_to?(:at)
+    assert_equal :found, hash.at("foo", "bar", "baz")
   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 +61,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
 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-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest