sinatra-param-validator 0.3.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54d6ed44b4046ecc9fd330aef4e719cbe10d4a953a8d07a80226822f59ed66d7
-  data.tar.gz: e70164b07f23972aeffa920719c6de35baff4576eed46260944daf3a1b5e404b
+  metadata.gz: 2f824395ffa6b3e38d61c1e4cd81ee2237987c47b04c51abb4cd43d2fdedd2ec
+  data.tar.gz: 9294cc7618a05d263df6f7e7415fdab88b0f6e846b05fce4cac2763d8a79b740
 SHA512:
-  metadata.gz: d4d54fc8f4d76d1499d9c15adec02e35ff2f7c36bf99f5606d15b60a579e45da1c0905624c12be5e4a01b645670a5f23603191cf87fd6be0fd3541c1f94f6afb
-  data.tar.gz: c1c40e3b72dcb644adaf9437b0b7b67cfec8e33efad17ded176b74f3d6cf942fd76d3e4b7bf47f11442ebbb279d08907678e7600813b0b8da37c13736e0fdef4
+  metadata.gz: 17ed2207a700e74b5114ac4b10fb9f8a3f6089d6661df044017a5b36ea558ffec2452e62d7ec0814a5ce30536ab039569cfa45f031960e791caaf57ae253afac
+  data.tar.gz: 8dd242fdf3f379612962ca5897e23e86782b061b16373bfc3dbf4b6e3e22b95e39787027e1499cca36872c9d88b7246871bbb882f6472caadbd5004de7763be4

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.6.0] - 2022-06-09
+
+- Add `block` to run blocks of code in the route context
+
+## [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

data/Gemfile.lock

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

data/README.md

@@ -86,6 +86,52 @@ 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
+```
+
+If you need to run some code in the route context, you can just use the `block` keyword:
+
+```ruby
+block do |validator|
+  #...
+  validator.param :val, Integer
+end
+```
+
 ## Rules
 
 Rules work on multiple parameters:
@@ -120,12 +166,26 @@ 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
+```
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.

data/lib/sinatra/param_validator/helpers.rb

@@ -13,10 +13,11 @@ module Sinatra
         raise "Filter params failed: #{e}"
       end
 
-      def validate(klass, identifier, args = {})
-        definition = settings.validator_definitions.get(identifier)
+      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, *args)
+        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,30 @@ 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 block(&block)
+        run_block :block, block
+      end
+
+      def param(key, type, message: nil, **args, &block)
         parameter = Parameter.new(@context.params[key], type, **args)
-        @context.params[key] = parameter.coerced if @context.params.key? key
-        @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 +49,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/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

@@ -15,8 +15,8 @@ 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?

data/lib/sinatra/param_validator/version.rb

@@ -2,6 +2,6 @@
 
 module Sinatra
   module ParamValidator
-    VERSION = '0.3.0'
+    VERSION = '0.6.0'
   end
 end

data/lib/sinatra/param_validator.rb

@@ -3,6 +3,7 @@
 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'
@@ -17,6 +18,10 @@ module Sinatra
       settings.validator_definitions.add(identifier, definition)
     end
 
+    def vi(identifier, *args)
+      Identifier.new(identifier, *args)
+    end
+
     class << self
       include SnakeCase
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-param-validator
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.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