method_man 2.1.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 831d183e2f5c7237beceebb557306fb9d80cc6b2
-  data.tar.gz: 35a28df7284c164aac634ca88d8174ff641562ab
+SHA256:
+  metadata.gz: 27ac0306df7dc6d12ff3eb481fde1a960c1a5356cad96edcc682058536d2150a
+  data.tar.gz: c6b4856e53dc9fd820a32505da6eed2f2da26ba45253f566e735cea9e8aad84b
 SHA512:
-  metadata.gz: d2265d8be6ed53fa75b8ec8ff49a6c6dc20d7345f33ad70aa348630fce86830c27dae1748c86efa37b4de466ca448a5f245bcc71c586735f0943ecf4ff1ffa7c
-  data.tar.gz: 0ca477c07b14d61ea8f201d04735792a359c6ef0870acd777ddddfec901454767db08b0c522a35b3fb705d5796a164ba108cbfdb48d80f049ff8e0038bee8087
+  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/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/lib/method_object.rb

@@ -1,102 +1,95 @@
 # frozen_string_literal: true
 
+require('delegate')
 require('method_object/version')
 
-# See gemspec for description
-class MethodObject
+# 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)
 
-    def inherited(child_class)
-      child_class.instance_variable_set(:@attributes, [])
+    def attrs(*attributes)
+      self.__object_factory__ = ObjectFactory.create(*attributes)
     end
-  end
-
-  def initialize(_); end
 
-  def call
-    raise NotImplementedError, 'Define the call method'
+    attr_accessor(:__object_factory__)
   end
 
-  def method_missing(name, *args, &block)
-    candidates = candidates_for_method_missing(name)
-    case candidates.length
-    when 0
-      super
-    when 1
-      delegate = candidates.first
-      define_delegated_method(delegate)
-      public_send(delegate.delegated_method, *args, &block)
-    else
-      handle_ambiguous_missing_method(candidates, name)
-    end
+  def call
+    raise(NotImplementedError, 'define the call method')
   end
 
-  def respond_to_missing?(name)
-    candidates_for_method_missing(name).length == 1
-  end
+  # 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
 
-  def candidates_for_method_missing(method_name)
-    potential_candidates =
-      self.class.attributes.map do |attribute|
-        PotentialDelegator.new(
-          attribute,
-          public_send(attribute),
-          method_name,
-        )
-      end +
-      self.class.attributes.map do |attribute|
-        PotentialDelegatorWithPrefix.new(
-          attribute,
-          public_send(attribute),
-          method_name,
-        )
+      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
+        true
       end
-    potential_candidates.select(&:candidate?)
-  end
 
-  def define_delegated_method(delegate)
-    self.class.class_eval(
-      if delegate.method_to_call_on_delegate.to_s.end_with?('=')
-        <<-RUBY
-          def #{delegate.delegated_method}(arg)
-            #{delegate.attribute}.#{delegate.method_to_call_on_delegate}(arg)
+      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
-        RUBY
-      else
-        <<-RUBY
+        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
-    )
-  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 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:
@@ -124,7 +117,7 @@ class MethodObject
       private
 
       def name_matches?
-        delegated_method.to_s.start_with?(prefix)
+        delegated_method.start_with?(prefix)
       end
 
       def prefix
@@ -132,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
@@ -156,18 +149,12 @@ 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
@@ -178,4 +165,8 @@ class MethodObject
       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,5 +1,7 @@
 # frozen_string_literal: true
 
-class MethodObject
-  VERSION = '2.1.5'
+require('delegate')
+
+class MethodObject < SimpleDelegator
+  VERSION = '3.0.0'
 end

data/method_man.gemspec

@@ -1,7 +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'
 
@@ -10,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'
 
@@ -22,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,208 +1,119 @@
 # frozen_string_literal: true
 
 require('method_object')
+require('ostruct')
 
 RSpec.describe(MethodObject) do
-  it 'makes new a private class method' do
-    expect { subject.new }.to raise_error(NoMethodError)
-  end
-
-  context 'without attrs' do
-    subject 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
-      end
-    end
 
-    describe 'calling a missing method' do
-      subject do
-        Class.new(described_class) do
-          def call
-            undefined_method
-          end
+        def local_method
+          [attr1, attr2]
         end
       end
-
-      it 'raises method missing exception' do
-        expect { subject.call }.to raise_error(NameError, /undefined_method/)
-      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)
-
-        def call
-          self.name = 'New Company Name'
-          self.company_name = 'New Company Name 2'
-          {
-            address: address,
-            respond_to_address: respond_to_missing?(:address),
-            company_address: company_address,
-            id_for_joe: company_id_for('Joe'),
-            block_arg: company_run_a_block { |block_arg| block_arg * 2 },
-            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
+    def call(&block)
+      method_object.call(block: block, attr1: attr1, attr2: attr2)
     end
 
-    let(:company) do
-      double('company', address: company_address, name: company_name)
-        .tap do |company|
-          allow(company).to receive(:id_for).with('Joe').and_return(1234)
-          allow(company).to receive(:run_a_block) do |&block|
-            block.call(4321)
-          end
-        end
+    it('makes .new a private class method') do
+      expect { method_object.new }.to(raise_error(NoMethodError))
     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(company).to receive(:name=).ordered.with('New Company Name')
-      expect(company).to receive(:name=).ordered.with('New Company Name 2')
-      expect(result).to eq(
-        address: company_address,
-        respond_to_address: true,
-        company_address: company_address,
-        id_for_joe: 1234,
-        block_arg: 8642,
-        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 = []
-
-          class << self
-            attr_reader(: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.5
+  version: 3.0.0
 platform: ruby
 authors:
 - Clay Shentrup
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-01-09 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.13
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Provides a MethodObject class which implements KentBeck's "method object"
   pattern.