amenable 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 133a9c4b0a84e4325394ededc6826cb7408a9505d1c45bdfdd06674a10fac5ff
-  data.tar.gz: 1345444593420700a2b84938c64f58343e6f33c8a6399fd955fb09cd717c74c0
+  metadata.gz: 0b63301072a15feda94f5c8a68ca8be4ed71ed08a4f33591c8bd50e0e70913d6
+  data.tar.gz: d066ce9fc0f6e20510a17715e68bd36ebf333b3e268775dff8d7a38fe8349892
 SHA512:
-  metadata.gz: 7fcb746e4541e5360d25b5281d0b407be1b851ba97196d5bae01fec41eae898227bc87aa09dba59d91e22b5045aa14dd93d63856323805cc4944641b79df71b6
-  data.tar.gz: 9072334b6a123882a656f07db3797064cf726fdaf7900ecddc90e808b27ca6503246c0417e1f953e4941fc9c69e2ddce1a5a04be69e245aada6a3b6cf64bccf1
+  metadata.gz: 8ac3cb8c04e8aab1072cd30c0116d4ae6a86784f827b10c515bec6e6c515069c62559604647668b41159b542fe7bb3f4c3ad2b483657b16924baa54c7e07faaa
+  data.tar.gz: 2e97dd44eca60f8ea2c16b59176ea9a5861e95de54a01814337fb0cded49f39b160ca6921f04d802825b4bf612d1c2065cf5bd8d4a8c51311ec8dc99730251d0

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+###  v0.1.1  (2026-11-03)
+- drop Ruby 3.0 and 3.1 (end of life); requires Ruby >= 3.2
+- fix: amenable methods no longer run with the first caller's `self` (instances, classes sharing a module, subclasses calling amenable class methods, concurrent first calls)
+- fix: amenable methods pass keyword arguments through instead of dropping them (`opt(1, b: 3)` returned the default `b`, `**opts` came back empty)
+- fix: keywords sent to a method with no keyword params are passed through as Ruby would bind them (to `*rest` or an open positional slot, e.g. `def m(opts = {})`, and to C methods like `String#encode`) instead of being dropped; they're only stripped when Ruby would reject them
+- fix: in a class or module body, `amenable` wraps the instance method even when a class method of the same name exists; `amenable def initialize` now works; module_function methods are wrapped on both the module and its includers
+- fix: `amenable` at the top level, and on a plain object's private singleton method, no longer crashes
+- fix: `amenable` with an unknown or inherited method raises NoMethodError naming the method and receiver
+- fix: a non-lambda proc given a lone Array now auto-splats it as a direct call does (`Amenable.call(proc { |a, b = 2, k: 1| [a, b] }, [5, 1])` returned `[[5, 1], 2]`)
+- fix: extra positionals and keywords sent to a non-lambda proc are left for the proc to drop, as a direct call does (`proc { |a,| a }` given `([5, 1], :x)` returned 5 instead of `[5, 1]`)
+
+###  v0.1.0  (2021-07-05)
+- readme spec
+- test coverage
+- simplify ci
+- remove wrapper and simplify usage around refinement or .call
+- refinement support
+- kwarg bugfix
+
+###  v0.0.2  (2021-06-26)
+- upgrade to .call / .wrap
+
+###  v0.0.1  (2021-04-07)
+- init
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Daniel Pepper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+Amenable
+======
+Removes excessive parameters from function calls.
+
+The rule: amenable drops only the arguments Ruby would reject with `ArgumentError`. Any call Ruby already accepts behaves exactly as it would without amenable.
+
+
+```ruby
+require 'amenable'
+
+class Dog
+  using Amenable
+
+  amenable def bark(n = 1)
+    ([ :woof ] * n).join(" ")
+  end
+end
+
+
+Dog.new.bark
+> "woof"
+
+Dog.new.bark(2)
+> "woof woof"
+
+Dog.new.bark(2, 3, 4, foo: 5)
+> "woof woof"
+```
+
+
+## Usage
+
+```ruby
+gem "amenable"  # requires Ruby >= 3.2
+```
+
+Activate the refinement with `using Amenable`, then wrap a method as you define it (`amenable def bark ...`) or afterwards by name (`amenable :bark`). It works on instance, private, protected, and class methods (`amenable def self.build`), on `module_function` methods, and at the top level.
+
+For a Method or Proc you already have, skip the refinement and use `Amenable.call(fn, *args, **kwargs, &block)`:
+
+```ruby
+Amenable.call(->(a) { a * 2 }, 3, 4, x: 1)
+> 6
+```
+
+
+## Keywords
+
+Extra keywords are dropped when the method can't take them. If it has an open positional slot, they land there as a Hash, as in plain Ruby:
+
+```ruby
+class Greeter
+  using Amenable
+
+  amenable def hello(name, greeting: "hi")
+    "#{greeting} #{name}"
+  end
+
+  amenable def configure(opts = {})
+    opts
+  end
+end
+
+
+Greeter.new.hello("bob", greeting: "yo", volume: 11)
+> "yo bob"
+
+Greeter.new.configure(verbose: true)
+> {verbose: true}
+```
+
+Missing arguments still raise. Amenable removes; it never fills in.
+
+
+## Limits
+
+- Only wraps methods defined directly on the receiver, not inherited ones (raises `NoMethodError`).
+- When a class method and an instance method share a name, `amenable def foo` in the class body wraps the instance method. Use `class << self` to wrap the class one.
+- Wrapped methods report the wrapper's `parameters`, `arity`, and `source_location`.
+- Curried lambdas and `Symbol#to_proc` can't be stripped: their real signature isn't visible.
+
+
+----
+## Contributing
+
+Yes please  :)
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-feature`)
+1. Ensure the tests pass (`bundle exec rspec`)
+1. Commit your changes (`git commit -am 'awesome new feature'`)
+1. Push your branch (`git push origin my-feature`)
+1. Create a Pull Request
+
+
+----
+![Gem](https://img.shields.io/gem/dt/amenable?style=plastic)
+[![codecov](https://codecov.io/gh/dpep/amenable_rb/branch/main/graph/badge.svg)](https://codecov.io/gh/dpep/amenable_rb)

data/amenable.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/amenable/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'amenable'
+  s.version     = Amenable::VERSION
+  s.authors     = ['Daniel Pepper']
+  s.summary     = 'Amenable'
+  s.description = <<~DESCRIPTION
+    A refinement that strips excess positional and keyword arguments
+    from method calls, so callers can pass extras without raising
+    ArgumentError.
+  DESCRIPTION
+  s.homepage    = "https://github.com/dpep/amenable_rb"
+  s.license     = 'MIT'
+  s.files       = `git ls-files * ':!:spec' ':!:CLAUDE.md'`.split("\n")
+
+  s.metadata = {
+    "changelog_uri" => "#{s.homepage}/blob/main/CHANGELOG.md",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => s.homepage,
+  }
+
+  s.required_ruby_version = ">= 3.2"
+
+  s.add_development_dependency 'debug'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'simplecov'
+end

data/lib/amenable/version.rb

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

data/lib/amenable.rb

@@ -4,15 +4,14 @@ 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
+    rest = keyrest = nokey = false
+    # a non-lambda proc drops extra positionals itself, and trimming them can
+    # make it auto-splat a lone Array
+    loose = fn.is_a?(Proc) && !fn.lambda?
     params = []
     keys = []
 
@@ -26,15 +25,76 @@ module Amenable
         rest = true
       when :keyrest
         keyrest = true
+      when :nokey
+        nokey = true
       end
     end
 
-    proc do |*args, **kwargs, &block|
-      # remove unreferenced params
-      args.slice! params.count unless rest
+    # remove excessive args
+    args = args.slice(0, params.count) unless rest || loose
+
+    if nokey
+      kwargs = {}
+    elsif !keys.empty? || keyrest
+      # remove excessive keywords
       kwargs = kwargs.slice(*keys) unless keyrest
+    elsif !(rest || loose || args.size < params.count)
+      # no keyword params: Ruby binds keywords to *rest or an open positional
+      # slot as a Hash, so strip them only when there's nowhere for them to go
+      kwargs = {}
+    end
+
+    # `**{}` is not a no-op: it stops a non-lambda proc auto-splatting
+    kwargs.empty? ? fn.call(*args, &block) : fn.call(*args, **kwargs, &block)
+  end
+
+  refine Object do
+    def amenable(name)
+      defines = ->(owner) do
+        owner.method_defined?(name, false) || owner.private_method_defined?(name, false)
+      end
+
+      wrap = ->(owner) do
+        fn = owner.instance_method(name)
+        visibility =
+          if owner.private_method_defined?(name, false) then :private
+          elsif owner.protected_method_defined?(name, false) then :protected
+          else :public
+          end
+
+        owner.send(:define_method, name) do |*args, **kwargs, &block|
+          # bind per call: `fn` is shared by every receiver, so never reassign it
+          Amenable.call(fn.bind(self), *args, **kwargs, &block)
+        end
+        owner.send(visibility, name)
+      end
+
+      # a top-level `def` lands on Object, not on main's singleton class
+      mod = TOPLEVEL_BINDING.receiver.equal?(self) ? Object : self
+
+      # in a class body, `def foo` means the instance method; only fall back
+      # to the singleton side when there isn't one
+      if mod.is_a?(Module) && defines.call(mod)
+        # module_function leaves a public copy on the singleton and makes the
+        # instance method private: wrap both. Location alone can't tell a copy
+        # from another def on the same line.
+        copy = mod.private_method_defined?(name, false) &&
+          mod.singleton_class.public_method_defined?(name, false) &&
+          mod.singleton_class.instance_method(name).source_location == mod.instance_method(name).source_location
+
+        wrap.call(mod)
+        wrap.call(mod.singleton_class) if copy
+      elsif defines.call(singleton_class)
+        wrap.call(singleton_class)
+      else
+        raise NoMethodError.new(
+          "amenable: no method '#{name}' defined directly on #{inspect}",
+          name,
+          receiver: self,
+        )
+      end
 
-      fn.call(*args, **kwargs, &block)
+      name
     end
   end
 end

metadata

@@ -1,45 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: amenable
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - Daniel Pepper
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: byebug
-  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: codecov
-  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: rake
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,20 +51,28 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Flexibility when you need it.
-email:
+description: |
+  A refinement that strips excess positional and keyword arguments
+  from method calls, so callers can pass extras without raising
+  ArgumentError.
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- amenable.gemspec
 - lib/amenable.rb
 - lib/amenable/version.rb
-- spec/amenable_spec.rb
 homepage: https://github.com/dpep/amenable_rb
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  changelog_uri: https://github.com/dpep/amenable_rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/dpep/amenable_rb
 rdoc_options: []
 require_paths:
 - lib
@@ -101,16 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Amenable
-test_files:
-- spec/amenable_spec.rb
+test_files: []

data/spec/amenable_spec.rb

@@ -1,119 +0,0 @@
-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