rack-app 3.6.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: daa93f45a998994d6b8185d95c868021905b191b
-  data.tar.gz: 86656b162da4020cce261b1b74f9385e1e507bcc
+  metadata.gz: 6cf38306bf272547c7a780a6a6e92f7138d8ebe5
+  data.tar.gz: 05929c52596d77e1caca9c46895ade3aa6a5b36d
 SHA512:
-  metadata.gz: 8c91d8539fcdf7e20ee8258b3a509a1b935cfb11ed32a18377a73114d7c854b4317620afc85603ce06b6034a49f90ee39cbb9c346969288304c00b4b407dd72a
-  data.tar.gz: 43025f318e638dc90a3bbfb460a8730cd3c55b202e22d87b5c1a8c4ff828bd26dad111c7112d9a5996c43acfeec94c7f6ea3d3502c62608aa419263062cfed16
+  metadata.gz: acfe46345c8ac900aee026f9249f053e17252224354afc803732b0f3b878761c305a6dbc0e2c29054052e45ae004662d9380b82851559446dd7bbf74991752e5
+  data.tar.gz: b4f5c6d7ce3e35cc34b16626641ae10dabd369adca3606f48098f6aaaf9f1ed50f687ed75c2a3cb35e56346d43607d859a020d0fd8294fc950617ff053438f7a

data/.gitignore

@@ -1 +1,3 @@
-/pkg/
+/pkg/
+Gemfile.lock
+.vagrant/

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Style/HashSyntax:
+  Enabled: false

data/.travis.yml

@@ -12,6 +12,8 @@ rvm:
   - 2.0.0
   - 2.1.1
   - 2.1.2
+  - 2.2.2
+  - 2.3.1
 
   - jruby-18mode
   - jruby-19mode

data/Gemfile

@@ -1,2 +1,6 @@
 source 'https://rubygems.org'
-gemspec
+gemspec
+
+if RUBY_VERSION < '2.2.2'
+  gem 'rack', '< 2.0.0'
+end

data/README.md

@@ -6,7 +6,7 @@
 
 ![Rack::App](http://rack-app-website.herokuapp.com/img/msruby_old.png)
 
-Your next favourite rack based micro framework that is totally addition free! 
+Your next favourite rack based micro framework that is totally addition free!
 Have a cup of awesomeness with your performance designed framework!
 
 The idea behind is simple.
@@ -62,17 +62,17 @@ Yes, in fact it's already powering heroku hosted micro-services.
 
 ## Features
 
-* easy to understand syntax 
+* easy to understand syntax
   * module method level endpoint definition inspirited heavily by the Sinatra DSL
   * unified error handling
-  * syntax sugar for default header definitions 
+  * syntax sugar for default header definitions
   * namespaces for endpoint request path declarations so it can be dry and unified
-* no Class method bloat, so you can enjoy pure ruby without any surprises 
+* no Class method bloat, so you can enjoy pure ruby without any surprises
 * App mounting so you can crete separated controllers for different task  
 * Null time look up routing
   * allows as many endpoint registration to you as you want, without impact on route look up speed
 * only basic sets for instance method lvl for the must need tools, such as params, payload
-* simple to use class level response serializer 
+* simple to use class level response serializer
   * so you can choose what type of serialization you want without any enforced convention
 * static file serving so you can mount even filesystem based endpoints too
 * built in testing module so your app can easily written with BDD approach
@@ -81,6 +81,7 @@ Yes, in fact it's already powering heroku hosted micro-services.
   * you can define middleware stack before endpoints and it will only applied to them, similar like protected method workflow
 * File Upload and file download in a efficient and elegant way with minimal memory consuming
   * note that this is not only memory friendly way pure rack solution, but also 2x faster than the usualy solution which includes buffering in memory
+* params validation with ease
 
 ## [Contributors](CONTRIBUTORS.md)
 
@@ -90,7 +91,7 @@ Yes, in fact it's already powering heroku hosted micro-services.
 
 config.ru
 
-#### basic 
+#### basic
 
 ```ruby
 
@@ -116,7 +117,7 @@ require 'rack/app'
 class App < Rack::App
 
   apply_extensions :front_end  
-  
+
   mount SomeAppClass
 
   headers 'Access-Control-Allow-Origin' => '*',
@@ -127,21 +128,27 @@ class App < Rack::App
   end
 
   desc 'some hello endpoint'
+  validate_params do
+    required 'words', :class => Array, :of => String, :desc => 'some word', :example => ['pug']
+    optional 'word', :class => String, :desc => 'one word', :example => 'pug'
+  end
   get '/hello' do
+    puts(validate_params['words'])
+
     return 'Hello World!'
   end
 
-  namespace '/users' do 
-  
+  namespace '/users' do
+
     desc 'some restful endpoint'
     get '/:user_id' do
       response.status = 201
       params['user_id'] #=> restful parameter :user_id
       say #=> "hello world!"
     end
-    
+
   end
-   
+
   desc 'some endpoint that has error and will be rescued'
   get '/make_error' do
     raise(StandardError,'error block rescued')
@@ -161,12 +168,12 @@ end
 
 ```
 
-you can access Rack::Request with the request method and 
-Rack::Response as response method. 
+you can access Rack::Request with the request method and
+Rack::Response as response method.
 
 By default if you dont write anything to the response 'body' the endpoint block logic return will be used
 
-## Testing 
+## Testing
 
 for testing use rack/test or the bundled testing module for writing unit test for your rack application
 
@@ -214,9 +221,13 @@ end
 
 ## Example Apps To start with
 
+* [Official website How To examples](http://rack-app.com/)
+
+* [Rack::App Team Github repositories](https://github.com/rack-app)
+
 * [Basic](https://github.com/rack-app/rack-app-example-basic)
-  * bare bone simple example app 
-  
+  * bare bone simple example app
+
 * [Escher Authorized Api](https://github.com/rack-app/rack-app-example-escher)
   * complex authorization for corporal level api use
 
@@ -250,7 +261,7 @@ the benchmarking was taken on the following hardware specification:
 
 For more reports check the Benchmark repo out :)
 
-## Roadmap 
+## Roadmap
 
 ### Team [Backlog](https://docs.google.com/spreadsheets/d/19GGX51i6uCQQz8pQ-lvsIxu43huKCX-eC1526-RL3YA/edit?usp=sharing)
 
@@ -267,6 +278,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 Bug reports and pull requests are welcome on GitHub at https://github.com/adamluzsi/rack-app.rb This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
 ## License and Copyright
-   
+
 Rack::App is free software released under the [Apache License V2](https://opensource.org/licenses/Apache-2.0) License.
 The logo was designed by Zsófia Gebauer. It is Copyright © 2015 Adam Luzsi. All Rights Reserved.

data/VERSION

@@ -1 +1 @@
-3.6.0
+4.0.1

data/lib/rack/app/constants.rb

@@ -15,5 +15,7 @@ module Rack::App::Constants
   PATH_PARAMS_MATCHER = 'rack-app.path_params_matcher'.freeze
   RACK_BASED_APPLICATION = '[Mounted Rack Application]'.freeze
   MOUNTED_DIRECTORY = '[Mounted Directory]'.freeze
-
-end
+  VALIDATED_PARAMS = 'rack-app.validated_params'
+  PARSED_PARAMS = 'rack-app.parsed_params'
+  
+end

data/lib/rack/app/instance_methods/core.rb

@@ -3,7 +3,11 @@ module Rack::App::InstanceMethods::Core
   attr_writer :request, :response
 
   def params
-    @__params__ ||= Rack::App::Params.new(request.env).to_hash
+    request.env[::Rack::App::Constants::PARSED_PARAMS] ||= Rack::App::Params.new(request.env).to_hash
+  end
+
+  def validated_params
+    request.env[::Rack::App::Constants::VALIDATED_PARAMS]
   end
 
   def request
@@ -15,4 +19,3 @@ module Rack::App::InstanceMethods::Core
   end
 
 end
-

data/lib/rack/app/middlewares.rb

@@ -1,3 +1,4 @@
 module Rack::App::Middlewares
   require 'rack/app/middlewares/header_setter'
-end
+  require 'rack/app/middlewares/params'
+end

data/lib/rack/app/middlewares/params.rb

@@ -0,0 +1,6 @@
+module Rack::App::Middlewares::Params
+  require "rack/app/middlewares/params/definition"
+  require "rack/app/middlewares/params/parser"
+  require "rack/app/middlewares/params/setter"
+  require "rack/app/middlewares/params/validator"
+end

data/lib/rack/app/middlewares/params/definition.rb

@@ -0,0 +1,22 @@
+class Rack::App::Middlewares::Params::Definition
+
+  require "rack/app/middlewares/params/definition/options"
+
+  def initialize(&descriptor)
+    @required = {}
+    @optional = {}
+    instance_exec(&descriptor)
+  end
+
+  def required(params_key,options)
+    @required[params_key.to_s]= self.class::Options.new(options).formatted
+  end
+
+  def optional(params_key,options)
+    @optional[params_key.to_s]= self.class::Options.new(options).formatted
+  end
+
+  def to_descriptor
+    {:required => @required, :optional => @optional}
+  end
+end

data/lib/rack/app/middlewares/params/definition/options.rb

@@ -0,0 +1,45 @@
+class Rack::App::Middlewares::Params::Definition::Options
+
+  ERROR_EACH = 'class must implement #each method to use :of expression in parameter definition'
+
+  def initialize(descriptor)
+    @descriptor = descriptor
+  end
+
+  def formatted
+    {
+      :class => parameter_class,
+      :of => parameter_class_elements,
+      :description => parameter_description,
+      :example => parameter_example
+    }
+  end
+
+  protected
+
+  def parameter_example
+    @descriptor[:example] 
+  end
+
+  def parameter_description
+    @descriptor[:desc] || @descriptor[:description]
+  end
+
+  def parameter_class
+    @descriptor[:class] || @descriptor[:type]
+  end
+
+  def parameter_class_elements
+    if @descriptor[:of]
+      raise "#{parameter_class} #{ERROR_EACH}" unless parameter_class_iterable?
+      @descriptor[:of]
+    end
+  end
+
+  def parameter_class_iterable?
+    parameter_class.instance_method(:each)
+  rescue NameError
+    false
+  end
+
+end

data/lib/rack/app/middlewares/params/parser.rb

@@ -0,0 +1,40 @@
+class Rack::App::Middlewares::Params::Parser
+
+  def initialize(app, descriptor)
+    @app = app
+    @descriptor = descriptor
+    @merged_params_descriptor = descriptor.values.reduce(:merge)
+  end
+
+  def call(env)
+    set_params(env)
+
+    @app.call(env)
+  end
+
+  protected
+
+  def set_params(env)
+    params = Rack::App::Params.new(env).to_hash
+    validated_params = (env[::Rack::App::Constants::VALIDATED_PARAMS] ||= {})
+    parse_params(validated_params, params)
+  end
+
+  def parse_params(validated_params, params)
+    @merged_params_descriptor.each do |key, properties|
+      next if params[key].nil?
+
+      if properties[:of]
+        validated_params[key]= [*params[key]].map{ |str| parse(properties[:of], str) }
+      else
+        validated_params[key]= parse(properties[:class], params[key])
+      end
+
+    end
+  end
+
+  def parse(type, str)
+    Rack::App::Utils::Parser.parse(type, str)
+  end
+
+end

data/lib/rack/app/middlewares/params/setter.rb

@@ -0,0 +1,19 @@
+class Rack::App::Middlewares::Params::Setter
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env[::Rack::App::Constants::PARSED_PARAMS] ||= params_hash(env)
+
+    @app.call(env)
+  end
+
+  protected
+
+  def params_hash(env)
+    Rack::App::Params.new(env).to_hash
+  end
+
+end

data/lib/rack/app/middlewares/params/validator.rb

@@ -0,0 +1,102 @@
+class Rack::App::Middlewares::Params::Validator
+  ValidateError = Class.new(ArgumentError)
+
+  def initialize(app, descriptor)
+    @descriptor = descriptor
+    @app = app
+  end
+
+  # => 422 required field missing | "422 Unprocessable Entity"
+  def call(env)
+    validate(env)
+    @app.call(env)
+  rescue ValidateError => ex
+    unprocessable_response(ex)
+  end
+
+  protected
+
+  def unprocessable_response(validate_error)
+    response = Rack::Response.new
+    response.status = 422
+    response.write("422 Unprocessable Entity\n")
+    response.write(validate_error.message)
+    response.finish
+  end
+
+  def validate(env)
+    params = Rack::App::Params.new(env).to_hash
+    validation_results(env, params)
+  end
+
+  def validation_results(env, params)
+    validate_required_params(env, params)
+    validate_optional_params(env, params)
+    validate_invalid_params(params)
+  end
+
+  def validate_required_params(env, params)
+    @descriptor[:required].each do |key, properties|
+      validate_key(key,properties,params)
+    end
+  end
+
+  def validate_optional_params(env, params)
+    @descriptor[:optional].each do |key, properties|
+      next unless params.has_key?(key)
+
+      validate_key(key,properties,params)
+    end
+  end
+
+  def validate_key(key,properties,params)
+    unless params.has_key?(key)
+      missing_key_error(key, properties[:class])
+    end
+
+    if properties[:of]
+      validate_array(properties[:class], properties[:of], key, *params[key])
+    elsif parse(properties[:class], params[key]).nil?
+      invalid_type_error(key, properties[:class])
+    end
+  end
+
+  def validate_invalid_params(params)
+    valid_keys = @descriptor[:required].keys + @descriptor[:optional].keys
+    (params.keys - valid_keys).each do |key|
+      invalid_key_error(key)
+    end
+  end
+
+  def validate_array(type, elements_type, key, *elements)
+    values = elements.map{ |str| parse(elements_type, str) }
+
+    if values.include?(nil)
+      invalid_type_of_error(key, type, elements_type)
+    end
+  end
+
+  def parse(type, str)
+    ::Rack::App::Utils::Parser.parse(type, str)
+  end
+
+  def error(message)
+    raise(ValidateError.new(message))
+  end
+
+  def missing_key_error(key, klass)
+    error "missing key: #{key}(#{klass})"
+  end
+
+  def invalid_key_error(key)
+    error "invalid key: #{key}"
+  end
+
+  def invalid_type_error(key,klass)
+    error "invalid type for #{key}: #{klass} expected"
+  end
+
+  def invalid_type_of_error(key,klass,of)
+    error "invalid type for #{key}: #{klass} of #{of} expected"
+  end
+end

data/lib/rack/app/params.rb

@@ -2,7 +2,11 @@ require 'cgi'
 class Rack::App::Params
 
   def to_hash
-    query_params.merge(request_path_params)
+    if @request_env[::Rack::App::Constants::PARSED_PARAMS]
+      @request_env[::Rack::App::Constants::PARSED_PARAMS]
+    else
+      query_params.merge(request_path_params)
+    end
   end
 
   protected
@@ -57,4 +61,4 @@ class Rack::App::Params
     @request_env[::Rack::App::Constants::PATH_PARAMS_MATCHER] || {}
   end
 
-end
+end

data/lib/rack/app/router.rb

@@ -19,21 +19,21 @@ class Rack::App::Router
 
     wd0 = endpoints.map { |endpoint| endpoint[:request_method].to_s.length }.max
     wd1 = endpoints.map { |endpoint| endpoint[:request_path].to_s.length }.max
-    wd2 = endpoints.map { |endpoint| endpoint[:description].to_s.length }.max
+    wd2 = endpoints.map { |endpoint| extract_description(endpoint).to_s.length }.max
 
     return endpoints.sort_by { |endpoint| [endpoint[:request_method], endpoint[:request_path]] }.map do |endpoint|
       [
           endpoint[:request_method].to_s.ljust(wd0),
           endpoint[:request_path].to_s.ljust(wd1),
-          endpoint[:description].to_s.ljust(wd2)
+          extract_description(endpoint).to_s.ljust(wd2)
       ].join('   ')
     end
 
   end
 
-  def register_endpoint!(request_method, request_path, description, endpoint)
+  def register_endpoint!(request_method, request_path, endpoint, properties)
     router = router_for(request_path)
-    router.register_endpoint!(request_method, request_path, description, endpoint)
+    router.register_endpoint!(request_method, request_path, endpoint, properties)
   end
 
   def merge_router!(router, prop={})
@@ -44,8 +44,8 @@ class Rack::App::Router
       register_endpoint!(
           endpoint[:request_method],
           request_path,
-          endpoint[:description],
-          endpoint[:endpoint]
+          endpoint[:endpoint],
+          endpoint[:properties]
       )
     end
     nil
@@ -70,4 +70,9 @@ class Rack::App::Router
         path_str.include?(Rack::App::Constants::RACK_BASED_APPLICATION)
   end
 
+  def extract_description(endpoint_struct)
+    if endpoint_struct[:properties]
+      endpoint_struct[:properties][:description]
+    end
+  end
 end

data/lib/rack/app/router/base.rb

@@ -20,13 +20,13 @@ class Rack::App::Router::Base
     @endpoints ||= []
   end
 
-  def register_endpoint!(request_method, request_path, description, endpoint)
+  def register_endpoint!(request_method, request_path, endpoint, properties={})
     endpoints.push(
         {
             :request_method => request_method,
             :request_path => Rack::App::Utils.normalize_path(request_path),
-            :description => description,
-            :endpoint => endpoint
+            :endpoint => endpoint,
+            :properties => properties
         }
     )
 
@@ -44,4 +44,4 @@ class Rack::App::Router::Base
     raise('IMPLEMENTATION MISSING ERROR')
   end
 
-end
+end

data/lib/rack/app/singleton_methods.rb

@@ -3,6 +3,7 @@ module Rack::App::SingletonMethods
   require 'rack/app/singleton_methods/http_methods'
   require 'rack/app/singleton_methods/inheritance'
   require 'rack/app/singleton_methods/mounting'
+  require 'rack/app/singleton_methods/params_validator'
   require 'rack/app/singleton_methods/rack_interface'
   require 'rack/app/singleton_methods/route_handling'
   require 'rack/app/singleton_methods/settings'
@@ -11,9 +12,10 @@ module Rack::App::SingletonMethods
   include Rack::App::SingletonMethods::HttpMethods
   include Rack::App::SingletonMethods::Inheritance
   include Rack::App::SingletonMethods::Mounting
+  include Rack::App::SingletonMethods::ParamsValidator
   include Rack::App::SingletonMethods::RackInterface
   include Rack::App::SingletonMethods::RouteHandling
   include Rack::App::SingletonMethods::Settings
   include Rack::App::SingletonMethods::Extensions
 
-end
+end

data/lib/rack/app/singleton_methods/http_methods.rb

@@ -35,7 +35,10 @@ module Rack::App::SingletonMethods::HttpMethods
     original_request_path = Rack::App::Utils.normalize_path(original_request_path)
 
     router.endpoints.select { |ep| ep[:request_path] == original_request_path }.each do |endpoint|
-      router.register_endpoint!(endpoint[:request_method], new_request_path, endpoint[:description], endpoint[:endpoint])
+      router.register_endpoint!(
+        endpoint[:request_method], new_request_path,
+        endpoint[:endpoint], endpoint[:properties]
+      )
     end
   end
 

data/lib/rack/app/singleton_methods/mounting.rb

@@ -1,18 +1,16 @@
 module Rack::App::SingletonMethods::Mounting
+  MOUNT = Rack::App::SingletonMethods::Mounting
 
-  def mount(api_class, properties={})
-    unless api_class.is_a?(Class) and api_class <= Rack::App
-      raise(ArgumentError, 'Invalid class given for mount, must be a Rack::App')
-    end
+  def mount(app, options={})
+    options.freeze
 
-    duplication = ::Rack::App::Utils.deep_dup(api_class)
-    duplication.on_mounted.each do |on_mount|
-      duplication.class_exec(::Rack::App::Utils.deep_dup(properties), &on_mount)
+    unless app.is_a?(Class) and app <= Rack::App
+      raise(ArgumentError, 'Invalid class given for mount, must be a Rack::App')
     end
 
-    cli.merge!(duplication.cli)
-    merge_prop = {:namespaces => [@namespaces, properties[:to]].flatten}
-    router.merge_router!(duplication.router, merge_prop)
+    cli.merge!(app.cli)
+    merge_prop = {:namespaces => [@namespaces, options[:to]].flatten}
+    router.merge_router!(app.router, merge_prop)
 
     nil
   end
@@ -41,16 +39,17 @@ module Rack::App::SingletonMethods::Mounting
   def serve_files_from(file_path, options={})
     file_server = Rack::App::FileServer.new(Rack::App::Utils.expand_path(file_path))
     request_path = Rack::App::Utils.join(@namespaces, options[:to], '**', '*')
-    router.register_endpoint!('GET', request_path, @last_description, file_server)
+    router.register_endpoint!('GET', request_path, file_server, route_registration_properties)
     @last_description = nil
   end
 
   def mount_rack_based_application(rack_based_app, options={})
     router.register_endpoint!(
-        ::Rack::App::Constants::HTTP::ANY,
-        Rack::App::Utils.join(@namespaces, options[:to], ::Rack::App::Constants::RACK_BASED_APPLICATION),
-        @last_description,
-        rack_based_app)
+      ::Rack::App::Constants::HTTP::ANY,
+      Rack::App::Utils.join(@namespaces, options[:to], ::Rack::App::Constants::RACK_BASED_APPLICATION),
+      rack_based_app,
+      route_registration_properties
+    )
 
     @last_description = nil
   end

data/lib/rack/app/singleton_methods/params_validator.rb

@@ -0,0 +1,12 @@
+module Rack::App::SingletonMethods::ParamsValidator
+  def validate_params(&block)
+    descriptor = Rack::App::Middlewares::Params::Definition.new(&block).to_descriptor
+    route_registration_properties[:params]= descriptor
+    only_next_endpoint_middlewares do |builder|
+      builder.use(Rack::App::Middlewares::Params::Setter)
+      builder.use(Rack::App::Middlewares::Params::Validator, descriptor)
+      builder.use(Rack::App::Middlewares::Params::Parser, descriptor)
+    end
+  end
+  alias params validate_params
+end

data/lib/rack/app/singleton_methods/route_handling.rb

@@ -7,11 +7,15 @@ module Rack::App::SingletonMethods::RouteHandling
   protected
 
   def root(endpoint_path)
-    alias_endpoint '/', endpoint_path
+    alias_endpoint('/', endpoint_path)
+  end
+
+  def route_registration_properties
+    @route_registration_properties ||= {}
   end
 
   def description(*description_texts)
-    @last_description = description_texts.join("\n")
+    route_registration_properties[:description]= description_texts.join("\n")
   end
 
   alias desc description
@@ -21,17 +25,18 @@ module Rack::App::SingletonMethods::RouteHandling
     request_path = ::Rack::App::Utils.join(@namespaces, request_path)
 
     builder = Rack::Builder.new
-    middlewares.each do |builder_block|
+    (middlewares + only_next_endpoint_middlewares).each do |builder_block|
       builder_block.call(builder)
     end
 
+    only_next_endpoint_middlewares.clear
+
     properties = {
         :user_defined_logic => block,
         :request_method => request_method,
         :request_path => request_path,
 
         :error_handler => error,
-        :description => @last_description,
         :serializer => serializer,
         :middleware => builder,
         :app_class => self
@@ -39,8 +44,9 @@ module Rack::App::SingletonMethods::RouteHandling
 
 
     endpoint = Rack::App::Endpoint.new(properties)
-    router.register_endpoint!(request_method, request_path, @last_description, endpoint)
+    router.register_endpoint!(request_method, request_path, endpoint, route_registration_properties)
 
+    @route_registration_properties = nil
     @last_description = nil
     return endpoint
 
@@ -55,4 +61,4 @@ module Rack::App::SingletonMethods::RouteHandling
     nil
   end
 
-end
+end

data/lib/rack/app/singleton_methods/settings.rb

@@ -43,4 +43,10 @@ module Rack::App::SingletonMethods::Settings
 
   alias middleware middlewares
 
-end
+  def only_next_endpoint_middlewares(&block)
+    @only_next_endpoint_middlewares ||= []
+    @only_next_endpoint_middlewares << block unless block.nil?
+    @only_next_endpoint_middlewares
+  end
+
+end

data/lib/rack/app/test.rb

@@ -16,10 +16,9 @@ module Rack::App::Test
 
       properties = args.select { |e| e.is_a?(Hash) }.reduce({}, &:merge!)
       url = args.select { |e| e.is_a?(String) }.first || properties.delete(:url)
-      request = Rack::MockRequest.new(rack_app)
-      env = Rack::App::Test::Utils.env_by(properties)
-
-      return @last_response = request.__send__(request_method, url, env)
+      mock_request = Rack::MockRequest.new(rack_app)
+      request_env = Rack::App::Test::Utils.env_by(properties)
+      return @last_response = mock_request.request(request_method, url, request_env)
 
     end
   end
@@ -29,7 +28,9 @@ module Rack::App::Test
     @app ||= lambda do
       app_class = defined?(__rack_app_class__) ? __rack_app_class__ : nil
       constructors = []
-      constructors << __rack_app_constructor__ if defined?(__rack_app_constructor__) and __rack_app_constructor__.is_a?(Proc)
+      if defined?(__rack_app_constructor__) and __rack_app_constructor__.is_a?(Proc)
+        constructors << __rack_app_constructor__
+      end
       Rack::App::Test::Utils.rack_app_by(app_class, constructors)
     end.call
 
@@ -37,4 +38,4 @@ module Rack::App::Test
 
   end
 
-end
+end

data/lib/rack/app/test/utils.rb

@@ -1,3 +1,4 @@
+require "cgi"
 module Rack::App::Test::Utils
 
   extend self
@@ -10,13 +11,10 @@ module Rack::App::Test::Utils
     properties
   end
 
-  def rack_app_by(subject_class, constructors, &block)
-
-    app_class = subject_class.respond_to?(:call) ? subject_class : Rack::App
-    app = Rack::App::Utils.deep_dup(app_class)
-    constructors.each { |constructor| app.class_eval(&constructor) }
-
-    return app
+  def rack_app_by(subject_class, constructors)
+    app_class = subject_class.respond_to?(:call) ? subject_class : Class.new(Rack::App)
+    constructors.each { |constructor| app_class.class_eval(&constructor) }
+    return app_class
   end
 
   def env_by(properties)
@@ -28,7 +26,6 @@ module Rack::App::Test::Utils
     env[::Rack::QUERY_STRING]= encode_www_form(properties[:params].to_a)
     env.merge!(properties[:env] || {})
 
-
     env
   end
 
@@ -67,30 +64,8 @@ module Rack::App::Test::Utils
     end.join('&')
   end
 
-  TBLENCWWWCOMP_ = {} # :nodoc:
-  256.times do |i|
-    TBLENCWWWCOMP_['%%%02X' % i] = i.chr
-  end
-  TBLENCWWWCOMP_[' '] = '+'
-  TBLENCWWWCOMP_.freeze
-  TBLDECWWWCOMP = {} # :nodoc:
-  256.times do |i|
-    h, l = i>>4, i&15
-    TBLDECWWWCOMP[i.chr]= '%%%X%X' % [h, l]
-    TBLDECWWWCOMP[i.chr]= '%%%X%X' % [h, l]
-    TBLDECWWWCOMP[i.chr]= '%%%x%X' % [h, l]
-    TBLDECWWWCOMP[i.chr]= '%%%X%x' % [h, l]
-    TBLDECWWWCOMP[i.chr]= '%%%x%x' % [h, l]
-  end
-  TBLDECWWWCOMP['+'] = ' '
-  TBLDECWWWCOMP.freeze
-
   def encode_www_form_component(str)
-    str = str.to_s.dup
-    TBLENCWWWCOMP_.each do |from, to|
-      str.gsub!(from, to)
-    end
-    str
+    CGI.escape(str.to_s)
   end
 
 end

data/lib/rack/app/utils.rb

@@ -3,6 +3,7 @@ module Rack::App::Utils
   extend self
 
   require 'rack/app/utils/deep_dup'
+  require 'rack/app/utils/parser'
 
   # Normalizes URI path.
   #
@@ -103,4 +104,4 @@ module Rack::App::Utils
     RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null'
   end
 
-end
+end

data/lib/rack/app/utils/parser.rb

@@ -0,0 +1,45 @@
+module Rack::App::Utils::Parser
+  extend(self)
+
+  require 'rack/app/utils/parser/custom'
+  require 'rack/app/utils/parser/string'
+  require 'rack/app/utils/parser/boolean'
+  require 'rack/app/utils/parser/date'
+  require 'rack/app/utils/parser/time'
+  require 'rack/app/utils/parser/date_time'
+  require 'rack/app/utils/parser/float'
+  require 'rack/app/utils/parser/integer'
+  require 'rack/app/utils/parser/numeric'
+
+  def parse(type, str)
+    string = str.to_s
+    parser = get_parser(type)
+    return unless parser.validate(string)
+    parser.parse(string)
+  end
+
+  protected
+
+  def get_parser(type)
+    case true
+    when [::String, :string].include?(type)
+      self::String.new
+    when [::TrueClass, ::FalseClass, :boolean].include?(type)
+      self::Boolean.new
+    when [::Date, :date].include?(type)
+      self::Date.new
+    when [::Time, :time].include?(type)
+      self::Time.new
+    when [::DateTime, :date_time, :datetime].include?(type)
+      self::DateTime.new
+    when [::Integer, :integer].include?(type)
+      self::Integer.new
+    when [::Float, :float].include?(type)
+      self::Float.new
+    when [::Numeric, :numeric].include?(type)
+      self::Numeric.new
+    else
+      self::Custom.new(type)
+    end
+  end
+end

data/lib/rack/app/utils/parser/boolean.rb

@@ -0,0 +1,30 @@
+class Rack::App::Utils::Parser::Boolean
+  def parse(str)
+    case true
+
+    when true?(str)
+      true
+
+    when false?(str)
+      false
+
+    else
+      str
+
+    end
+  end
+
+  def validate(str)
+    false?(str) || true?(str)
+  end
+
+  protected
+
+  def false?(obj)
+    !!(obj =~ /^false$/)
+  end
+
+  def true?(obj)
+    !!(obj =~ /^true$/)
+  end
+end

data/lib/rack/app/utils/parser/custom.rb

@@ -0,0 +1,16 @@
+class Rack::App::Utils::Parser::Custom
+  def initialize(type)
+    @type = type
+  end
+
+  def parse(str)
+    @type.parse(str)
+  end
+
+  def validate(str)
+    parse(str)
+    return true
+  rescue Exception
+    return false
+  end
+end

data/lib/rack/app/utils/parser/date.rb

@@ -0,0 +1,15 @@
+require 'date'
+class Rack::App::Utils::Parser::Date
+  def parse(str)
+    ::Date.parse(str)
+  end
+
+  def validate(str)
+    [
+      /^\d+-\d\d-\d\d$/,
+      /^\w+, \d+ \w+ \d+$/
+    ].any? do |regexp|
+      !!(str =~ regexp)
+    end
+  end
+end

data/lib/rack/app/utils/parser/date_time.rb

@@ -0,0 +1,18 @@
+require 'date'
+class Rack::App::Utils::Parser::DateTime
+  def parse(str)
+    ::DateTime.parse(str)
+  end
+
+  def validate(str)
+    [
+      /(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})[+-](\d{2})\:(\d{2})/,
+      /^\w+, \d+ \w+ \d+ \d\d:\d\d:\d\d \+\d+$/,
+      /^-?\d+-\d\d-\d\d\w\d\d:\d\d:\d\d\+\d\d:\d\d$/,
+      /\w+ \w+ \d+ \d+ \d+:\d+:\d+ \w+\+\d+ \(\w+\)/,
+      /^-?\d+-\d\d?-\d\d?\w\d\d?:\d\d?:\d\d?\w$/
+    ].any? do |regexp|
+      !!(str =~ regexp)
+    end
+  end
+end

data/lib/rack/app/utils/parser/float.rb

@@ -0,0 +1,15 @@
+class Rack::App::Utils::Parser::Float
+  def parse(str)
+    str.to_f
+  end
+
+  def validate(str)
+    case str.to_s
+      when /^\d+\.\d+$/, /^\d+,\d+$/
+        return true
+      else
+        return false
+    end
+  end
+
+end

data/lib/rack/app/utils/parser/integer.rb

@@ -0,0 +1,9 @@
+class Rack::App::Utils::Parser::Integer
+  def parse(str)
+    str.to_s.to_i
+  end
+
+  def validate(str)
+    !!(str =~ /^\d+$/)
+  end
+end

data/lib/rack/app/utils/parser/numeric.rb

@@ -0,0 +1,26 @@
+class Rack::App::Utils::Parser::Numeric
+  def parse(str)
+    case true
+    when int_parser.validate(str)
+      int_parser.parse(str)
+    when float_parser.validate(str)
+      float_parser.parse(str)
+    else
+      str
+    end
+  end
+
+  def validate(str)
+    int_parser.validate(str) || float_parser.validate(str)
+  end
+
+  protected
+
+  def int_parser
+    Rack::App::Utils::Parser::Integer.new
+  end
+
+  def float_parser
+    Rack::App::Utils::Parser::Float.new
+  end
+end

data/lib/rack/app/utils/parser/string.rb

@@ -0,0 +1,9 @@
+class Rack::App::Utils::Parser::String
+  def parse(str)
+    str.to_s
+  end
+
+  def validate(str)
+    true 
+  end
+end

data/lib/rack/app/utils/parser/time.rb

@@ -0,0 +1,15 @@
+require 'time'
+class Rack::App::Utils::Parser::Time
+  def parse(str)
+    ::Time.parse(str)
+  end
+
+  def validate(str)
+    [
+      /(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})[+-](\d{2})\:(\d{2})/,
+      /^\d+-\d\d-\d\d \d\d:\d\d:\d\d \+\d+$/
+    ].any? do |regexp|
+      !!(str =~ regexp)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-app
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-21 00:00:00.000000000 Z
+date: 2016-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,6 +77,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
@@ -112,6 +113,12 @@ files:
 - lib/rack/app/instance_methods/upload.rb
 - lib/rack/app/middlewares.rb
 - lib/rack/app/middlewares/header_setter.rb
+- lib/rack/app/middlewares/params.rb
+- lib/rack/app/middlewares/params/definition.rb
+- lib/rack/app/middlewares/params/definition/options.rb
+- lib/rack/app/middlewares/params/parser.rb
+- lib/rack/app/middlewares/params/setter.rb
+- lib/rack/app/middlewares/params/validator.rb
 - lib/rack/app/params.rb
 - lib/rack/app/request_configurator.rb
 - lib/rack/app/router.rb
@@ -126,6 +133,7 @@ files:
 - lib/rack/app/singleton_methods/http_methods.rb
 - lib/rack/app/singleton_methods/inheritance.rb
 - lib/rack/app/singleton_methods/mounting.rb
+- lib/rack/app/singleton_methods/params_validator.rb
 - lib/rack/app/singleton_methods/rack_interface.rb
 - lib/rack/app/singleton_methods/route_handling.rb
 - lib/rack/app/singleton_methods/settings.rb
@@ -134,8 +142,19 @@ files:
 - lib/rack/app/test/utils.rb
 - lib/rack/app/utils.rb
 - lib/rack/app/utils/deep_dup.rb
+- lib/rack/app/utils/parser.rb
+- lib/rack/app/utils/parser/boolean.rb
+- lib/rack/app/utils/parser/custom.rb
+- lib/rack/app/utils/parser/date.rb
+- lib/rack/app/utils/parser/date_time.rb
+- lib/rack/app/utils/parser/float.rb
+- lib/rack/app/utils/parser/integer.rb
+- lib/rack/app/utils/parser/numeric.rb
+- lib/rack/app/utils/parser/string.rb
+- lib/rack/app/utils/parser/time.rb
 - lib/rack/app/version.rb
 - rack-app.gemspec
+- src/Net__HTTP Cheat Sheet.pdf
 homepage: http://www.rack-app.com/
 licenses:
 - Apache License 2.0