amenable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 641c3e9528672faac363aedc32ab19e35494d4ed23b247f8a0962f02b0c53bc7
-  data.tar.gz: e4e39cf70b4f5b90b78c8896655c50df183c005eb59550b2556541df1d46c5a6
+  metadata.gz: 0b63301072a15feda94f5c8a68ca8be4ed71ed08a4f33591c8bd50e0e70913d6
+  data.tar.gz: d066ce9fc0f6e20510a17715e68bd36ebf333b3e268775dff8d7a38fe8349892
 SHA512:
-  metadata.gz: b4bafaf94f2a612bc53f1000426d56a6d42f67076fc33dd887fc53c36dca2a616080a6eb7c35f4c2a59a41b2b2b5a408b4040dce948d655954d53a275d2e9d87
-  data.tar.gz: d1c499194cb06d2975ccbe73ae044ad217952feac63257b310be218c0b18f0262eb7a9ade8c5d25c158bcbac154a594612a709aa9a51ac64408176c15846f6a7
+  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.1.0'
+  VERSION = '0.1.1'
 end

data/lib/amenable.rb

@@ -8,7 +8,10 @@ module Amenable
       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 = []
 
@@ -22,60 +25,73 @@ module Amenable
         rest = true
       when :keyrest
         keyrest = true
+      when :nokey
+        nokey = true
       end
     end
 
     # remove excessive args
-    args = args.slice(0, params.count) unless rest
+    args = args.slice(0, params.count) unless rest || loose
 
-    if !keys.empty? || keyrest
+    if nokey
+      kwargs = {}
+    elsif !keys.empty? || keyrest
       # remove excessive keywords
       kwargs = kwargs.slice(*keys) unless keyrest
-      fn.call(*args, **kwargs, &block)
-    else
-      fn.call(*args, &block)
+    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)
-      # 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
+      defines = ->(owner) do
+        owner.method_defined?(name, false) || owner.private_method_defined?(name, false)
       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)
+      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
 
-        Amenable.call(fn, *args, &block)
+      # 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
 
       name

metadata

@@ -1,31 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: amenable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Daniel Pepper
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-06 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
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,22 +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
-- spec/readme_spec.rb
-- spec/refinement_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
@@ -89,18 +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
-- spec/refinement_spec.rb
-- spec/readme_spec.rb
+test_files: []

data/spec/amenable_spec.rb

@@ -1,182 +0,0 @@
-describe Amenable do
-  describe '.call' do
-    let(:fn) { proc {|x, y = :y, a:, b: 2| [ [ x, y ], { a: a, b: b } ] } }
-
-    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
-
-    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

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

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