sinatra-param-validator 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c121f205eb49bdae18ff06dd346292bd8c9fc9018468002cf26836728a466449
-  data.tar.gz: eceddebc3e9bcfeef60e69c6e190fc33e360b14458613e20951f7f8fc0b952a2
+  metadata.gz: f474d7b6ff2e2ed3de6f58e3bd0ab0b328cc11886ac36701c5a1557a8713e5be
+  data.tar.gz: 378f0b0bb00df8adca7f951175133833d68ce457066f79423aadb52cab1ba6fb
 SHA512:
-  metadata.gz: 5e629007dc0aa4cf0e6edf751992031d366b6eceea1c615c23b05ad0d05fe3681bfae9346c1139c9c4ad9b0f3c40cf41a815e9b95cf426a772aa4aedd4ecd999
-  data.tar.gz: 89ba7f100e4314453d3fa0d1bee0f6237f56c970fa6580e1cd2a73451f05e9ae2645ff056c7c7eafadb4be531362bdfbc1f8911de48f38ea8eca4229e2df1664
+  metadata.gz: 045a26ac9992b92e1dab3c63527b6ebfd2b70c84b554d20a7f38abfa070f0402da47776d663619c0ae1ff95c681a52ccfb7da34fa2f5c10928c28626c77f75a9
+  data.tar.gz: cefd05d4f4babca139755e05d891802e375732bc944d278a8313e14759e87cd58b300c567e236ccf844897233072ce37e79d9c70f27385babd8b35435008a5c3

data/.rubocop.yml

@@ -18,3 +18,6 @@ Metrics/BlockLength:
 # Extend permitted line length
 Layout/LineLength:
   Max: 120
+
+RSpec/NestedGroups:
+  Max: 4

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 ## [Unreleased]
 
+## [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

@@ -4,10 +4,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in sinatra-param_validator-validator.gemspec
 gemspec
-
-gem 'rake', '~> 13.0'
-gem 'rspec', '~> 3.0'
-gem 'rubocop', '~> 1.21'
-gem 'rubocop-performance', '~> 1.0'
-gem 'rubocop-rake', '~> 0.5'
-gem 'rubocop-rspec', '~> 2.0'

data/Gemfile.lock

@@ -1,19 +1,27 @@
 PATH
   remote: .
   specs:
-    sinatra-param-validator (0.1.0)
+    sinatra-param-validator (0.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
     diff-lcs (1.5.0)
+    multi_json (1.15.0)
+    mustermann (1.1.1)
+      ruby2_keywords (~> 0.0.1)
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
+    rack (2.2.3)
+    rack-protection (2.2.0)
+      rack
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.3.1)
+    regexp_parser (2.4.0)
     rexml (3.2.5)
     rspec (3.11.0)
       rspec-core (~> 3.11.0)
@@ -28,7 +36,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    rubocop (1.29.0)
+    rubocop (1.29.1)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
@@ -37,7 +45,7 @@ GEM
       rubocop-ast (>= 1.17.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.17.0)
+    rubocop-ast (1.18.0)
       parser (>= 3.1.1.0)
     rubocop-performance (1.13.3)
       rubocop (>= 1.7.0, < 2.0)
@@ -47,18 +55,33 @@ GEM
     rubocop-rspec (2.10.0)
       rubocop (~> 1.19)
     ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
+    sinatra (2.2.0)
+      mustermann (~> 1.0)
+      rack (~> 2.2)
+      rack-protection (= 2.2.0)
+      tilt (~> 2.0)
+    sinatra-contrib (2.2.0)
+      multi_json
+      mustermann (~> 1.0)
+      rack-protection (= 2.2.0)
+      sinatra (= 2.2.0)
+      tilt (~> 2.0)
+    tilt (2.0.10)
     unicode-display_width (2.1.0)
 
 PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  rack-test (~> 1.1)
   rake (~> 13.0)
   rspec (~> 3.0)
-  rubocop (~> 1.21)
+  rubocop (~> 1.0)
   rubocop-performance (~> 1.0)
   rubocop-rake (~> 0.5)
   rubocop-rspec (~> 2.0)
+  sinatra-contrib (~> 2.0)
   sinatra-param-validator!
 
 BUNDLED WITH

data/README.md

@@ -1,5 +1,6 @@
 # Sinatra::Param::Validator
 
+Validate parameters in a Sinatra app.
 
 ## Installation
 
@@ -11,9 +12,165 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install sinatra-param-validator
 
-## Usage
+## Sample Usage
+
+```ruby
+validator :user_id do
+  param :id, Integer, required: true
+end
+
+get '/user/:id', validate: :user_id do
+  # ...
+end
+
+validator :new_user do
+  param :name, String, required: true
+  param :age, Integer, required: true, min: 0 
+end
+
+post '/new-user', validate: :new_user do
+  # ...
+end
+```
+
+## Parameter Types
+
+The following parameter types are built-in,
+and values will be coerced to an object of that type.
+
+* `Array`
+  * Accepts a comma-separated list of values, as well as an array
+  * e.g. `a,b,c`
+* `Boolean`
+  * `false|f|no|n|0` or `true|t|yes|y|1`
+* `Date`
+  * All formats accepted by `Date.parse`
+* `Float`
+* `Hash`
+  * Accepts a comma-separated list of colon-separated key-value pairs
+  * e.g. `a:1,b:2,c:3`
+* `Integer`
+* `String`
+* `Time`
+  * All formats accepted by `Time.parse`
+
+Types can be defined using class names or symbols:
+
+```ruby
+param :name, String
+param :tick_box, :boolean 
+```
+
+## Parameter Validations
+
+```ruby
+param :number, Integer, required: true, in: 0..100
+```
+
+All parameters have the following validations available:
+
+* `nillable`
+  * If this is set, all other validations are skipped if the value is nil
+* `required`
+  * The parameter must be present and cannot be nil
+* `in`
+  * The value is in the given array / range
+* `is`
+  * Match a specific value
+
+`Array`, `Hash` and `String` have the following validations:
+
+* `min_length` / `max_length`
+
+`Date`, `Time`, `Float` and `Integer` have the following validations:
+
+* `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.
+
+## Rules
+
+Rules work on multiple parameters:
+
+```ruby
+rule :all_or_none_of, :a, :b
+```
+
+* `all_or_none_of`
+* `any_of`
+  * At least one of the given fields must be present
+* `one_of`
+  * Only one of the given fields can be present
+
+## Validator Types
+
+The default validator will raise `Sinatra::ParamValidator::ValidationFailedError` when validation fails.
+
+There are two other provided validators, that handle failure differently:
+
+* `url_param`
+  * will `halt 403`
+* `form`
+  * if [sinatra-flash](https://github.com/SFEley/sinatra-flash) is available, it will flash the errors and `redirect back`
+  * will provide a JSON object with errors to an XHR request
+  * will `halt 400`
+
+These validators can be invoked with a different conditional on the route:
+
+```ruby
+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
+```
+
 
-TODO: Write usage instructions here
 
 ## Development
 

data/lib/sinatra/param_validator/camelize.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Helpers for validating parameters
+    module Camelize
+      def camelize(symbol)
+        symbol.to_s.split('_').map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/definitions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Store of valid definitions
+    class Definitions
+      def initialize
+        @definitions = {}
+      end
+
+      def add(identifier, validator)
+        raise "Validator already defined: '#{identifier}'" if @definitions.key? identifier
+
+        @definitions[identifier] = validator
+      end
+
+      def get(identifier)
+        raise "Unknown validator: '#{identifier}'" unless @definitions.key? identifier
+
+        @definitions[identifier]
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Helpers for validating parameters
+    module Helpers
+      def filter_params
+        params.each do |(param, value)|
+          params[param] = nil if value == ''
+          params[param] = [] if value == ['']
+        end
+      rescue StandardError => e
+        raise "Filter params failed: #{e}"
+      end
+
+      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
+  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/array.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for arrays
+      class Array
+        include Common
+        include CommonMinMaxLength
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+          return value if value.is_a? ::Array
+          return value.split(',') if value.is_a? ::String
+
+          raise ArgumentError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for booleans
+      class Boolean
+        include Common
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+
+          case value.to_s
+          when /^(false|f|no|n|0)$/i then false
+          when /^(true|t|yes|y|1)$/i then true
+          else raise ArgumentError
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Common validation methods shared between parameters
+      module Common
+        attr_reader :coerced, :errors
+
+        def initialize(value, **options)
+          @errors = []
+          @coerced = coerce value
+          @options = options
+
+          validate_options
+          validate unless nil_and_ok?
+        rescue ArgumentError
+          @errors.push "'#{value}' is not a valid #{self.class}"
+        end
+
+        def valid?
+          @errors.empty?
+        end
+
+        def validate_options
+          @options.each { |key, _| raise "Unknown option '#{key}' for #{self.class}" unless respond_to? key }
+        end
+        private :validate_options
+
+        def validate
+          @options.each { |key, value| method(key).call(value) }
+        end
+        private :validate
+
+        def in(options)
+          @errors.push "Parameter must be within #{options}" unless in? options
+        end
+
+        def in?(options)
+          case options
+          when Range
+            options.include? @coerced
+          else
+            Array(options).include? @coerced
+          end
+        end
+        private :in?
+
+        def is(option_value)
+          @errors.push "Parameter must be #{option_value}" unless @coerced == option_value
+        end
+
+        def nillable(_)
+          # Does nothing. Allows other tests to ignore nil values if present in the options
+        end
+
+        def nil_and_ok?
+          @options.key?(:nillable) && @coerced.nil?
+        end
+        private :nil_and_ok?
+
+        def required(enabled)
+          @errors.push 'Parameter is required' if enabled && @coerced.nil?
+        end
+      end
+
+      # min/max tests
+      module CommonMinMax
+        def max(maximum)
+          return if @coerced.respond_to?(:<=) && @coerced <= maximum
+
+          @errors.push "Parameter cannot be greater than #{maximum}"
+        end
+
+        def min(minimum)
+          return if @coerced.respond_to?(:>=) && @coerced >= minimum
+
+          @errors.push "Parameter cannot be less than #{minimum}"
+        end
+      end
+
+      # min/max length tests
+      module CommonMinMaxLength
+        def max_length(length)
+          return if @coerced.respond_to?(:length) && @coerced.length <= length
+
+          @errors.push "Parameter cannot have length greater than #{length}"
+        end
+
+        def min_length(length)
+          return if @coerced.respond_to?(:length) && @coerced.length >= length
+
+          @errors.push "Parameter cannot have length less than #{length}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'date'
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for dates
+      class Date
+        include Common
+        include CommonMinMax
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+
+          ::Date.parse(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for floats
+      class Float
+        include Common
+        include CommonMinMax
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+
+          Float(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for hashes
+      class Hash
+        include Common
+        include CommonMinMaxLength
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+          return value if value.is_a? ::Hash
+          return value.split(',').to_h { |s| s.split(':') } if value.is_a? ::String
+
+          raise ArgumentError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for integers
+      class Integer
+        include Common
+        include CommonMinMax
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+
+          Integer(value, 10)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for strings
+      class String
+        include Common
+        include CommonMinMaxLength
+
+        def format(format_string)
+          @errors.push "Parameter must match the format #{format_string}" unless @coerced&.match?(format_string)
+        end
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+
+          String(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative 'common'
+
+module Sinatra
+  module ParamValidator
+    class Parameter
+      # Validation for times
+      class Time
+        include Common
+        include CommonMinMax
+
+        private
+
+        def coerce(value)
+          return nil if value.nil?
+
+          ::Time.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/parameter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'camelize'
+require_relative 'parameter/array'
+require_relative 'parameter/boolean'
+require_relative 'parameter/date'
+require_relative 'parameter/float'
+require_relative 'parameter/hash'
+require_relative 'parameter/integer'
+require_relative 'parameter/string'
+require_relative 'parameter/time'
+
+module Sinatra
+  module ParamValidator
+    # Load and validate a single parameter
+    class Parameter
+      class << self
+        include Camelize
+
+        def new(value, type, **args)
+          type = camelize(type) if type.is_a? Symbol
+          klass = Object.const_get "Sinatra::ParamValidator::Parameter::#{type}"
+          klass.new(value, **args)
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require_relative 'invalid_parameter_error'
+require_relative 'parameter'
+require_relative 'rule'
+
+module Sinatra
+  module ParamValidator
+    # Run the definition in the given scope
+    class Parser < SimpleDelegator
+      attr_reader :errors
+
+      def initialize(definition, context, *args)
+        super(context)
+        @context = context
+        @errors = {}
+
+        instance_exec(*args, &definition)
+      end
+
+      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 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
+
+      def rule(name, *args, **kwargs)
+        rule = Rule.new(name, @context.params, *args, **kwargs)
+        unless rule.passes?
+          @errors[:rules] ||= []
+          @errors[:rules].push(rule.errors)
+        end
+      rescue NameError
+        raise 'Invalid rule type'
+      end
+
+      def run_block(key, block)
+        @context.instance_exec(&block)
+      rescue InvalidParameterError => e
+        add_error key, e.message
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/rule/all_or_none_of.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    class Rule
+      # Rule to enforce all given params, or none of them
+      class AllOrNoneOf
+        attr_reader :errors
+
+        def initialize(params, *fields, **_kwargs)
+          @errors = []
+          @params = params
+          @fields = fields
+
+          validate(fields)
+        end
+
+        def passes?
+          @errors.empty?
+        end
+
+        def validate(fields)
+          count = fields.count { |f| @params.key? f }
+          return if count.zero? || count == fields.count
+
+          @errors.push "All or none of [#{fields.join ', '}] must be provided"
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/rule/any_of.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    class Rule
+      # Rule to enforce at least one of the given params exists
+      class AnyOf
+        attr_reader :errors
+
+        def initialize(params, *fields, **_kwargs)
+          @errors = []
+          @params = params
+          @fields = fields
+
+          validate(fields)
+        end
+
+        def passes?
+          @errors.empty?
+        end
+
+        def validate(fields)
+          count = fields.count { |f| @params.key? f }
+          @errors.push "One of [#{fields.join ', '}] must be provided" if count < 1
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/rule/one_of.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    class Rule
+      # Rule to enforce only one of the given params has been given
+      class OneOf
+        attr_reader :errors
+
+        def initialize(params, *fields, **_kwargs)
+          @errors = []
+          @params = params
+          @fields = fields
+
+          validate(fields)
+        end
+
+        def passes?
+          @errors.empty?
+        end
+
+        def validate(fields)
+          count = fields.count { |f| @params.key? f }
+          @errors.push "Only one of [#{fields.join ', '}] is allowed" if count > 1
+          @errors.push "One of [#{fields.join ', '}] must be provided" if count < 1
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/rule.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'camelize'
+require_relative 'rule/all_or_none_of'
+require_relative 'rule/any_of'
+require_relative 'rule/one_of'
+
+module Sinatra
+  module ParamValidator
+    # Class to check a single rule
+    class Rule
+      class << self
+        include Camelize
+
+        def new(name, params, *args, **kwargs)
+          name = camelize(name) if name.is_a? Symbol
+          klass = Object.const_get "Sinatra::ParamValidator::Rule::#{name}"
+          klass.new(params, *args, **kwargs)
+        end
+      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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Error raised when validation fails
+    class ValidationFailedError < StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super("Validation failed: #{errors}")
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/validator/form.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    class Validator
+      # A form validator
+      class Form < Validator
+        def handle_failure(context)
+          case context.request.preferred_type.to_s
+          when 'application/json' then return json_failure(context)
+          when 'text/html'
+            return flash_failure(context) if defined? Sinatra::Flash
+          end
+
+          context.halt 400
+        end
+
+        def run(context)
+          @original_params = context.params
+          super(context)
+        end
+
+        private
+
+        def json_failure(context)
+          context.halt 400, { error: 'Validation failed', fields: @errors }.to_json
+        end
+
+        def flash_failure(context)
+          context.flash[:params] = @original_params
+          context.flash[:form_errors] = @errors
+          context.redirect context.back
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/validator/url_param.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    class Validator
+      # A URL parameter; handle validation failure with
+      class UrlParam < Validator
+        def handle_failure(context)
+          context.halt 403
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/validator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module ParamValidator
+    # Definition of a single validator
+    class Validator
+      attr_reader :errors
+
+      def initialize(&definition)
+        @definition = definition
+        @errors = {}
+      end
+
+      def handle_failure(_context)
+        raise ValidationFailedError, @errors
+      end
+
+      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.1.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/sinatra/param_validator.rb

@@ -1,10 +1,48 @@
 # 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'
 
 module Sinatra
-  # Validator for param
+  # Module to register in Sinatra app
   module ParamValidator
-    # Your code goes here...
+    include Camelize
+
+    def validator(identifier, &definition)
+      settings.validator_definitions.add(identifier, definition)
+    end
+
+    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
   end
 end

data/sinatra-param-validator.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'lib/sinatra/param_validator'
+require_relative 'lib/sinatra/param_validator/version'
 
 Gem::Specification.new do |spec|
   spec.name = 'sinatra-param-validator'
@@ -27,6 +27,12 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_development_dependency 'rack-test', '~> 1.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.0'
+  spec.add_development_dependency 'rubocop-rake', '~> 0.5'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0'
+  spec.add_development_dependency 'sinatra-contrib', '~> 2.0'
 end

metadata

@@ -1,15 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-param-validator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Rick Selby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
-dependencies: []
+date: 2022-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: 
 email:
 - rick@selby-family.co.uk
@@ -27,6 +139,31 @@ files:
 - README.md
 - Rakefile
 - lib/sinatra/param_validator.rb
+- 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
+- lib/sinatra/param_validator/parameter/common.rb
+- lib/sinatra/param_validator/parameter/date.rb
+- lib/sinatra/param_validator/parameter/float.rb
+- lib/sinatra/param_validator/parameter/hash.rb
+- lib/sinatra/param_validator/parameter/integer.rb
+- lib/sinatra/param_validator/parameter/string.rb
+- lib/sinatra/param_validator/parameter/time.rb
+- lib/sinatra/param_validator/parser.rb
+- lib/sinatra/param_validator/rule.rb
+- 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
+- lib/sinatra/param_validator/validator/url_param.rb
 - lib/sinatra/param_validator/version.rb
 - sinatra-param-validator.gemspec
 homepage: https://github.com/rickselby/sinatra-param_validator-validator