invokable 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cefa41d32399484ad2204268eaecfbe2b60618c9eed79b327786dd10aae9e0a7
-  data.tar.gz: 8ad5d706b553d62d244ee3e45c262c8f2c61a5b765fd2f55fa5be3243f00dda4
+  metadata.gz: b1c89f44b80135945cce3300f6f9b8e5b1210282d8c3d10256c2593ccf281948
+  data.tar.gz: 2a0e9ce82c10b9f57b1767087d56b5d53a67bdfeb139e5a642fb071a9bc6a8e6
 SHA512:
-  metadata.gz: 416e5627985548c82477f61010368489ef9af9f134e15f4623a743bd36e50e0fbeb97cee5b82de99fc4db68f8d0f0e6a9890478c000ae4958d4d6119a0c55dd9
-  data.tar.gz: 23a9d25e0ca3b92cad9177e07ea2e0e84266f97fd3a007c23a343e66e4e22002d97cf8d7aaa0a6b718e7d0c6da053516602f3e7ad8dca8f37323bc6c932a57da
+  metadata.gz: 20d8a431d84d973709f122211c8e606d4ac43e162c54a7bdf8e7507873c0235dede63a8e73a69d296152b6020ebd93a3001be8c73916dee7a7cfbcc6c600b0df
+  data.tar.gz: c1df682d8c7eed2525d7a2eaadce3e5dedb8114b18d64df3f7e323995b7c30c31827d2c6f2da94738094c06614a74bf4309dc20a1d3a2e9b66152c6e265b7035

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# 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`
+
+## 0.5.2
+
+- `Invokable::Command` deprecated in favor of `Invokable::Closure`.
+
+## 0.6.0
+
+- `Invokable::Closure` deprecated comparable behavior has been added to `Invokable` itself.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    invokable (0.4.1)
+    invokable (0.6.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -8,40 +8,68 @@ 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'
+
+class TwitterPoster
+  include Invokable
+
+  def initialize(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 anywhere Procs are.
+
+Model.where(created_at: Date.today).map(&TwitterPoster) # => [#<TwitterPoster ...>, ...]
 ```
 
 Use as much or a little as you need:
@@ -51,7 +79,7 @@ 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 hash, array, and set patches
+require 'invokable/data'    # loads hash and set patches
 ```
 
 ## Why?
@@ -111,6 +139,7 @@ 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/lib/invokable.rb

@@ -2,6 +2,7 @@ require 'invokable/version'
 require 'invokable/core'
 require 'invokable/compose'
 
+# TODO: make use of Gem::Version
 if RUBY_VERSION.split('.').take(2).join('.').to_f < 2.6
   require 'invokable/proc'
   require 'invokable/method'
@@ -11,5 +12,46 @@ module Invokable
   def self.included(base)
     base.include(Invokable::Core)
     base.include(Invokable::Compose)
+    base.extend(Invokable::Core)
+    base.extend(Invokable::Compose)
+    base.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.6.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
+
+    # 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.6.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
+
+    private
+
+    def initializer_arity
+      instance_method(:initialize).arity
+    end
   end
 end

data/lib/invokable/closure.rb

@@ -0,0 +1,115 @@
+module Invokable
+  # Treat classes as curried functions
+  #
+  # @see https://ruby-doc.org/core-2.7.0/Proc.html#method-i-curry Proc#curry
+  #
+  # @version 0.5.2
+  # @deprecated These features are included in the Invokable by default now.
+  module Closure
+    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
+        instance_method(:initialize).arity
+      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/command.rb

@@ -0,0 +1,18 @@
+require_relative 'closure'
+
+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
+  # @deprecated These features are included in the Invokable by default now.
+  module Command
+    def self.included(klass)
+      klass.include(Invokable)
+      klass.extend(Invokable::Core)
+      klass.extend(Invokable::Compose)
+      klass.extend(Invokable::Closure::ClassMethods)
+    end
+  end
+end

data/lib/invokable/core.rb

@@ -36,5 +36,14 @@ module Invokable
         @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 'core'
 require_relative 'hash'
 require_relative 'set'
-require_relative 'array'

data/lib/invokable/version.rb

@@ -1,3 +1,3 @@
 module Invokable
-  VERSION = "0.4.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invokable
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Delon Newman
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2020-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -63,6 +63,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -71,6 +72,8 @@ files:
 - invokable.gemspec
 - lib/invokable.rb
 - lib/invokable/array.rb
+- lib/invokable/closure.rb
+- lib/invokable/command.rb
 - lib/invokable/compose.rb
 - lib/invokable/core.rb
 - lib/invokable/data.rb
@@ -88,7 +91,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
@@ -104,7 +107,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)