abstractivator 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fde467c865fb41d53a7c256fd150d5c2f3bbb947
-  data.tar.gz: 97e60569e7a56d45c24bafaf345f22856eb3b8c7
+  metadata.gz: 2b0ee668927a5106db357ec157e8be9899625987
+  data.tar.gz: 9c21aa5f625b98a54947173793153cd28001583b
 SHA512:
-  metadata.gz: 1671b95d9e955f6ec00fc93972b6cea6b18311a0c0be80880010394c26fd3563c42d32228ceb8c500d463c4d95b567e4f48b03a88fdfea76d476ddd3b76f2535
-  data.tar.gz: 5655785a88eb97cd688bfbecf4923ce4f3db7074425e470c33d52143207d72681a49980cba7a44db07bfd592b37fa8a2abacab4463681403567776f83eba7450
+  metadata.gz: 2f236c615a444fc301302a193c5c084e8710d9dd9522a92a6d69b27a31f7de32e1f1599153482c5ebda9cd41be6d77e805b41672f3b13f8bf5d8ff14a11150bb
+  data.tar.gz: 6cf0c72dd6be94141af891b6a2ced2b3ef9a13be9d973a64095afc2157b1a7bca73ba82b7dcee80a7675cadc8d2688d089b7d6a4aa944426362318038f2d7dd5

data/lib/abstractivator/proc_ext.rb

@@ -1,10 +1,11 @@
 require 'abstractivator/enumerable_ext'
+require 'abstractivator/array_ext'
 
 module MethodAndProcExtensions
   # returns a version of the procedure that accepts any number of arguments
   def loosen_args
-    proc do |*args, &block|
-      Proc.loose_call(self, args, &block)
+    proc do |*args, **kws, &block|
+      Proc.loose_call(self, args, kws, &block)
     end
   end
 end
@@ -54,11 +55,31 @@ class Proc
   # 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.
-  def self.loose_call(x, args, &block)
+  def self.loose_call(x, args, kws={}, &block)
     x = x.to_proc if x.respond_to?(:to_proc)
     x.callable? or return x
-    args = args.take(x.arity).pad_right(x.arity) if x.arity >= 0
-    x.call(*args, &block)
+    arg_types = x.parameters.map(&:first)
+    # 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)
+    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)})
+    end
+    if kws.any?
+      x.call(*args, **kws, &block)
+    else
+      x.call(*args, &block)
+    end
   end
 end
 

data/lib/abstractivator/version.rb

@@ -1,3 +1,3 @@
 module Abstractivator
-  VERSION = '0.4.0'
+  VERSION = '0.4.1'
 end

data/spec/lib/abstractivator/proc_ext_spec.rb

@@ -51,35 +51,103 @@ context 'in the world of functional programming' do
     end
   end
 
-  describe 'Proc::loose_call' do
-    it 'returns the first argument if it is not a proc' do
-      expect(Proc.loose_call('a', ['b', 'c'])).to eql 'a'
-    end
-    it 'attempts to convert the first argument to proc' do
-      expect(Proc.loose_call(:to_s, ['5'])).to eql '5'
-    end
+  shared_examples 'an arity loosener' do
     it 'calls the proc with an appropriate number of arguments' do
       events = []
       args = [:here, :are, :some, :arguments]
-      Proc.loose_call(->{events << 0}, args)
-      Proc.loose_call(->(a){events << 1}, args)
-      Proc.loose_call(->(a, b){events << 2}, args)
-      Proc.loose_call(->(a, b, c){events << 3}, args)
-      expect(events).to eql [0, 1, 2, 3]
+      do_call(->{events << 0}, args)
+      do_call(->(a){events << 1}, args)
+      do_call(->(a, b){events << 2}, args)
+      do_call(->(a, b, c){events << 3}, args)
+      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
-      expect(Proc.loose_call(->(a, b) {[a, b]}, [1])).to eql [1, nil]
+      verify_called_with ->(a, b) {[a, b]},
+                         [1],
+                         [1, nil]
+    end
+    it 'passes optional arguments, while preserving defaults' do
+      verify_called_with ->(a, b=2, c=3) {[a, b, c]},
+                         [11, 22],
+                         [11, 22, 3]
     end
     it 'works with variable-arity procs' do
-      expect(Proc.loose_call(->(*args) {args}, [1, 2])).to eql [1, 2]
+      verify_called_with ->(*args) {args},
+                         [1, 2],
+                         [1, 2]
+      verify_called_with ->(first, *rest) {[first, rest]},
+                         [1, 2, 3],
+                         [1, [2, 3]]
+    end
+    it 'passes the block' do
+      expect(do_call(proc{|&b| b.call}, []) {42}).to eql 42
+    end
+    it 'calls the proc with the declared keyword arguments, while preserving defaults' do
+      verify_called_with_keywords ->(a: 1, b: 2, c: 3) {[a, b, c]},
+                                  {a: 11, b: 22, d: 44},
+                                  [11, 22, 3]
+    end
+    it 'calls the proc with the declared required keyword arguments' do
+      verify_called_with_keywords ->(a:, b:) {[a, b]},
+                                  {a: 1, b: 2, c: 3},
+                                  [1, 2]
+    end
+    it 'replaces missing required keyword arguments with nil' do
+      verify_called_with_keywords ->(a:, b:) {[a, b]},
+                                  {a: 1},
+                                  [1, nil]
+    end
+    it 'works with variable-keyword procs' do
+      verify_called_with_keywords ->(**kws) {kws},
+                                  {a: 1, b: 2, c: 3},
+                                  {a: 1, b: 2, c: 3}
+      verify_called_with_keywords ->(a:, **kws) {[a, kws]},
+                                  {a: 1, b: 2, c: 3},
+                                  [1, {b: 2, c: 3}]
+    end
+    it 'works with a mixture of argument types' do
+      p = ->(a, b=2, c=3, d: 4, e: 5, f:, &block){[a, b, c, d, e, f, block.call]}
+      result = do_call(p, [11, 22], {d: 44, z: 5}) { 42 }
+      expect(result).to eql [11, 22, 3, 44, 5, nil, 42]
+    end
+    it 'works with a mixture of splat types' do
+      p = ->(*args, **kws, &block){[args, kws, block.call]}
+      result = do_call(p, [1, 2], {c: 3, d: 4}) { 42 }
+      expect(result).to eql [[1, 2], {c: 3, d: 4}, 42]
+    end
+
+    def verify_called_with(p, input_args, output)
+      expect(do_call(p, input_args, {})).to eql output
+    end
+
+    def verify_called_with_keywords(p, input_kws, output)
+      expect(do_call(p, [], input_kws)).to eql output
+    end
+  end
+
+  describe 'Proc::loose_call' do
+    it_behaves_like 'an arity loosener'
+
+    it 'returns the first argument if it is not a proc' do
+      expect(Proc.loose_call('a', ['b', 'c'])).to eql 'a'
+    end
+    it 'attempts to convert the first argument to proc' do
+      expect(Proc.loose_call(:to_s, ['5'])).to eql '5'
+    end
+
+    def do_call(p, args, kws={}, &block)
+      Proc.loose_call(p, args, kws, &block)
     end
   end
 
   describe 'Proc#loosen_args' do
-    it 'returns a procedure with loose arity semantics' do
-      p = ->(a, b, c) { [a, b, c] }
-      lp = p.loosen_args
-      expect(lp.call(1, 2)).to eql [1, 2, nil]
+    it_behaves_like 'an arity loosener'
+
+    def do_call(p, args, kws={}, &block)
+      p.loosen_args.call(*args, **kws, &block)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractivator
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Peter Winton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-05 00:00:00.000000000 Z
+date: 2015-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler