method_man 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d67d499162c36a14396e908ac1ffe6835b001d6c
-  data.tar.gz: 67605fbb508be908833988854cee950c37715e1e
+SHA256:
+  metadata.gz: 27ac0306df7dc6d12ff3eb481fde1a960c1a5356cad96edcc682058536d2150a
+  data.tar.gz: c6b4856e53dc9fd820a32505da6eed2f2da26ba45253f566e735cea9e8aad84b
 SHA512:
-  metadata.gz: ba2ec6b4c412c521a433db64029fc5b309153024cc35b4aa03aa521b054c7cc48cef3ef3e790d480af869e71a5cddd7653a050eaca281ac3e185a8d01cba7355
-  data.tar.gz: f48f8e1691cfc523c744f807dcb020429e304861c8b3dded09925ff99a2272ea78208c38849870764d2bc86812530220ae5842ce40c0ff3cfe45c4035c0391e7
+  metadata.gz: ab1e722b4c5e2bfd01b3e70c4504a14c1bb592918bd8fe048d14045f937113912ae6341fc2cf144cff4de25b8aa9a0f6489847149866c8308d8fdc13a0b5961c
+  data.tar.gz: ffde0b87325abf0f187f4cb712286128151e3e782d027e2f6566bdfd6c5ef58eba9761154b443edd51ceee7c0bebdedda824571b1c84dbfd6d9ccaa52e27edcb

data/.rubocop.yml

@@ -1,22 +1,27 @@
 AllCops:
-  Exclude:
-    - spec/*
-  TargetRubyVersion: 2.4
+  NewCops: enable
+  TargetRubyVersion: 2.5
 
 # We don't care about method length, since we check method cyclomatic
 # complexity.
 Metrics/MethodLength:
   Enabled: false
+Metrics/BlockLength:
+  Enabled: false
 Metrics/ClassLength:
-    Enabled: false
+  Enabled: false
 Metrics/ModuleLength:
-    Enabled: false
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
 
 # Trailing commas make for clearer diffs because the last line won't appear
 # to have been changed, as it would if it lacked a comma and had one added.
 Style/TrailingCommaInArguments:
   EnforcedStyleForMultiline: comma
-Style/TrailingCommaInLiteral:
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: comma
 
 # Cop supports --auto-correct.

data/.ruby-version

@@ -1,2 +1,2 @@
-2.4.0
+2.7.1
 

data/CHANGELOG.md

@@ -1,9 +1,18 @@
 # Change log
 
+## 2.1.5
+Fix bug where a MethodObject missing attr would raise a nil MethodObject @attributes error instead of method_missing.
+
+## 2.1.4
+Fix bug with delegating to assignment methods like `foo=`.
+
+## 2.1.1
+Fix bug preventing arguments from being forwarded to delegated methods.
+
+## 2.1.0
+Allow automatic delegation inspired by Golang's embedding.
+
 ## 2.0.0
 Convert MethodObject to use inheritance and a class method for dynamic setup of class internals
   - Enables code editors to find declaration of MethodObject
   - Allows constants to be nested whereas previous implementation was based on a Struct which could not contain constants.
-
-## 2.1.0
-Allow automatic delegation inspired by Golang's embedding.

data/Gemfile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in method_man.gemspec

data/README.md

@@ -64,3 +64,33 @@ Also allows automatic delegation inspired by Go's
   MakeArbitraryArray.call(company: company)
   => ['Tyrell Corporation', 'Tyrell Corporation', 'Tyrell Corporation']
 ```
+
+## Naming
+
+Why is the class method called `call`? Some people have argued for names like `TaskSender.send_task` instead of `TaskSender.call`. My reasoning is.
+
+1. `call` is a ubiquitous concept in Ruby, as it's how you invoke `Procs`.
+2. There's even a syntactic sugar for this, `.()` instead of `.call()`, e.g. `TaskSender.(task)`.
+3. The name `call` clearly _calls_ out to someone reading the code that "this is an invocation of a method object". I would say this is especially so if you see something like `TaskSender.(task)`.
+4. Avoiding redundancy. Any custom name will always just match the module/class name, e.g.
+```ruby
+TaskSender.send_task # This is redundant
+```
+5. Minimizing complexity: adding an option to specify the class method would introduce additional complexity.
+
+### History
+In [Refactoring: Ruby Edition](http://www.informit.com/store/refactoring-ruby-edition-9780321603500), we see this at the top of the section on the method object pattern.
+
+> Stolen shamelessly from Kent Beck’s Smalltalk Best Practices.
+> 1. Create a new class, name it after the method.
+
+In the example, the instance method `Account#gamma` is refactored to `Gamma.compute`. Kent Beck's original example refactored `Obligation#sendTask` to `TaskSender.compute`.
+
+### Noun vs. verb
+
+Beck uses `TaskSender`. I personally prefer `SendTask`, essentially just preserving the name of whatever method you're converting to a method object. However I don't think this detail is of much import. I might recommend trying a little of both, and seeing which naming seems least confusing when you're coming back to it weeks later.
+
+## How useful is this pattern?
+Kent Beck has [raved about it](https://twitter.com/kentbeck/status/195168291134783489), saying:
+
+> extract method object is such deep deep magic. it brings clarity to the confused and structure to the chaotic.

data/Rakefile

@@ -1,2 +1,3 @@
 # frozen_string_literal: true
+
 require 'bundler/gem_tasks'

data/lib/method_object.rb

@@ -1,83 +1,95 @@
 # frozen_string_literal: true
-require 'method_object/version'
 
-# See gemspec for description
-class MethodObject
+require('delegate')
+require('method_object/version')
+
+# See gemspec for description.
+class MethodObject < SimpleDelegator
   class AmbigousMethodError < NameError; end
 
   class << self
-    def attrs(*attributes)
-      @attributes = attributes
-      Setup.call(attributes: attributes, subclass: self)
-    end
-
     def call(**args)
-      new(args).call
+      new(__object_factory__&.new(**args)).call
     end
 
-    attr_reader(:attributes)
-
     private(:new)
-  end
 
-  def initialize(_); end
-
-  def call
-    raise NotImplementedError, 'Define the call method'
-  end
-
-  def method_missing(name, *args, &block)
-    candidates = candidates_for_method_missing(name)
-    case candidates.length
-    when 0
-      super
-    when 1
-      define_and_call_new_method(candidates.first)
-    else
-      handle_ambiguous_missing_method(candidates, name)
+    def attrs(*attributes)
+      self.__object_factory__ = ObjectFactory.create(*attributes)
     end
+
+    attr_accessor(:__object_factory__)
   end
 
-  def respond_to_missing?(name)
-    candidates_for_method_missing(name).length == 1
+  def call
+    raise(NotImplementedError, 'define the call method')
   end
 
-  def candidates_for_method_missing(method_name)
-    potential_candidates =
-      self.class.attributes.map do |attribute|
-        PotentialDelegator.new(attribute, send(attribute), method_name)
-      end +
-      self.class.attributes.map do |attribute|
-        PotentialDelegatorWithPrefix.new(
-          attribute,
-          send(attribute),
-          method_name,
-        )
+  # Creates instances for delegation and caching method definitions.
+  class ObjectFactory
+    STRUCT_DEFINITION = lambda do |_class|
+      def method_missing(name, *args)
+        candidates = candidates_for_method_missing(name)
+        handle_ambiguous_missing_method(candidates, name) if candidates.length > 1
+        super
       end
-    potential_candidates.select(&:candidate?)
-  end
 
-  def define_and_call_new_method(candidate)
-    self.class.class_eval(
-      <<-RUBY
-        def #{candidate.delegated_method}
-          #{candidate.attribute}.#{candidate.method_to_call_on_delegate}
+      def respond_to_missing?(name, _include_private)
+        candidates = candidates_for_method_missing(name)
+        case candidates.length
+        when 0
+          return(super)
+        when 1
+          define_delegated_method(candidates.first)
         end
-      RUBY
-    )
-    public_send(candidate.delegated_method)
-  end
+        true
+      end
 
-  def handle_ambiguous_missing_method(candidates, method_name)
-    raise(
-      AmbigousMethodError,
-      "#{method_name} is ambiguous: " +
-      candidates
-        .map do |candidate|
-          "#{candidate.attribute}.#{candidate.method_to_call_on_delegate}"
-        end
-        .join(', '),
-    )
+      def candidates_for_method_missing(method_name)
+        potential_candidates =
+          members.map do |attribute|
+            PotentialDelegator.new(
+              attribute,
+              public_send(attribute),
+              method_name,
+            )
+          end +
+          members.map do |attribute|
+            PotentialDelegatorWithPrefix.new(
+              attribute,
+              public_send(attribute),
+              method_name,
+            )
+          end
+        potential_candidates.select(&:candidate?)
+      end
+
+      def define_delegated_method(delegate)
+        code = <<~RUBY
+          def #{delegate.delegated_method}(*args, &block)
+            #{delegate.attribute}
+              .#{delegate.method_to_call_on_delegate}(*args, &block)
+          end
+        RUBY
+        self.class.class_eval(code, __FILE__, __LINE__ + 1)
+      end
+
+      def handle_ambiguous_missing_method(candidates, method_name)
+        raise(
+          AmbigousMethodError,
+          "#{method_name} is ambiguous: " +
+          candidates
+            .map do |candidate|
+              "#{candidate.attribute}.#{candidate.method_to_call_on_delegate}"
+            end
+            .join(', '),
+        )
+      end
+    end
+
+    def self.create(*attributes)
+      Struct.new(*attributes, keyword_init: true, &STRUCT_DEFINITION)
+    end
   end
 
   # Represents a possible match of the form:
@@ -87,11 +99,7 @@ class MethodObject
       object.respond_to?(delegated_method)
     end
 
-    def call
-      object.public_send(delegated_method)
-    end
-
-    alias_method :method_to_call_on_delegate, :delegated_method
+    alias_method(:method_to_call_on_delegate, :delegated_method)
   end
 
   # Represents a possible match of the form:
@@ -102,10 +110,6 @@ class MethodObject
         name_matches? && object.respond_to?(method_to_call_on_delegate)
       end
 
-      def call
-        object.public_send(method_to_call_on_delegate)
-      end
-
       def method_to_call_on_delegate
         delegated_method.to_s.sub(prefix, '')
       end
@@ -113,7 +117,7 @@ class MethodObject
       private
 
       def name_matches?
-        delegated_method.to_s.start_with?(prefix)
+        delegated_method.start_with?(prefix)
       end
 
       def prefix
@@ -121,7 +125,7 @@ class MethodObject
       end
     end
 
-  # Dynamically defines custom attr_readers and initializer
+  # Dynamically defines custom attr_readers and initializer.
   class Setup < SimpleDelegator
     def self.call(attributes:, subclass:)
       new(attributes, subclass).call
@@ -145,26 +149,24 @@ class MethodObject
       __getobj__.send(:attr_reader, *attributes)
     end
 
-    def attr_accessor(attribute)
-      super
-    end
-
     def define_initializer
-      class_eval(
-        <<-RUBY
-          def initialize(#{required_keyword_args_string})
-            #{assignments}
-          end
-        RUBY
-      )
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def initialize(#{required_keyword_args_string})
+          #{assignments}
+        end
+      RUBY
     end
 
     def required_keyword_args_string
-      attributes.map { |arg| "#{arg}:" }.join(',')
+      attributes.map { |arg| "#{arg}:" }.join(', ')
     end
 
     def assignments
       attributes.map { |attribute| "@#{attribute} = #{attribute}\n" }.join
     end
   end
+
+  def respond_to_missing?(*args)
+    super || __getobj__.respond_to?(*args)
+  end
 end

data/lib/method_object/version.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
-class MethodObject
-  VERSION = '2.1.1'
+
+require('delegate')
+
+class MethodObject < SimpleDelegator
+  VERSION = '3.0.0'
 end

data/method_man.gemspec

@@ -1,6 +1,6 @@
-# coding: utf-8
 # frozen_string_literal: true
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'method_object/version'
 
@@ -9,10 +9,8 @@ Gem::Specification.new do |spec|
   spec.version       = MethodObject::VERSION
   spec.authors       = ['Clay Shentrup']
   spec.email         = %w[cshentrup@gmail.com]
-  spec.summary       = 'Provides a MethodObject class which implements Kent' +
-                       %q(Beck's "method object" pattern.)
-  spec.description   = 'Provides a MethodObject class which implements Kent' +
-                       %q(Beck's "method object" pattern.)
+  spec.summary       = %(Provides a MethodObject class which implements KentBeck's "method object" pattern.)
+  spec.description   = %(Provides a MethodObject class which implements KentBeck's "method object" pattern.)
   spec.homepage      = 'https://github.com/brokenladder/method_man'
   spec.license       = 'MIT'
 
@@ -21,9 +19,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w[lib]
 
-  spec.required_ruby_version = '>= 2.1'
+  spec.required_ruby_version = '>= 2.5'
 
-  spec.add_development_dependency 'bundler', '~> 1.9'
-  spec.add_development_dependency 'rake', '~> 10.4'
-  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency('bundler')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('rspec')
+  spec.add_development_dependency('rubocop')
 end

data/spec/method_man_spec.rb

@@ -1,185 +1,119 @@
 # frozen_string_literal: true
-require 'method_object'
 
-describe MethodObject do
-  it 'makes new a private class method' do
-    expect { subject.new }.to raise_error(NoMethodError)
-  end
+require('method_object')
+require('ostruct')
 
-  context 'without attrs' do
-    subject do
+RSpec.describe(MethodObject) do
+  context('with attrs') do
+    let(:method_object) do
       Class.new(described_class) do
+        attrs(:block, :attr1, :attr2)
+
         def call
-          true
+          instance_eval(&block)
+        end
+
+        def local_method
+          [attr1, attr2]
         end
       end
     end
+    let(:attr1) { double('attr1', ambiguous_method: nil, delegated_method: delegated_value) }
+    let(:delegated_value) { 'delegated value' }
+    let(:attr2) do
+      double('attr2', ambiguous_method: nil, attr1_ambiguous_method: nil)
+    end
 
-    specify { expect(subject.call).to be(true) }
-  end
-
-  context 'with attrs' do
-    subject do
-      Class.new(described_class) do
-        attrs(:company, :user)
-
-        @sent_messages = []
-
-        def self.sent_messages
-          @sent_messages
-        end
+    def call(&block)
+      method_object.call(block: block, attr1: attr1, attr2: attr2)
+    end
 
-        def call
-          {
-            address: address,
-            respond_to_address: respond_to_missing?(:address),
-            company_address: company_address,
-            respond_to_company_address: respond_to_missing?(:company_address),
-            company: company,
-            respond_to_name: respond_to_missing?(:name),
-            company_name: company_name,
-            respond_to_company_name: respond_to_missing?(:company_name),
-            user: user,
-            user_name: user_name,
-            respond_to_user_name: respond_to_missing?(:user_name),
-            respond_to_missing: respond_to_missing?(:undefined_method),
-          }
-        end
-      end
+    it('makes .new a private class method') do
+      expect { method_object.new }.to(raise_error(NoMethodError))
     end
 
-    let(:company) do
-      double('company', address: company_address, name: company_name)
-    end
-    let(:company_address) { '101 Minitru Lane' }
-    let(:company_name) { 'Periscope Data' }
-    let(:user) { double('user', name: user_name) }
-    let(:user_name) { 'Woody' }
-
-    let(:result) { subject.call(company: company, user: user) }
-
-    specify do
-      expect(result).to eq(
-        address: company_address,
-        respond_to_address: true,
-        company_address: company_address,
-        respond_to_company_address: true,
-        company: company,
-        respond_to_name: false,
-        company_name: company_name,
-        respond_to_company_name: true,
-        user: user,
-        user_name: user_name,
-        respond_to_user_name: true,
-        respond_to_missing: false,
-      )
+    it('raises method missing exception for undefined methods') do
+      expect { call { undefined_method } }.to(raise_error(NameError, /undefined_method/))
     end
 
-    it 'uses required keyword arguments' do
-      expect { subject.call }.to raise_error(ArgumentError)
+    it('calls its own methods and passed attrs') do
+      expect(call { local_method }).to(eq([attr1, attr2]))
     end
 
-    context 'with ambiguous method call' do
-      subject do
-        Class.new(described_class) do
-          attrs(:company, :user)
+    def delegates?(method)
+      call { respond_to?(method) }
+    end
 
-          def call
-            name
-          end
-        end
-      end
+    it('delegates to attrs') do
+      expect(delegates?(:delegated_method)).to(be(true))
 
-      specify do
-        expect { result }.to raise_error(
-          MethodObject::AmbigousMethodError,
-          a_string_including('company.name, user.name'),
-        )
-      end
+      expect(call { delegated_method }).to(be(delegated_value))
     end
 
-    context 'ambigous method call due to delegation' do
-      subject do
-        Class.new(described_class) do
-          attrs(:company, :user)
+    it('delegates to attrs with prefix') do
+      expect(delegates?(:attr1_delegated_method)).to(be(true))
 
-          def call
-            company_address
-          end
-        end
-      end
+      expect(call { attr1_delegated_method }).to(be(delegated_value))
+    end
 
-      let(:user) { double('user', company_address: nil) }
+    it('raises for ambiguity on delegated method names') do
+      expect(delegates?(:ambiguous_method)).to(be(true))
 
-      specify do
-        expect { result }.to raise_error(
+      expect { call { ambiguous_method } }.to(
+        raise_error(
           MethodObject::AmbigousMethodError,
-          a_string_including('user.company_address, company.address'),
-        )
-      end
+          a_string_including('ambiguous_method is ambiguous: attr1.ambiguous_method, attr2.ambiguous_method'),
+        ),
+      )
     end
 
-    describe 'respecting method privacy' do
-      let(:subject) do
-        Class.new(described_class) do
-          attrs(:diary)
+    it('raises for ambiguity on delegated and prefixed delegated method names') do
+      expect(delegates?(:attr1_ambiguous_method)).to(be(true))
 
-          def call
-            diary_contents
-          end
-        end
-      end
-      let(:diary) do
-        Module.new do
-          def self.contents; end
+      expect { call { attr1_ambiguous_method } }.to(
+        raise_error(
+          MethodObject::AmbigousMethodError,
+          a_string_including(
+            'attr1_ambiguous_method is ambiguous: ' \
+            'attr2.attr1_ambiguous_method, attr1.ambiguous_method',
+          ),
+        ),
+      )
+    end
 
-          private_class_method(:contents)
-        end
-      end
+    describe('assignments') do
+      let(:attr1) { OpenStruct.new }
 
-      specify do
-        expect { subject.call(diary: diary) }.to raise_error(StandardError)
+      it('assigns') do
+        call { attr1.foo = 'bar' }
+        expect(attr1.foo).to(eq('bar'))
       end
     end
+  end
+
+  context('without attrs') do
+    let(:method_object) do
+      Class.new(described_class) do
+        def call
+          receiver_test
+        end
 
-    describe '"memoizes" method calls' do
-      subject do
-        Class.new(described_class) do
-          attrs(:company)
-          @sent_messages = []
-
-          def self.sent_messages
-            @sent_messages
-          end
-
-          def call
-            [name, name]
-          end
-
-          # Ensure it defines resolved methods
-          def method_missing(method, *_args)
-            if self.class.sent_messages.include?(method)
-              raise 'method not memoized'
-            end
-            self.class.sent_messages << method
-            super
-          end
+        def receiver_test
+          42
         end
       end
+    end
 
-      specify do
-        expect(subject.call(company: company)).to eq([company_name, company_name])
-      end
+    def call
+      method_object.call
     end
-  end
 
-  context 'without a provided instance call method' do
-    subject do
-      Class.new(described_class) { attrs(:user_1_age) }
+    it 'makes new a private class method' do
+      expect { method_object.new }.to raise_error(NoMethodError)
     end
 
-    specify do
-      expect { subject.call(user_1_age: user_1_age) }.to raise_error(NameError)
+    it('calls itself') do
+      expect(call { receiver_test }).to eq(42)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only

metadata

@@ -1,57 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: method_man
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Clay Shentrup
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-03-14 00:00:00.000000000 Z
+date: 2020-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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'
 description: Provides a MethodObject class which implements KentBeck's "method object"
   pattern.
 email:
@@ -79,7 +93,7 @@ homepage: https://github.com/brokenladder/method_man
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -87,16 +101,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Provides a MethodObject class which implements KentBeck's "method object"
   pattern.