param_param 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 61d152a83cea632bd4e660508c5dc62d26231e9bb60a35626e1991548171e205
+  data.tar.gz: 28d02503d7fc9a374d1e555c3e9328aac9418194ed6520989165b66fe5d4a3cd
+SHA512:
+  metadata.gz: bdef7f585fc8f1050327bcdbe0946cc3255eca321c2f43b17fd42035cdc4d029f5d85011f91e01e2813af50b9e47ae70593f676078e483611efeed2e2a3f583b
+  data.tar.gz: '004692833ec9cefe0d4ebdc6ec02ffa1c4de71ef38995e03aa62eecf2cbe4e8fa839f75a9119ca4adcab5576742909d69955f332f5e833c01965544fdd54c504'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Mr Dev
+
+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.md

@@ -0,0 +1,4 @@
+# param_param
+Params parser built on lambdas.
+
+Inspired by Martin Chabot's [Simple Functional Strong Parameters In Ruby](https://blog.martinosis.com/blog/simple-functional-strong-params-in-ruby) article.

data/lib/param_param/result.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ParamParam
+  # Defines operation result pattern.
+  # A result can be a success or a failure and has some value.
+  class Result
+    # Returns +false+.
+    def success?
+      false
+    end
+
+    # Returns +false+.
+    def failure?
+      false
+    end
+  end
+
+  # Describes successful result.
+  class Success < Result
+    # A value related to the success.
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    # Returns +true+.
+    def success?
+      true
+    end
+  end
+
+  # Describes failed result.
+  class Failure < Result
+    # An error related to the failure.
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+
+    # Returns +true+.
+    def failure?
+      true
+    end
+  end
+end

data/lib/param_param/std.rb

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

data/lib/param_param.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+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 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
+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
+  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)]
+      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
+
+  # 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
+
+  # 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
+
+  # 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) }
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: param_param
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Michał Radmacher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: optiomist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+description: 
+email: michal@radmacher.pl
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/param_param.rb
+- lib/param_param/result.rb
+- lib/param_param/std.rb
+homepage: https://github.com/mradmacher/param_param
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Params parser built on lambdas
+test_files: []