method_man 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f6ff20e7c2d99f044220e1ec5ac2f2797e1d69e
-  data.tar.gz: 1c3d343db211b89563d90d542ca55571f7da57f6
+  metadata.gz: c0ddc3147244cc0dc922a4ebc1aa9512efedfecf
+  data.tar.gz: 5139372bb0da36319b9cd7a3338da3dd507e1724
 SHA512:
-  metadata.gz: 9ec339e5eb97608a7ef871d8bb2a6481f0e3bdb451de0b887c798ea810133b00afdcdd20398ed084250be4381ab4e36bc3bc7671c6d146e53371fe6e5a822f10
-  data.tar.gz: 5045fc01e0279d6c99dbe8e5dce37bf612e058f4f6da6edd5768f31ed531565ac610300f03327dbad301b81cbf5168626919f0a9e8053c700e7247620f51e51f
+  metadata.gz: 71436d2cf1e9b82acf277477ae6009d1e6d05288f93a848cb8055dfa8b6169c27fdc615ed5ca3ab710b4241f45f658aa0ec5989e2f42380f7b1df92893453a21
+  data.tar.gz: 7cf527f78e56ed58fa9e64f7e0149f006fc398fbb81309f4315fe790288075ed07cd600c623f987daafdffc12dbb8fb127bc5c320a9b0bd83075d218b2eb45d7

data/.rubocop.yml

@@ -0,0 +1,30 @@
+AllCops:
+  Exclude:
+    - spec/*
+  TargetRubyVersion: 2.4
+
+# We don't care about method length, since we check method cyclomatic
+# complexity.
+Metrics/MethodLength:
+  Enabled: false
+Metrics/ClassLength:
+    Enabled: false
+Metrics/ModuleLength:
+    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:
+  EnforcedStyleForMultiline: comma
+
+# Cop supports --auto-correct.
+# Configuration parameters: PreferredDelimiters.
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    # Using `[]` for string arrays instead of `()`, since normal arrays are
+    # indicated with `[]` not `()`.
+    '%w': '[]'
+    '%W': '[]'
+    '%i': '[]'

data/.ruby-version

@@ -1 +1,2 @@
-2.2.1
+2.4.0
+

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change log
+
+## 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,3 +1,4 @@
+# frozen_string_literal: true
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in method_man.gemspec

data/README.md

@@ -2,8 +2,6 @@
 
 Defines a MethodObject class which facilitates basic setup for Kent Beck's "[method object](http://c2.com/cgi/wiki?MethodObject)".
 
-The MethodObject class is largely based on a Ruby Struct, but with a few additional features:
-
 * Facilitates basic method object pattern setup. You only need to supply an instance `call` method.
 * Accepts a list of arguments which are mapped to required keyword arguments.
 * Disallows calling `new` on the resulting MethodObject class instance.
@@ -22,13 +20,13 @@ gem 'method_man', require: 'method_object'
 ```ruby
   require 'method_object'
 
-  MakeArbitraryArray = MethodObject.new(:first_name, :last_name, :message) do
+  class MakeArbitraryArray < MethodObject
+    attrs(:first_name, :last_name, :message)
+
     def call
       [fullname, message, 42]
     end
 
-    private
-
     def fullname
       "#{first_name} #{last_name}"
     end
@@ -39,5 +37,30 @@ gem 'method_man', require: 'method_object'
     last_name: 'Smith',
     message: 'Hi',
   )
-  => ["John Smith", 'Hi', 42]
+  => ['John Smith', 'Hi', 42]
+```
+
+Also allows automatic delegation inspired by Go's
+[delegation](https://nathany.com/good/).
+
+
+```ruby
+  require 'method_object'
+
+  class MakeArbitraryArray < MethodObject
+    attrs(:company)
+
+    def call
+      [
+        company.name,
+        name, # Automatic delegation since company has a `name` method
+        company_name, # Automatic delegation with prefix
+      ]
+    end
+  end
+
+  company = Company.new(name: 'Tyrell Corporation')
+
+  MakeArbitraryArray.call(company: company)
+  => ['Tyrell Corporation', 'Tyrell Corporation', 'Tyrell Corporation']
 ```

data/Rakefile

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

data/lib/method_object/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class MethodObject
-  VERSION = '1.0.0'
+  VERSION = '2.1.0'
 end

data/lib/method_object.rb

@@ -1,42 +1,170 @@
+# frozen_string_literal: true
 require 'method_object/version'
 
+# See gemspec for description
 class MethodObject
-  def self.new(*args, &block)
-    super(*args, block).call
-  end
+  class AmbigousMethodError < NameError; end
+
+  class << self
+    def attrs(*attributes)
+      @attributes = attributes
+      Setup.call(attributes: attributes, subclass: self)
+    end
 
-  def initialize(*required_keyword_args, block)
-    @required_keyword_args = required_keyword_args
-    @block = block
+    def call(**args)
+      new(args).call
+    end
+
+    attr_reader(:attributes)
+
+    private(:new)
   end
 
+  def initialize(_); end
+
   def call
-    code = self.code
-    block = @block
+    raise NotImplementedError, 'Define the call method'
+  end
 
-    Struct.new(*@required_keyword_args) do
-      private_class_method :new
-      eval(code)
-      def call
-        fail NotImplementedError, "Please define the call method"
-      end
-      class_eval(&block)
+  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)
     end
   end
 
-  def code
-    <<-CODE
-      def self.call(#{required_keyword_args_string})
-        new(#{ordered_args_string}).call
+  def respond_to_missing?(name)
+    candidates_for_method_missing(name).length == 1
+  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,
+        )
       end
-    CODE
+    potential_candidates.select(&:candidate?)
   end
 
-  def required_keyword_args_string
-    @required_keyword_args.map { |arg| "#{arg}:" }.join(',')
+  def define_and_call_new_method(candidate)
+    self.class.class_eval(
+      <<-RUBY
+        def #{candidate.delegated_method}
+          #{candidate.attribute}.#{candidate.method_to_call_on_delegate}
+        end
+      RUBY
+    )
+    send(candidate.delegated_method)
   end
 
-  def ordered_args_string
-    @required_keyword_args.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
+
+  # Represents a possible match of the form:
+  #   some_method => my_attribute.some_method
+  PotentialDelegator = Struct.new(:attribute, :object, :delegated_method) do
+    def candidate?
+      object.respond_to?(delegated_method)
+    end
+
+    def call
+      object.public_send(delegated_method)
+    end
+
+    alias_method :method_to_call_on_delegate, :delegated_method
+  end
+
+  # Represents a possible match of the form:
+  #   my_attribute_some_method => my_attribute.some_method
+  PotentialDelegatorWithPrefix =
+    Struct.new(:attribute, :object, :delegated_method) do
+      def candidate?
+        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
+
+      private
+
+      def name_matches?
+        delegated_method.to_s.start_with?(prefix)
+      end
+
+      def prefix
+        "#{attribute}_"
+      end
+    end
+
+  # Dynamically defines custom attr_readers and initializer
+  class Setup < SimpleDelegator
+    def self.call(attributes:, subclass:)
+      new(attributes, subclass).call
+    end
+
+    attr_accessor(:attributes)
+
+    def initialize(attributes, subclass)
+      self.attributes = attributes
+      super(subclass)
+    end
+
+    def call
+      define_attr_readers
+      define_initializer
+    end
+
+    private
+
+    def define_attr_readers
+      __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
+      )
+    end
+
+    def required_keyword_args_string
+      attributes.map { |arg| "#{arg}:" }.join(',')
+    end
+
+    def assignments
+      attributes.map { |attribute| "@#{attribute} = #{attribute}\n" }.join
+    end
   end
 end

data/method_man.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'method_object/version'
@@ -7,16 +8,18 @@ Gem::Specification.new do |spec|
   spec.name          = 'method_man'
   spec.version       = MethodObject::VERSION
   spec.authors       = ['Clay Shentrup']
-  spec.email         = %w(cshentrup@gmail.com)
-  spec.summary       = %q{Provides a MethodObject class which implements Kent Beck's "method object" pattern.}
-  spec.description   = %q{Provides a MethodObject class which implements Kent Beck's "method object" pattern.}
+  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.homepage      = 'https://github.com/brokenladder/method_man'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = %w(lib)
+  spec.require_paths = %w[lib]
 
   spec.required_ruby_version = '>= 2.1'
 

data/spec/method_man_spec.rb

@@ -1,38 +1,185 @@
+# frozen_string_literal: true
 require 'method_object'
 
 describe MethodObject do
-  subject do
-    described_class.new(:value_one, :value_two) do
-      def call
-        value_one + value_two
+  it 'makes new a private class method' do
+    expect { subject.new }.to raise_error(NoMethodError)
+  end
+
+  context 'without attrs' do
+    subject do
+      Class.new(described_class) do
+        def call
+          true
+        end
       end
     end
-  end
 
-  let(:value_one) { 1 }
-  let(:value_two) { 2 }
-  let(:actual_result) do
-    subject.call(value_one: value_one, value_two: value_two)
+    specify { expect(subject.call).to be(true) }
   end
 
-  it 'works' do
-    expect(actual_result).to eq 3
-  end
+  context 'with attrs' do
+    subject do
+      Class.new(described_class) do
+        attrs(:company, :user)
 
-  it 'uses required keyword arguments' do
-    expect { subject.call }.to raise_error ArgumentError
-  end
+        @sent_messages = []
 
-  it 'makes new a private class method' do
-    expect { subject.new }.to raise_error NoMethodError
+        def self.sent_messages
+          @sent_messages
+        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
+    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,
+      )
+    end
+
+    it 'uses required keyword arguments' do
+      expect { subject.call }.to raise_error(ArgumentError)
+    end
+
+    context 'with ambiguous method call' do
+      subject do
+        Class.new(described_class) do
+          attrs(:company, :user)
+
+          def call
+            name
+          end
+        end
+      end
+
+      specify do
+        expect { result }.to raise_error(
+          MethodObject::AmbigousMethodError,
+          a_string_including('company.name, user.name'),
+        )
+      end
+    end
+
+    context 'ambigous method call due to delegation' do
+      subject do
+        Class.new(described_class) do
+          attrs(:company, :user)
+
+          def call
+            company_address
+          end
+        end
+      end
+
+      let(:user) { double('user', company_address: nil) }
+
+      specify do
+        expect { result }.to raise_error(
+          MethodObject::AmbigousMethodError,
+          a_string_including('user.company_address, company.address'),
+        )
+      end
+    end
+
+    describe 'respecting method privacy' do
+      let(:subject) do
+        Class.new(described_class) do
+          attrs(:diary)
+
+          def call
+            diary_contents
+          end
+        end
+      end
+      let(:diary) do
+        Module.new do
+          def self.contents; end
+
+          private_class_method(:contents)
+        end
+      end
+
+      specify do
+        expect { subject.call(diary: diary) }.to raise_error(StandardError)
+      end
+    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
+        end
+      end
+
+      specify do
+        expect(subject.call(company: company)).to eq([company_name, company_name])
+      end
+    end
   end
 
   context 'without a provided instance call method' do
-    subject { described_class.new(:value_one) {} }
+    subject do
+      Class.new(described_class) { attrs(:user_1_age) }
+    end
 
-    it 'raises an error' do
-      expect { subject.call(value_one: value_one) }
-        .to raise_error NotImplementedError
+    specify do
+      expect { subject.call(user_1_age: user_1_age) }.to raise_error(NameError)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+# 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: method_man
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Clay Shentrup
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-05 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
-description: Provides a MethodObject class which implements Kent Beck's "method object"
+description: Provides a MethodObject class which implements KentBeck's "method object"
   pattern.
 email:
 - cshentrup@gmail.com
@@ -62,7 +62,9 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - LICENSE.txt
@@ -93,10 +95,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: Provides a MethodObject class which implements Kent Beck's "method object"
+summary: Provides a MethodObject class which implements KentBeck's "method object"
   pattern.
 test_files:
 - spec/method_man_spec.rb