invocations 0.2.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 212878a412f9d0078de6d2a13192a8d4867d72a3ec64c1a5680dd1e4bfd03acf
+  data.tar.gz: e9bf132d50b08da294099cb995ede79dadd9fc7304d2ab6fb8ab11839dfd49d4
+SHA512:
+  metadata.gz: da1fbe8a35ece0b67dbaebb87e300c970f4319f52532b922e3813ffb917f996f353632d43244e8278c4ff3894a8148bd855c80242a97f424945acc681117d99c
+  data.tar.gz: dae0dcfe98e1653f5e068ace7dd986ceb43eaaf61857f8e4139e7b7c878f47c0ad8e5e2faf0ff85faa01b8d1c561af204aeca3c701868928791d2735f28857a4

data/.gitignore

@@ -0,0 +1,57 @@
+
+# Created by https://www.gitignore.io/api/ruby
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+
+# End of https://www.gitignore.io/api/ruby

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+Copyright © 2018 Chris Olstrom <chris@olstrom.com>
+Copyright © 2018 SUSE LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.org

@@ -0,0 +1,128 @@
+#+TITLE: Invocations
+#+LATEX: \pagebreak
+
+* Overview
+
+  ~Invocations~ are better partial functions for Ruby, because sometimes
+  =Proc#curry= just isn't enough.
+
+* What problem does this solve?
+
+  Partial function evaluation is a very useful tool, but understanding the state
+  carried by a curried =Proc= is often cumbersome and unintuitive.
+
+* How does Invocations address this problem?
+
+  ~Invocations~ provides a single class: the =Invocation=. It functions as a
+  drop-in alternative to a =Proc=, with a few notable improvements (none of
+  which break compatibility):
+
+    - An =Invocation= is implicitly self-currying. Which is to say that if you
+      call it without all the parameters it requires, it simply returns an
+      =Invocation= that requires the missing parameters.
+    - An =Invocation= allows non-keyword arguments to be given as keywords.
+    - An =Invocation= allows arguments to be given out of order, as keyword
+      arguments.
+    - An =Invocation= has several methods for inspection, including ones for
+      listing the missing arguments, identifying keyword inferences, explaining
+      how the underlying function will be called, and reporting internal state.
+
+* Installation
+
+  #+BEGIN_SRC shell
+    gem install invocations
+  #+END_SRC
+
+* How can I start using this majestic tool?
+
+  An =Invocation= is a drop-in alternative to =Proc=, or =lambda=. You can use
+  it as an explicit =&block=, etc. As a result, it's very easy to adapt existing
+  code to use it.
+
+  Let's lay out a simple function that will serve as our example, going forward.
+
+  This =power= function takes two arguments, =n= (a number) and =e= (an
+  exponent) and returns the result of raising =n= to =e=:
+
+  #+BEGIN_SRC ruby
+    lambda_power = lambda { |n, e| n ** e }
+  #+END_SRC
+
+  Now, this is somewhat contrived, because I've deliberately defined the
+  arguments in the least convenient order, for illustrative purposes.
+
+  The equivalent =Invocation= would be:
+
+  #+BEGIN_SRC ruby
+    invoke_power = Invocation.new { |n, e| n ** e }
+  #+END_SRC
+
+  ~Invocations~ includes an optional =Refinement= for that brings the syntax
+  more in line with =proc= and =lambda=:
+
+  #+BEGIN_SRC ruby
+    using Invocations
+    invoke_power = invocation { |n, e| n ** e }
+  #+END_SRC
+
+  Calling either of these is the same:
+
+  #+BEGIN_SRC ruby
+    lambda_power.(5, 2) #=> 25
+    invoke_power.(5, 2) #=> 25
+  #+END_SRC
+
+  Let's say we wanted to define =lambda_square= and =lambda_cube= functions,
+  that do what their names imply:
+
+  #+BEGIN_SRC ruby
+    lambda_square = lambda { |n| lambda_power.(n, 2) }
+    lambda_cube   = lambda { |n| lambda_power.(n, 3) }
+  #+END_SRC
+
+  The order of the arguments to =lambda_power= makes these definitions more
+  awkward. If instead, we had defined it like so:
+
+  #+BEGIN_SRC ruby
+    lambda_power = lambda { |e, n| n ** e }.curry
+  #+END_SRC
+
+  Then we could have done this:
+
+  #+BEGIN_SRC ruby
+    lambda_square = lambda_power.(2)
+    lambda_cube   = lambda_power.(3)
+  #+END_SRC
+
+  That said, we don't define every function we use. Often we use the functions
+  provided by a library, and if those have inconvenient argument ordering, too
+  bad.
+
+  If we had been using an =Invocation=, we could have done this:
+
+  #+BEGIN_SRC ruby
+    invoke_square = invoke_power.(e: 2)
+    invoke_cube   = invoke_power.(e: 3)
+  #+END_SRC
+
+** Wait what? Those weren't keyword arguments.
+
+   True, but the block parameters have names. Since it is a =SyntaxError= for a
+   block to have two parameters with the same name, an =Invocation= can Do The
+   Right Thing.
+
+* Explore It!
+
+  ~Invocations~ really shines when used with a great REPL like [[https://github.com/pry/pry][pry]].
+  
+  I've uploaded a short screencast [[https://asciinema.org/a/DW4ctct8Nkx1qdwjmOF9Eyw4O][here]] that demonstrates the sort of
+  information an =Invocation= provides (using the example scenario above).
+
+* License
+
+  ~Invocations~ is available under the [[https://tldrlegal.com/license/mit-license][MIT License]]. See ~LICENSE.txt~ for the
+  full text.
+
+* Contributors
+
+  - [[https://colstrom.github.io/][Chris Olstrom]] | [[mailto:chris@olstrom.com][e-mail]] | [[https://twitter.com/ChrisOlstrom][Twitter]]

data/invocations.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |gem|
+  tag = `git describe --tags --abbrev=0`.chomp
+
+  gem.name          = 'invocations'
+  gem.homepage      = 'https://github.com/colstrom/invocations'
+  gem.summary       = 'Drop-in alternative to procs and lambdas.'
+
+  gem.version       = "#{tag}"
+  gem.licenses      = ['MIT']
+  gem.authors       = ['Chris Olstrom']
+  gem.email         = 'chris@olstrom.com'
+
+  gem.cert_chain    = ['trust/certificates/colstrom.pem']
+  gem.signing_key   = File.expand_path ENV.fetch 'GEM_SIGNING_KEY'
+
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.test_files    = `git ls-files -z -- {test,spec,features}/*`.split("\x0")
+  gem.executables   = `git ls-files -z -- bin/*`.split("\x0").map { |f| File.basename(f) }
+
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = '~> 2.3.0' # Explicit Non-Support of Unsupported Ruby Versions
+end

data/lib/invocations.rb

@@ -0,0 +1,17 @@
+
+# -*- ruby -*-
+
+require_relative 'invocations/invocation'
+
+# This module refines Kernel, adding "invocation" and "Invocation" as methods.
+module Invocations
+  refine Kernel do
+    # Creates a new Invocation with the provided parameters
+    def invocation(*rest, **keyrest, &block)
+      ::Invocation.new(*rest, **keyrest, &block)
+    end
+
+    alias_method :Invocation, :invocation
+  end
+end
+

data/lib/invocations/invocation.rb

@@ -0,0 +1,253 @@
+
+# -*- ruby -*-
+
+# Invocations are drop-in replacements for other functions (such as
+# procs/blocks, lambdas, methods, etc).
+#
+# They differ in that they are self-currying, allow partial evaluation with
+# arbitrary argument ordering, and allow non-keyword arguments to be given as
+# keywords.
+#
+class Invocation
+  %i(call yield []).each { |name| singleton_class.alias_method name, :new }
+
+  # Creates a new Invocation.
+  #
+  # @param callable [#call] a proc-like object
+  #
+  # @raise [ArgumentError] if neither a callable object nor a block is provided.
+  #
+  # @return [Invocation] a new instance of Invocation
+  #
+  def initialize(callable = nil, *rest, **state, &block)
+    raise ::ArgumentError, "#{self.class}##{__callee__} requires a callable object or a block" unless (callable.respond_to?(:call) || block)
+
+    if callable.respond_to? :call
+      @function = callable
+      @block    = block
+    else
+      @function = block
+    end
+
+    @state = state
+    @rest = rest
+
+    %i(required optional inferences unassigned arguments keywords).each { |method| send method }
+
+    self
+  end
+
+  attr_reader :function, :state
+
+  # Which parameters are required?
+  #
+  # @return [Array<Symbol>] the required parameters of the function
+  #
+  def required
+    @required ||= (
+      required_arguments = function_parameters(:req)
+      required_keywords  = function_parameters(:keyreq)
+      needed = function_arity - (required_arguments.length + (required_keywords.length > 0 ? 1 : 0))
+
+      @required = function_parameters(:opt, :key).take(needed) + required_arguments + required_keywords
+    )
+  end
+
+  # Which parameters are optional?
+  #
+  # @return [Array<Symbol>] the optional parameters of the function
+  #
+  def optional
+    @optional ||= function_parameters(:opt, :key)
+                    .drop(function_arity - function_parameters(:req).length)
+  end
+
+  # Which parameters can be inferred from arguments?
+  #
+  # @return [Hash<Symbol, Object>] the inferred association of non-keyword
+  #   arguments to parameter names.
+  #
+  def inferences
+    @inferences ||= if @rest.empty?
+                      {}
+                    else
+                      (function_parameters(:req, :opt) - @state.keys)
+                        .map
+                        .with_index { |argument, index| [argument, @rest[index]] if index < @rest.length }
+                        .compact
+                        .to_h
+                    end
+  end
+
+  # Which arguments are not assigned to known parameters?
+  #
+  # @return [Array] the arguments that are not assigned to parameters.
+  #
+  def unassigned
+    @unassigned ||= @rest.drop(inferences.length)
+  end
+
+  # Which parameters have been provided?
+  #
+  # @return [Hash<Symbol, Object>] all known parameters provided for the function.
+  #
+  def known
+    @known ||= @state.merge(inferences)
+  end
+
+  # Which parameters are missing?
+  #
+  # @return [Array<Symbol>] the names of any missing parameters.
+  def missing
+    @missing ||= required - known.keys
+  end
+
+  # What are the arguments?
+  #
+  # @return [Array] the provided arguments for the function.
+  def arguments
+    @arguments ||= function_parameters(:req, :opt, :rest)
+                     .map { |argument| known[argument] }
+  end
+
+  # What are the keywords?
+  #
+  # @return [Hash<Symbol, Object>] the provided keywords for the functino.
+  #
+  def keywords
+    @keywords ||= function_parameters(:keyreq, :key, :keyrest)
+                    .map { |keyword| [keyword, known[keyword]] if known.key?(keyword) }
+                    .compact
+                    .to_h
+  end
+
+  # How will the function be called?
+  #
+  # @return Array the list of arguments that will be used to call the function.
+  #
+  def invocation(*rest, **keyrest)
+    @invocation ||= [*[*arguments, *unassigned].compact, *rest, *[**keywords.merge(keyrest)].reject(&:empty?)]
+  end
+
+  # Is the function ready to be called?
+  #
+  # @return [Boolean] if this Invocation has all required parameters specified.
+  #
+  def prepared?
+    missing.empty?
+  end
+
+  # Prepares an Invocation, without calling it.
+  #
+  # @return [Invocation] a new Invocation populated with the parameters given.
+  #
+  def prepare(*rest, **keyrest, &block)
+    self.class.new(@function, *[*unassigned, *rest], **known.merge(keyrest), &(block || @block))
+  end
+
+  # Prepares an Invocation, and invokes it if able.
+  #
+  # If the provided parameters produce a properly prepared Invocation, it will
+  # be invoked. Otherwise, it will be returned.
+  #
+  # @note This is very similar to how #call works with a curried Proc.
+  #
+  def call(*rest, **keyrest, &block)
+    if block || [rest, keyrest].all?(&:empty?)
+      prepared? ? invoke : self
+    else
+      function = prepare(*rest, **keyrest, &block)
+      function.prepared? ? function.send(:invoke) : function
+    end
+  end
+
+  alias [] call
+  alias yield call
+
+  # How many additional parameters are needed?
+  #
+  # @return [Integer] the number of required parameters.
+  #
+  # @note when multiple keyword parameters are required, they count as one
+  #   parameter. This is consistent with other Ruby functions (Proc, etc).
+  #
+  def arity
+    @arity ||= (
+      required_keywords = function_parameters(:keyreq)
+      missing_keywords  = required_keywords - known.keys
+      (missing - required_keywords).length + (missing_keywords.length > 0 ? 1 : 0)
+    )
+  end
+
+  # Converts the Invocation into a Proc
+  #
+  # @return [Proc] a Proc that calls the Invocation with any parameters given.
+  #
+  def to_proc
+    proc { |*rest, **keyrest, &block| self.(*rest, **keyrest, &block) }
+  end
+
+  # Converts the Invocation into a curried Proc.
+  #
+  # @return [Proc] a Proc, curried with the arity of the Invocation.
+  #
+  def curry(n = arity)
+    to_proc.curry(n)
+  end
+
+  # Is the Invocation a lambda?
+  #
+  # @return [false] false, always.
+  #
+  # @note An Invocation is not a lambda, as it does not handle arguments
+  # strictly. It is semantically much more proc-like.
+  #
+  def lambda?
+    false
+  end
+
+  # Which parameters have not been provided?
+  #
+  # @return [Array<Symbol, Symbol>] the remaining parameters of the function.
+  #
+  def parameters
+    @function.parameters.reject { |_, name| known.keys.include? name }
+  end
+
+  ####################
+  # Internal Methods #
+  ####################
+
+  private
+
+  # Invokes the function.
+  #
+  # @note This is used internally to call the function. A return cannot be
+  # specified, because it depends entirely on the function this Invocation was
+  # created with.
+  #
+  def invoke(*rest, **keyrest, &block)
+    @function.(*invocation(*rest, **keyrest), &(block || @block))
+  end
+
+  # How many parameters does the function require?
+  #
+  # @return [Integer] The arity of the initial function.
+  #
+  # @note this is for internal use, and is *not* strictly equivalent to
+  #   function.arity. For example, it always returns a non-negative value.
+  #
+  def function_arity
+    @function.arity.positive? ? @function.arity : @function.arity.succ.abs
+  end
+
+  # What are the names of the parameters of certain types?
+  #
+  # @return [Array<Symbol>] the names of parameters matching the given types.
+  #
+  def function_parameters(*types)
+    @function.parameters
+      .select { |type, _| types.include? type }
+      .flat_map(&:last)
+  end
+end

data/tests/invocations.rb

@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby
+# -*- ruby -*-
+
+require_relative '../lib/invocations'
+
+class Invocation
+  def self.test
+    {
+      '&lambda' => (self.new(&lambda { |am1, am2, ao = nil, *ar, km1:, km2:, ko: nil, **kr| [am1, am2, ao, ar, km1, km2, ko, kr] })),
+      'lambda'  => (self.new(lambda  { |am1, am2, ao = nil, *ar, km1:, km2:, ko: nil, **kr| [am1, am2, ao, ar, km1, km2, ko, kr] })),
+      '&proc'   => (self.new(&proc   { |am1, am2, ao = nil, *ar, km1:, km2:, ko: nil, **kr| [am1, am2, ao, ar, km1, km2, ko, kr] })),
+      'proc'    => (self.new(proc    { |am1, am2, ao = nil, *ar, km1:, km2:, ko: nil, **kr| [am1, am2, ao, ar, km1, km2, ko, kr] })),
+      '&block'  => (self.new         { |am1, am2, ao = nil, *ar, km1:, km2:, ko: nil, **kr| [am1, am2, ao, ar, km1, km2, ko, kr] }),
+    }
+  end
+end
+
+abort unless 1 == Invocation
+                    .test
+                    .map { |style, function| [style, function.(1).(2).(3).(4, 5).(km1: 6).(km2: 7)] }
+                    .to_h
+                    .values
+                    .uniq
+                    .length

data/trust/certificates/colstrom.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIENDCCApygAwIBAgIBATANBgkqhkiG9w0BAQsFADAiMSAwHgYDVQQDDBdjaHJp
+cy9EQz1vbHN0cm9tL0RDPWNvbTAeFw0xODAzMTUxODMxMTdaFw0xOTAzMTUxODMx
+MTdaMCIxIDAeBgNVBAMMF2NocmlzL0RDPW9sc3Ryb20vREM9Y29tMIIBojANBgkq
+hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAp31YmQvpMuQSlgX22B++/rxl4p4LYyaq
+cDDbi8DBro9cm2H60lbpCuAUALiED2CagZEK0vel5W8AnZhhns0OEYAlpQtBSJtN
+8P/jlNYruuY26aVhfHfyA5j1n7tVecJz3i/awEPGC3zuTfvUq7Ahn5czOy+hIm4M
+epee881dqnJlXjzTX/TKFYQa9tYj4bhsjfJOV+EDMcao/DE3vmNcBKH8XFVv/wQe
+MGC7VY5zBwow00AkCicNmIr0Psy5hLvqphJ/E3Eiu4UpXhiBfM0z7xiBPoPMBqOx
+r1RzgfKm/JbDO7leFmrEi8hLofyMmbuGvrSTE274vS4EnKaW6OtK7QM5R+jOJZbd
+67KUgSw+LdHNwu8xCuuQOdKPeSfWdNz94KAdczjzHdXUl/SpfmTuN/D+BCZjTxSo
+F1kACSU6uGTBFKZy35XK+yqeny/1l6xRs6j+cON+LSRMKYSt7jdLcKQVk5wH2xLo
+83njwnumFxKhiWu0oaT5dlDCtyYM85j9AgMBAAGjdTBzMAkGA1UdEwQCMAAwCwYD
+VR0PBAQDAgSwMB0GA1UdDgQWBBQEd3/D0MMj9FHhMZk0QJDlrUtKaTAcBgNVHREE
+FTATgRFjaHJpc0BvbHN0cm9tLmNvbTAcBgNVHRIEFTATgRFjaHJpc0BvbHN0cm9t
+LmNvbTANBgkqhkiG9w0BAQsFAAOCAYEALritM5RkGNZ7cs8hlljSEyuwJrbJYOSX
+6p1S0D83GlfGZ/5XABy1p4EGQjxiAYuDrnnIw6GLHpgxFEtUNvyNYVfAa6u6yz4Y
+nEjbEF76zAAxoRfivDApGJ3G9wuZ14cHZswFJppf2N4RG14F8bfLtU1OMYDLw8eK
+QJOpynqHtrSj+FfsyNb6d93K8rlNCEd4UHkdRH1m7VnG6M18HvkbQCRMJtOFg/3j
+c66TgdClDMJJXXiktVinfsmpTwxe2IzjGvwo2CZ/S53WPU/jb4uQMUzY0tMw48rl
+S07/1DQNogstTnLYueqkUS1PYEwtavKVnpAtnaOdf0rJ/Rk4hA36BRgAVyQrp0uu
+mSbo3NCvepJNYsTOUM+Df421VuPq713JV0aJDqltyfPptTM7fmNMcukbRh0aRuMT
+EIKh6yDoB+oCRuiTV0uw/lKE2PtbONhJb7uN1qhZqla/iBpmUjiEu8+skI+ygv9n
+7Krw8FJrV3+VRCiZTPKHeshAfL9yeIZh
+-----END CERTIFICATE-----

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: invocations
+version: !ruby/object:Gem::Version
+  version: 0.2.6
+platform: ruby
+authors:
+- Chris Olstrom
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIENDCCApygAwIBAgIBATANBgkqhkiG9w0BAQsFADAiMSAwHgYDVQQDDBdjaHJp
+  cy9EQz1vbHN0cm9tL0RDPWNvbTAeFw0xODAzMTUxODMxMTdaFw0xOTAzMTUxODMx
+  MTdaMCIxIDAeBgNVBAMMF2NocmlzL0RDPW9sc3Ryb20vREM9Y29tMIIBojANBgkq
+  hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAp31YmQvpMuQSlgX22B++/rxl4p4LYyaq
+  cDDbi8DBro9cm2H60lbpCuAUALiED2CagZEK0vel5W8AnZhhns0OEYAlpQtBSJtN
+  8P/jlNYruuY26aVhfHfyA5j1n7tVecJz3i/awEPGC3zuTfvUq7Ahn5czOy+hIm4M
+  epee881dqnJlXjzTX/TKFYQa9tYj4bhsjfJOV+EDMcao/DE3vmNcBKH8XFVv/wQe
+  MGC7VY5zBwow00AkCicNmIr0Psy5hLvqphJ/E3Eiu4UpXhiBfM0z7xiBPoPMBqOx
+  r1RzgfKm/JbDO7leFmrEi8hLofyMmbuGvrSTE274vS4EnKaW6OtK7QM5R+jOJZbd
+  67KUgSw+LdHNwu8xCuuQOdKPeSfWdNz94KAdczjzHdXUl/SpfmTuN/D+BCZjTxSo
+  F1kACSU6uGTBFKZy35XK+yqeny/1l6xRs6j+cON+LSRMKYSt7jdLcKQVk5wH2xLo
+  83njwnumFxKhiWu0oaT5dlDCtyYM85j9AgMBAAGjdTBzMAkGA1UdEwQCMAAwCwYD
+  VR0PBAQDAgSwMB0GA1UdDgQWBBQEd3/D0MMj9FHhMZk0QJDlrUtKaTAcBgNVHREE
+  FTATgRFjaHJpc0BvbHN0cm9tLmNvbTAcBgNVHRIEFTATgRFjaHJpc0BvbHN0cm9t
+  LmNvbTANBgkqhkiG9w0BAQsFAAOCAYEALritM5RkGNZ7cs8hlljSEyuwJrbJYOSX
+  6p1S0D83GlfGZ/5XABy1p4EGQjxiAYuDrnnIw6GLHpgxFEtUNvyNYVfAa6u6yz4Y
+  nEjbEF76zAAxoRfivDApGJ3G9wuZ14cHZswFJppf2N4RG14F8bfLtU1OMYDLw8eK
+  QJOpynqHtrSj+FfsyNb6d93K8rlNCEd4UHkdRH1m7VnG6M18HvkbQCRMJtOFg/3j
+  c66TgdClDMJJXXiktVinfsmpTwxe2IzjGvwo2CZ/S53WPU/jb4uQMUzY0tMw48rl
+  S07/1DQNogstTnLYueqkUS1PYEwtavKVnpAtnaOdf0rJ/Rk4hA36BRgAVyQrp0uu
+  mSbo3NCvepJNYsTOUM+Df421VuPq713JV0aJDqltyfPptTM7fmNMcukbRh0aRuMT
+  EIKh6yDoB+oCRuiTV0uw/lKE2PtbONhJb7uN1qhZqla/iBpmUjiEu8+skI+ygv9n
+  7Krw8FJrV3+VRCiZTPKHeshAfL9yeIZh
+  -----END CERTIFICATE-----
+date: 2018-05-10 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: chris@olstrom.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.org
+- invocations.gemspec
+- lib/invocations.rb
+- lib/invocations/invocation.rb
+- tests/invocations.rb
+- trust/certificates/colstrom.pem
+homepage: https://github.com/colstrom/invocations
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Drop-in alternative to procs and lambdas.
+test_files: []