amenable 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 133a9c4b0a84e4325394ededc6826cb7408a9505d1c45bdfdd06674a10fac5ff
-  data.tar.gz: 1345444593420700a2b84938c64f58343e6f33c8a6399fd955fb09cd717c74c0
+  metadata.gz: 641c3e9528672faac363aedc32ab19e35494d4ed23b247f8a0962f02b0c53bc7
+  data.tar.gz: e4e39cf70b4f5b90b78c8896655c50df183c005eb59550b2556541df1d46c5a6
 SHA512:
-  metadata.gz: 7fcb746e4541e5360d25b5281d0b407be1b851ba97196d5bae01fec41eae898227bc87aa09dba59d91e22b5045aa14dd93d63856323805cc4944641b79df71b6
-  data.tar.gz: 9072334b6a123882a656f07db3797064cf726fdaf7900ecddc90e808b27ca6503246c0417e1f953e4941fc9c69e2ddce1a5a04be69e245aada6a3b6cf64bccf1
+  metadata.gz: b4bafaf94f2a612bc53f1000426d56a6d42f67076fc33dd887fc53c36dca2a616080a6eb7c35f4c2a59a41b2b2b5a408b4040dce948d655954d53a275d2e9d87
+  data.tar.gz: d1c499194cb06d2975ccbe73ae044ad217952feac63257b310be218c0b18f0262eb7a9ade8c5d25c158bcbac154a594612a709aa9a51ac64408176c15846f6a7

data/lib/amenable.rb

@@ -4,12 +4,8 @@ module Amenable
   extend self
 
   def call(fn, *args, **kwargs, &block)
-    wrap(fn).call(*args, **kwargs, &block)
-  end
-
-  def wrap(fn)
-    unless fn.respond_to?(:call)
-      raise ArgumentError, "fn must be callable: #{fn}"
+    unless fn.is_a?(Method) || fn.is_a?(Proc)
+      raise ArgumentError, "expecting type Method or Proc, found: #{fn.class}"
     end
 
     rest = keyrest = false
@@ -29,12 +25,60 @@ module Amenable
       end
     end
 
-    proc do |*args, **kwargs, &block|
-      # remove unreferenced params
-      args.slice! params.count unless rest
-      kwargs = kwargs.slice(*keys) unless keyrest
+    # remove excessive args
+    args = args.slice(0, params.count) unless rest
 
+    if !keys.empty? || keyrest
+      # remove excessive keywords
+      kwargs = kwargs.slice(*keys) unless keyrest
       fn.call(*args, **kwargs, &block)
+    else
+      fn.call(*args, &block)
+    end
+  end
+
+  refine Object do
+    def amenable(name)
+      # identify method and way to dynamically redefine it
+      if methods(false).include?(name)
+        fn = method(name).unbind # rebind later to support subclassing
+        definer = method(:define_singleton_method)
+      elsif private_methods(false).include?(name)
+        fn = method(name).unbind
+        definer = ->(name, &block) do
+          define_singleton_method(name, &block)
+          private_class_method(name)
+        end
+      elsif private_instance_methods(false).include?(name)
+        fn = instance_method(name)
+        definer = ->(name, &block) do
+          define_method(name, &block)
+          private(name)
+        end
+      elsif protected_instance_methods(false).include?(name)
+        fn = instance_method(name)
+        definer = ->(name, &block) do
+          define_method(name, &block)
+          protected(name)
+        end
+      elsif instance_methods(false).include?(name)
+        fn = instance_method(name)
+        definer = method(:define_method)
+      else
+        raise NoMethodError
+      end
+
+      # rebuild method with Amenable wrapper
+      definer.call(name) do |*args, &block|
+        # bind method to instance or subclass, which is now available
+        if fn.respond_to? :bind
+          fn = fn.bind(self)
+        end
+
+        Amenable.call(fn, *args, &block)
+      end
+
+      name
     end
   end
 end

data/lib/amenable/version.rb

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

data/spec/amenable_spec.rb

@@ -1,32 +1,7 @@
 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)
@@ -115,5 +90,93 @@ describe Amenable do
         ])
       end
     end
+
+    context 'with a method that does not take params' do
+      before do
+        def test_fn; end
+      end
+
+      it 'works without args' do
+        expect(Amenable.call(method(:test_fn))).to be_nil
+      end
+
+      it 'works with args' do
+        expect(Amenable.call(method(:test_fn), :x, :y)).to be_nil
+      end
+
+      it 'works with kwargs' do
+        expect(Amenable.call(method(:test_fn), a: 1, b: 2)).to be_nil
+      end
+    end
+
+    context 'with a method that only takes args' do
+      before do
+        def test_fn(arg)
+          arg
+        end
+      end
+
+      it 'fails without args' do
+        expect {
+          Amenable.call(method(:test_fn))
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'works with args' do
+        expect(Amenable.call(method(:test_fn), :x, :y)).to be :x
+      end
+
+      it 'works with kwargs' do
+        expect(Amenable.call(method(:test_fn), :x, a: 1, b: 2)).to be :x
+      end
+    end
+
+    context 'with a method that only takes varargs' do
+      before do
+        def test_fn(*args)
+          args
+        end
+      end
+
+      it 'works without args' do
+        expect(Amenable.call(method(:test_fn))).to eq []
+      end
+
+      it 'works with args' do
+        expect(Amenable.call(method(:test_fn), :x, :y)).to eq [ :x, :y ]
+      end
+
+      it 'works with kwargs' do
+        expect(Amenable.call(method(:test_fn), :x, :y, a: 1, b: 2)).to eq [ :x, :y ]
+      end
+    end
+
+    context 'with a method that only takes keywords' do
+      before do
+        def test_fn(a:)
+          a
+        end
+      end
+
+      it 'fails without args' do
+        expect {
+          Amenable.call(method(:test_fn))
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'works with args' do
+        expect(Amenable.call(method(:test_fn), :x, a: 1)).to be 1
+      end
+
+      it 'works with kwargs' do
+        expect(Amenable.call(method(:test_fn), a: 1, b: 2)).to be 1
+      end
+    end
+
+    it 'requires a Method or Proc' do
+      expect {
+        Amenable.call(:foo)
+      }.to raise_error(ArgumentError)
+    end
   end
 end

data/spec/readme_spec.rb

@@ -0,0 +1,21 @@
+class Dog
+  using Amenable
+
+  amenable def bark(n = 1)
+    ([ :woof ] * n).join(" ")
+  end
+end
+
+describe Dog do
+  it 'barks' do
+    expect(Dog.new.bark).to eq "woof"
+  end
+
+  it 'barks n times' do
+    expect(Dog.new.bark(2)).to eq "woof woof"
+  end
+
+  it 'ignores excessive parameters' do
+    expect(Dog.new.bark(2, 3, :x, a: 1)).to eq "woof woof"
+  end
+end

data/spec/refinement_spec.rb

@@ -0,0 +1,159 @@
+class Animal
+  using Amenable
+
+  def initialize(name)
+    @name = name
+  end
+
+  amenable def name
+    @name
+  end
+
+  amenable def self.species
+    to_s.downcase
+  end
+end
+
+class Dog < Animal
+  using Amenable
+
+  def bark(n = 1)
+    [ :woof ] * n
+  end
+  amenable :bark
+end
+
+
+describe Dog do
+  let(:gino) { Dog.new('Gino') }
+
+  before do
+    expect(Amenable).to receive(:call).and_call_original
+  end
+
+  describe '#bark' do
+    it 'works with the default value' do
+      expect(gino.bark).to eq [ :woof ]
+    end
+
+    it 'accepts args' do
+      expect(gino.bark(2)).to eq [ :woof, :woof ]
+    end
+
+    it 'ignores excessive args' do
+      expect(gino.bark(2, :x, a: 4)).to eq [ :woof, :woof ]
+    end
+  end
+
+  describe '#name' do
+    it 'works without args' do
+      expect(gino.name).to eq 'Gino'
+    end
+
+    it 'works with any args' do
+      expect(gino.name(:x, a: 1)).to eq 'Gino'
+    end
+  end
+
+  describe '.species' do
+    it 'works without args' do
+      expect(Dog.species).to eq 'dog'
+    end
+
+    it 'works with any args' do
+      expect(Dog.species(:x, a: 1)).to eq 'dog'
+    end
+  end
+end
+
+
+class Cat < Animal
+  using Amenable
+
+  private amenable def asleep?
+    true
+  end
+
+  protected def lives
+    9
+  end
+  amenable :lives
+
+  private
+
+  amenable def nice?
+    false
+  end
+
+  private_class_method def self.agreeable?
+    false
+  end
+  amenable :agreeable?
+
+  class << self
+    private
+
+    amenable def evil?
+      true
+    end
+  end
+end
+
+describe Cat do
+  let(:cat) { Cat.new('Cheshire') }
+
+  describe '#lives' do
+    it 'is protected' do
+      expect(Cat.protected_instance_methods(false)).to include(:lives)
+      expect { cat.lives }.to raise_error(NoMethodError)
+    end
+
+    it 'works with any params' do
+      expect(cat.send(:lives, :x, :y, a: 1, b: 2)).to be 9
+    end
+  end
+
+  describe '#asleep?' do
+    it 'is private' do
+      expect(Cat.private_instance_methods(false)).to include(:asleep?)
+      expect { cat.asleep? }.to raise_error(NoMethodError)
+    end
+
+    it 'works with any params' do
+      expect(cat.send(:asleep?, :x, :y, a: 1, b: 2)).to be true
+    end
+  end
+
+  describe '#nice?' do
+    it 'is private' do
+      expect(Cat.private_instance_methods(false)).to include(:nice?)
+      expect { cat.nice? }.to raise_error(NoMethodError)
+    end
+
+    it 'works with any params' do
+      expect(cat.send(:nice?, :x, :y, a: 1, b: 2)).to be false
+    end
+  end
+
+  describe '.agreeable?' do
+    it 'is private' do
+      expect(Cat.private_methods(false)).to include(:agreeable?)
+      expect { Cat.agreeable? }.to raise_error(NoMethodError)
+    end
+
+    it 'works with any params' do
+      expect(Cat.send(:agreeable?, :x, :y, a: 1, b: 2)).to be false
+    end
+  end
+
+  describe '.evil?' do
+    it 'is private' do
+      expect(Cat.private_methods(false)).to include(:evil?)
+      expect { Cat.evil? }.to raise_error(NoMethodError)
+    end
+
+    it 'works with any params' do
+      expect(Cat.send(:evil?, :x, :y, a: 1, b: 2)).to be true
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amenable
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-26 00:00:00.000000000 Z
+date: 2021-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +75,8 @@ files:
 - lib/amenable.rb
 - lib/amenable/version.rb
 - spec/amenable_spec.rb
+- spec/readme_spec.rb
+- spec/refinement_spec.rb
 homepage: https://github.com/dpep/amenable_rb
 licenses:
 - MIT
@@ -114,3 +102,5 @@ specification_version: 4
 summary: Amenable
 test_files:
 - spec/amenable_spec.rb
+- spec/refinement_spec.rb
+- spec/readme_spec.rb