fat 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fffbd3df88760a30ab94ec780231688a17944655
-  data.tar.gz: 9bdbe4cff365157a89f42cde46e5de3b94112abc
+  metadata.gz: 7cb164e13d70c6ba83c7a6388dee09b09f1c16ad
+  data.tar.gz: c83ade83a11961ed0e878f4be1f983864d02f185
 SHA512:
-  metadata.gz: 39307004150f2606963b21e8f8adae44d269b2cb7f01142ff333fd6740a098f881672259c738f5282523330d2cfab6de452f8c330923f2569c42591212409144
-  data.tar.gz: 11adbb07becc3a42b6c480aa7fc23d5598142932f66e12b20b98604e8307b65f8fdcf62ee590ed46868c26f4c9f57a72dd926abb23d7034f286384f46bba18f4
+  metadata.gz: dcbb1ecdb3c05e52ce5575fc5c4f5f9c46c25ab591e63237fcbe5b7efb1ec78385b7e8e4037c8bf614095486de2bd48de102d1817c24e4699859e47fdf5831b8
+  data.tar.gz: 1c4e40eafe1e97a2eee88b5f2042d3189575d3fadd223ec0c30570c49546395a4d9b1f238bdd2f30e4af202bbdde40a05fc0af05f836cad0266f439eebe48b80

data/.gitignore

@@ -1,2 +1,3 @@
 tmp/
 *.bundle
+lib/*.dSYM

data/README.md

@@ -21,7 +21,7 @@ hash = {
 
 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, give me some `nil`.
+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"
@@ -30,9 +30,11 @@ Fat.at(hash, "foo", "bar", "baz")
 # => :value
 
 Fat.at(hash, "foo", "not", "here")
-# => nil
+# => 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
@@ -57,7 +59,7 @@ hash.at("foo", "bar", "baz")
 # => :value
 ```
 
-And the last one! If all your keys are Strings you can *namespace* them with dots.
+If all your keys are Strings you can *namespace* them with dots.
 
 ```ruby
 Hash.include(Fat)

data/benchmarks/fat.rb

@@ -8,10 +8,9 @@ class Hash
     fields = args.length == 1 ? args[0].split(".") : args
     value = self
 
-    fields.each do |field|
-      value = self[field]
-      return unless value
-      return value unless value.kind_of?(Hash)
+    fields[0..-2].each_with_index do |field, index|
+      value = value[field]
+      raise Fat::FatError, "No hash found at #{fields[0..index].join(".")}" unless value.kind_of?(Hash)
     end
 
     value
@@ -30,21 +29,23 @@ hash = {
 
 puts "### String chain as a single argument."
 Benchmark.ips do |bench|
-  bench.report("ruby") { hash.ruby_at("foo.bar.baz") }
-  bench.report("c")    { hash.at("foo.bar.baz") }
+  bench.report("ruby") { hash.ruby_at("foo.bar.baz.key") }
+  bench.report("c")    { hash.at("foo.bar.baz.key") }
   bench.compare!
 end
 
-# ### String chain as a single argument.
+### String chain as a single argument.
 # Calculating -------------------------------------
-#                 ruby     47304 i/100ms
-#                    c     55888 i/100ms
+#                 ruby     37856 i/100ms
+#                    c     47169 i/100ms
 # -------------------------------------------------
-#                 ruby   741487.1 (±10.6%) i/s -    3642408 in   5.002662s
-#                    c   977630.9 (±11.3%) i/s -    4806368 in   5.001422s
+#                 ruby   538803.8 (±7.3%) i/s -    2687776 in   5.026742s
+#                    c   722313.8 (±7.2%) i/s -    3584844 in   5.006989s
+#
 # Comparison:
-#                    c:   977630.9 i/s
-#                 ruby:   741487.1 i/s - 1.32x slower
+#                    c:   722313.8 i/s
+#                 ruby:   538803.8 i/s - 1.34x slower
+
 
 puts "### Each key as an argument."
 Benchmark.ips do |bench|
@@ -53,84 +54,108 @@ Benchmark.ips do |bench|
   bench.compare!
 end
 
-# ### Each key as an argument.
+### Each key as an argument.
 # Calculating -------------------------------------
-#                 ruby     57145 i/100ms
-#                    c     73161 i/100ms
+#                 ruby     59783 i/100ms
+#                    c     74832 i/100ms
 # -------------------------------------------------
-#                 ruby  1035908.2 (±9.7%) i/s -    5143050 in   5.036346s
-#                    c  1513478.5 (±11.1%) i/s -    7462422 in   5.017305s
+#                 ruby  1074906.7 (±3.1%) i/s -    5380470 in   5.010624s
+#                    c  1590070.0 (±4.9%) i/s -    7932192 in   5.004163s
+#
 # Comparison:
-#                    c:  1513478.5 i/s
-#                 ruby:  1035908.2 i/s - 1.46x slower
+#                    c:  1590070.0 i/s
+#                 ruby:  1074906.7 i/s - 1.48x slower
 
 puts "### No value found."
 Benchmark.ips do |bench|
-  bench.report("ruby") { hash.ruby_at("foo.one.key") }
-  bench.report("c")    { hash.at("foo.one.key") }
+  bench.report("ruby") { hash.ruby_at("foo.one.key") rescue Fat::FatError }
+  bench.report("c")    { hash.at("foo.one.key") rescue Fat::FatError }
   bench.compare!
 end
 
-# ### No value found.
+### No value found.
 # Calculating -------------------------------------
-#                 ruby     46842 i/100ms
-#                    c     62515 i/100ms
+#                 ruby     17493 i/100ms
+#                    c     18993 i/100ms
 # -------------------------------------------------
-#                 ruby   733070.0 (±10.0%) i/s -    3653676 in   5.052594s
-#                    c  1103249.9 (±11.2%) i/s -    5438805 in   5.026985s
+#                 ruby   208018.1 (±4.9%) i/s -    1049580 in   5.060661s
+#                    c   225204.0 (±5.1%) i/s -    1139580 in   5.074972s
+#
 # Comparison:
-#                    c:  1103249.9 i/s
-#                 ruby:   733070.0 i/s - 1.50x slower
+#                    c:   225204.0 i/s
+#                 ruby:   208018.1 i/s - 1.08x slower
+
+deep_hash = {}
+1.upto(100) do |n|
+  key = (1...n).to_a.join(".")
+  current_hash = deep_hash.at(key)
+  current_hash[n.to_s] = {}
+end
 
-deep_hash = {
-  "foo" => {
-    "bar" => {
-      "baz" => {
-        "and" => {
-          "one" => {
-            "more" => {
-              "key" => :value
-            }
-          }
-        }
-      }
-    }
-  }
-}
+path_to_100 = 1.upto(100).to_a.map(&:to_s)
+
+deep_hash.at(path_to_100.join("."))["foo"] = :bar
+
+path_to_foo = path_to_100 << "foo"
 
 puts "### Deep hash - String chain argument."
 Benchmark.ips do |bench|
-  bench.report("ruby") { deep_hash.ruby_at("foo.bar.baz.and.one.more.key") }
-  bench.report("c")    { deep_hash.at("foo.bar.baz.and.one.more.key") }
+  bench.report("ruby") { deep_hash.ruby_at(path_to_foo.join(".")) }
+  bench.report("c")    { deep_hash.at(path_to_foo.join(".")) }
   bench.compare!
 end
 
-# ### Deep hash - String chain argument.
+### Deep hash - String chain argument.
 # Calculating -------------------------------------
-#                 ruby     35209 i/100ms
-#                    c     37201 i/100ms
+#                 ruby      2549 i/100ms
+#                    c      3633 i/100ms
 # -------------------------------------------------
-#                 ruby   490384.6 (±10.9%) i/s -    2429421 in   5.040102s
-#                    c   530276.4 (±10.0%) i/s -    2641271 in   5.057748s
+#                 ruby    27061.4 (±4.1%) i/s -     135097 in   5.002624s
+#                    c    37773.5 (±3.0%) i/s -     188916 in   5.006074s
+#
 # Comparison:
-#                    c:   530276.4 i/s
-#                 ruby:   490384.6 i/s - 1.08x slower
+#                    c:    37773.5 i/s
+#                 ruby:    27061.4 i/s - 1.40x slower
 
 puts "### Deep hash - Each key as an argument."
 Benchmark.ips do |bench|
-  bench.report("ruby") { deep_hash.ruby_at("foo", "bar", "baz", "and", "one", "more", "key") }
-  bench.report("c")    { deep_hash.at("foo", "bar", "baz", "and", "one", "more", "key") }
+  bench.report("ruby") { deep_hash.ruby_at(*path_to_foo) }
+  bench.report("c")    { deep_hash.at(*path_to_foo) }
+  bench.compare!
+end
+
+### Deep hash - Each key as an argument.
+# Calculating -------------------------------------
+#                 ruby      4812 i/100ms
+#                    c     14712 i/100ms
+# -------------------------------------------------
+#                 ruby    49779.4 (±5.1%) i/s -     250224 in   5.042241s
+#                    c   168563.4 (±3.4%) i/s -     853296 in   5.068311s
+#
+# Comparison:
+#                    c:   168563.4 i/s
+#                 ruby:    49779.4 i/s - 3.39x slower
+
+path_to_not = 1.upto(99).to_a.map(&:to_s)
+path_to_not << "not"
+path_to_not << "100"
+
+puts "### Deep hash - No value found."
+Benchmark.ips do |bench|
+  bench.report("ruby") { deep_hash.ruby_at(*path_to_not) rescue Fat::FatError }
+  bench.report("c")    { deep_hash.at(*path_to_not) rescue Fat::FatError }
   bench.compare!
 end
 
-# ### Deep hash - Each key as an argument.
+### Deep hash - No value found.
 # Calculating -------------------------------------
-#                 ruby     44009 i/100ms
-#                    c     46413 i/100ms
+#                 ruby      2787 i/100ms
+#                    c      8277 i/100ms
 # -------------------------------------------------
-#                 ruby   674854.4 (±10.2%) i/s -    3344684 in   5.040045s
-#                    c   734889.3 (±8.5%) i/s -    3666627 in   5.039101s
+#                 ruby    30667.8 (±1.3%) i/s -     156072 in   5.090009s
+#                    c    86884.1 (±5.1%) i/s -     438681 in   5.064367s
+#
 # Comparison:
-#                    c:   734889.3 i/s
-#                 ruby:   674854.4 i/s - 1.09x slower
+#                    c:    86884.1 i/s
+#                 ruby:    30667.8 i/s - 2.83x slower
 

data/ext/fat/fat.c

@@ -1,30 +1,30 @@
 #include<ruby.h>
 
 VALUE Fat = Qnil;
+VALUE rb_eFatError = Qnil;
 
 void Init_fat();
 
 // Interface methods
 static VALUE singleton_method_at(int argc, VALUE *argv, VALUE self);
-static VALUE singleton_method_fetch_at(int argc, VALUE *argv, VALUE self);
 static VALUE method_at(int argc, VALUE *argv, VALUE hash);
-static VALUE method_fetch_at(int argc, VALUE *argv, VALUE hash);
 
-static VALUE fat(VALUE hash, VALUE fields, int raise_on_nil);
+static VALUE fat(VALUE hash, VALUE fields);
 
 // 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);
 
 void Init_fat(void) {
   Fat = rb_define_module("Fat");
+  rb_eFatError = rb_define_class_under(Fat, "FatError", rb_eStandardError);
 
   rb_define_module_function(Fat, "at", singleton_method_at, -1);
-  rb_define_module_function(Fat, "fetch_at", singleton_method_fetch_at, -1);
   rb_define_method(Fat, "at", method_at, -1);
-  rb_define_method(Fat, "fetch_at", method_fetch_at, -1);
 }
 
 static VALUE singleton_method_at(int argc, VALUE *argv, VALUE self) {
@@ -33,16 +33,7 @@ static VALUE singleton_method_at(int argc, VALUE *argv, VALUE self) {
 
   parse_singleton_args(argc, argv, &hash, &fields);
 
-  return fat(hash, fields, 0);
-}
-
-static VALUE singleton_method_fetch_at(int argc, VALUE *argv, VALUE self) {
-  VALUE hash;
-  VALUE fields;
-
-  parse_singleton_args(argc, argv, &hash, &fields);
-
-  return fat(hash, fields, 1);
+  return fat(hash, fields);
 }
 
 static VALUE method_at(int argc, VALUE *argv, VALUE hash) {
@@ -50,33 +41,17 @@ static VALUE method_at(int argc, VALUE *argv, VALUE hash) {
 
   parse_method_args(argc, argv, &fields);
 
-  return fat(hash, fields, 0);
-}
-
-static VALUE method_fetch_at(int argc, VALUE *argv, VALUE hash) {
-  VALUE fields;
-
-  parse_method_args(argc, argv, &fields);
-
-  return fat(hash, fields, 1);
+  return fat(hash, fields);
 }
 
-static VALUE fat(VALUE hash, VALUE fields, int raise_on_nil) {
+static VALUE fat(VALUE hash, VALUE fields) {
   VALUE value = hash;
 
   for (long i = 0; i < RARRAY_LEN(fields); i++) {
     value = rb_hash_aref(value, RARRAY_AREF(fields, i));
 
-    if (value == Qnil) {
-      if (raise_on_nil) {
-        rb_raise(rb_eKeyError, "No value found at %s", RSTRING_PTR(fields_upto_index(fields, i)));
-      } else {
-        return Qnil;
-      }
-    }
-
-    if (TYPE(value) != T_HASH) {
-      return value;
+    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)));
     }
   }
 
@@ -92,9 +67,11 @@ static inline void parse_fields(VALUE args, VALUE *fields) {
 }
 
 static inline VALUE fields_upto_index(VALUE fields, long index) {
-  VALUE range = rb_range_new(INT2FIX(0), INT2FIX(index), 0);
-  VALUE slice = rb_funcall(fields, rb_intern("slice"), 1, range);
-  return rb_ary_join(slice, rb_str_new2("."));
+  char error_message_pointer[compute_error_message_length(fields, index)];
+
+  copy_error_message(fields, index, error_message_pointer);
+
+  return rb_str_new2(error_message_pointer);
 }
 
 static inline void parse_singleton_args(int argc, VALUE *argv, VALUE *hash, VALUE *fields) {
@@ -108,3 +85,48 @@ static inline void parse_method_args(int argc, VALUE *argv, VALUE *fields) {
   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;
+
+  for (long j = 0; j <= index; j++) {
+    VALUE field = RARRAY_AREF(fields, j);
+
+    if (TYPE(field) == T_SYMBOL) {
+      error_length += rb_str_length(rb_id2str(SYM2ID(field)));
+    } else {
+      error_length += RSTRING_LEN(field);
+    }
+
+    if (j != index) {
+      error_length++;
+    }
+  }
+
+  return error_length;
+}
+
+static inline void copy_error_message(VALUE fields, long index, char* error_message_pointer) {
+  char* current_char_pointer = error_message_pointer;
+
+  for (long j = 0; j <= index; j++) {
+    VALUE field = RARRAY_AREF(fields, j);
+
+    long size;
+    if (TYPE(field) == T_SYMBOL) {
+      size = rb_str_length(rb_id2str(SYM2ID(field)));
+      memcpy(current_char_pointer, RSTRING_PTR(rb_id2str(SYM2ID(field))), size);
+    } else {
+      size = RSTRING_LEN(field);
+      memcpy(current_char_pointer, RSTRING_PTR(field), size);
+    }
+
+    current_char_pointer += size;
+
+    if (j != index) {
+      memcpy(current_char_pointer, ".", 1);
+      current_char_pointer++;
+    }
+  }
+}
+

data/fat.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "fat"
-  s.version = "0.0.5"
+  s.version = "0.1.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

@@ -13,11 +13,9 @@ scope do
   end
 
   test "honor key type" do |hash|
-    assert_equal nil, Fat.at(hash, "foo", :not, :found)
-    assert_raise { Fat.fetch_at(hash, "foo", :not, :found) }
+    assert_raise(Fat::FatError) { Fat.at(hash, :foo, :not, :found) }
 
     assert_equal :found, Fat.at(hash, :foo, "bar", :baz)
-    assert_equal :found, Fat.fetch_at(hash, :foo, "bar", :baz)
   end
 end
 
@@ -33,11 +31,9 @@ scope do
   end
 
   test "namespaced string keys" do |hash|
-    assert_equal nil, Fat.at(hash, "foo.not.found")
-    assert_raise { Fat.fetch_at(hash, "foo.not.found") }
+    assert_raise(Fat::FatError) { Fat.at(hash, "foo", :not, :found) }
 
     assert_equal :found, Fat.at(hash, "foo.bar.baz")
-    assert_equal :found, Fat.fetch_at(hash, "foo.bar.baz")
   end
 end
 
@@ -56,15 +52,11 @@ scope do
 
   test "include the module" do |hash|
     assert hash.respond_to?(:at)
-    assert hash.respond_to?(:fetch_at)
   end
 
   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, hash.fetch_at("foo", "bar", "baz")
-    assert_equal :found, hash.fetch_at("foo.bar.baz")
   end
 end
 
@@ -80,9 +72,19 @@ scope do
     }
   end
 
-  test "break and return if a value is not a hash" do |hash|
-    assert_equal :wat, Fat.at(hash, "foo.not_a_hash.baz")
-    assert_equal :wat, Fat.fetch_at(hash, "foo.not_a_hash.baz")
+  test "raise error if a value is not a hash" do |hash|
+    assert_raise(Fat::FatError) { Fat.at(hash, "foo.not_a_hash.baz") }
+  end
+end
+
+scope do
+  setup do
+    Hash.include(Fat)
+  end
+
+  test "corner case" do
+    assert_raise(Fat::FatError) { {}.at(:foo, :bar) }
+    assert_raise(Fat::FatError) { Fat.at({}, :foo, :bar) }
   end
 end
 

data/test/memleak.rb

@@ -0,0 +1,11 @@
+require "cutest"
+require_relative "../lib/fat"
+
+# The point of this test is to check for memory leaks.
+# The idea is to run the test suite forever and monitor the process with `htop`
+# to see if the memory consumption increases.
+
+loop do
+  Cutest.run_file(File.absolute_path("test/fat_test.rb"))
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Lucas Tolchinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-09 00:00:00.000000000 Z
+date: 2014-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
@@ -58,6 +58,7 @@ files:
 - fat.gemspec
 - lib/.gitkeep
 - test/fat_test.rb
+- test/memleak.rb
 homepage: https://github.com/tonchis/fat
 licenses:
 - MIT