fat 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fd45ba2047a3be07e832e7fb9a7ba405098b080
-  data.tar.gz: b28efdaad73f42987a52f813b6ca6292e23cbfd7
+  metadata.gz: fffbd3df88760a30ab94ec780231688a17944655
+  data.tar.gz: 9bdbe4cff365157a89f42cde46e5de3b94112abc
 SHA512:
-  metadata.gz: 45feaf74742e8023bf38e02b52667627f49a638ea6d9a6e41715c94665a02d1b5a88b9e36bea854445271d229fc5ee1564d1f6efc5112372a6aa1fe7a375b18e
-  data.tar.gz: 234d08f9d9c752fce80a6e3dda850b3abcd2896b8ac83a33ad1ef09031a59b3b4df804eecdcc66bd2d36f76b8c95cc54758eb8c5fee7996fe46ab1fcfd8a2288
+  metadata.gz: 39307004150f2606963b21e8f8adae44d269b2cb7f01142ff333fd6740a098f881672259c738f5282523330d2cfab6de452f8c330923f2569c42591212409144
+  data.tar.gz: 11adbb07becc3a42b6c480aa7fc23d5598142932f66e12b20b98604e8307b65f8fdcf62ee590ed46868c26f4c9f57a72dd926abb23d7034f286384f46bba18f4

data/benchmarks/fat.rb

@@ -0,0 +1,136 @@
+require "benchmark/ips"
+require_relative "../lib/fat"
+
+class Hash
+  include Fat
+
+  def ruby_at(*args)
+    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)
+    end
+
+    value
+  end
+end
+
+hash = {
+  "foo" => {
+    "bar" => {
+      "baz" => {
+        "key" => :value
+      }
+    }
+  }
+}
+
+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.compare!
+end
+
+# ### String chain as a single argument.
+# Calculating -------------------------------------
+#                 ruby     47304 i/100ms
+#                    c     55888 i/100ms
+# -------------------------------------------------
+#                 ruby   741487.1 (±10.6%) i/s -    3642408 in   5.002662s
+#                    c   977630.9 (±11.3%) i/s -    4806368 in   5.001422s
+# Comparison:
+#                    c:   977630.9 i/s
+#                 ruby:   741487.1 i/s - 1.32x slower
+
+puts "### Each key as an argument."
+Benchmark.ips do |bench|
+  bench.report("ruby") { hash.ruby_at("foo", "bar", "baz") }
+  bench.report("c")    { hash.at("foo", "bar", "baz") }
+  bench.compare!
+end
+
+# ### Each key as an argument.
+# Calculating -------------------------------------
+#                 ruby     57145 i/100ms
+#                    c     73161 i/100ms
+# -------------------------------------------------
+#                 ruby  1035908.2 (±9.7%) i/s -    5143050 in   5.036346s
+#                    c  1513478.5 (±11.1%) i/s -    7462422 in   5.017305s
+# Comparison:
+#                    c:  1513478.5 i/s
+#                 ruby:  1035908.2 i/s - 1.46x 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.compare!
+end
+
+# ### No value found.
+# Calculating -------------------------------------
+#                 ruby     46842 i/100ms
+#                    c     62515 i/100ms
+# -------------------------------------------------
+#                 ruby   733070.0 (±10.0%) i/s -    3653676 in   5.052594s
+#                    c  1103249.9 (±11.2%) i/s -    5438805 in   5.026985s
+# Comparison:
+#                    c:  1103249.9 i/s
+#                 ruby:   733070.0 i/s - 1.50x slower
+
+deep_hash = {
+  "foo" => {
+    "bar" => {
+      "baz" => {
+        "and" => {
+          "one" => {
+            "more" => {
+              "key" => :value
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+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.compare!
+end
+
+# ### Deep hash - String chain argument.
+# Calculating -------------------------------------
+#                 ruby     35209 i/100ms
+#                    c     37201 i/100ms
+# -------------------------------------------------
+#                 ruby   490384.6 (±10.9%) i/s -    2429421 in   5.040102s
+#                    c   530276.4 (±10.0%) i/s -    2641271 in   5.057748s
+# Comparison:
+#                    c:   530276.4 i/s
+#                 ruby:   490384.6 i/s - 1.08x 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.compare!
+end
+
+# ### Deep hash - Each key as an argument.
+# Calculating -------------------------------------
+#                 ruby     44009 i/100ms
+#                    c     46413 i/100ms
+# -------------------------------------------------
+#                 ruby   674854.4 (±10.2%) i/s -    3344684 in   5.040045s
+#                    c   734889.3 (±8.5%) i/s -    3666627 in   5.039101s
+# Comparison:
+#                    c:   734889.3 i/s
+#                 ruby:   674854.4 i/s - 1.09x slower
+

data/ext/fat/fat.c

@@ -13,8 +13,10 @@ static VALUE method_fetch_at(int argc, VALUE *argv, VALUE hash);
 static VALUE fat(VALUE hash, VALUE fields, int raise_on_nil);
 
 // Helpers
-static void parse_fields(VALUE args, VALUE *fields);
-static VALUE fields_upto_index(VALUE fields, int index);
+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);
 
 void Init_fat(void) {
   Fat = rb_define_module("Fat");
@@ -27,44 +29,34 @@ void Init_fat(void) {
 
 static VALUE singleton_method_at(int argc, VALUE *argv, VALUE self) {
   VALUE hash;
-  VALUE args;
-
-  rb_scan_args(argc, argv, "1*", &hash, &args);
-
   VALUE fields;
-  parse_fields(args, &fields);
+
+  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 args;
-
-  rb_scan_args(argc, argv, "1*", &hash, &args);
-
   VALUE fields;
-  parse_fields(args, &fields);
+
+  parse_singleton_args(argc, argv, &hash, &fields);
 
   return fat(hash, fields, 1);
 }
 
 static VALUE method_at(int argc, VALUE *argv, VALUE hash) {
-  VALUE args;
-  rb_scan_args(argc, argv, "*", &args);
-
   VALUE fields;
-  parse_fields(args, &fields);
+
+  parse_method_args(argc, argv, &fields);
 
   return fat(hash, fields, 0);
 }
 
 static VALUE method_fetch_at(int argc, VALUE *argv, VALUE hash) {
-  VALUE args;
-  rb_scan_args(argc, argv, "*", &args);
-
   VALUE fields;
-  parse_fields(args, &fields);
+
+  parse_method_args(argc, argv, &fields);
 
   return fat(hash, fields, 1);
 }
@@ -72,12 +64,11 @@ static VALUE method_fetch_at(int argc, VALUE *argv, VALUE hash) {
 static VALUE fat(VALUE hash, VALUE fields, int raise_on_nil) {
   VALUE value = hash;
 
-  for (int i = 0; i < RARRAY_LEN(fields); i++) {
-    VALUE key = RARRAY_PTR(fields)[i];
-    value = rb_hash_aref(value, key);
+  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 == 1) {
+      if (raise_on_nil) {
         rb_raise(rb_eKeyError, "No value found at %s", RSTRING_PTR(fields_upto_index(fields, i)));
       } else {
         return Qnil;
@@ -92,19 +83,28 @@ static VALUE fat(VALUE hash, VALUE fields, int raise_on_nil) {
   return value;
 }
 
-static void parse_fields(VALUE args, VALUE *fields) {
+static inline void parse_fields(VALUE args, VALUE *fields) {
   if (RARRAY_LEN(args) == 1) {
-    VALUE chain = RARRAY_PTR(args)[0];
-
-    StringValue(chain);
-    *fields = rb_str_split(chain, ".");
+    *fields = rb_str_split(RARRAY_PTR(args)[0], ".");
   } else {
     *fields = args;
   }
 }
 
-static VALUE fields_upto_index(VALUE fields, int index) {
+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("."));
 }
+
+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);
+}

data/fat.gemspec

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

@@ -44,21 +44,22 @@ end
 scope do
   setup do
     Hash.include(Fat)
-  end
-
-  test "include the module" do
-    assert Hash.new.respond_to?(:at)
-  end
 
-  test "honor Fat interface" do
-    hash = {
+    {
       "foo" => {
         "bar" => {
           "baz" => :found
         }
       }
     }
+  end
+
+  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")
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Lucas Tolchinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-04 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
@@ -52,6 +52,7 @@ files:
 - Makefile
 - README.md
 - Rakefile
+- benchmarks/fat.rb
 - ext/fat/extconf.rb
 - ext/fat/fat.c
 - fat.gemspec