param_param 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61d152a83cea632bd4e660508c5dc62d26231e9bb60a35626e1991548171e205
-  data.tar.gz: 28d02503d7fc9a374d1e555c3e9328aac9418194ed6520989165b66fe5d4a3cd
+  metadata.gz: 73a3ff3dffbee8500b224cef365440d71cb01b5f8e8a8c8f0e7995e894892493
+  data.tar.gz: c958be904a5b0794c93dbae002da9a33c10a809d168d4234beb0b184e7d2cd8f
 SHA512:
-  metadata.gz: bdef7f585fc8f1050327bcdbe0946cc3255eca321c2f43b17fd42035cdc4d029f5d85011f91e01e2813af50b9e47ae70593f676078e483611efeed2e2a3f583b
-  data.tar.gz: '004692833ec9cefe0d4ebdc6ec02ffa1c4de71ef38995e03aa62eecf2cbe4e8fa839f75a9119ca4adcab5576742909d69955f332f5e833c01965544fdd54c504'
+  metadata.gz: da3253615f397f6bd04f080e9c9e32178bbfa1e59e193287c27ab7a81198194aece453a31fb71f4ef402d6b589da653436d79341a7d221eda838265f65ed7a28
+  data.tar.gz: 51db488247772ae2db84f6ec5883721c9b9c7108a5596f98c98b197028bf0580cba5e1f0110ad062f035ad8802bf947ded9f47afe692df2f06b8413bc28b83df

data/README.md

@@ -1,4 +1,82 @@
 # param_param
-Params parser built on lambdas.
+Lambda powered pipelines.
+Define pipelines transforming hash values.
 
 Inspired by Martin Chabot's [Simple Functional Strong Parameters In Ruby](https://blog.martinosis.com/blog/simple-functional-strong-params-in-ruby) article.
+
+# Examples
+## Validate and transform a user provided data in a web application.
+
+```
+require 'param_param'
+require 'param_param/std'
+
+class UserParams
+  include ParamParam
+  include ParamParam::Std
+
+  # You can add your own actions
+  capitalized = ->(option) { Success.new(Optiomist.some(option.value.capitalize)) }
+
+  RULES = define.(
+    name: required.(string.(all_of.([not_blank, max_size.(50), capitalized]))),
+    admin: required.(bool.(any)),
+    age: optional.(integer.(gt.(0))),
+  )
+
+  def process(params)
+    RULES.(params)
+  end
+end
+
+params, errors = UserParams.new.process(
+  name: 'JOHN',
+  admin: '0',
+  age: '30',
+  race: 'It is not important',
+)
+params # {:name=>"John", :admin=>false, :age=>30}
+errors # {}
+
+params, errors = UserParams.new.process(admin: 'no', age: 'very old')
+params # {:admin=>false}
+errors # {:name=>:missing, :age=>:non_integer}
+```
+
+## Perform some chain of operations on provided data.
+```
+require 'param_param'
+
+module Mather
+  include ParamParam
+
+  def self.add
+    ->(value, option) { Success.new(Optiomist.some(option.value + value)) }.curry
+  end
+
+  def self.mul
+    ->(value, option) { Success.new(Optiomist.some(option.value * value)) }.curry
+  end
+
+  def self.sub
+    ->(value, option) { Success.new(Optiomist.some(option.value - value)) }.curry
+  end
+end
+
+rules = Mather.define.(
+  a: Mather.add.(5),
+  b: Mather.mul.(3),
+  c: Mather.sub.(1),
+  d: Mather.all_of.([Mather.add.(2), Mather.mul.(2), Mather.sub.(2)]),
+)
+
+params, _ = rules.(
+  a: 0,
+  b: 1,
+  c: 2,
+  d: 3,
+)
+
+params # {:a=>5, :b=>3, :c=>1, :d=>8}
+
+```

data/lib/param_param/std.rb

@@ -1,168 +1,247 @@
 # frozen_string_literal: true
 
-# It contains a collection of some useful rules.
 module ParamParam
-  # Some string values that can be considered as +true+ (thank you dry-rb for inspiration).
-  TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES Y].freeze
-  # Some string values that can be considered as +false+ (thank you dry-rb for inspiration).
-  FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
-
-  NOT_GTE = :not_gte
-  NOT_GT = :not_gt
-  NOT_LTE = :not_lte
-  NOT_LT = :not_lt
-  NOT_INCLUDED = :not_included
-  TOO_LONG = :too_long
-  TOO_SHORT = :too_short
-
-  NON_BOOL = :non_bool
-  NON_DECIMAL = :non_decimal
-  NON_INTEGER = :non_integer
-  NON_STRING = :non_string
-
-  # Verifies inclusion of a value in a collection.
-  #
-  # Returns
-  #  lambda { |collection, option| ... }.
-  #
-  # Verifies if value of the +option+ is included in the provided +collection+.
-  def self.included_in
-    lambda { |collection, option|
-      collection.include?(option.value) ? Success.new(option) : Failure.new(NOT_INCLUDED)
-    }.curry
-  end
+  # It defines some actions that can be useful in an everyday life.
+  module Std
+    def self.included(base)
+      base.include(Messages)
+      base.extend(Actions)
+    end
 
-  # Returns
-  #  lambda { |limit, option| ... }.
-  #
-  # Checks if the +option+'s value is greater than or equal to the provided +limit+.
-  def self.gte
-    ->(limit, option) { option.value >= limit ? Success.new(option) : Failure.new(NOT_GTE) }.curry
-  end
+    # Some string values that can be considered as +true+ (thank you dry-rb for inspiration).
+    TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES Y].freeze
+    # Some string values that can be considered as +false+ (thank you dry-rb for inspiration).
+    FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
 
-  # Returns
-  #  lambda { |limit, option| ... }.
-  #
-  # Checks if the +option+'s value is greater than the provided +limit+.
-  def self.gt
-    ->(limit, option) { option.value > limit ? Success.new(option) : Failure.new(NOT_GT) }.curry
-  end
+    # Validation messages for rules.
+    module Messages
+      BLANK = :blank
+      MISSING = :missing
 
-  # Returns
-  #  lambda { |limit, option| ... }.
-  #
-  # Checks if the +option+'s value is less than or equal to the provided +limit+.
-  def self.lte
-    ->(limit, option) { option.value <= limit ? Success.new(option) : Failure.new(NOT_LTE) }.curry
-  end
+      NOT_GTE = :not_gte
+      NOT_GT = :not_gt
+      NOT_LTE = :not_lte
+      NOT_LT = :not_lt
+      NOT_INCLUDED = :not_included
+      TOO_LONG = :too_long
+      TOO_SHORT = :too_short
 
-  # Returns
-  #  lambda { |limit, option| ... }.
-  #
-  # Checks if the +option+'s value is less than the provided +limit+.
-  def self.lt
-    ->(limit, option) { option.value < limit ? Success.new(option) : Failure.new(NOT_LT) }.curry
-  end
+      NON_BOOL = :non_bool
+      NON_DECIMAL = :non_decimal
+      NON_INTEGER = :non_integer
+      NON_STRING = :non_string
+    end
 
-  # Returns
-  #  lambda { |limit, option| ... }.
-  #
-  # Checks if the size of the value in +option+ does not exceed provided +limit+.
-  def self.max_size
-    lambda { |limit, option|
-      option.value.size <= limit ? Success.new(option) : Failure.new(TOO_LONG)
-    }.curry
-  end
+    # Actions definitions.
+    module Actions
+      # Verifies inclusion of a value in a collection.
+      #
+      # Returns
+      #  lambda { |collection, option| ... }.
+      #
+      # Verifies if value of the +option+ is included in the provided +collection+.
+      def included_in
+        lambda { |collection, option|
+          collection.include?(option.value) ? Success.new(option) : Failure.new(Messages::NOT_INCLUDED)
+        }.curry
+      end
 
-  # Returns
-  #  lambda { |limit, option| ... }.
-  #
-  # Checks if the size of the value in +option+ is not lower than the provided +limit+.
-  def self.min_size
-    lambda { |limit, option|
-      option.value.size >= limit ? Success.new(option) : Failure.new(TOO_SHORT)
-    }.curry
-  end
+      # Describes an optional value.
+      #
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # If +option+ is the +Optiomist::None+ it succeeds causing the parameter not to be included in the final result.
+      # Otherwise executes the funciton +fn+ for the option.
+      def optional
+        lambda { |fn, option|
+          case option
+          in Optiomist::None
+            Success.new(option)
+          in Optiomist::Some
+            fn.call(option)
+          end
+        }.curry
+      end
 
-  # Returns
-  #  lambda { |option| ... }.
-  #
-  # Removes leading and trailing spaces from string provided in +option+'s value.
-  def self.stripped
-    ->(option) { Success.new(Optiomist.some(option.value.strip)) }
-  end
+      # Describes a required value.
+      #
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # If +option+ is a +Optiomist::None+ it fails otherwise executes the funciton +fn+ for the option.
+      def required
+        lambda { |fn, option|
+          case option
+          in Optiomist::None
+            Failure.new(Messages::MISSING)
+          in Optiomist::Some
+            fn.call(option)
+          end
+        }.curry
+      end
 
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # Converts provided +option+'s value to integer.
-  # If the conversion is not possible it fails, otherwise executes the provider function +fn+
-  # for the converted integer value.
-  def self.integer
-    lambda { |fn, option|
-      begin
-        integer_value = Integer(option.value)
-      rescue StandardError
-        return Failure.new(NON_INTEGER)
-      end
-      fn.call(Optiomist.some(integer_value))
-    }.curry
-  end
+      # Converts blank value to nil or passes non blank value to next rule.
+      #
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # If provided +option+'s value is blank it succeeds with +nil+
+      # otherwise executes provided function for the +option+.
+      def blank_to_nil_or
+        lambda { |fn, option|
+          blank?(option.value) ? Success.new(Optiomist.some(nil)) : fn.call(option)
+        }.curry
+      end
 
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # Converts provided +option+'s value to float.
-  # If the conversion is not possible it fails, otherwise executes the provider function +fn+
-  # for the converted float value.
-  def self.decimal
-    lambda { |fn, option|
-      begin
-        float_value = Float(option.value)
-      rescue StandardError
-        return Failure.new(NON_DECIMAL)
-      end
-      fn.call(Optiomist.some(float_value))
-    }.curry
-  end
+      # Verifies if value is not blank.
+      #
+      # Returns
+      #  lambda { |option| ... }.
+      #
+      # It fails if provided +option+ is blank, otherwise succeeds with the +option+.
+      def not_blank
+        ->(option) { blank?(option.value) ? Failure.new(Messages::BLANK) : Success.new(option) }
+      end
 
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # Converts provided +option+'s value to boolean.
-  # If the conversion is not possible it fails, otherwise executes the provider function +fn+
-  # for the converted boolean value.
-  def self.bool
-    lambda { |fn, option|
-      case option
-      in Optiomist::Some
-        if [true, *TRUE_VALUES].include?(option.value)
-          fn.call(Optiomist.some(true))
-        elsif [false, *FALSE_VALUES].include?(option.value)
-          fn.call(Optiomist.some(false))
-        else
-          Failure.new(NON_BOOL)
-        end
-      in Optiomist::None
-        Failure.new(NON_BOOL)
-      end
-    }.curry
-  end
+      # Verifies if provided value is nil, empty string or string consisting only from spaces.
+      def blank?(value)
+        value.nil? || (value.is_a?(String) && value.strip.empty?)
+      end
+
+      # Returns
+      #  lambda { |limit, option| ... }.
+      #
+      # Checks if the +option+'s value is greater than or equal to the provided +limit+.
+      def gte
+        ->(limit, option) { option.value >= limit ? Success.new(option) : Failure.new(Messages::NOT_GTE) }.curry
+      end
 
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # Converts provided +option+'s value to string.
-  # If the conversion is not possible it fails, otherwise executes the provider function +fn+
-  # for the converted string value.
-  def self.string
-    lambda { |fn, option|
-      case option
-      in Optiomist::Some
-        fn.call(Optiomist.some(option.value.to_s))
-      in Optiomist::None
-        Failure.new(NON_STRING)
-      end
-    }.curry
+      # Returns
+      #  lambda { |limit, option| ... }.
+      #
+      # Checks if the +option+'s value is greater than the provided +limit+.
+      def gt
+        ->(limit, option) { option.value > limit ? Success.new(option) : Failure.new(Messages::NOT_GT) }.curry
+      end
+
+      # Returns
+      #  lambda { |limit, option| ... }.
+      #
+      # Checks if the +option+'s value is less than or equal to the provided +limit+.
+      def lte
+        ->(limit, option) { option.value <= limit ? Success.new(option) : Failure.new(Messages::NOT_LTE) }.curry
+      end
+
+      # Returns
+      #  lambda { |limit, option| ... }.
+      #
+      # Checks if the +option+'s value is less than the provided +limit+.
+      def lt
+        ->(limit, option) { option.value < limit ? Success.new(option) : Failure.new(Messages::NOT_LT) }.curry
+      end
+
+      # Returns
+      #  lambda { |limit, option| ... }.
+      #
+      # Checks if the size of the value in +option+ does not exceed provided +limit+.
+      def max_size
+        lambda { |limit, option|
+          option.value.size <= limit ? Success.new(option) : Failure.new(Messages::TOO_LONG)
+        }.curry
+      end
+
+      # Returns
+      #  lambda { |limit, option| ... }.
+      #
+      # Checks if the size of the value in +option+ is not lower than the provided +limit+.
+      def min_size
+        lambda { |limit, option|
+          option.value.size >= limit ? Success.new(option) : Failure.new(Messages::TOO_SHORT)
+        }.curry
+      end
+
+      # Returns
+      #  lambda { |option| ... }.
+      #
+      # Removes leading and trailing spaces from string provided in +option+'s value.
+      def stripped
+        ->(option) { Success.new(Optiomist.some(option.value.strip)) }
+      end
+
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # Converts provided +option+'s value to integer.
+      # If the conversion is not possible it fails, otherwise executes the provider function +fn+
+      # for the converted integer value.
+      def integer
+        lambda { |fn, option|
+          begin
+            integer_value = Integer(option.value)
+          rescue StandardError
+            return Failure.new(Messages::NON_INTEGER)
+          end
+          fn.call(Optiomist.some(integer_value))
+        }.curry
+      end
+
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # Converts provided +option+'s value to float.
+      # If the conversion is not possible it fails, otherwise executes the provider function +fn+
+      # for the converted float value.
+      def decimal
+        lambda { |fn, option|
+          begin
+            float_value = Float(option.value)
+          rescue StandardError
+            return Failure.new(Messages::NON_DECIMAL)
+          end
+          fn.call(Optiomist.some(float_value))
+        }.curry
+      end
+
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # Converts provided +option+'s value to boolean.
+      # If the conversion is not possible it fails, otherwise executes the provider function +fn+
+      # for the converted boolean value.
+      def bool
+        lambda { |fn, option|
+          case option
+          in Optiomist::Some
+            if [true, *TRUE_VALUES].include?(option.value)
+              fn.call(Optiomist.some(true))
+            elsif [false, *FALSE_VALUES].include?(option.value)
+              fn.call(Optiomist.some(false))
+            else
+              Failure.new(Messages::NON_BOOL)
+            end
+          in Optiomist::None
+            Failure.new(Messages::NON_BOOL)
+          end
+        }.curry
+      end
+
+      # Returns
+      #  lambda { |fn, option| ... }.
+      #
+      # Converts provided +option+'s value to string.
+      # If the conversion is not possible it fails, otherwise executes the provider function +fn+
+      # for the converted string value.
+      def string
+        lambda { |fn, option|
+          case option
+          in Optiomist::Some
+            fn.call(Optiomist.some(option.value.to_s))
+          in Optiomist::None
+            Failure.new(Messages::NON_STRING)
+          end
+        }.curry
+      end
+    end
   end
 end

data/lib/param_param.rb

@@ -2,156 +2,80 @@
 
 require 'optiomist'
 require 'param_param/result'
-require 'param_param/std'
 
-# The main purpose of this module is to convert hash data
-# applying a chain of rules to values in the provided hash.
+# It allows to define pipelines that transform hash values.
 #
-# It can be used to process form data in a web application converting
-# user provided data to values understood by the application and validate
-# it the data fulfills constraints required by the application.
-#
-# Example:
-#
-#   class UserOperation
-#     Rules = ParamParam.define.(
-#       name: ParamParam.required.(
-#         ParamParam.string.(ParamParam.all_of.([ParamParam.not_nil, ParamParam.stripped, ParamParam.max_size.(50)]))
-#       ),
-#       admin: ParamParam.required.(ParamParam.bool.(ParamParam.any)),
-#       age: ParamParam.optional.(ParamParam.integer.(ParamParam.gt.(0))),
-#     )
-#
-#     def create(name:, age:)
-#       params, errors = Rules.(name: name, age: age)
-#       throw errors unless errors.empty?
-#
-#       # do something with params
-#     end
-#   end
+# Each pipeline is bound to a particular key and processes a value related to that key.
+# A pipeline consists of a chain of actions that are executed one by one.
+# An actions receives a value from a previous action and is expected to return successful or failed result.
+# A successful result contains a new value being the result of the processing.
+# The new value is passed further in the chain to the next action.
+# A failed result contains a message from an action saying why a particular value can't be processed.
+# Following actions in the chain are not executed.
 module ParamParam
-  MISSING = :missing
-  BLANK = :blank
-
-  # Converts provided value to +Optiomist::Some+.
-  # If the value is already +Optiomist::Some+ or +Optiomist::None+ returns it untouched.
-  def self.optionize(value)
-    if value.is_a?(Optiomist::Some) || value.is_a?(Optiomist::None)
-      value
-    else
-      Optiomist.some(value)
-    end
+  def self.included(base)
+    base.extend(Actions)
   end
 
-  # Verifies if provided value is nil, empty string or string consisting only from spaces.
-  def self.blank?(value)
-    value.nil? || (value.is_a?(String) && value.strip.empty?)
-  end
-
-  # Returns lambda that allows defining a set of rules and bind them to symbols.
-  # Later those rules can be applied to parameters provided in a for of a hash.
-  # Each rule defined for a given key processes a value related to the same key in provided parameters.
-  #   lambda { |rules, params| ... }
-  #
-  # The lambda returns two hashes:
-  # - if a value related to a key can be procesed by the rules,
-  #   the result is bound to the key and added to the first hash
-  # - if a rule can't be applied to a value,
-  #   the error is bound to the key and added to the second hash
-  #
-  # Each rule needs to be a lambda taking +Optiomist+ as the only or the last parameter and returning either:
-  # - +ParamParam::Success+ with processed option
-  # - +ParamParam::Failure+ with an error
-  def self.define
-    lambda { |rules, params|
-      results = rules.to_h do |key, fn|
-        option = params.key?(key) ? optionize(params[key]) : Optiomist.none
-        [key, fn.call(option)]
+  # Actions definitions.
+  module Actions
+    # Converts provided value to +Optiomist::Some+.
+    # If the value is already +Optiomist::Some+ or +Optiomist::None+ returns it untouched.
+    def optionize(value)
+      if value.is_a?(Optiomist::Some) || value.is_a?(Optiomist::None)
+        value
+      else
+        Optiomist.some(value)
       end
+    end
 
-      errors = results.select { |_, result| result.failure? }
-                      .transform_values(&:error)
-      params = results.select { |_, result| result.success? && result.value.some? }
-                      .transform_values { |result| result.value.value }
-      [params, errors]
-    }.curry
-  end
-
-  # It return lambda that allows defining a chain of rules that will be applied one by one
-  # to value processed by a previous rule.
-  #
-  # Returns:
-  #   lambda { |fns, option| ... }
-  # If some rule fails the chain is broken and value stops being processed.
-  def self.all_of
-    lambda { |fns, option|
-      fns.reduce(Success.new(option)) { |result, fn| result.failure? ? result : fn.call(result.value) }
-    }.curry
-  end
-
-  # Returns
-  #  lambda { |option| ... }.
-  #
-  # Always succeeds with the provided +option+.
-  def self.any
-    ->(option) { Success.new(option) }
-  end
-
-  # Describes an optional value.
-  #
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # If +option+ is the +Optiomist::None+ it succeeds causing the parameter not to be included in the final result.
-  # Otherwise executes the funciton +fn+ for the option.
-  def self.optional
-    lambda { |fn, option|
-      case option
-      in Optiomist::None
-        Success.new(option)
-      in Optiomist::Some
-        fn.call(option)
-      end
-    }.curry
-  end
+    # Defines pipelines and binds them to symbols.
+    # Pipelines are used to process parameters provided in a form of a hash.
+    # Each pipeline is defined for a key and processes a value related to that key in provided parameters.
+    #   lambda { |rules, params| ... }
+    #
+    # The lambda returns two hashes:
+    # - if a value related to a key can be procesed by an action,
+    #   the result is bound to the key and added to the first hash
+    # - if a value related to a key can't be processed by an action,
+    #   the error is bound to the key and added to the second hash
+    #
+    # Each action needs to be a lambda taking +Optiomist+ as the only or the last parameter and returning either:
+    # - +ParamParam::Success+ with processed option
+    # - +ParamParam::Failure+ with an error
+    def define
+      lambda { |rules, params|
+        results = rules.to_h do |key, fn|
+          option = params.key?(key) ? optionize(params[key]) : Optiomist.none
+          [key, fn.call(option)]
+        end
 
-  # Describes a required value.
-  #
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # If +option+ is a +Optiomist::None+ it fails otherwise executes the funciton +fn+ for the option.
-  def self.required
-    lambda { |fn, option|
-      case option
-      in Optiomist::None
-        Failure.new(MISSING)
-      in Optiomist::Some
-        fn.call(option)
-      end
-    }.curry
-  end
+        errors = results.select { |_, result| result.failure? }
+                        .transform_values(&:error)
+        params = results.select { |_, result| result.success? && result.value.some? }
+                        .transform_values { |result| result.value.value }
+        [params, errors]
+      }.curry
+    end
 
-  # Converts blank value to nil or passes non blank value to next rule.
-  #
-  # Returns
-  #  lambda { |fn, option| ... }.
-  #
-  # If provided +option+'s value is blank it succeeds with +nil+
-  # otherwise executes provided function for the +option+.
-  def self.blank_to_nil_or
-    lambda { |fn, option|
-      blank?(option.value) ? Success.new(Optiomist.some(nil)) : fn.call(option)
-    }.curry
-  end
+    # It return lambda that allows defining a chain of rules that will be applied one by one
+    # to value processed by a previous rule.
+    #
+    # Returns:
+    #   lambda { |fns, option| ... }
+    # If some rule fails the chain is broken and value stops being processed.
+    def all_of
+      lambda { |fns, option|
+        fns.reduce(Success.new(option)) { |result, fn| result.failure? ? result : fn.call(result.value) }
+      }.curry
+    end
 
-  # Verifies if value is not blank.
-  #
-  # Returns
-  #  lambda { |option| ... }.
-  #
-  # It fails if provided +option+ is blank, otherwise succeeds with the +option+.
-  def self.not_blank
-    ->(option) { blank?(option.value) ? Failure.new(BLANK) : Success.new(option) }
+    # Returns
+    #  lambda { |option| ... }.
+    #
+    # Always succeeds with the provided +option+.
+    def any
+      ->(option) { Success.new(option) }
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: param_param
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Michał Radmacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-11 00:00:00.000000000 Z
+date: 2023-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: optiomist
@@ -57,8 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Params parser built on lambdas
+summary: Lambda powered pipelines for hash values
 test_files: []