invokable 0.3.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4908866aac724a3af3d142852f6412f3cc93ee7ab8c85f2dd856b08f0039c6c
-  data.tar.gz: bf5f3d83df9c69f5357eacef3bdc2ecc44384852124f4fc012fa6d3e14716cd5
+  metadata.gz: 0a5eab3dc64de36ef9f40927b0d4fa4d68fb0cc1cf867a2f94effa90a0872027
+  data.tar.gz: 1fdc343357e9931e7dc5d62e71712159178cd44236ce6d50f7d37a88574d1403
 SHA512:
-  metadata.gz: f71bcec50cf1e9d0049259803eae9d5b19e102f78f14fe0854d5e2c238c3b7679552d64bb66608305c497379418f717fa29a0fe1d921c835c3397a58b37d5a47
-  data.tar.gz: 23827b487b5bb767871585d3bb641f53e8aaa4f28c1e4ef1934e93f200b7665a4a62a34f855767a7bc5424fa472ca62854021e4726b05c0901618ca119a3030c
+  metadata.gz: '0760094c175a2e23824bd07ef6830528b09d5ad3f331d1c07dcf35ab2a635d08c9ee3172ff3ef6c7edb0fc83d7d8da36dbd8e76417acfb700f940c6d962c79db'
+  data.tar.gz: 278f13b9c4126e75704cffc87f472a2607acfeeabf10c3bd754f22ede54c5c1f2b073aaf399cb9f90f7085ce39bde425da04828648fc98386c1087b0a15e3a10

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+## 0.4.2
+
+- `invokable/array` is no longer loaded with `invokable/data`.
+   This created a bit of havok in a few places. Including breaking
+   puma bootup in Rails 5.2.4.1.
+
+## 0.5.0
+
+- Added `Invokable::Command` and `Invokable::Core#arity`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    invokable (0.3.0)
+    invokable (0.5.1)
 
 GEM
   remote: https://rubygems.org/
@@ -20,7 +20,7 @@ GEM
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    rake (10.5.0)
+    rake (13.0.1)
     regexp-examples (1.5.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
@@ -45,7 +45,7 @@ DEPENDENCIES
   gen-test
   invokable!
   pry
-  rake (~> 10.0)
+  rake (~> 13.0)
   rspec (~> 3.0)
   yard
 

data/README.md

@@ -8,57 +8,103 @@ Objects are functions! Treat any Object, Hashes, Arrays, and Sets as Procs (like
 ## Synopsis
 
 ```ruby
-  require 'invokable/hash'
+require 'invokable'
+require 'invokable/hash'
 
-  number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
-  [1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
+number_names = { 1 => "One", 2 => "Two", 3 => "Three" }
+[1, 2, 3, 4].map(&number_names) # => ["One", "Two", "Three", nil]
 ```
 
 ```ruby
-  require 'invokable/array'
+require 'invokable'
+require 'invokable/array'
 
-  alpha = ('a'..'z').to_a
-  [1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
+alpha = ('a'..'z').to_a
+[1, 2, 3, 4].map(&alpha) # => ["b", "c", "d", "e"]
 ```
 
 ```ruby
-  require 'invokable/set'
+require 'invokable'
+require 'invokable/set'
 
-  favorite_numbers = Set[3, Math::PI]
-  [1, 2, 3, 4].select(&favorite_numbers) # => [3]
+favorite_numbers = Set[3, Math::PI]
+[1, 2, 3, 4].select(&favorite_numbers) # => [3]
 ```
 
 ```ruby
-  require 'invokable'
+# service objects
+require 'invokable'
 
-  # service objects
-  class GetDataFromSomeService
-    include Invokable
+class GetDataFromSomeService
+  include Invokable
 
-    def call(user)
-      # do the dirt
-    end
+  def call(user)
+    # do the dirt
   end
+end
 
-  data_for_user = GetDataFromSomeService.new.memoize # 'memoize' makes a proc that caches results
-  User.all.map(&data_for_user)
+data_for_user = GetDataFromSomeService.new.memoize # 'memoize' makes a proc that caches results
+User.all.map(&data_for_user)
+```
+```ruby
+# command objects that enclose state, can be treated as automatically curried functions.
+require 'invokable'
+require 'invokable/command'
+
+class TwitterPoster
+  include Invokable::Command
+
+  enclose do |model|
+    @model = model
+  end
+
+  def call(user)
+    # do the dirt
+    ...
+    TwitterStatus.new(user, data)
+  end
+end
+
+TwitterPoster.call(Model.find(1)) # => #<TwitterPoster ...>
+TwitterPoster.call(Model.find(1), current_user) # => #<TwitterStatus ...>
+
+# both the class and it's instances can be used any where Procs are.
+
+Model.where(created_at: Date.today).map(&:TwitterPoster) # => [#<TwitterPoster ...>, ...]
 ```
 
 Use as much or a little as you need:
 
 ```ruby
-require 'invokable'       # loads Invokable module
-require 'invokable/hash'  # loads hash patch
-require 'invokable/array' # loads array patch
-require 'invokable/set'   # loads set patch
-require 'invokable/data'  # loads all patches
+require 'invokable'         # loads Invokable module
+require 'invokable/command' # loads Invokable::Command module
+require 'invokable/hash'    # loads hash patch
+require 'invokable/array'   # loads array patch
+require 'invokable/set'     # loads set patch
+require 'invokable/data'    # loads hash and set patches
 ```
 
 ## Why?
 
 A function is a mapping of one value to another with the additional constraint that for the one input value you will
 always get the same output value. So, conceptually, Ruby Hashes, Arrays, and Sets are all functions. Also, there are
-many one method objects out there (e.g. ServiceObjects) that are essentially functions. Why not treat them as such?
+many one method objects out there (e.g. Service Objects) that are essentially functions. Why not treat them as such?
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'invokable'
+```
+
+And then execute:
+
+    > bundle
+
+Or install it yourself as:
+
+    > gem install invokable
 
 ## API
 
@@ -83,26 +129,19 @@ Returns a curried proc. If the `arity` is given, it determines the number of arg
 
 ### `memoize => Proc`
 
-Returns a memoized proc, that is, a proc that caches it return values by it's arguments.
+Returns a memoized proc, that is, a proc that caches it's return values by it's arguments.
 
-## Installation
+### `<<(invokable) => Proc`
 
-Add this line to your application's Gemfile:
+Returns a proc that is a composition of this invokable and the given invokable.
 
-```ruby
-gem 'invokable'
-```
+### `>>(invokable) => Proc`
 
-And then execute:
-
-    > bundle
-
-Or install it yourself as:
-
-    > gem install invokable
+Returns a proc that is a composition of this invokable and the given invokable.
 
 ## See Also
 
+  - [Closures and Objects are Equivalent](http://wiki.c2.com/?ClosuresAndObjectsAreEquivalent)
   - [Clojure](https://clojure.org)
   - [Arc](http://www.arclanguage.org)
 

data/invokable.gemspec

@@ -37,6 +37,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.17"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/invokable.rb

@@ -1,40 +1,16 @@
 require 'invokable/version'
+require 'invokable/core'
+require 'invokable/compose'
 
-module Invokable
-  # If object responds to `call` convert into a Proc forwards it's arguments along to `call`.
-  #
-  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-call Proc#call
-  # @return [Proc]
-  def to_proc
-    if respond_to?(:call)
-      # TODO: Would method(:call) be more performant? We need benchmarks.
-      Proc.new do |*args|
-        call(*args)
-      end
-    else
-      raise "Don't know how to convert #{self.inspect} into a Proc"
-    end
-  end
-
-  # Return a curried proc. If the optional `arity` argument is given, it determines the number of arguments.
-  # A curried proc receives some arguments. If a sufficient number of arguments are supplied, it passes the
-  # supplied arguments to the original proc and returns the result. Otherwise, returns another curried proc
-  # that takes the rest of arguments.
-  #
-  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
-  # @param arity [Number]
-  # @return [Proc]
-  def curry(arity = nil)
-    to_proc.curry(arity)
-  end
+# TODO: make use of Gem::Version
+if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.6
+  require 'invokable/proc'
+  require 'invokable/method'
+end
 
-  # Return a memoized proc, that is, a proc that caches it's return values by it's arguments.
-  #
-  # @return [Proc]
-  def memoize
-    Proc.new do |*args|
-      @memo ||= {}
-      @memo[args.hash] ||= call(*args)
-    end
+module Invokable
+  def self.included(base)
+    base.include(Invokable::Core)
+    base.include(Invokable::Compose)
   end
 end

data/lib/invokable/array.rb

@@ -1,10 +1,10 @@
-require_relative '../invokable'
+require_relative 'core'
 
 # Extend core Array object by aliasing it's `[]` method as `call`,
 # and including the `Invokable` module.
 #
 # @see https://ruby-doc.org/core-2.7.0/Array.html#method-i-5B-5D Array#[]
 class Array
-  include Invokable
+  include Invokable::Core
   alias call []
 end

data/lib/invokable/command.rb

@@ -0,0 +1,116 @@
+module Invokable
+  # Treat "Command Objects" as curried functions
+  #
+  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
+  #
+  # @version 0.5.0
+  module Command
+    def self.included(klass)
+      klass.include(Invokable)
+      klass.extend(Invokable::Core)
+      klass.extend(Invokable::Compose)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return the "total" arity of the class (i.e. the arity of the initializer and the arity of the call method)
+      #
+      # @version 0.5.0
+      # @see https://ruby-doc.org/core-2.7.1/Proc.html#method-i-arity Proc#arity
+      # @see initializer_arity
+      #
+      # @return [Integer]
+      def arity
+        initializer_arity + instance_method(:call).arity
+      end
+  
+      # Return the arity of the initializer
+      #
+      # @version 0.5.0
+      # @see arity
+      #
+      # @return [Integer]
+      def initializer_arity
+        return @initializer_arity if @initializer_arity
+
+        @initializer ? @initializer.arity : 0
+      end
+  
+      # Handle automatic currying--will accept either the initializer arity or the total arity of the class. If
+      # the initializer arity is used return a class instance. If the total arity is used instantiate the class
+      # and return the results of the `call` method.
+      #
+      # @version 0.5.0
+      # @see arity
+      # @see initializer_arity
+      def call(*args)
+        if args.length == initializer_arity
+          new(*args)
+        elsif args.length == arity
+          init_args = args.slice(0, initializer_arity)
+          call_args = args.slice(initializer_arity, args.length)
+          new(*init_args).call(*call_args)
+        else
+          raise ArgumentError, "wrong number of arguments (given #{args.length}, expected #{initializer_arity} or #{arity})"
+        end
+      end
+
+      # Specify any enclosed state with a block or named attributes
+      # 
+      # @example
+      #   class TwitterPater
+      #     include Invokable::Command
+      #
+      #     enclose :api_key
+      #
+      #     def call(user)
+      #       # interact with twitter, return results
+      #     end
+      #   end
+      #
+      #   TwitterPater.new(API_KEY).call(User.find(1))
+      #   TwitterPater.new(API_KEY).api_key == API_KEY # => true
+      #
+      #   class TwitterPater
+      #     include Invokable::Command
+      #
+      #     enclose do |api_key|
+      #       @api_key = api_key
+      #     end
+      #
+      #     def call(user)
+      #       # interact with twitter, return results
+      #     end
+      #   end
+      #
+      #   TwitterPater.new(API_KEY).call(User.find(1))
+      #   TwitterPater.new(API_KEY).api_key # error 'method' missing
+      def enclose(*names, &block)
+        return define_initializer_with_block(block) unless block.nil?
+
+        define_initializer_with_names(names)
+      end
+  
+      private
+
+      def define_initializer_with_block(block)
+        @initializer = block
+        define_method :initialize, &block
+      end
+
+      def define_initializer_with_names(names)
+        @initializer_arity = names.length
+
+        names.each do |name|
+          attr_reader name
+        end
+
+        define_method :initialize do |*args|
+          names.each_with_index do |name, i|
+            instance_variable_set(:"@#{name}", args[i])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/invokable/compose.rb

@@ -0,0 +1,25 @@
+module Invokable
+  module Compose
+    # Return a proc that is the composition of this invokable and the given `invokable`.
+    # The returned proc takes a variable number of arguments, calls `invokable` with
+    # them then calls this proc with the result.
+    #
+    # @return [Proc]
+    def <<(invokable)
+      Proc.new do |*args|
+        call(invokable.call(*args))
+      end
+    end
+
+    # Return a proc that is the composition of this invokable and the given `invokable`.
+    # The returned proc takes a variable number of arguments, calls `invokable` with
+    # them then calls this proc with the result.
+    #
+    # @return [Proc]
+    def >>(invokable)
+      Proc.new do |*args|
+        invokable.call(call(*args))
+      end
+    end
+  end
+end

data/lib/invokable/core.rb

@@ -0,0 +1,49 @@
+module Invokable
+  module Core
+    # If object responds to `call` convert into a Proc forwards it's arguments along to `call`.
+    #
+    # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-call Proc#call
+    # @return [Proc]
+    def to_proc
+      if respond_to?(:call)
+        # TODO: Would method(:call) be more performant? We need benchmarks.
+        Proc.new do |*args|
+          call(*args)
+        end
+      else
+        raise "Don't know how to convert #{self.inspect} into a Proc"
+      end
+    end
+  
+    # Return a curried proc. If the optional `arity` argument is given, it determines the number of arguments.
+    # A curried proc receives some arguments. If a sufficient number of arguments are supplied, it passes the
+    # supplied arguments to the original proc and returns the result. Otherwise, returns another curried proc
+    # that takes the rest of arguments.
+    #
+    # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
+    # @param arity [Integer]
+    # @return [Proc]
+    def curry(arity = nil)
+      to_proc.curry(arity)
+    end
+  
+    # Return a memoized proc, that is, a proc that caches it's return values by it's arguments.
+    #
+    # @return [Proc]
+    def memoize
+      Proc.new do |*args|
+        @memo ||= {}
+        @memo[args.hash] ||= call(*args)
+      end
+    end
+
+    # Return the arity (i.e. the number of arguments) of the `call` method.
+    #
+    # @version 0.5.0
+    # @see https://ruby-doc.org/core-2.7.1/Proc.html#method-i-arity Proc#arity
+    # @return [Integer]
+    def arity
+      method(:call).arity
+    end
+  end
+end

data/lib/invokable/data.rb

@@ -1,4 +1,2 @@
-require_relative '../invokable'
 require_relative 'hash'
 require_relative 'set'
-require_relative 'array'

data/lib/invokable/hash.rb

@@ -1,10 +1,12 @@
-require_relative '../invokable'
+require_relative 'core'
 
 # Extend core Hash object by aliasing it's `dig` method as `call`,
 # and including the `Invokable` module.
 #
 # @see https://ruby-doc.org/core-2.7.0/Hash.html#method-i-dig Hash#dig
 class Hash
-  include Invokable
-  alias call dig
+  if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.7
+    include Invokable::Core
+    alias call dig
+  end
 end

data/lib/invokable/method.rb

@@ -0,0 +1,5 @@
+require_relative 'compose'
+
+class Method
+  include Invokable::Compose
+end

data/lib/invokable/proc.rb

@@ -0,0 +1,5 @@
+require_relative 'compose'
+
+class Proc
+  include Invokable::Compose
+end

data/lib/invokable/set.rb

@@ -1,11 +1,11 @@
 require 'set'
-require_relative '../invokable'
+require_relative 'core'
 
 # Extend stdlib Set object by aliasing it's `include?` method as `call`,
 # and including the `Invokable` module.
 #
 # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/set/rdoc/Set.html#method-i-include-3F Set#include?
 class Set
-  include Invokable
+  include Invokable::Core
   alias call include?
 end

data/lib/invokable/version.rb

@@ -1,3 +1,3 @@
 module Invokable
-  VERSION = "0.3.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Delon Newman
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -63,6 +63,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -71,8 +72,13 @@ files:
 - invokable.gemspec
 - lib/invokable.rb
 - lib/invokable/array.rb
+- lib/invokable/command.rb
+- lib/invokable/compose.rb
+- lib/invokable/core.rb
 - lib/invokable/data.rb
 - lib/invokable/hash.rb
+- lib/invokable/method.rb
+- lib/invokable/proc.rb
 - lib/invokable/set.rb
 - lib/invokable/version.rb
 homepage: https://github.com/delonnewman/invokable
@@ -84,7 +90,7 @@ metadata:
   source_code_uri: https://github.com/delonnewman/invokable
   changelog_uri: https://github.com/delonnewman/invokable#changelog
   documentation_uri: https://www.rubydoc.info/gems/invokable
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Objects are functions! Treat any Object, Hashes, Arrays and Sets as Procs
   (like Enumerable but for Proc-like objects)