double_dispatch 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 936769b4aaeb8b7f0e2a8c8b16a175f5f17d27c7
+  data.tar.gz: 3ef496d5c58ccc08cb80abc265c2e88aa39bb231
+SHA512:
+  metadata.gz: 702bb989a35229bbca5f3a0baf612d438dc1f76bed60430a8bd6fa4ecd8453ce3df2ce39fb1c08a1ed39cbe5c1432ad91e0e4d353f542a1c8726095b48373045
+  data.tar.gz: b73fed857af9aab57f9e70657aa1b468fae4a45422aa5003cb08ef66023d686d9ef2c4156316e2354739e5060429c5ec18e08859b01ceac7445f7f117d15b5c3

data/README.md

@@ -0,0 +1,147 @@
+double_dispatch
+========
+
+Call different functions depending on the runtime types of two objects.
+Extremely simple to use and extend.
+
+I personally use it to compensate the lack of _method overloading_ in Ruby and
+separate concerns into smaller `modules`.
+
+## Usage
+
+1. Define a unique `dispatch_id` for each class using the `dispatch_as` method.
+
+    class Dog
+      include DoubleDispatch
+
+      dispatch_as :dog
+
+      def pet
+        #...
+      end
+    end
+
+    class Human
+      include DoubleDispatch
+
+      dispatch_as :human
+
+      attr_accessor :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+2. Write concrete functions for each class you want handle
+
+    module Salutations
+      def salute_to_human(human)
+        "Hi #{human.name}!"
+      end
+
+      def salute_to_dog(dog)
+        dog.pet
+
+        "Woof woof!"
+      end
+    end
+
+3. Call `double_dispatch` to handle different non-necessary-polymorphic objects.
+
+    Dog.new.double_dispatch(:salute_to, Salutations)
+    # => "Woof woof!"
+
+    Human.new("Emiliano").double_dispatch(:salute_to, Salutations)
+    # => "Hi Emiliano!"
+
+
+## Common patterns
+
+### Create modules to encapsulate the logic
+
+This is my favourite pattern.
+Using the same example described above, we can create a better internal API if we
+encapsulate all the salutation logic into a single `module`
+
+    module Salutations
+      def self.salute(somebody)
+        somebody.double_dispatch(:salute_to, self)
+      end
+
+      def salute_to_human(human)
+        "Hi #{human.name}!"
+      end
+
+      def salute_to_dog(dog)
+        dog.pet
+
+        "Woof woof!"
+      end
+    end
+
+And then, we use the module in a cleaner way:
+
+    Salutations.salute Dog.new
+    # => "Woof woof!"
+
+    Salutations.salute Human.new("Emiliano")
+    # => "Hi Emiliano!"
+
+### Use `class.name` as `dispatch_id`
+
+I frequently find myself using the same `dispatch_id` as the _class name_, so
+I used to extend `DoubleDispatch` with the following snippet
+
+    module DoubleDispatch
+      module ByClassName
+        module ClassMethods
+          def dispatch_id
+            @dispatch_id ||= self.name.split('::').last.downcase
+          end
+        end
+
+        def self.included(base)
+          base.include(::DoubleDispatch)
+          base.extend(ClassMethods)
+        end
+      end
+    end
+
+
+### Use _table's name_ as `dispatch_id`
+
+Most of the time, we will use Active Record objects (or Sequel models, etc) in
+our system and we want to identify these models by the table name.
+
+Since this gem is flexible and easy to extend, I suggest to extend `DoubleDispatch`
+with a specific module using the ORM-specific methods.
+
+For example, an extension for `Sequel` models would be:
+
+    module DoubleDispatch
+      module ByTableName::Sequel
+        module ClassMethods
+          def dispatch_id
+            @dispatch_id ||= self.table_name
+          end
+        end
+
+        def self.included(base)
+          base.include(::DoubleDispatch)
+          base.extend(ClassMethods)
+        end
+      end
+    end
+
+And use this logic in a single line:
+
+    class User < Sequel::Model
+      include DoubleDispatch::ByTableName::Sequel
+
+      ...
+    end
+
+As you can see, it won't **need** to call `dispatch_as` method, but you can always
+call it and overwrite the `dispatch_id`. This is extremely useful when you define
+more than a model over the same _table name_.

data/double_dispatch.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = 'double_dispatch'
+  s.version = '1.0.0'
+  s.date = Time.now.strftime('%Y-%m-%d')
+  s.summary = 'Method overloading with runtime types made easy'
+  s.description = '`achetepe` is a small and simple library to execute a block of code after an asynchronous HTTP request.'
+  s.description = 'Call different functions depending on the runtime types of two objects, use method overloading, separate concerns, etc.'
+  s.authors = ['Emiliano Mancuso']
+  s.email = ['emiliano.mancuso@gmail.com']
+  s.homepage = 'http://github.com/emancu/double_dispatch'
+  s.license = 'MIT'
+
+  s.files = Dir[
+    'README.md',
+    'rakefile',
+    'lib/double_dispatch.rb',
+    'double_dispatch.gemspec'
+  ]
+  s.test_files = Dir['test/double_dispatch_test.rb']
+end

data/lib/double_dispatch.rb

@@ -0,0 +1,19 @@
+module DoubleDispatch
+  module ClassMethods
+    def dispatch_as(id)
+      @dispatch_id = id
+    end
+
+    def dispatch_id
+      @dispatch_id || fail('undefined :dispatch_id for class: ' + self.name)
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def double_dispatch(method_name, resolver, *args)
+    resolver.send("#{method_name}_#{self.class.dispatch_id}", self, *args)
+  end
+end

data/rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/*_test.rb'
+end
+
+task default: :test

data/test/double_dispatch_test.rb

@@ -0,0 +1,88 @@
+require 'minitest/autorun'
+require_relative '../lib/double_dispatch'
+
+module DoubleDispatch
+  module ByClassName
+    module ClassMethods
+      def dispatch_id
+        @dispatch_id ||= self.name.split('::').last.downcase
+      end
+    end
+
+    def self.included(base)
+      base.include(::DoubleDispatch)
+      base.extend(ClassMethods)
+    end
+  end
+end
+
+class TestDoubleDispatch < Minitest::Test
+  class FailureTestingModel
+    include DoubleDispatch
+  end
+
+  module Resolver
+    module_function
+
+    def perform_for_dog(dog, *args)
+      [dog, args]
+    end
+
+    def perform_for_not_a_dog(dog, *args)
+      'Not a dog'
+    end
+
+    def test_for_human(human)
+      true
+    end
+  end
+
+  class Dog
+    include DoubleDispatch
+
+    dispatch_as :dog
+  end
+
+  class Human
+    include DoubleDispatch::ByClassName
+  end
+
+  def test_fails_when_dispatch_id_is_undefined
+    assert_raises { FailureTestingModel.new.double_dispatch(:please_fail, Resolver) }
+  end
+
+  def test_double_dispatch
+    resolver = Object.new
+    instance = Dog.new
+
+    result = instance.double_dispatch(:perform_for, Resolver)
+
+    assert_equal [instance, []], result
+  end
+
+  def test_double_dispatch_with_more_arguments
+    instance = Dog.new
+
+    result = instance.double_dispatch(:perform_for, Resolver, 2, :other_arg)
+
+    assert_equal [instance, [2, :other_arg]], result
+  end
+
+  def test_overwrite_dispatch_id
+    Dog.dispatch_as :not_a_dog
+
+    instance = Dog.new
+
+    result = instance.double_dispatch(:perform_for, Resolver)
+
+    assert_equal 'Not a dog', result
+
+    Dog.dispatch_as :dog
+  end
+
+  def test_extension_by_class_name
+    assert_equal 'human', Human.dispatch_id
+
+    assert Human.new.double_dispatch(:test_for, Resolver)
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: double_dispatch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Emiliano Mancuso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-04 00:00:00.000000000 Z
+dependencies: []
+description: Call different functions depending on the runtime types of two objects,
+  use method overloading, separate concerns, etc.
+email:
+- emiliano.mancuso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- double_dispatch.gemspec
+- lib/double_dispatch.rb
+- rakefile
+- test/double_dispatch_test.rb
+homepage: http://github.com/emancu/double_dispatch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Method overloading with runtime types made easy
+test_files:
+- test/double_dispatch_test.rb