sinatra-param-validator 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda1b5487b870b26f4b2ca5c6a575a57c91441ac319b78567295ab0b4517a8bc
-  data.tar.gz: 331f3cace8d87a35fa410ae28c3df15e07f851d276ad2a2173ce799572cfae04
+  metadata.gz: 1312fa49d8b256875f1c6de21269a7be31ab1c3f2ca0a5efdb9902c31b5406d4
+  data.tar.gz: 4b483ce648a24026e26964b0cdd358a4f1256ffe7dc810770e8dbf2b98204306
 SHA512:
-  metadata.gz: caceb492da8562135850ecf1c7a77ecd4fd850ab31d714ff1fa555c4316e63074aa7ed9f75e331336ddf30c1921a5d3cc2f895447d7ec76f3767b46448e6a7c4
-  data.tar.gz: 729686317687d72ff23ce570991a88e6731314320f3e702ba631c7452b75e117997fc30207c2cee7be52c1aa458424311666b734061bb7c3aefb6911b07a9dc2
+  metadata.gz: 2714270e73581d5beb88eb136516fc1d5275d05ebe2a3c5efca08d54b64bb2bcda467cb45cb4ab3fa7fee063606171356f9fe869cbedc0950afc7b92cb5dc8eb
+  data.tar.gz: 692691bde5e786c23897080967004fc5fb5b695d49942fd671db69ef6ec91c00771a0afbfc5e69954b5e22f8e585829c8e08a04b6a954cf14ec46b1c19dfdf8c

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 ## [Unreleased]
 
+## [0.5.0] - 2022-06-09
+
+- Allow the validator to be passed to the block for a valid parameter
+
+## [0.4.0] - 2022-06-09
+
+- Allow custom error messages to be used when validation fails
+- Ensure running multiple validations for a single parameter merges the errors correctly
+- Allow validations to run code if successful
+- Allow exceptions to be raised by the parameter block to indicate failure
+- Allow parameters to be passed to validators
+
+## [0.3.0] - 2022-06-08
+
+- Don't create entries in `params` for parameters that are not passed
+- Don't set validator type during definition
+- Add unique validator conditionals for each validator:
+  - validate
+  - validate_form
+  - validate_url_param
+
+## [0.2.0] - 2022-06-08
+
+- Add validators:
+  - Standard
+  - URL Parameter
+  - Form
+- Add parameters:
+  - Array
+  - Boolean
+  - Date
+  - Float
+  - Hash
+  - Integer
+  - String
+  - Time
+- Add rules:
+  - All or none of
+  - Any of
+  - One of
+
 ## [0.1.0] - 2022-05-16
 
 - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sinatra-param-validator (0.2.0)
+    sinatra-param-validator (0.5.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -15,7 +15,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 ## Sample Usage
 
 ```ruby
-validator identifier: :user_id do
+validator :user_id do
   param :id, Integer, required: true
 end
 
@@ -23,7 +23,7 @@ get '/user/:id', validate: :user_id do
   # ...
 end
 
-validator identifier: :new_user do
+validator :new_user do
   param :name, String, required: true
   param :age, Integer, required: true, min: 0 
 end
@@ -86,6 +86,44 @@ All parameters have the following validations available:
 
 * `min` / `max`
 
+## Custom Messages
+
+It is possible to return a custom error message when a validation fails:
+
+```ruby
+param :number, Integer, required: true, message: 'The number is required'
+```
+
+It is also possible to run multiple validations against a single parameter. 
+This can be useful if different failures require different messages. 
+
+```ruby
+param :number, Integer, required: true, message: 'The number is required'
+param :number, Integer, min: 100, message: 'The number is not large enough'
+```
+
+## Validation blocks
+
+It is possible to run code after a validation succeeds, by passing a block to `param`:
+
+```ruby
+param :number, Integer, required: true do
+  # ...
+end
+```
+
+If you wish to indicate a validation failure within a block, raise `Sinatra::ParameterValidator::InvalidParameterError`
+with a message, and it will be passed through as an error for the parameter.
+
+If you need to do further validation with your parameter, the validator can be passed to the block:
+
+```ruby
+
+param :number, Integer, required: true do |validator|
+  validator.param :digit, Integer, min: params[:number]
+end
+```
+
 ## Rules
 
 Rules work on multiple parameters:
@@ -113,12 +151,30 @@ There are two other provided validators, that handle failure differently:
   * will provide a JSON object with errors to an XHR request
   * will `halt 400`
 
-These validators can be set when a validator is defined:
+These validators can be invoked with a different conditional on the route:
 
 ```ruby
-validator type: :form, identifier: :new_user do
-  param :name, String, required: true
-  param :age, Integer, required: true, min: 0 
+post '/new-user', validate_form: :new_user do
+  # ...
+end
+
+get '/user/:id', validate_url_param: :user_id do
+  # ...
+end
+```
+
+## Validators with parameters
+
+It is possible to define a validator with a parameter.
+To call the validator, you can use the `vi` helper to wrap a validator identifier with arguments:
+
+```ruby
+validator :number do |min|
+  param :id, Integer, min: min
+end
+
+post '/number', validate: vi(:new_user, 10) do
+  # ...
 end
 ```
 

data/lib/sinatra/param_validator/helpers.rb

@@ -13,9 +13,11 @@ module Sinatra
         raise "Filter params failed: #{e}"
       end
 
-      def validate(identifier, args = {})
-        validator = settings.validator_definitions.get(identifier)
-        validator.run(self, *args)
+      def validate(klass, identifier)
+        identifier = Identifier.new(identifier) if identifier.is_a? Symbol
+        definition = settings.validator_definitions.get(identifier.identifier)
+        validator = klass.new(&definition)
+        validator.run(self, *identifier.args)
         validator.handle_failure(self) unless validator.success?
       end
     end

data/lib/sinatra/param_validator/identifier.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Class to hold a validator identifier plus arguments
+    class Identifier
+      attr_reader :identifier, :args
+
+      def initialize(identifier, *args)
+        @identifier = identifier
+        @args = args
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/invalid_parameter_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Error raised when validation fails
+    class InvalidParameterError < StandardError
+    end
+  end
+end

data/lib/sinatra/param_validator/parameter/common.rb

@@ -9,13 +9,17 @@ module Sinatra
 
         def initialize(value, **options)
           @errors = []
-          @coerced = coerce value
           @options = options
 
+          begin
+            @coerced = coerce value
+          rescue ArgumentError
+            @errors.push "'#{value}' is not a valid #{self.class}"
+            return
+          end
+
           validate_options
           validate unless nil_and_ok?
-        rescue ArgumentError
-          @errors.push "'#{value}' is not a valid #{self.class}"
         end
 
         def valid?

data/lib/sinatra/param_validator/parser.rb

@@ -2,6 +2,7 @@
 
 require 'delegate'
 
+require_relative 'invalid_parameter_error'
 require_relative 'parameter'
 require_relative 'rule'
 
@@ -11,18 +12,26 @@ module Sinatra
     class Parser < SimpleDelegator
       attr_reader :errors
 
-      def initialize(definition, context)
+      def initialize(definition, context, *args)
         super(context)
         @context = context
         @errors = {}
 
-        instance_exec({}, &definition)
+        instance_exec(*args, &definition)
       end
 
-      def param(key, type, **args)
+      def add_error(key, error)
+        @errors[key] = @errors.fetch(key, []).concat(Array(error))
+      end
+
+      def param(key, type, message: nil, **args, &block)
         parameter = Parameter.new(@context.params[key], type, **args)
-        @context.params[key] = parameter.coerced
-        @errors[key] = parameter.errors unless parameter.valid?
+        @context.params[key] = parameter.coerced if @context.params.key?(key) && parameter.coerced
+        if parameter.valid?
+          run_block(key, block) if block
+        else
+          add_error key, message || parameter.errors
+        end
       rescue NameError
         raise 'Invalid parameter type'
       end
@@ -36,6 +45,13 @@ module Sinatra
       rescue NameError
         raise 'Invalid rule type'
       end
+
+      def run_block(key, block)
+        args = block.arity == 1 ? [self] : []
+        @context.instance_exec(*args, &block)
+      rescue InvalidParameterError => e
+        add_error key, e.message
+      end
     end
   end
 end

data/lib/sinatra/param_validator/snake_case.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Helpers for validating parameters
+    module SnakeCase
+      def snake_case(string)
+        string.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/validation_failed_error.rb

@@ -6,9 +6,9 @@ module Sinatra
     class ValidationFailedError < StandardError
       attr_reader :errors
 
-      def initialize(errors, msg = nil)
+      def initialize(errors)
         @errors = errors
-        super(msg)
+        super("Validation failed: #{errors}")
       end
     end
   end

data/lib/sinatra/param_validator/validator.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'validation_failed_error'
-require_relative 'validator/form'
-require_relative 'validator/url_param'
-
 module Sinatra
   module ParamValidator
     # Definition of a single validator
@@ -19,13 +15,28 @@ module Sinatra
         raise ValidationFailedError, @errors
       end
 
-      def run(context)
-        @errors = Parser.new(@definition, context).errors
+      def run(context, *args)
+        @errors = Parser.new(@definition, context, *args).errors
       end
 
       def success?
         @errors.empty?
       end
+
+      @validators = []
+
+      class << self
+        attr_reader :validators
+
+        def inherited(subclass)
+          super
+          @validators << subclass
+        end
+      end
     end
   end
 end
+
+require_relative 'validation_failed_error'
+require_relative 'validator/form'
+require_relative 'validator/url_param'

data/lib/sinatra/param_validator/version.rb

@@ -2,6 +2,6 @@
 
 module Sinatra
   module ParamValidator
-    VERSION = '0.2.0'
+    VERSION = '0.5.0'
   end
 end

data/lib/sinatra/param_validator.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'param_validator/camelize'
 require_relative 'param_validator/definitions'
 require_relative 'param_validator/helpers'
+require_relative 'param_validator/identifier'
 require_relative 'param_validator/parser'
+require_relative 'param_validator/snake_case'
 require_relative 'param_validator/validator'
 require_relative 'param_validator/version'
 
@@ -11,19 +14,33 @@ module Sinatra
   module ParamValidator
     include Camelize
 
-    def validator(identifier:, type: nil, &definition)
-      class_name = 'Sinatra::ParamValidator::Validator'
-      class_name = "#{class_name}::#{camelize(type)}" unless type.nil?
-      settings.validator_definitions.add(identifier, Object.const_get(class_name).new(&definition))
+    def validator(identifier, &definition)
+      settings.validator_definitions.add(identifier, definition)
     end
 
-    def self.registered(app)
-      app.helpers Helpers
-      app.before { filter_params }
-      app.set(:validator_definitions, Definitions.new)
-      app.set(:validate) do |*identifiers|
-        condition do
-          identifiers.each { |identifier| validate identifier }
+    def vi(identifier, *args)
+      Identifier.new(identifier, *args)
+    end
+
+    class << self
+      include SnakeCase
+
+      def registered(app)
+        app.helpers Helpers
+        app.before { filter_params }
+        app.set(:validator_definitions, Definitions.new)
+        validator_conditional app, :validate, Sinatra::ParamValidator::Validator
+
+        Sinatra::ParamValidator::Validator.validators.each do |validator|
+          validator_conditional app, :"validate_#{snake_case(validator.to_s.split('::').last)}", validator
+        end
+      end
+
+      def validator_conditional(app, name, klass)
+        app.set(name) do |*identifiers|
+          condition do
+            identifiers.each { |identifier| validate klass, identifier }
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-param-validator
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Rick Selby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-08 00:00:00.000000000 Z
+date: 2022-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack-test
@@ -142,6 +142,8 @@ files:
 - lib/sinatra/param_validator/camelize.rb
 - lib/sinatra/param_validator/definitions.rb
 - lib/sinatra/param_validator/helpers.rb
+- lib/sinatra/param_validator/identifier.rb
+- lib/sinatra/param_validator/invalid_parameter_error.rb
 - lib/sinatra/param_validator/parameter.rb
 - lib/sinatra/param_validator/parameter/array.rb
 - lib/sinatra/param_validator/parameter/boolean.rb
@@ -157,6 +159,7 @@ files:
 - lib/sinatra/param_validator/rule/all_or_none_of.rb
 - lib/sinatra/param_validator/rule/any_of.rb
 - lib/sinatra/param_validator/rule/one_of.rb
+- lib/sinatra/param_validator/snake_case.rb
 - lib/sinatra/param_validator/validation_failed_error.rb
 - lib/sinatra/param_validator/validator.rb
 - lib/sinatra/param_validator/validator/form.rb