invokable 0.2.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faf0947e19adf5c11f17f5893122d24aa48323807dd364593a38c391e8901c34
-  data.tar.gz: a482d9ddd514251f362c149eca16774b5b4853159eb52c79653c3f5f8df5b9ac
+  metadata.gz: 6dcc085ff857ef0a95578db5f816338c0ade3da6ef4ecb263f86924e4b4e2cfb
+  data.tar.gz: 235f058b7b39b8ff91b8d2580281fad56a388fcea46d19ae3a4bc3657c913d1c
 SHA512:
-  metadata.gz: 7d2b9ac66665785662b3ab016981a4c747ab32c88e637cb2bfc2a52e34ed353e5f341a5ef178582e7a3cae584576c341aa88907967cd4722acd07c2cb29d001e
-  data.tar.gz: a89620c1f7127ed27794ef84d45803cbabaf93ceee680edf80a638f4c020551fbde83b3682d8afef70597a692158b157c701d9f3c27b634e5e24476c37f81337
+  metadata.gz: bc8294c008fedd2a69337d886515b8fb9c3a2dd6fea8330b15371ffa9b44db0a5ce3c679badede4e2455230db25845ac723b11aa6736f9b62d690b462f7623e9
+  data.tar.gz: f6cab459416371d902933ee1ef3fd24f935bcc0ad7b6c9e0a9bd261bf95d8736c763ec416b94b063acf52fbc4a08df04586ac4b6bde8c02aedcb47b8f8074ef9

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# 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.

data/Gemfile

@@ -9,3 +9,7 @@ group :development do
   gem 'pry'
   gem 'yard'
 end
+
+group :test do
+  gem 'gen-test'
+end

data/Gemfile.lock

@@ -1,18 +1,27 @@
 PATH
   remote: .
   specs:
-    invokable (0.2.2)
+    invokable (0.5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     coderay (1.1.2)
+    concurrent-ruby (1.1.5)
     diff-lcs (1.3)
+    faker (1.9.6)
+      i18n (>= 0.7)
+    gen-test (0.1.1)
+      faker (~> 1.9.6)
+      regexp-examples (~> 1.5.0)
+    i18n (1.8.2)
+      concurrent-ruby (~> 1.0)
     method_source (0.9.2)
     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)
       rspec-expectations (~> 3.9.0)
@@ -33,9 +42,10 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.17)
+  gen-test
   invokable!
   pry
-  rake (~> 10.0)
+  rake (~> 13.0)
   rspec (~> 3.0)
   yard
 

data/README.md

@@ -3,66 +3,112 @@
 
 # Invokable
 
-Treat any Object, Hashes, Arrays, and Sets as Procs (like Enumerable but for Procs)
+Objects are functions! Treat any Object, Hashes, Arrays, and Sets as Procs (like Enumerable but for Procs)
 
-# Synopsis
+## 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
-  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?
+## 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'
+```
 
-# API
+And then execute:
 
-## `to_proc -> Proc`
+    > bundle
+
+Or install it yourself as:
+
+    > gem install invokable
+
+## API
+
+### `to_proc => Proc`
 
 ```ruby
 hash = { a: 1, b, 2 }
@@ -76,37 +122,33 @@ returning a proc that passes it's arguments to the object's `call` method. When
 loaded `Hash#call` is mapped to `Hash#dig`, `Array#call` is mapped to `Array#at`, and `Set#call`
 is mapped to `Set#include?`.
 
-## `curry([arity]) -> Proc`
+### `curry(arity = nil) => Proc`
 
 Returns a curried proc. If the `arity` is given, it determines the number of arguments.
 (see [Proc#curry](https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry)).
 
-# Installation
+### `memoize => Proc`
 
-Add this line to your application's Gemfile:
+Returns a memoized proc, that is, a proc that caches it's return values by it's arguments.
 
-```ruby
-gem 'invokable'
-```
-
-And then execute:
+### `<<(invokable) => Proc`
 
-    > bundle
+Returns a proc that is a composition of this invokable and the given invokable.
 
-Or install it yourself as:
+### `>>(invokable) => Proc`
 
-    > gem install invokable
+Returns a proc that is a composition of this invokable and the given invokable.
 
-# See Also
+## See Also
 
+  - [Closures and Objects are Equivalent](http://wiki.c2.com/?ClosuresAndObjectsAreEquivalent)
   - [Clojure](https://clojure.org)
   - [Arc](http://www.arclanguage.org)
 
-# TODO
+## TODO
 
-  - add support for `memoize` and maybe transducers.
   - benchmark Invokable#to_proc
 
-# License
+## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/invokable.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Delon Newman"]
   spec.email         = ["contact@delonnewman.name"]
 
-  spec.summary       = %q{Treat any Object, Hashes, Arrays and Sets as Procs (like Enumerable but for Proc-like objects)}
+  spec.summary       = %q{Objects are functions! Treat any Object, Hashes, Arrays and Sets as Procs (like Enumerable but for Proc-like objects)}
   spec.description   = spec.summary
   spec.homepage      = "https://github.com/delonnewman/invokable"
   spec.license       = "MIT"
@@ -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,31 +1,16 @@
 require 'invokable/version'
+require 'invokable/core'
+require 'invokable/compose'
 
-# TODO: Add memoize, transducers?
-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
+# 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 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)
+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,65 @@
+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
+        @initializer ? @initializer.arity : 0
+      end
+  
+      # To specify any enclosed state
+      def enclose(&block)
+        raise 'A block is required' if block.nil?
+  
+        @initializer = block
+        define_method :initialize, &block
+      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 "Wrong number of arguments expected #{initializer_arity} or #{arity}, got: #{args.length}"
+        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.2.2"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.5.0
 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
@@ -52,8 +52,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Treat any Object, Hashes, Arrays and Sets as Procs (like Enumerable but
-  for Proc-like objects)
+description: Objects are functions! Treat any Object, Hashes, Arrays and Sets as Procs
+  (like Enumerable but for Proc-like objects)
 email:
 - contact@delonnewman.name
 executables: []
@@ -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,8 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
-summary: Treat any Object, Hashes, Arrays and Sets as Procs (like Enumerable but for
-  Proc-like objects)
+summary: Objects are functions! Treat any Object, Hashes, Arrays and Sets as Procs
+  (like Enumerable but for Proc-like objects)
 test_files: []