validate_my_routes 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7bbe49d25595b0b18e832e1296bef3e8ba29cc6d
+  data.tar.gz: de5cbfe90139663a05c9055b6696e7a846fa6f30
+SHA512:
+  metadata.gz: fdb2afba0936e7f025cc4f375a01dcc1312e7bfa466c001e1ea4c7031f6474af968919d6d5151fbed68df6fc374e5cbd3a77582e606f00fa035d577627c72976
+  data.tar.gz: fb517bac0d2b6c368e00b024ad5f35ef3f2aa9a8d575cbf5712b3274764938050a385a96d9174b8afe911c61513a195871513dfed0cd6f47410dc0f3be8b3be3

data/lib/validate_my_routes.rb

@@ -0,0 +1,9 @@
+require_relative 'validate_my_routes/version'
+require_relative 'validate_my_routes/errors'
+require_relative 'validate_my_routes/validation_rules'
+require_relative 'validate_my_routes/validate'
+require_relative 'validate_my_routes/validatable'
+
+# General module that defines the base access to ValidateMyRoutes
+module ValidateMyRoutes
+end

data/lib/validate_my_routes/errors.rb

@@ -0,0 +1,42 @@
+module ValidateMyRoutes
+  # Defining errors
+  module Errors
+    # Base error for validate_my_routes
+    class Error < ::RuntimeError; end
+
+    # Raised when type conversion fails
+    class InvalidTypeError < Error; end
+
+    # Raised when rule is not following required protocol
+    class UnsupportedRuleError < Error; end
+
+    # Raised when using validation DSL and missing validation block
+    class MissingValidationDeclarationBlock < Error; end
+
+    # Raised when using validation DSL when validation rule is already defined
+    class ValidationRuleNamingConflict < Error; end
+
+    # Raised when rule is missused
+    class MissusedRuleError < Error; end
+
+    # Basic error raised for validation failures
+    class ValidationError < Error
+      attr_reader :status_code, :message
+      def initialize(message, status_code)
+        super(message)
+        @status_code = status_code
+        @message = message
+      end
+    end
+
+    # Raised when soft failure occurs
+    class ConditionalValidationError < ValidationError; end
+
+    # Raised when exceptions occurs in validation block
+    class ValidationRaisedAnExceptionError < ValidationError
+      def initialize(custom_exception, status_code)
+        super(custom_exception.to_s, status_code)
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validatable.rb

@@ -0,0 +1,102 @@
+module ValidateMyRoutes
+  # Route parameters validation extension
+  # To start using it, the extension needs to be registered
+  #
+  #   register ValidateMyRoutes::Validatable
+  #
+  # Registering Validatable extension adds two conditions:
+  #  - validate_all_params - a list of rules that need to be applied to all parameters together
+  #  - validate_params - a hash with parameter names as keys and rules with extra information
+  #      in values
+  module Validatable
+    class << self
+      def registered(app)
+        add_validate_params_condition_to app
+        add_validate_all_params_condition_to app
+      end
+
+      private
+
+      def add_validate_all_params_condition_to(app)
+        app.set(:validate_all_params) do |*rules|
+          condition do
+            rules.all? { |rule| Validate.validate!(self, rule, params, false) }
+          end
+        end
+      end
+
+      # rubocop:disable AbcSize
+      def add_validate_params_condition_to(app)
+        app.set(:validate_params) do |*validations|
+          condition do
+            path_validations = validations.select { |_, rule| rule[:path_param] }
+            query_validations = validations.reject { |_, rule| rule[:path_param] }
+
+            [path_validations, query_validations].all? do |param_validations|
+              param_validations.select { |_, rule| rule[:path_param] }.all? do |param_name, rule|
+                value = params[param_name]
+                Validate.validate!(self, rule[:rule], value, rule[:path_param], param_name)
+              end
+            end
+          end
+        end
+      end
+    end
+    # rubocop:enable AbcSize
+
+    # Define path parameter with validation for all routes (including nested routes)
+    #
+    #   param_validation :service_id, from_enum(%w[a b c])
+    def param_validation(name, rule)
+      Validate::Rules.validate_single_param_rule! rule
+      (@param_validations ||= {})[name.to_sym] = rule
+    end
+
+    # Define all parameters validation for a single route
+    #
+    #   all_params_validation at_least_one_of(%i[version class status owner])
+    #   get '/' do
+    #     # params contain at least one of :version, :class, :status or :owner parameter
+    #   end
+    def all_params_validation(rule)
+      Validate::Rules.validate_all_params_rule! rule
+      (@all_params_validation ||= []) << rule
+    end
+
+    # Hook into .route Sinatra method to add validation for parameters
+    def route(verb, route_pattern, conditions = {}, &block)
+      route_path_parameters(route_pattern).each do |name|
+        next unless param_validations.key? name
+
+        rule = param_validations[name]
+        # Add path parameter validation if it was specified
+        (conditions[:validate_params] ||= {})[name] ||= { path_param: true, rule: rule }
+      end
+
+      # Add all params validation if it was specified
+      conditions[:validate_all_params] = @all_params_validation if @all_params_validation
+      @all_params_validation = nil # remove params validation as it is defined on per-route bases
+
+      super(verb, route_pattern, conditions, &block)
+    end
+
+    def route_path_parameters(route_pattern)
+      path_parameters = route_pattern.split('/').map do |part|
+        part.start_with?(':') ? part[1..-1].to_sym : nil
+      end
+
+      path_parameters.flatten.compact.uniq.map(&:to_sym)
+    end
+
+    protected
+
+    def param_validations
+      parameters_defined_in_superclass = {}
+      # For nested routes we need to look for defined parameters with validation in
+      # superclass also.
+      parameters_defined_in_superclass = superclass.param_validations \
+        if superclass.respond_to?(:param_validations, true)
+      parameters_defined_in_superclass.merge(@param_validations || {})
+    end
+  end
+end

data/lib/validate_my_routes/validate.rb

@@ -0,0 +1,27 @@
+require_relative 'validate/convert_to_type'
+require_relative 'validate/rules'
+
+module ValidateMyRoutes
+  # Module for validation. Provides method to validate value by specified rule.
+  module Validate
+    class << self
+      # Perform validation of a single rule in-place
+      # Note: this method is not validating that rule is for all parameters or just a single
+      # Example:
+      #
+      #    get 'some/:id' do |id|
+      #      ValidateMyRoutes::Validate.validate!(self, greater_than(5), id.to_i, 'id') do |msg|
+      #        halt 400, "Id <#{id}> failed validation: #{msg}"
+      #      end
+      #    end
+      def validate!(app, rule, *args)
+        rule.validate!(app, *args)
+      rescue Errors::ConditionalValidationError
+        false
+      rescue Errors::ValidationError => failure
+        app.halt failure.status_code, failure.message unless block_given?
+        yield failure.message
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/convert_to_type.rb

@@ -0,0 +1,80 @@
+require 'time'
+
+module ValidateMyRoutes
+  module Validate
+    # ConvertToType module provides single method convert_to_type to convert value into type
+    # to_type. Conversion can fail with InvalidTypeError.
+    module ConvertToType
+      class << self
+        Boolean         = :Boolean # rubocop:disable Naming/ConstantName
+        SIMPLE_TYPES    = [Float, String, Date, Time, DateTime, Integer].freeze
+        COMPOSITE_TYPES = [Array, Hash].freeze
+        BOOLEAN_TYPES   = [Boolean, TrueClass, FalseClass].freeze
+
+        def convert_to_type(value, to_type)
+          return value if already_of_type?(value, to_type)
+
+          if SIMPLE_TYPES.include?(to_type)
+            parse_simple_type(value, to_type)
+          elsif COMPOSITE_TYPES.include?(to_type)
+            parse_composite_type(value, to_type)
+          elsif BOOLEAN_TYPES.include?(to_type)
+            parse_boolean(value)
+          else
+            raise_unknown_type(to_type)
+          end
+        rescue ArgumentError
+          raise_with_invalid_type(value, to_type)
+        end
+
+        private
+
+        def already_of_type?(value, typ)
+          (typ.is_a?(Class) || typ.is_a?(Module)) && value.is_a?(typ)
+        end
+
+        def parse_simple_type(value, to_type)
+          if to_type == Integer
+            Integer(value)
+          elsif [Float, String].include?(to_type)
+            Kernel.send(to_type.to_s.to_sym, value)
+          elsif to_type.respond_to? :parse
+            to_type.parse(value)
+          else
+            raise_unknown_type(to_type)
+          end
+        end
+
+        def parse_composite_type(value, to_type)
+          if to_type == Array
+            value.split(',')
+          elsif to_type == Hash
+            Hash[value.split(',').map { |item| item.split(':') }]
+          else
+            raise_unknown_type(to_type)
+          end
+        end
+
+        def parse_boolean(value)
+          if value.to_s.casecmp('false').zero?
+            false
+          elsif value.to_s.casecmp('true').zero?
+            true
+          else
+            raise_with_invalid_type(value, Boolean)
+          end
+        end
+
+        def raise_with_invalid_type(value, type)
+          raise ValidateMyRoutes::Errors::InvalidTypeError,
+                "'#{value}' is not a valid '#{type}'"
+        end
+
+        def raise_unknown_type(type)
+          raise ValidateMyRoutes::Errors::InvalidTypeError,
+                "don't know how to convert type '#{type}'"
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/mixins/macros.rb

@@ -0,0 +1,51 @@
+module ValidateMyRoutes
+  module Validate
+    # Helper functions to provide a DSL for creating validation rules
+    module Macros
+      # Define all parameters validation
+      #
+      # validate do |params|
+      #   params.key? 'some_parameter_name'
+      # end
+      def validate(&block)
+        define_method(:validate, &block)
+      end
+
+      # Customize validation rule description
+      #
+      # description do
+      #   'this is my custom validation rule description'
+      # end
+      def description(&block)
+        define_method(:description, &block)
+      end
+
+      # Customize message returned when validation fails for all parameters
+      #
+      # failure_message do |params|
+      #   "oh no! validation failed for #{params}"
+      # end
+      def failure_message(&block)
+        define_method(:failure_message, &block)
+      end
+
+      # Customize message returned when opposite rule validation fails (not of type A)
+      #
+      # failure_message_when_negated do |params|
+      #   "oh no! validation failed for #{params}, but it was not expected"
+      # end
+      def failure_message_when_negated(&block)
+        define_method(:failure_message_when_negated, &block)
+      end
+
+      # Customize http status code of the failure
+      #
+      # failure_code do |in_path|
+      #   in_path ? 404 : 400
+      # end
+      def failure_code(&block)
+        define_method(:failure_code, &block)
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/mixins/rules_combinators.rb

@@ -0,0 +1,30 @@
+module ValidateMyRoutes
+  module Validate
+    # Helper functions to provide a DSL for creating validation rules
+    module RulesCombinators
+      # Negate the rule to validate opposite expectation
+      #
+      #     is_an_integer = of_type(Integer)
+      #     is_not_an_integer = of_type(Integer).negate
+      def negate
+        ValidateMyRoutes::ValidationRules.not self
+      end
+
+      # Chain rule with another one to perform both validations
+      # Note that if first rule fails validation, second is ignored
+      #
+      #     required.and of_type(Integer)
+      def and(other_rule)
+        ValidateMyRoutes::ValidationRules.and(self, other_rule)
+      end
+
+      # Chain rule with another one to perform one or another validations
+      # Note that second validation will be performed only if first fails
+      #
+      #     eql('all').or of_type(Integer)
+      def or(other_rule)
+        ValidateMyRoutes::ValidationRules.or(self, other_rule)
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules.rb

@@ -0,0 +1,61 @@
+require_relative 'validation_rule'
+
+require_relative 'rules/compound'
+require_relative 'rules/anything'
+require_relative 'rules/comparable'
+require_relative 'rules/conditional'
+require_relative 'rules/of_type'
+require_relative 'rules/required'
+require_relative 'rules/transforms'
+require_relative 'rules/enum'
+require_relative 'rules/all_parameters'
+
+module ValidateMyRoutes
+  module Validate
+    # Module provides methods to validate if rule is a rule and if it can be used for single
+    # or all parameters validation.
+    module Rules
+      class << self
+        REQUIRED_RULE_METHODS = %i[validate! description rule_type].freeze
+
+        def single_param_rule?(rule)
+          validation_rule?(rule) && %i[single_param general].include?(rule.rule_type)
+        end
+
+        def all_params_rule?(rule)
+          validation_rule?(rule) && %i[all_params general].include?(rule.rule_type)
+        end
+
+        # Validate that rule can be used for single parameter validation
+        #
+        # Example:
+        #
+        #    Rules.validate_single_param_rule! required(:q) # => throws an exception
+        def validate_single_param_rule!(rule)
+          return if Rules.single_param_rule?(rule)
+          raise ValidateMyRoutes::Errors::UnsupportedRuleError,
+                "rule #{rule} must implement #{REQUIRED_RULE_METHODS.join(', ')} " \
+                'and be either :generic or :single_param rule type.'
+        end
+
+        # Validate that rule can be used for all parameters validation
+        #
+        # Example:
+        #
+        #    Rules.validate_all_params_rule! of_type(Integer) # => throws an exception
+        def validate_all_params_rule!(rule)
+          return if Rules.all_params_rule?(rule)
+          raise ValidateMyRoutes::Errors::UnsupportedRuleError,
+                "rule #{rule} must implement #{REQUIRED_RULE_METHODS.join(', ')} " \
+                'and be either :generic or :all_params rule type.'
+        end
+
+        private
+
+        def validation_rule?(rule)
+          REQUIRED_RULE_METHODS.all? { |method_name| rule.respond_to? method_name }
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/all_parameters.rb

@@ -0,0 +1,75 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Validation rules that designed to be used for validating all parameters
+      # in the route.
+      #
+      # For example if we need to allow specifying "all" or "search" criteria,
+      # but not both at the same time.
+      module AllParameters
+        ValidateMyRoutes::ValidationRules.def_all_params_validator :only_one_of do |names|
+          raise Errors::MissusedRuleError, 'names must be an array' unless names.is_a? Array
+
+          validate do |params|
+            present_parameters_count = names.count { |name| params.key? name.to_s }
+            present_parameters_count <= 1
+          end
+
+          description { "only one of <#{names.join(', ')}> parameters" }
+
+          failure_message do |actual|
+            "was expected to have only one of <#{names.join(', ')}> parameters, " \
+            "but <#{actual.keys.join(', ')}> #{actual.size > 1 ? 'were' : 'was'} provided"
+          end
+
+          failure_message_when_negated do |actual|
+            "was expected to have all of <#{names.join(', ')}> parameters, " \
+            "but <#{actual.keys.join(', ')}> #{actual.size > 1 ? 'were' : 'was'} provided"
+          end
+        end
+
+        ValidateMyRoutes::ValidationRules.def_all_params_validator :exactly_one_of do |names|
+          raise Errors::MissusedRuleError, 'names must be an array' unless names.is_a? Array
+
+          validate do |params|
+            present_parameters_count = names.count { |name| params.key? name.to_s }
+            present_parameters_count == 1
+          end
+
+          description { "exactly one of <#{names.join(', ')}> parameters" }
+
+          failure_message do |actual|
+            "was expected to have exactly one of <#{names.join(', ')}> parameters, " \
+            "but <#{actual.keys.join(', ')}> #{actual.size > 1 ? 'were' : 'was'} provided"
+          end
+
+          failure_message_when_negated do |actual|
+            "was expected to have none or more than one of <#{names.join(', ')}>, " \
+            "but <#{actual.keys.join(', ')}> #{actual.size > 1 ? 'were' : 'was'} provided"
+          end
+        end
+
+        ValidateMyRoutes::ValidationRules.def_all_params_validator :at_least_one_of do |names|
+          raise Errors::MissusedRuleError, 'names must be an array' unless names.is_a? Array
+
+          validate do |params|
+            present_parameters_count = names.count { |name| params.key? name.to_s }
+            present_parameters_count >= 1
+          end
+
+          description { "at least one of <#{names.join(', ')}> parameters" }
+
+          failure_message do |actual|
+            "was expected to have at least one of <#{names.join(', ')}> parameters, " \
+            "but <#{actual.keys.join(', ')}> #{actual.size > 1 ? 'were' : 'was'} provided"
+          end
+
+          failure_message_when_negated do |actual|
+            "was expected to have none of <#{names.join(', ')}>, " \
+            "but <#{actual.keys.join(', ')}> #{actual.size > 1 ? 'were' : 'was'} provided"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/anything.rb

@@ -0,0 +1,13 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Always successful validation rule
+      module Anything
+        ValidateMyRoutes::ValidationRules.def_validation_rule :anything do
+          validate { |*_| true }
+          description { 'anything' }
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/comparable.rb

@@ -0,0 +1,82 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # List of comparison rules
+      module Comparable
+        VR = ValidateMyRoutes::ValidationRules
+
+        VR.def_single_param_validator :eql do |expected|
+          validate { |actual, _| actual == expected }
+          description { "equal to <#{expected}>" }
+          failure_message do |actual, name|
+            "was expected #{name} parameter to equal <#{expected}>, but was <#{actual}>"
+          end
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to not equal <#{expected}>, but was <#{actual}>"
+          end
+        end
+
+        VR.def_single_param_validator :greater_than do |expected|
+          validate { |actual, _| actual > expected }
+          description { "greater than <#{expected}>" }
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be greater than <#{expected}>, but was <#{actual}>"
+          end
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to be less than or equal to <#{expected}>, " \
+            "but was <#{actual}>"
+          end
+        end
+
+        VR.def_single_param_validator :greater_than_or_equal_to do |expected|
+          validate { |actual, _| actual >= expected }
+          description { "greater than or equal to <#{expected}>" }
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be greater than or equal to <#{expected}>, " \
+            "but was <#{actual}>"
+          end
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to be less than <#{expected}>, but was <#{actual}>"
+          end
+        end
+
+        VR.def_single_param_validator :less_than do |expected|
+          validate { |actual, _| actual < expected }
+          description { "less than <#{expected}>" }
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be less than <#{expected}>, but was <#{actual}>"
+          end
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to be greater than or equal to <#{expected}>, " \
+            "but was <#{actual}>"
+          end
+        end
+
+        VR.def_single_param_validator :less_than_or_equal_to do |expected|
+          validate { |actual, _| actual <= expected }
+          description { "less than or equal to <#{expected}>" }
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be less than or equal to <#{expected}>, " \
+            "but was <#{actual}>"
+          end
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to be greater than <#{expected}>, but was <#{actual}>"
+          end
+        end
+
+        VR.def_single_param_validator :between do |min, max|
+          validate { |actual, _| actual >= min && actual <= max }
+          description { "between <#{min}> and <#{max}>" }
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be between <#{min}> and <#{max}>, " \
+            "but was <#{actual}>"
+          end
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to be less than <#{min}> or greater than <#{max}>, " \
+            "but was <#{actual}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/compound.rb

@@ -0,0 +1,41 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Rules combinators
+      # TODO: add validations to the rules before combining them
+      module Compound
+        ValidateMyRoutes::ValidationRules.def_validation_rule :not do |rule|
+          validate do |*args|
+            begin
+              !check(rule, *args)
+            rescue Errors::ValidationError
+              true
+            end
+          end
+
+          failure_message { |*args| rule.failure_message_when_negated(*args) }
+          failure_message_when_negated { |*args| rule.failure_message(*args) }
+          description { "NOT #{rule.description}" }
+          failure_code { |*args| rule.failure_code(*args) }
+        end
+
+        ValidateMyRoutes::ValidationRules.def_validation_rule :and do |first_rule, second_rule|
+          validate { |*args| check(first_rule, *args) && check(second_rule, *args) }
+          description { "(#{first_rule.description} AND #{second_rule.description})" }
+        end
+
+        ValidateMyRoutes::ValidationRules.def_validation_rule :or do |first_rule, second_rule|
+          validate do |*args|
+            begin
+              check(first_rule, *args) || check(second_rule, *args)
+            rescue Errors::ValidationError
+              check(second_rule, *args)
+            end
+          end
+
+          description { "(#{first_rule.description} OR #{second_rule.description})" }
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/conditional.rb

@@ -0,0 +1,21 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Validation rule that on failure instruct Sinatra to search for another route instead of
+      # failing with validation error
+      module Conditional
+        ValidateMyRoutes::ValidationRules.def_validation_rule :conditional do |rule|
+          validate do |*args|
+            begin
+              check(rule, *args)
+            rescue Errors::ValidationError => error
+              raise Errors::ConditionalValidationError.new(error.message, error.status_code)
+            end
+          end
+
+          description { "conditional, #{rule.description}" }
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/enum.rb

@@ -0,0 +1,21 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Always successful validation rule
+      module Enum
+        ValidateMyRoutes::ValidationRules.def_single_param_validator :from_enum do |values|
+          unless values.respond_to? :include?
+            raise Errors::MissusedRuleError, 'from_enum rule requires #include? method on ' \
+                                             'expectation'
+          end
+          validate { |actual, _| values.include? actual }
+          failure_message do |actual, name|
+            "parameter <#{name}> was expected to have one of following values: " \
+            "<#{values.join ', '}>, but was <#{actual}>"
+          end
+          description { "of enum type with values: #{values.join(', ')}" }
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/of_type.rb

@@ -0,0 +1,31 @@
+require_relative '../convert_to_type'
+
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Rule to validate type of parameter
+      module OfType
+        ValidateMyRoutes::ValidationRules.def_single_param_validator :of_type do |typ|
+          validate do |actual, _|
+            begin
+              ConvertToType.convert_to_type(actual, typ)
+              true
+            rescue ValidateMyRoutes::Errors::InvalidTypeError
+              false
+            end
+          end
+
+          description { "of a type <#{typ}>" }
+
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be of a type <#{typ}>, but was <#{actual}>"
+          end
+
+          failure_message_when_negated do |actual, name|
+            "was expected #{name} parameter to not be of a type <#{typ}>, but was <#{actual}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/required.rb

@@ -0,0 +1,17 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Validation rule that fails if parameter was not provided
+      module Required
+        ValidateMyRoutes::ValidationRules.def_all_params_validator :required do |parameter_name|
+          validate { |params| params.key? parameter_name.to_s }
+          description { "parameter <#{parameter_name}> is required" }
+          failure_message { |_| "parameter <#{parameter_name}> was expected to be present" }
+          failure_message_when_negated do |_|
+            "parameter <#{parameter_name}> was expected not to be present"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/rules/transforms.rb

@@ -0,0 +1,50 @@
+module ValidateMyRoutes
+  module Validate
+    module Rules
+      # Rules that perform transformation of value before sending it to another rule
+      module Transforms
+        ValidateMyRoutes::ValidationRules.def_single_param_validator :value_as do |typ, rule|
+          validate do |actual, name|
+            begin
+              converted_value = ConvertToType.convert_to_type(actual, typ)
+              check(rule, converted_value, name)
+            rescue ValidateMyRoutes::Errors::InvalidTypeError
+              false
+            end
+          end
+
+          description { rule.description }
+
+          failure_message do |actual, name|
+            "was expected #{name} parameter to be of type <#{typ}>, but was <#{actual}>"
+          end
+
+          failure_message_when_negated do |_, _|
+            # TODO: make sure that not(value_as(...)) can not be used instead of failing here
+            raise Errors::MissusedRuleError, 'value_as does not support negate operation'
+          end
+
+          failure_code { |*args| rule.failure_code(*args) }
+        end
+
+        ValidateMyRoutes::ValidationRules.def_validation_rule :transform do |transformation, rule|
+          description { rule.description }
+          validate do |*args|
+            if args.size == 2
+              # this means single parameter validation with value and name
+              check(rule, transformation.call(args[0]), args[1])
+            elsif args.size == 1
+              # this means all parameters validation with value only
+              check(rule, transformation.call(args[0]))
+            else
+              raise Errors::MissusedRuleError, "Received #{args.size} instead of 1 or 2"
+            end
+          end
+          failure_message { |*args| rule.failure_message(*args) }
+          failure_message_when_negated { |*args| rule.failure_message_when_negated(*args) }
+          failure_code { |*args| rule.failure_code(*args) }
+        end
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validate/validation_rule.rb

@@ -0,0 +1,123 @@
+require_relative 'mixins/macros'
+require_relative 'mixins/rules_combinators'
+
+module ValidateMyRoutes
+  module Validate
+    # ValidationRule is a base class for all rules
+    class ValidationRule
+      # Add DSL support for declarations in constructor
+      extend Macros
+      include RulesCombinators
+
+      attr_reader :rule_type
+
+      def initialize(rule_name, rule_type, *expected, declarations)
+        self.rule_name = rule_name
+        self.rule_type = rule_type
+        self.app = nil # this is a Sinatra application instance
+        singleton_class.class_exec(*expected, &declarations)
+      end
+
+      # Current method can be used for validation
+      def validate!(app, value, path_param, *args)
+        # save current Sinatra app instance for method lookup on it
+        self.app = app
+
+        self.value = value
+        self.path_param = path_param == true
+
+        validate(value, *args) || fail_validation(failure_message(value, *args))
+      rescue Errors::ValidationError
+        # validation failed, so just re-raise an error to buble it up to the root
+        # re-raising is needed in order to catch all other exceptions to wrap them in
+        # special error
+        raise
+      rescue => ex # rubocop:disable Style/RescueStandardError
+        # unexpected exception happened in validation block, so we should wrap it in special error
+        raise Errors::ValidationRaisedAnExceptionError.new(ex, failure_code(path_param?))
+      end
+
+      def validate(*_args)
+        raise Errors::MissusedRuleError, 'validate method not implemented'
+      end
+
+      def description
+        rule_name.to_s.capitalize.tr('_', ' ')
+      end
+
+      def failure_code(in_path)
+        in_path ? 404 : 400
+      end
+
+      def failure_message(*args)
+        if args.size == 1
+          "parameters were expected to satisfy: #{description} but were <#{args[0]}>"
+        elsif args.size == 2
+          "parameter #{args[1]} was expected to satisfy: #{description} but was <#{args[0]}>"
+        else
+          raise Errors::MissusedRuleError, "failure_message method called with #{args.size} " \
+                                           'arguments'
+        end
+      end
+
+      def failure_message_when_negated(*args)
+        if args.size == 1
+          "parameters were expected not to satisfy: #{description} but were <#{args[0]}>"
+        elsif args.size == 2
+          "parameter #{args[1]} was expected not to satisfy: #{description} but was <#{args[0]}>"
+        else
+          raise Errors::MissusedRuleError, 'failure_message_when_negated method called with ' \
+                                           "#{args.size} arguments"
+        end
+      end
+
+      # Expand method lookup to the application scope
+      def method_missing(method_name, *args, &block)
+        app && app.respond_to?(method_name) ? app.send(method_name, *args, &block) : super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        super || app.respond_to?(method_name) || super
+      end
+
+      private
+
+      attr_accessor :app, :value, :path_param, :rule_name
+      attr_writer :rule_type
+
+      # Helper method to perform validation of other rules inside validation block
+      #
+      #    validate do |params|
+      #      # make use of built in validation rules in custom validations
+      #      check(of_type(Integer), params[:id], :id)
+      #      # or validate all parameters
+      #      check(required(:id), params)
+      #    end
+      def check(rule, value, *args)
+        if args.empty?
+          ValidateMyRoutes::Validate::Rules.validate_all_params_rule! rule
+        elsif args.size == 1
+          ValidateMyRoutes::Validate::Rules.validate_single_param_rule! rule
+        else
+          raise Errors::MissusedRuleError, "check method called with #{args.size} arguments"
+        end
+
+        rule.validate!(app, value, path_param?, *args)
+      end
+
+      # Helper method to fail validation
+      #
+      #    validate do |params|
+      #      fail_validation 'no!' if params.size > 1
+      #    end
+      def fail_validation(message, code = nil)
+        code ||= failure_code(path_param?)
+        raise Errors::ValidationError.new(message, code)
+      end
+
+      def path_param?
+        path_param
+      end
+    end
+  end
+end

data/lib/validate_my_routes/validation_rules.rb

@@ -0,0 +1,29 @@
+require_relative './validate/validation_rule'
+
+module ValidateMyRoutes
+  # Mixin to add custom rules to the application.
+  #
+  # To create custom rule you can extend your class with ValidationRules:
+  #   extend ValidateMyRoutes::ValidationRules
+  module ValidationRules
+    module_function
+
+    def def_single_param_validator(name, &declarations)
+      def_validation_rule name, :single_param, &declarations
+    end
+
+    def def_all_params_validator(name, &declarations)
+      def_validation_rule name, :all_params, &declarations
+    end
+
+    def def_validation_rule(name, typ = :general, &declarations)
+      raise Errors::MissingValidationDeclarationBlock unless block_given?
+      raise Errors::ValidationRuleNamingConflict, name.to_sym if respond_to? name.to_sym
+
+      rule = ->(*expected) { Validate::ValidationRule.new(name, typ, *expected, declarations) }
+
+      define_method(name, rule)
+      define_singleton_method(name, rule)
+    end
+  end
+end

data/lib/validate_my_routes/version.rb

@@ -0,0 +1,4 @@
+# ValidateMyRoutes version
+module ValidateMyRoutes
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: validate_my_routes
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Workday, Ltd.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ValidateMyRoutes provides a way to annotate Sinatra routes and validate
+  parameters before executing the route
+email:
+- prd.eng.os@workday.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/validate_my_routes.rb
+- lib/validate_my_routes/errors.rb
+- lib/validate_my_routes/validatable.rb
+- lib/validate_my_routes/validate.rb
+- lib/validate_my_routes/validate/convert_to_type.rb
+- lib/validate_my_routes/validate/mixins/macros.rb
+- lib/validate_my_routes/validate/mixins/rules_combinators.rb
+- lib/validate_my_routes/validate/rules.rb
+- lib/validate_my_routes/validate/rules/all_parameters.rb
+- lib/validate_my_routes/validate/rules/anything.rb
+- lib/validate_my_routes/validate/rules/comparable.rb
+- lib/validate_my_routes/validate/rules/compound.rb
+- lib/validate_my_routes/validate/rules/conditional.rb
+- lib/validate_my_routes/validate/rules/enum.rb
+- lib/validate_my_routes/validate/rules/of_type.rb
+- lib/validate_my_routes/validate/rules/required.rb
+- lib/validate_my_routes/validate/rules/transforms.rb
+- lib/validate_my_routes/validate/validation_rule.rb
+- lib/validate_my_routes/validation_rules.rb
+- lib/validate_my_routes/version.rb
+homepage: https://github.com/Workday/validate_my_routes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A simple gem to validate Sinatra routes
+test_files: []