amenable 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a475b65e0b28577bf21459d1267f9a80b32636b2ea9ad614a07ca02e2969e4e8
-  data.tar.gz: ce7f241ba21d1e0380e0027665f1b33464864b61f1fdf76b50b3e99644f1a9ad
+  metadata.gz: 133a9c4b0a84e4325394ededc6826cb7408a9505d1c45bdfdd06674a10fac5ff
+  data.tar.gz: 1345444593420700a2b84938c64f58343e6f33c8a6399fd955fb09cd717c74c0
 SHA512:
-  metadata.gz: 8011289c31bad632ebefe20fc42edf4454cffb9ffbde0cd96e576e6ab1bf91f83ac8c707b3e4769af505f5d1bef10a1d428e38a526641b75af1a3cd08ae04988
-  data.tar.gz: 91bbdf8c82fe716f4d727f8b4a2212d906ec34cf9f9034ddd710a72e382d2336ec8f818fb2c27af0e043b10c7ed69448ada7023d8d0081fbcca27a0e92325467
+  metadata.gz: 7fcb746e4541e5360d25b5281d0b407be1b851ba97196d5bae01fec41eae898227bc87aa09dba59d91e22b5045aa14dd93d63856323805cc4944641b79df71b6
+  data.tar.gz: 9072334b6a123882a656f07db3797064cf726fdaf7900ecddc90e808b27ca6503246c0417e1f953e4941fc9c69e2ddce1a5a04be69e245aada6a3b6cf64bccf1

data/lib/amenable.rb

@@ -1,30 +1,17 @@
 require 'amenable/version'
 
 module Amenable
-  def tighten(fn)
-    name, redefiner = parse(fn)
-    rebuild(fn, :tighten)
+  extend self
 
-    # remount
+  def call(fn, *args, **kwargs, &block)
+    wrap(fn).call(*args, **kwargs, &block)
   end
 
-  private
-
-  def parse fn
-    case fn
-    when Symbol
-      name = fn
-      fn = method(fn)
-      redefiner = method(:define_method)
-    when Method
-      name = fn.name
-      redefiner = method(:define_method)
+  def wrap(fn)
+    unless fn.respond_to?(:call)
+      raise ArgumentError, "fn must be callable: #{fn}"
     end
 
-    [ name, redefiner ]
-  end
-
-  def rebuild(fn, mode:)
     rest = keyrest = false
     params = []
     keys = []
@@ -39,21 +26,14 @@ module Amenable
         rest = true
       when :keyrest
         keyrest = true
-      else
-        raise RuntimeError, "unexpected parameter type: #{type}"
       end
     end
 
     proc do |*args, **kwargs, &block|
-      if mode == :tighten
-        # remove unreferenced params
-        args.slice! params.count unless rest
-        kwargs = kwargs.slice(*keys) unless keyrest
-      else
-        # loosen
-      end
+      # remove unreferenced params
+      args.slice! params.count unless rest
+      kwargs = kwargs.slice(*keys) unless keyrest
 
-      puts "call(#{args}, #{kwargs})"
       fn.call(*args, **kwargs, &block)
     end
   end

data/lib/amenable/version.rb

@@ -1,3 +1,3 @@
-class Amenable
-  VERSION = '0.0.1'
+module Amenable
+  VERSION = '0.0.2'
 end

data/spec/amenable_spec.rb

@@ -1,3 +1,119 @@
 describe Amenable do
+  describe '.wrap' do
+    let(:fn) { proc {} }
 
+    it 'requires a function-like input' do
+      expect { Amenable.wrap(nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'wraps a function with a function' do
+      res = Amenable.wrap(fn)
+      expect(res).to be_a Proc
+      expect(res).not_to be fn
+    end
+
+    it 'returns a function that takes any input' do
+      params = Amenable.wrap(fn).parameters.map &:first
+      expect(params).to eq [ :rest, :keyrest, :block ]
+    end
+  end
+
+  describe '.call' do
+    let(:fn) { proc {|x, y = :y, a:, b: 2| [ [ x, y ], { a: a, b: b } ] } }
+
+    it 'calls .wrap under the hood' do
+      fn = proc {}
+      expect(Amenable).to receive(:wrap).with(fn).and_call_original
+      Amenable.call(fn)
+    end
+
+    it 'takes args and kwargs as expected' do
+      expect(fn).to receive(:call).with(:x, :y, a: 1, b: 2)
+      Amenable.call(fn, :x, :y, a: 1, b: 2)
+    end
+
+    it 'removes excessive parameters' do
+      expect(fn).to receive(:call).with(:x, :y, a: 1, b: 2)
+      Amenable.call(fn, :x, :y, :z, a: 1, b: 2, c: 3)
+    end
+
+    it 'works with splat operator' do
+      args = [ :x, :y, :z ]
+      kwargs = { a: 1, b: 2, c: 3 }
+
+      expect(fn).to receive(:call).with(:x, :y, a: 1, b: 2)
+      Amenable.call(fn, *args, **kwargs)
+    end
+
+    it 'works with default args' do
+      expect(fn).to receive(:call).with(:x, a: 1).and_call_original
+
+      expect(Amenable.call(fn, :x, a: 1)).to eq([
+        [ :x, :y ],
+        { a: 1, b: 2 },
+      ])
+    end
+
+    it 'raises if required arguments are not passed' do
+      expect {
+        Amenable.call(fn, :x)
+      }.to raise_error(ArgumentError)
+
+      expect {
+        Amenable.call(fn, :x, :y)
+      }.to raise_error(ArgumentError)
+
+      expect {
+        Amenable.call(fn, :x, :y, b: 2)
+      }.to raise_error(ArgumentError)
+
+      expect {
+        Amenable.call(fn, a: 1, b: 2)
+      }.to raise_error(ArgumentError)
+    end
+
+    context 'with var args' do
+      let(:fn) { proc {|x, *z, a:, **c| [ x, z, a, c ] } }
+
+      it 'works with just enough args' do
+        expect(fn).to receive(:call).with(:x, a: 1).and_call_original
+
+        expect(Amenable.call(fn, :x, a: 1)).to eq([
+          :x, [], 1, {},
+        ])
+      end
+
+      it 'fails without enough args' do
+        expect {
+          Amenable.call(fn, :x)
+        }.to raise_error(ArgumentError)
+
+        expect {
+          Amenable.call(fn, a: 1)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'passes through all args' do
+        expect(Amenable.call(fn, :x, :y, :z, a: 1, b: 2, c: 3)).to eq([
+          :x, [ :y, :z ], 1, { b: 2, c: 3 },
+        ])
+      end
+    end
+
+    context 'with a method' do
+      before do
+        def test_fn(x, a:, &block)
+          [ x, a, block ]
+        end
+      end
+
+      it 'works all the same' do
+        test_block = proc {}
+
+        expect(Amenable.call(method(:test_fn), :x, a: 1, &test_block)).to eq([
+          :x, 1, test_block
+        ])
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amenable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-08 00:00:00.000000000 Z
+date: 2021-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug