sinatra-params-validator 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gem 'rack', '1.5.2'
+gem 'sinatra', '1.4.2'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 tsov, lube8uy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+# sinatra-params-validator
+========================
+
+## Description
+
+This sinatra module validates the incoming parameter and lets you configure the pattern.
+Once it's registered with your sinatra app, it will act as a before filter, that validates your parameters.
+You can configure it with the newly available sinatra method `validation_required`.
+
+## Sinatra Module
+
+Configure your routes to require parameters and validate their values. If the
+validator finds errors, it will execute sinatras halt method, which will prevent
+invocation of your sinatra code block, and set the response status to 400. The missing
+or invalid parameters can be found in the environment variable, like in the example
+below. That means you can customize your own error responses, for example by catching the errors
+with some middleware.
+
+### Examples
+
+```ruby
+require 'sinatra'
+
+class App < Sinatra::Base
+  register Rack::Validator::Sinatra
+
+  helpers do
+    def missing_parameters
+      @env['validator.missing']
+    end
+
+    def invalid_parameters
+      @env['validator.invalid']
+    end
+
+    def messages
+      @env['validator.messages']
+    end
+  end
+
+  after do
+    puts missing_parameters
+    puts invalid_parameters
+    puts messages
+    puts params
+  end
+
+  validation_required :GET, '/', :params => [
+    { :name => :name, :required => true },
+    { :name => :email, :type => :email, :required => true },
+    { :name => :age, :range => [ 0, 120 ], :default => 1000 },
+    { :name => :latitude, :type => :float, :default => 0.0 },
+    { :name => :longitude, :type => :float, :default => 0.0 },
+    { :name => :message },
+    { :name => :price, :matches => /^[\d]*.[\d]{2}$/ }
+  ]
+
+  get '/' do
+
+  end
+
+  validation_required :POST, '/group', :params => [
+    { :name => :name, :required => true }
+  ]
+
+  post '/group' do
+
+  end
+
+end
+```
+
+Try it out yourself and run this in the root directory `rackup example/app.rb`.
+
+## Validator class
+
+A class with several methods to validate and clean data from sinatra params holder.
+Can be used for an adopter for other libraries/frameworks, like rails.
+
+### Examples
+
+Initialize class in lazy mode, this means that once a validation fail the following ones are not executed:
+
+```ruby
+validator = Rack::Validator.new(params)
+#required_3 is not present
+validator.required [:required_1, :required_2, :required_3]
+validator.trim
+validator.downcase [:required_2, :other_param]
+validator.is_in_range 3, 32, :required_1
+validator.is_email :contact
+validator.matches /[a-z]{2}_[A-Z]{2}|[a-z]{2}/i, :locale
+
+if validator.has_errors?
+  p validator.messages.join('|')
+  #Inputs "required_3 is required"
+end
+```
+
+If you want to get all the errors at the end of the validation calls pass false as second parameter in the constructor:
+	validator = Rack::Validator.new(params, true)
+	
+Available methods:
+
+* trim
+* downcase
+* required
+* is_integer
+* is_float
+* is_greater_equal_than
+* is_in_range
+* is_less_equal_than
+* is_email
+* matches
+
+To see more examples check tests/params_validator_spec.rb

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rack/validator/sinatra.rb

@@ -0,0 +1,234 @@
+require 'rack'
+
+module Rack
+  class Validator
+
+    attr_reader :invalid_params
+    attr_reader :missing_params
+    attr_reader :messages
+    attr_accessor :lazy_mode
+
+    def initialize(params, lazy_mode = true)
+      @params = params
+      @invalid_params = []
+      @missing_params = []
+      @messages = []
+      @lazy_mode = lazy_mode
+    end
+
+    def has_errors?
+      @invalid_params.length > 0 or @missing_params.length > 0
+    end
+
+    def trim
+      @params.each_key { |k| @params[k] = @params[k].strip if @params[k]}
+    end
+
+    def downcase(keys)
+      keys.each { |k| @params[k.to_s] = @params[k.to_s].to_s.downcase if @params[k.to_s]}
+    end
+
+    def required(keys)
+      if lazy_check_disabled
+        keys.each { |k|
+          k = k.to_s
+          unless @params.has_key?(k)
+            @invalid_params.push(k)
+            @missing_params.push(k)
+            @messages.push("#{k} is required")
+          end
+        }
+      end
+    end
+
+    def is_integer(key)
+      if lazy_check_disabled
+        key = key.to_s
+        value = @params[key]
+        unless is_valid_integer(value)
+          @invalid_params.push(key)
+          @messages.push("#{key} is not an integer")
+        end
+      end
+    end
+
+    def is_float(key)
+      if lazy_check_disabled
+        key = key.to_s
+        value = @params[key]
+        unless is_valid_float(value)
+          @invalid_params.push(key)
+          @messages.push("#{key} is not a float")
+        end
+      end
+    end
+
+    def is_greater_equal_than(min, key)
+      if lazy_check_disabled
+        key = key.to_s
+        if !is_valid_float(@params[key])
+          if !@params[key] || @params[key].length < min
+            @invalid_params.push(key)
+            @messages.push("#{key} length is less than #{min}")
+          end
+        else
+          value = is_valid_integer(@params[key]) ? @params[key].to_i : @params[key].to_f
+          if  !value || value < min
+            @invalid_params.push(key)
+            @messages.push("#{key} is less than #{min}")
+          end
+        end
+      end
+    end
+
+    def is_in_range(min, max, key)
+      if lazy_check_disabled
+        key = key.to_s
+        unless is_valid_float(@params[key])
+          if !@params[key] || @params[key].length < min || @params[key].length > max
+            @invalid_params.push(key)
+            @messages.push("#{key} length is not in range #{min},#{max}")
+          end
+        else
+          value = is_valid_integer(@params[key]) ? @params[key].to_i : @params[key].to_f
+          if !value || value < min || value > max
+            @invalid_params.push(key)
+            @messages.push("#{key} is not in range #{min},#{max}")
+          end
+        end
+      end
+    end
+
+    def is_less_equal_than(max, key)
+      if lazy_check_disabled
+        key = key.to_s
+        unless is_valid_float(@params[key])
+          if !@params[key] || @params[key].length > max
+            @invalid_params.push(key)
+            @messages.push("#{key} length is greater than #{max}")
+          end
+        else
+          value = is_valid_integer(@params[key]) ? @params[key].to_i : @params[key].to_f
+          if !value || value > max
+            @invalid_params.push(key)
+            @messages.push("#{key} is greater than #{max}")
+          end
+        end
+      end
+    end
+
+    def is_email(key)
+      if lazy_check_disabled
+        key = key.to_s
+        unless @params[key].to_s[/^\S+@\S+\.\S+$/]
+          @invalid_params.push(key)
+          @messages.push("#{key} is not a valid email")
+        end
+      end
+    end
+
+    def matches(regexp, key)
+      if lazy_check_disabled
+        key = key.to_s
+        unless @params[key] =~ regexp
+          @invalid_params.push(key)
+          @messages.push("#{key} is not a valid expression")
+        end
+      end
+    end
+
+    private
+
+    def lazy_check_disabled
+      return !@lazy_mode || !has_errors?
+    end
+
+    def is_valid_integer(value)
+      key = key.to_s
+      value.to_i.to_s == value.to_s
+    end
+
+    def is_valid_float(value)
+      key = key.to_s
+      value.to_f.to_s == value.to_s || is_valid_integer(value)
+    end
+
+    module Sinatra
+
+      def validation_required(method, path, options = { })
+        before path do
+          validate_parameters(options) if same_method? method
+        end
+      end
+
+      module Helpers
+        def same_method?(method)
+          @env['REQUEST_METHOD'] == method.to_s
+        end
+
+        # TODO: Needs a general cleanup!!!
+        def validate_parameters(options)
+          validator = Rack::Validator.new params, false
+          required_params = [ ]
+          integer_params = [ ]
+          float_params = [ ]
+          email_params = [ ]
+          range_params = [ ]
+          matches_params = [ ]
+          default_params = [ ]
+
+          options[:params].each do |param|
+            required_params << (param[:name]) if param[:required]
+            integer_params << (param) if param[:type] == :integer
+            float_params << (param) if param[:type] == :float
+            email_params << (param) if param[:type] == :email
+            range_params << (param) if param[:range]
+            matches_params << (param) if param[:matches]
+            default_params << (param) if param[:default]
+          end
+
+          validator.required required_params
+          integer_params.each do |param|
+            validator.is_integer param[:name] unless params[param[:name].to_s].nil?
+          end
+          float_params.each do |param|
+            validator.is_float param[:name] unless params[param[:name].to_s].nil?
+          end
+          email_params.each do |param|
+            validator.is_email param[:name] unless params[param[:name].to_s].nil?
+          end
+          range_params.each do |param|
+            validator.is_in_range param[:range].first, param[:range].last, param[:name] unless params[param[:name].to_s].nil?
+          end
+          matches_params.each do |param|
+            validator.matches param[:matches], param[:name] unless params[param[:name].to_s].nil?
+          end
+
+          default_params.each do |param|
+            if params[param[:name].to_s].nil?
+              params[param[:name].to_s] = param[:default]
+              validator.invalid_params.delete param[:name]
+              validator.missing_params.delete param[:name]
+            end
+          end
+
+          if validator.has_errors?
+            @env['validator.missing'] = validator.missing_params
+            @env['validator.invalid'] = validator.invalid_params
+            @env['validator.messages'] = validator.messages
+            halt missing_params!
+          end
+        end
+
+        def missing_params!
+          @response.status = 400
+        end
+      end
+
+      def self.registered(base)
+        base.helpers Helpers
+      end
+
+    end
+  end
+end

data/sinatra-params-validator.gemspec

@@ -0,0 +1,14 @@
+$: << File.dirname(__FILE__) + "/lib"
+
+Gem::Specification.new do |spec|
+  spec.name           = "sinatra-params-validator"
+  spec.version        = IO.read("VERSION")
+  spec.authors        = ["tsov", "lube8buy"]
+  spec.email          = "tsov@me.com"
+  spec.homepage       = "http://github.com/tsov/#{spec.name}"
+  spec.summary        = "A Sinatra Module to validate incoming parameters"
+  spec.description    = "This sinatra module validates the incoming parameter and lets you configure the pattern."
+
+  spec.files          = Dir["lib/**/*", "VERSION", "LICENSE", "README.md", "Gemfile", "*.gemspec"]
+  spec.license          = "MIT"
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-params-validator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- tsov
+- lube8buy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-30 00:00:00.000000000 Z
+dependencies: []
+description: This sinatra module validates the incoming parameter and lets you configure
+  the pattern.
+email: tsov@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/validator/sinatra.rb
+- VERSION
+- LICENSE
+- README.md
+- Gemfile
+- sinatra-params-validator.gemspec
+homepage: http://github.com/tsov/sinatra-params-validator
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Sinatra Module to validate incoming parameters
+test_files: []
+has_rdoc: