sinatra-param-validator 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c121f205eb49bdae18ff06dd346292bd8c9fc9018468002cf26836728a466449
-  data.tar.gz: eceddebc3e9bcfeef60e69c6e190fc33e360b14458613e20951f7f8fc0b952a2
+  metadata.gz: dda1b5487b870b26f4b2ca5c6a575a57c91441ac319b78567295ab0b4517a8bc
+  data.tar.gz: 331f3cace8d87a35fa410ae28c3df15e07f851d276ad2a2173ce799572cfae04
 SHA512:
-  metadata.gz: 5e629007dc0aa4cf0e6edf751992031d366b6eceea1c615c23b05ad0d05fe3681bfae9346c1139c9c4ad9b0f3c40cf41a815e9b95cf426a772aa4aedd4ecd999
-  data.tar.gz: 89ba7f100e4314453d3fa0d1bee0f6237f56c970fa6580e1cd2a73451f05e9ae2645ff056c7c7eafadb4be531362bdfbc1f8911de48f38ea8eca4229e2df1664
+  metadata.gz: caceb492da8562135850ecf1c7a77ecd4fd850ab31d714ff1fa555c4316e63074aa7ed9f75e331336ddf30c1921a5d3cc2f895447d7ec76f3767b46448e6a7c4
+  data.tar.gz: 729686317687d72ff23ce570991a88e6731314320f3e702ba631c7452b75e117997fc30207c2cee7be52c1aa458424311666b734061bb7c3aefb6911b07a9dc2

data/.rubocop.yml

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

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.2.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,115 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install sinatra-param-validator
 
-## Usage
+## Sample Usage
 
-TODO: Write usage instructions here
+```ruby
+validator identifier: :user_id do
+  param :id, Integer, required: true
+end
+
+get '/user/:id', validate: :user_id do
+  # ...
+end
+
+validator identifier: :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`
+
+## 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 set when a validator is defined:
+
+```ruby
+validator type: :form, identifier: :new_user do
+  param :name, String, required: true
+  param :age, Integer, required: true, min: 0 
+end
+```
 
 ## 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,23 @@
+# 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(identifier, args = {})
+        validator = settings.validator_definitions.get(identifier)
+        validator.run(self, *args)
+        validator.handle_failure(self) unless validator.success?
+      end
+    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,41 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+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)
+        super(context)
+        @context = context
+        @errors = {}
+
+        instance_exec({}, &definition)
+      end
+
+      def param(key, type, **args)
+        parameter = Parameter.new(@context.params[key], type, **args)
+        @context.params[key] = parameter.coerced
+        @errors[key] = parameter.errors unless parameter.valid?
+      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
+    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/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, msg = nil)
+        @errors = errors
+        super(msg)
+      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,31 @@
+# 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
+    class Validator
+      attr_reader :errors
+
+      def initialize(&definition)
+        @definition = definition
+        @errors = {}
+      end
+
+      def handle_failure(_context)
+        raise ValidationFailedError, @errors
+      end
+
+      def run(context)
+        @errors = Parser.new(@definition, context).errors
+      end
+
+      def success?
+        @errors.empty?
+      end
+    end
+  end
+end

data/lib/sinatra/param_validator/version.rb

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

data/lib/sinatra/param_validator.rb

@@ -1,10 +1,31 @@
 # frozen_string_literal: true
 
+require_relative 'param_validator/definitions'
+require_relative 'param_validator/helpers'
+require_relative 'param_validator/parser'
+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:, 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))
+    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 }
+        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.2.0
 platform: ruby
 authors:
 - Rick Selby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
-dependencies: []
+date: 2022-06-08 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,28 @@ 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/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/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