abstractivator 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45c8fba3280c1d29b04f039b41ad5f9f1fb0d9ce
-  data.tar.gz: 466908745cf321c32d574ab98df30f0329656fba
+  metadata.gz: aa5f0441439d94fb15db90acbcc41c99f378d5fd
+  data.tar.gz: 66885acd1df0f4322a21dcbedf41da2028416604
 SHA512:
-  metadata.gz: 8ca79e31fdece1d82be3be63147f30ec618ce81b3290d5418778ff5620604e9dbaab86dbe4f6c8181bfbbfb23792cff7def8fe2b73263fdcb2c28dc314b9093b
-  data.tar.gz: f9a2a806b5a48721bd2969cb9e9f38826b33d0db14794ed4072f05493333414d6b57ba4c81ad2d2fd8eeb6f318950cd45aec3d229e4c72b4e551c5f706bf1313
+  metadata.gz: db0062035f743c6a51c716ff3b52db47ed96f16b96333d858f0e698d1d864153cabcff4f5bad10ab4f6ad75101ef0742a4199e57f2cfef37328e116b16596d8f
+  data.tar.gz: e120d0ba2180cb4dda23e6d9a9a57043b277a2cab2fd8c720a7c96b6c8e73f86ac1e4ec834b2f4db5477339c5309ff479d36c2599f14e50dfce939a5d3daf5d7

data/lib/abstractivator/enumerable_ext.rb

@@ -9,8 +9,8 @@ module Enumerable
   # returns an array of 2-element arrays, each of which is a left/right pair.
   def self.outer_join(left, right, get_left_key, get_right_key, left_default, right_default)
 
-    ls = left.hash_map(get_left_key)
-    rs = right.hash_map(get_right_key)
+    ls = left.inject({}) { |h, x| h.store(get_left_key.call(x), x); h }   # Avoid #hash_map and Array#to_h
+    rs = right.inject({}) { |h, x| h.store(get_right_key.call(x), x); h } #   for better performance
 
     raise 'duplicate left keys' if ls.size < left.size
     raise 'duplicate right keys' if rs.size < right.size

data/lib/abstractivator/proc_ext.rb

@@ -68,29 +68,56 @@ class Proc
     end
   end
 
-  # tries to coerce x into a procedure, then calls it with
-  # the given argument list.
+  LooseCallInfo = Struct.new(:params, :accepts_arg_splat, :total_arity, :req_arity,
+                             :requires_kw_customization, :all_key_names, :kw_padding)
+
+  # Tries to coerce x into a procedure, then calls it with the given argument list.
   # If x cannot be coerced into a procedure, returns x.
+  # This method is optimized for use cases typically found in tight loops,
+  # namely where x is either a symbol or a keyword-less fixed-arity proc.
+  # It attempts to minimize the number of intermediate arrays created for these cases
+  # (as would be produced by calls to #map, #select, #take, #pad_right, etc.)
+  # CPU overhead created by loose_call is bad, but unexpected memory consumption would
+  # be worse, considering Proc#call has zero memory footprint.
+  # These optimizations produce a ~5x speedup, which is still 2-4x slower than
+  # regular Proc#call.
   def self.loose_call(x, args, kws={}, &block)
+    return x.to_proc.call(*args) if x.is_a?(Symbol) # optimization for a typical use case
     x = x.to_proc if x.respond_to?(:to_proc)
-    x.callable? or return x
-    arg_types = x.parameters.map(&:first)
+    return x unless x.callable?
+
+    # cache proc info for performance
+    info = x.instance_variable_get(:@loose_call_info)
+    unless info
+      params = x.parameters
+      info = LooseCallInfo.new
+      info.params = params
+      info.req_arity = params.count { |p| p.first == :req }
+      info.total_arity = info.req_arity + params.count { |p| p.first == :opt }
+      info.accepts_arg_splat = params.any? { |p| p.first == :rest }
+      accepts_kw_splat = params.any? { |p| p.first == :keyrest }
+      has_kw_args = params.any? { |(type, name)| (type == :key || type == :keyreq) && !name.nil? }
+      info.requires_kw_customization = has_kw_args && !accepts_kw_splat
+      if info.requires_kw_customization
+        opt_key_names = info.params.select { |(type, name)| type == :key && !name.nil? }.map(&:value)
+        req_key_names = info.params.select { |(type, name)| type == :keyreq && !name.nil? }.map(&:value)
+        info.all_key_names = opt_key_names + req_key_names
+        info.kw_padding = req_key_names.hash_map { nil }
+      end
+      x.instance_variable_set(:@loose_call_info, info)
+    end
+
     # customize args
-    req_arity = arg_types.select{|x| x == :req}.size
-    total_arity = req_arity + arg_types.select{|x| x == :opt}.size
-    accepts_arg_splat = arg_types.include?(:rest)
-    unless accepts_arg_splat
-      args = args.take(total_arity).pad_right(req_arity)
+    unless info.accepts_arg_splat
+      args = args.take(info.total_arity) if args.size > info.total_arity
+      args = args.pad_right(info.req_arity) if args.size < info.req_arity
     end
+
     # customize keywords
-    accepts_kw_splat = arg_types.include?(:keyrest)
-    unless accepts_kw_splat
-      opt_key_names = x.parameters.select{|(type, name)| type == :key && !name.nil?}.map(&:value)
-      req_key_names = x.parameters.select{|(type, name)| type == :keyreq && !name.nil?}.map(&:value)
-      all_key_names = opt_key_names + req_key_names
-      padding = req_key_names.hash_map{nil}
-      kws = padding.merge(kws.select{|k| all_key_names.include?(k)})
+    if info.requires_kw_customization
+      kws = info.kw_padding.merge(kws.select { |k| info.all_key_names.include?(k) })
     end
+
     if kws.any?
       x.call(*args, **kws, &block)
     else

data/lib/abstractivator/version.rb

@@ -1,3 +1,3 @@
 module Abstractivator
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 end

data/spec/lib/abstractivator/proc_ext_spec.rb

@@ -62,7 +62,6 @@ context 'in the world of functional programming' do
       expect(events).to eql [0, 1, 2, 3]  # lambdas are strict in arity,
       # so if their bodies executed, then we know
       # they were called with the correct number of arguments
-
     end
     it 'pads with nils' do
       verify_called_with ->(a, b) {[a, b]},
@@ -120,11 +119,18 @@ context 'in the world of functional programming' do
     end
 
     def verify_called_with(p, input_args, output)
-      expect(do_call(p, input_args, {})).to eql output
+      2.times do
+        # Run twice to ensure the LooseCallInfo caching works.
+        # This is not paranoia; there actually was a bug thanks
+        # to ruby's sloppy scope.
+        expect(do_call(p, input_args, {})).to eql output
+      end
     end
 
     def verify_called_with_keywords(p, input_kws, output)
-      expect(do_call(p, [], input_kws)).to eql output
+      2.times do
+        expect(do_call(p, [], input_kws)).to eql output
+      end
     end
   end
 
@@ -138,6 +144,33 @@ context 'in the world of functional programming' do
       expect(Proc.loose_call(:to_s, ['5'])).to eql '5'
     end
 
+    # # Uncomment this to test performance. It runs several typical
+    # # scenarios through both Proc#call and Proc#loose_call to
+    # # evaluate relative performance.
+    # # As of this commit, loose_call was 2-4x slower.
+    # it 'has reasonable performance' do
+    #   require 'benchmark'
+    #   Benchmark.bm do |bm|
+    #     bench = proc do |label, proc_ish, args, kws|
+    #       bm.report("call       #{label}") do
+    #         proc_ish = proc_ish.to_proc if proc_ish.is_a?(Symbol)
+    #         if kws.none?
+    #           1_000_000.times { proc_ish.call(*args) }
+    #         else
+    #           1_000_000.times { proc_ish.call(*args, **kws) }
+    #         end
+    #       end
+    #       bm.report("loose_call #{label}") do
+    #         1_000_000.times { Proc.loose_call(proc_ish, args, kws) }
+    #       end
+    #     end
+    #     bench.('symbol ', :to_s,                  [42], {})
+    #     bench.('proc   ', proc   { |x| x.to_s },  [42], {})
+    #     bench.('lambda ', lambda { |x| x.to_s },  [42], {})
+    #     bench.('keyword', proc   { |a:| a.to_s }, [],   {a: 42})
+    #   end
+    # end
+
     def do_call(p, args, kws={}, &block)
       Proc.loose_call(p, args, kws, &block)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractivator
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Peter Winton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-16 00:00:00.000000000 Z
+date: 2017-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler