calls 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aecc26178de00f8b7440cc617980fd92e44393e4dc630b593f1253f87f26459b
+  data.tar.gz: 39f7a41a588d9e2682f08a251d6f113cad22a6f8dc01e14740d7f98caf4cf903
+SHA512:
+  metadata.gz: f23af889c1b7eecb68d4578d2723417cbb5a82e2e6dcaabd3e8c90d3e2bde2206c6633f0a0740c1f014ee27937200dfd998aa8e89bb87610948da3c792a40d6e
+  data.tar.gz: 3ff4a15d638243d65c2d606e93597a5243a03e2b28309eb65173ec9f99b8cf5e0591ffcf6644e80f22e856065ff8bc23bf59a1494f5227c5f1cb7e70de2c7017

data/README.md

@@ -0,0 +1,162 @@
+# Calls
+
+[![Version](https://img.shields.io/gem/v/calls)](https://github.com/halo/calls.svg/releases)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/halo/calls/blob/master/LICENSE.md)
+![Build Status](https://github.com/halo/calls/actions/workflows/tests.yml/badge.svg)
+
+### TL; DR
+
+Instead of writing a method in Ruby, you might as well write an entire class for the task. That's called the [method object pattern](https://refactoring.guru/replace-method-with-method-object) and helps to reduce complexity.
+
+
+This gem helps you to do that, like so:
+
+```ruby
+class SaySometing
+  include Calls
+
+  # Input
+  option :text
+
+  # Output
+  def call
+    puts text
+  end
+end
+
+SaySometihng.call(text: 'Hi there!') # => 'Hi there!'
+```
+
+## Installation
+
+```
+# Add this to your Gemfile
+gem 'calls'
+```
+
+## Usage
+
+If you only have one mandatory, obvious argument, this is what your implementation most likely would look like:
+
+```ruby
+class CalculateTax
+  include Calls
+
+  param :product
+
+  def call
+    product.price * 0.1
+  end
+end
+
+bike = Bike.new(price: 50)
+CalculateTax.call(bike) # => 5
+```
+
+If you prefer to use named keywords, use this instead:
+
+````ruby
+class CalculateTax
+  include Calls
+
+  option :product
+
+  def call
+    product.price * 0.1
+  end
+end
+
+bike = Bike.new(price: 50)
+CalculateTax.call(product: bike) # => 5
+````
+
+You can also use both params and options. They are all mandatory.
+
+````ruby
+class CalculateTax
+  include Calls
+
+  param :product
+  option :dutyfree
+
+  def call
+    return 0 if dutyfree
+    product.price * 0.1
+  end
+end
+
+bike = Bike.new(price: 50)
+CalculateTax.call(bike, dutyfree: true) # => 0
+````
+
+You can make options optional by defining a default value in a proc:
+
+````ruby
+class CalculateTax
+  include Calls
+
+  param :product
+  option :dutyfree, default: -> { false }
+
+  def call
+    return 0 if dutyfree
+    product.price * 0.1
+  end
+end
+
+bike = Bike.new(price: 50)
+CalculateTax.call(bike) # => 5
+````
+
+That's it!
+
+## History
+
+A minimal implementation of the method object pattern would probably look like the following. This is sometimes also referred to as "service class".
+
+This is what [deadlyicon/calls](https://github.com/deadlyicon/calls) originally used (that's where the gem name comes from).
+
+```ruby
+class SaySometing
+  def self.call(*args, &block)
+    new.call(*args, &block)
+  end
+
+  def call(text)
+    puts text
+  end
+end
+```
+
+Basically everything passed to `MyClass.call(...)` would be passed on to `MyClass.new.call(...)`.
+
+Even better still, it *should* be passed on to `MyClass.new(...).call` so that your implementation becomes cleaner:
+
+```ruby
+class SaySometing
+  def self.call(*args, &block)
+    new(*args, &block).call
+  end
+
+  def initialize(text:)
+    @text = text
+  end
+
+  def call
+    puts @text
+  end
+end
+```
+
+People [implemented that](https://rubygems.org/gems/Calls), but in doing so reinvented the wheel. Because now you not only have the method object pattern (i.e. `call`), now you also have to deal with initialization (i.e. `new`).
+
+That's where the popular [dry-initializer](https://dry-rb.org/gems/dry-initializer) gem comes in. It is a battle-tested way to initialize objects with mandatory and optional attributes.
+
+The `calls` gem (you're looking at it right now), combines both the method object pattern and dry initialization. The [team](https://github.com/bukowskis), who initially came up with using `dry-initializer`, published the initial code version under the name [method_object](https://github.com/bukowskis/method_object).
+# Caveats
+
+* `params` cannot be optional (or have default values). This is because there can be several params in a row, which leads to confusion when they are optional.
+
+# License
+
+MIT License, see [LICENSE.md](https://github.com/halo/calls/blob/master/LICENSE.md)

data/lib/calls.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+# Include this module to enable dry-initialization like a method object.
+module Calls
+  def self.included(base)
+    base.extend Dry::Initializer
+    base.extend ClassMethods
+    base.send(:private_class_method, :new)
+  end
+
+  # Methods that are added to your class.
+  module ClassMethods
+    def call(*args, **kwargs, &block)
+      __check_for_unknown_options(*args, **kwargs)
+
+      if kwargs.empty?
+        # Preventing the warning "Passing the keyword argument as the last hash parameter is deprecated"
+        new(*args).call(&block)
+      else
+        new(*args, **kwargs).call(&block)
+      end
+    end
+
+    # Overriding the implementation of `#param` in the `dry-initializer` gem.
+    # Because of the positioning of multiple params, params can never be omitted in a method object.
+    # See https://github.com/dry-rb/dry-initializer/blob/main/lib/dry/initializer.rb
+    def param(name, type = nil, **opts, &block)
+      raise ArgumentError, "Default value for param not allowed - #{name}" if opts.key? :default
+      raise ArgumentError, "Optional params not supported - #{name}" if opts.fetch(:optional, false)
+
+      super
+    end
+
+    def __check_for_unknown_options(*args, **kwargs)
+      return if __defined_options.empty?
+
+      # Checking params
+      opts = args.drop(__defined_params.length).first || kwargs
+      raise ArgumentError, "Unexpected argument #{opts}" unless opts.is_a? Hash
+
+      # Checking options
+      unknown_options = opts.keys - __defined_options
+      message = "Key(s) #{unknown_options} not found in #{__defined_options}"
+      raise KeyError, message if unknown_options.any?
+    end
+
+    def __defined_options
+      dry_initializer.options.map(&:source)
+    end
+
+    def __defined_params
+      dry_initializer.params.map(&:source)
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: calls
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- halo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: rubocop-minitest
+  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: warning
+  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:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/calls.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/halo/calls/issues
+  changelog_uri: https://github.com/halo/calls/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/halo/calls
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Combining the method object pattern with DRY initialization
+test_files: []