request_exception_handler 0.4 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 161f65acac0facbace5cd9ca6c97b5505d6eb37f
+  data.tar.gz: 1cc3a96669b70eb6b2b78cb7f946674ca4eed339
+SHA512:
+  metadata.gz: 8f4cb1cac97ae79f15d49a7eaaab3773a432b01363ec4192fdb19c53a01845d65aff075063d271c17bc60baed6c1468f207924c73719f19860a52d8e6a5a6b7b
+  data.tar.gz: 068f53859e8c7d8f058f4337712dc36d1eebbde96d92aee7cffda6ef87fc504b9ef27f74d4c2c99182bc00578924ef703ccd99501f756fae576aa0329ef822fc

data/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright (c) 2009 Karol Bucek
+   Copyright (c) 2014 Karol Bucek
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -1,71 +1,81 @@
 # RequestExceptionHandler
 
 Rails is not capable of calling your exception handlers when an error occurs
-during the parsing of request parameters (e.g. in case of invalid XML body).
+during the parsing of request parameters (e.g. in case of invalid JSON body).
 
-This will hopefully change someday, but until then I have created this biutiful
-monkey-patch for request parameter parsing to allow more flexibility when
+This will hopefully change someday, but until then I have created this delicate
+monkey-patch for the request parameter parser to allow more flexibility when
 an invalid request body is received.
 
-Tested on 3.0, 3.1 and 3.2 it should still work on Rails 2.3 and 2.2.3 as well.
+Tested on 4.x and 3.x but it should still work on Rails 2.3 and 2.2.3 as well.
 
+[![Build Status][0]](http://travis-ci.org/#!/kares/request_exception_handler)
 
 ## Install
 
     gem 'request_exception_handler'
 
-or as a plain-old rails plugin :
+~~or as a plain-old (obsolete) rails plugin~~ :
 
     script/plugin install git://github.com/kares/request_exception_handler.git
 
 ## Example
 
 The code hooks into parameter parsing and allows a request to be constructed
-even if the params can not be parsed from the submitted raw content. A before
-filter is installed that checks for a request exception and re-raises it thus
-it seems to Rails that the exception comes from the application code and is
-processed as all other "business" exceptions.
-you might skip this filter and install your own to handle such cases (it's good
-to make sure the filter gets to the beginning of the chain) :
+even if the parsing of the submitted raw content fails (JSON/XML backend raises
+a parse error). A before filter is installed that checks for a request exception
+and re-raises, it thus it seems to Rails that the exception comes from the
+application code and is processed as all other "business" exceptions.
 
-    class MyController < ApplicationController
+One might skip this "request-exception" filter (e.g. per action - the usual way)
+and install another to handle such cases (it's good to make sure the filter gets
+at the beginning of the chain) :
 
-      skip_before_filter :check_request_exception # filter the plugin installed
+```ruby
+class MyController < ApplicationController
 
-      # custom before filter use request_exception to detect occured errors
-      prepend_before_filter :return_409_on_json_errors
+  skip_before_filter :check_request_exception # filter the plugin installed
 
-      private
-
-        def return_409_on_json_errors
-          if re = request_exception && re.is_a?(ActiveSupport::JSON::ParseError)
-            head 409
-          else
-            head 500
-          end
-        end
+  # custom before filter use request_exception to detect occured errors
+  prepend_before_filter :return_409_on_json_errors
 
+  private
+  def return_409_on_json_errors
+    if e = request_exception && e.is_a?(ActiveSupport::JSON::ParseError)
+      head 409
+    else
+      head 500
     end
+  end
+
+end
+```
 
 Another option of how to modify the returned 500 status is to use exception
 handlers the same way you're (hopefully) using them for your own exceptions :
 
-    class ApplicationController < ActionController::Base
+```ruby
+class ApplicationController < ActionController::Base
 
-      rescue_from 'REXML::ParseException' do |exception|
-        render :text => exception.to_s, :status => 422
-      end
+  rescue_from 'REXML::ParseException' do |exception|
+    render :text => exception.to_s, :status => 422
+  end
 
-    end
+end
+```
 
 If you're not using REXML as a parsing backend the exception might vary, e.g.
 for Nokogiri the rescue block would look something like :
 
-    rescue_from 'Nokogiri::XML::SyntaxError' do |exception|
-      render :text => exception.to_s, :status => 422
-    end
+```ruby
+rescue_from 'Nokogiri::XML::SyntaxError' do |exception|
+  render :text => exception.to_s, :status => 422
+end
+```
 
 ## Copyright
 
-Copyright (c) 2009-2012 [Karol Bucek](https://github.com/kares). 
-See LICENSE (http://www.apache.org/licenses/LICENSE-2.0) for details.
+Copyright (c) 2014 [Karol Bucek](https://github.com/kares).
+See LICENSE (http://www.apache.org/licenses/LICENSE-2.0) for details.
+
+[0]: https://secure.travis-ci.org/kares/request_exception_handler.png

data/lib/request_exception_handler.rb

@@ -3,31 +3,35 @@
 module RequestExceptionHandler
 
   THREAD_LOCAL_NAME = :_request_exception
-  
+
   @@parse_request_parameters_exception_handler = lambda do |request, exception|
-    Thread.current[THREAD_LOCAL_NAME] = exception
+    RequestExceptionHandler.store_request_exception(exception)
     request_body = request.respond_to?(:body) ? request.body : request.raw_post
 
     logger = RequestExceptionHandler.logger
-    if logger.info?
+    if logger.debug?
       content_log = request_body
       if request_body.is_a?(StringIO)
         pos = request_body.pos
         content_log = request_body.read
       end
-      logger.info "#{exception.class.name} occurred while parsing request parameters." +
-                  "\nContents:\n#{content_log}\n"
+      logger.debug "#{exception.class.name} occurred while parsing request parameters." <<
+                   "\nContents:\n#{content_log}\n"
       request_body.pos = pos if pos
+    elsif logger.info?
+      logger.info "#{exception.class.name} occurred while parsing request parameters."
     end
-              
-    content_type = if request.respond_to?(:content_type_with_parameters)
-      request.send :content_type_with_parameters # AbstractRequest
-    else # rack request
-      request.respond_to?(:content_mime_type) ? request.content_mime_type : request.content_type
+
+    content_type = if request.respond_to?(:content_mime_type)
+      request.content_mime_type
+    elsif request.respond_to?(:content_type_with_parameters)
+      request.send :content_type_with_parameters # (legacy) ActionController::AbstractRequest
+    else
+      request.content_type
     end
     { "body" => request_body, "content_type" => content_type, "content_length" => request.content_length }
   end
-  
+
   begin
     mattr_accessor :parse_request_parameters_exception_handler
   rescue NoMethodError => e
@@ -35,34 +39,62 @@ module RequestExceptionHandler
     raise e
   end
 
-  # Resets the current +request_exception+ (to nil).
-  def self.reset_request_exception
-    Thread.current[THREAD_LOCAL_NAME] = nil
-  end
+  @@parse_request_parameters_exception_logger = nil
 
   # Retrieves the Rails logger.
   def self.logger
-    defined?(Rails.logger) ? Rails.logger : 
-      defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : 
-        Logger.new($stderr)
+    @@parse_request_parameters_exception_logger ||=
+      defined?(Rails.logger) ? Rails.logger :
+        defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER :
+          Logger.new(STDERR)
   end
-  
+
   def self.included(base)
     base.prepend_before_filter :check_request_exception
   end
 
-  # Checks and raises a +request_exception+ (gets prepended as a before filter).
-  def check_request_exception
-    e = request_exception
-    raise e if e && e.is_a?(Exception)
+  # Resets the current +request_exception+ (to nil).
+  def self.reset_request_exception
+    store_request_exception nil
+  end
+
+  if defined? Thread.current.thread_variables
+
+    # Resets the current +request_exception+ (to nil).
+    def self.store_request_exception(exception)
+      Thread.current.thread_variable_set THREAD_LOCAL_NAME, exception
+    end
+
+    # Retrieves and keeps track of the current request exception if any.
+    def request_exception
+      return @_request_exception if defined? @_request_exception
+      @_request_exception = Thread.current.thread_variable_get(THREAD_LOCAL_NAME)
+      RequestExceptionHandler.reset_request_exception
+      @_request_exception
+    end
+
+  else
+
+    # Resets the current +request_exception+ (to nil).
+    def self.store_request_exception(exception)
+      Thread.current[THREAD_LOCAL_NAME] = exception
+    end
+
+    # Retrieves and keeps track of the current request exception if any.
+    def request_exception
+      return @_request_exception if defined? @_request_exception
+      @_request_exception = Thread.current[THREAD_LOCAL_NAME]
+      RequestExceptionHandler.reset_request_exception
+      @_request_exception
+    end
+
   end
 
-  # Retrieves and keeps track of the current request exception if any.
-  def request_exception
-    return @_request_exception if defined? @_request_exception
-    @_request_exception = Thread.current[THREAD_LOCAL_NAME]
-    RequestExceptionHandler.reset_request_exception
-    @_request_exception
+  # Checks and raises a +request_exception+ (gets prepended as a before filter).
+  def check_request_exception
+    if e = request_exception
+      raise e if e.is_a?(Exception)
+    end
   end
 
 end
@@ -70,11 +102,36 @@ end
 require 'action_controller/base'
 ActionController::Base.send :include, RequestExceptionHandler
 
-# NOTE: Rails monkey patching follows :
+# NOTE: Rails "parameters-parser" monkey patching follows :
+
+if defined? ActionDispatch::ParamsParser::ParseError # Rails 4.x
+
+  class ActionDispatch::ParamsParser
+
+    alias_method 'parse_formatted_parameters_without_exception_handler', 'parse_formatted_parameters'
+
+    def parse_formatted_parameters_with_exception_handler(env)
+      begin
+        out = parse_formatted_parameters_without_exception_handler(env)
+        RequestExceptionHandler.reset_request_exception # make sure it's nil
+        out
+      rescue ParseError => e
+        e = e.original_exception
+        handler = RequestExceptionHandler.parse_request_parameters_exception_handler
+        handler ? handler.call(ActionDispatch::Request.new(env), e) : raise
+      rescue => e # all Exception-s get wrapped into ParseError ... but just in case
+        handler = RequestExceptionHandler.parse_request_parameters_exception_handler
+        handler ? handler.call(ActionDispatch::Request.new(env), e) : raise
+      end
+    end
+
+    alias_method 'parse_formatted_parameters', 'parse_formatted_parameters_with_exception_handler'
+
+  end
 
-if defined? ActionDispatch::ParamsParser # Rails 3.x
+elsif defined? ActionDispatch::ParamsParser # Rails 3.x
 
-  ActionDispatch::ParamsParser.class_eval do
+  class ActionDispatch::ParamsParser
 
     def parse_formatted_parameters_with_exception_handler(env)
       begin
@@ -87,13 +144,13 @@ if defined? ActionDispatch::ParamsParser # Rails 3.x
       end
     end
 
-    alias_method_chain :parse_formatted_parameters, :exception_handler
+    alias_method_chain 'parse_formatted_parameters', 'exception_handler'
 
   end
 
 elsif defined? ActionController::ParamsParser # Rails 2.3.x
 
-  ActionController::ParamsParser.class_eval do
+  class ActionController::ParamsParser
 
     def parse_formatted_parameters_with_exception_handler(env)
       begin
@@ -106,7 +163,7 @@ elsif defined? ActionController::ParamsParser # Rails 2.3.x
       end
     end
 
-    alias_method_chain :parse_formatted_parameters, :exception_handler
+    alias_method_chain 'parse_formatted_parameters', 'exception_handler'
 
   end
 

data/test/_test-unit-rails4.rb

@@ -0,0 +1,62 @@
+# mock require 'active_support/testing/autorun'
+$LOADED_FEATURES << 'active_support/testing/autorun.rb'
+require 'test-unit'
+##
+
+# mock require 'active_support/test_case'
+$LOADED_FEATURES << 'active_support/test_case.rb'
+
+require 'active_support/testing/tagged_logging'
+require 'active_support/testing/setup_and_teardown' # ?
+require 'active_support/testing/assertions'
+require 'active_support/testing/deprecation'
+#require 'active_support/testing/pending'
+#require 'active_support/testing/declarative'
+#require 'active_support/testing/isolation'
+require 'active_support/testing/constant_lookup'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/deprecation'
+
+#begin
+#  silence_warnings { require 'mocha/setup' }
+#rescue LoadError
+#end
+
+module ActiveSupport
+  class TestCase < Test::Unit::TestCase
+    #Assertion = Test::Unit::Assertions
+
+    @@tags = {}
+    def self.for_tag(tag)
+      yield if @@tags[tag]
+    end
+
+    include ActiveSupport::Testing::TaggedLogging
+    include ActiveSupport::Testing::SetupAndTeardown
+    include ActiveSupport::Testing::Assertions
+    include ActiveSupport::Testing::Deprecation
+    #include ActiveSupport::Testing::Pending
+    #extend ActiveSupport::Testing::Declarative
+
+    # Fails if the block raises an exception.
+    #
+    # assert_nothing_raised do
+    # ...
+    # end
+    #def assert_nothing_raised(*args)
+    #  yield
+    #end
+  end
+end
+
+##
+
+#require "test/unit/active_support"
+#require "test/unit/notify"
+#require "test/unit/rr"
+
+# due ActionDispatch::Integration
+$LOADED_FEATURES << 'minitest/unit.rb'
+module MiniTest
+  Assertions = Test::Unit::Assertions
+end

data/test/request_exception_handler_test.rb

@@ -1,28 +1,15 @@
 require File.expand_path('test_helper', File.dirname(__FILE__))
 
-#
-# NOTE: due to the test_helper.rb argument parsing this test might
-#       be run with different versions of Rails e.g. :
-# 
-# ruby request_exception_handler_test.rb RAILS_VERSION=2.1.2
-#
-
 class TestController < ActionController::Base
 
-  def parse
-    head :ok
-  end
+  def parse; head :ok end
 
-  def parse_with_check_request_exception_skipped
-    head :ok
-  end
+  def parse_with_check_request_exception_skipped; head :ok end
 
   skip_before_filter :check_request_exception, :only =>
     [ :parse_with_check_request_exception_skipped, :parse_with_check_request_exception_replaced ]
 
-  def parse_with_check_request_exception_replaced
-    head :ok
-  end
+  def parse_with_check_request_exception_replaced; head :ok end
 
   before_filter :return_501_on_request_exception, :only => [ :parse_with_check_request_exception_replaced ]
 
@@ -38,9 +25,7 @@ class TestWithRexmlRescueController < ActionController::Base
     render :text => exception.class.name, :status => 405
   end
 
-  def index
-    head :ok
-  end
+  def index; head :ok end
 
 end
 
@@ -50,21 +35,19 @@ class TestWithNokogiriRescueController < ActionController::Base
     render :text => exception.class.name, :status => 505
   end
 
-  def index
-    head :ok
-  end
+  def index; head :ok end
 
 end
 
-if Rails.version < '3.0.0'
-  ActionController::Routing::Routes.draw do |map|
-    map.connect '/parse_with_rexml_rescue_block',
-                :controller => 'test_with_rexml_rescue', :action => 'index'
-    map.connect '/parse_with_nokogiri_rescue_block',
-                :controller => 'test_with_nokogiri_rescue', :action => 'index'
-    map.connect '/:action', :controller => "test"
+if Rails::VERSION::MAJOR >= 4
+  RequestExceptionHandlerTest::Application.routes.draw do
+    post "/parse_with_rexml_rescue_block", :to => 'test_with_rexml_rescue#index'
+    post "/parse_with_nokogiri_rescue_block", :to => 'test_with_nokogiri_rescue#index'
+    post '/parse' => "test#parse"
+    post '/parse_with_check_request_exception_skipped', :to => "test#parse_with_check_request_exception_skipped"
+    post '/parse_with_check_request_exception_replaced', :to => "test#parse_with_check_request_exception_replaced"
   end
-else
+elsif Rails::VERSION::MAJOR >= 3
   RequestExceptionHandlerTest::Application.routes.draw do
     match "/parse_with_rexml_rescue_block", :to => 'test_with_rexml_rescue#index'
     match "/parse_with_nokogiri_rescue_block", :to => 'test_with_nokogiri_rescue#index'
@@ -72,9 +55,17 @@ else
     match '/parse_with_check_request_exception_skipped', :to => "test#parse_with_check_request_exception_skipped"
     match '/parse_with_check_request_exception_replaced', :to => "test#parse_with_check_request_exception_replaced"
   end
+else
+  ActionController::Routing::Routes.draw do |map|
+    map.connect '/parse_with_rexml_rescue_block',
+                :controller => 'test_with_rexml_rescue', :action => 'index'
+    map.connect '/parse_with_nokogiri_rescue_block',
+                :controller => 'test_with_nokogiri_rescue', :action => 'index'
+    map.connect '/:action', :controller => "test"
+  end
 end
 
-class RequestExceptionHandlerJsonTest < ActionController::IntegrationTest
+class RequestExceptionHandlerJsonTest < IntegrationTest
 
   def test_parse_valid_json
     post "/parse", '{"cicinbrus": {"name": "Ferko"}}', 'CONTENT_TYPE' => 'application/json'
@@ -94,18 +85,18 @@ class RequestExceptionHandlerJsonTest < ActionController::IntegrationTest
 
   private
 
-    def assert_json_parse_exception(error)
-      if ActiveSupport::JSON.respond_to?(:parse_error) # 2.3.5
-        parse_error_class = ActiveSupport::JSON.parse_error
-        assert_instance_of parse_error_class, error
-      else
-        assert_instance_of ActiveSupport::JSON::ParseError, error
-      end
+  def assert_json_parse_exception(error)
+    if ActiveSupport::JSON.respond_to?(:parse_error) # 2.3.5
+      parse_error_class = ActiveSupport::JSON.parse_error
+      assert_instance_of parse_error_class, error
+    else
+      assert_instance_of ActiveSupport::JSON::ParseError, error
     end
+  end
 
 end
 
-class RequestExceptionHandlerXmlTest < ActionController::IntegrationTest
+class RequestExceptionHandlerXmlTest < IntegrationTest
 
   def test_parse_valid_xml
     post "/parse", "<cicinbrus> <name>Ferko</name> </cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
@@ -167,35 +158,34 @@ class RequestExceptionHandlerXmlTest < ActionController::IntegrationTest
     assert_response 405
   end
 
-  if Rails.version >= '2.3'
-
-    def test_on_parse_error_custom_rescue_handler_gets_called_for_nokogiri
-      nokogiri =
-        begin
-          require 'nokogiri'
-        rescue LoadError
-          :nil
-        end
-      if nokogiri != :nil
-        backend = ActiveSupport::XmlMini.backend
-        begin
-          ActiveSupport::XmlMini.backend = 'Nokogiri'
-          post "/parse_with_nokogiri_rescue_block", "<cicinbrus> <name>Ferko</name>", 'CONTENT_TYPE' => 'application/xml'
-          assert_response 505
-        ensure
-          ActiveSupport::XmlMini.backend = backend
-        end
-      else
-        puts "nokogiri not available - test skipped !"
-      end
-    end
-
+  begin
+    require 'nokogiri'
+    NOKOGIRI = true
+  rescue LoadError
+    NOKOGIRI = false
   end
 
-  private
+  def test_on_parse_error_custom_rescue_handler_gets_called_for_nokogiri
+    return skip('nokogiri not available - test skipped !') unless NOKOGIRI
 
-    def assert_xml_parse_exception(error)
-      assert_instance_of REXML::ParseException, error
+    backend = ActiveSupport::XmlMini.backend
+    begin
+      ActiveSupport::XmlMini.backend = 'Nokogiri'
+      post "/parse_with_nokogiri_rescue_block", "<cicinbrus> <name>Ferko</name>", 'CONTENT_TYPE' => 'application/xml'
+      assert_response 505
+    ensure
+      ActiveSupport::XmlMini.backend = backend
     end
+  end if Rails.version >= '2.3'
+
+  private
+
+  def skip(message = nil)
+    super
+  end
+
+  def assert_xml_parse_exception(error)
+    assert_instance_of REXML::ParseException, error
+  end
 
 end

data/test/test_helper.rb

@@ -1,62 +1,90 @@
 require 'rubygems'
-gem 'test-unit' rescue nil
-require 'test/unit'
+require 'bundler/setup' rescue nil
 
 # enable testing with different version of rails via argv :
-# ruby request_exception_handler_test.rb RAILS_VERSION=2.2.2
-
+# ruby request_exception_handler_test.rb RAILS_VERSION=2.3.18
 version =
   if ARGV.find { |opt| /RAILS_VERSION=([\d\.]+)/ =~ opt }
     $~[1]
   else
-    # rake test RAILS_VERSION=2.3.5
-    ENV['RAILS_VERSION']
+    ENV['RAILS_VERSION'] # rake test RAILS_VERSION=3.2.18
   end
 
 if version
   RAILS_VERSION = version
-  gem 'activesupport', "= #{RAILS_VERSION}"
-  #gem 'activerecord', "= #{RAILS_VERSION}"
-  gem 'actionpack', "= #{RAILS_VERSION}"
-  #gem 'actionmailer', "= #{RAILS_VERSION}"
-  gem 'rails', "= #{RAILS_VERSION}"
+  gem 'activesupport', "#{RAILS_VERSION}"
+  gem 'actionpack', "#{RAILS_VERSION}"
+  gem 'rails', "#{RAILS_VERSION}"
 else
   gem 'activesupport'
-  #gem 'activerecord'
   gem 'actionpack'
-  #gem 'actionmailer'
   gem 'rails'
+end unless defined? Bundler
+
+require 'rails/version'
+puts "emulating Rails.version = #{Rails::VERSION::STRING}"
+
+if Rails::VERSION::MAJOR < 4
+  gem 'test-unit' rescue nil
+  begin
+    require 'test/unit'
+  rescue LoadError
+    gem 'minitest'
+    require 'minitest/unit'
+    MiniTest::Unit.autorun
+  end
+else
+  gem 'minitest'
 end
 
+begin
+  require 'iconv'
+rescue LoadError
+  begin
+    require 'active_support/inflector'
+  rescue LoadError
+    $LOADED_FEATURES << 'iconv.rb'
+    require 'active_support/inflector'
+  end
+end if Rails::VERSION::MAJOR < 3
 require 'active_support'
 require 'active_support/test_case'
 require 'action_controller'
 require 'action_controller/test_case'
 
-require 'rails/version'
-puts "emulating Rails.version = #{Rails::VERSION::STRING}"
-
 require 'action_controller/integration' if Rails::VERSION::MAJOR < 3
 require 'action_controller/session_management' if Rails::VERSION::MAJOR < 3
 require 'action_dispatch' if Rails::VERSION::MAJOR >= 3
 require 'action_dispatch/routing' if Rails::VERSION::MAJOR >= 3
 
+begin
+  require 'action_dispatch/testing/integration'
+  IntegrationTest = ActionDispatch::IntegrationTest
+rescue LoadError
+  IntegrationTest = ActionController::IntegrationTest
+end
+
 if Rails::VERSION::MAJOR >= 3
   ActiveSupport::Deprecation.behavior = :stderr
 else
   ActiveSupport::Deprecation.debug = true
 end
 
-if Rails::VERSION::MAJOR >= 3
+if Rails::VERSION::MAJOR >= 4
   require 'rails'
   # a minimal require 'rails/all' :
-  require "action_controller/railtie"
-  require "rails/test_unit/railtie"
+  require 'action_controller/railtie'
+  require 'rails/test_help'
+elsif Rails::VERSION::MAJOR >= 3
+  require 'rails'
+  # a minimal require 'rails/all' :
+  require 'action_controller/railtie'
+  require 'rails/test_unit/railtie'
   require 'rails/test_help'
 else
   module Rails
     class << self
-      
+
       def initialized?
         @initialized || false
       end
@@ -100,7 +128,7 @@ else
       def public_path=(path)
         @@public_path = path
       end
-      
+
     end
   end
 end
@@ -109,7 +137,7 @@ silence_warnings { RAILS_ROOT = File.expand_path( File.dirname(__FILE__) ) }
 
 # Make double-sure the RAILS_ENV is set to test,
 # so fixtures are loaded to the right database
-silence_warnings { RAILS_ENV = "test" }
+silence_warnings { RAILS_ENV = 'test' }
 
 Rails.backtrace_cleaner.remove_silencers! if Rails.backtrace_cleaner
 
@@ -130,25 +158,35 @@ if ActionController::Base.respond_to? :session_options # Rails 2.x
   ActionController::Base.session_options[:secret] = 'x' * 30
 
 else # since Rails 3.0.0 :
-  
+
   module RequestExceptionHandlerTest
-    class Application < Rails::Application
-      config.secret_token = 'x' * 30
+
+    class Application < Rails::Application; end
+
+    Application.configure do
+      if config.respond_to?(:secret_key_base=)
+        config.secret_key_base = 'x' * 30
+      else
+        config.secret_token = 'x' * 30
+      end
+      config.cache_classes = true if config.respond_to?(:cache_classes=)
+      config.eager_load = false if config.respond_to?(:eager_load=)
+      config.action_controller.allow_forgery_protection = false
+      config.active_support.deprecation = :stderr
     end
-  end
-  
-  # Initialize the rails application
-  RequestExceptionHandlerTest::Application.initialize!
 
-end
+    # Since 4.0 only DEFAULT_PARSERS = { Mime::JSON => :json } is setup by default
+    unless ActionDispatch::ParamsParser::DEFAULT_PARSERS[ Mime::XML ]
+      ActionDispatch::ParamsParser::DEFAULT_PARSERS[ Mime::XML ] = Proc.new do
+        |raw_post| ( Hash.from_xml(raw_post) || {} ).with_indifferent_access
+      end
+    end if defined? ActionDispatch::ParamsParser::DEFAULT_PARSERS
 
-ActiveSupport::TestCase.class_eval do
+    Application.initialize!
 
-  def setup_fixtures
-    return nil # Rails 3 load hooks !
   end
-  
+
 end
 
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
 require 'request_exception_handler'

metadata

@@ -1,99 +1,84 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: request_exception_handler
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: "0.4"
+version: !ruby/object:Gem::Version
+  version: 0.5.0
 platform: ruby
-authors: 
-  - Karol Bucek
+authors:
+- Karol Bucek
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-11-15 00:00:00 Z
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: actionpack
-    version_requirements: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "2.1"
-    requirement: *id001
-    prerelease: false
-    type: :runtime
-  - !ruby/object:Gem::Dependency 
-    name: rake
-    version_requirements: &id002 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "0"
-    requirement: *id002
-    prerelease: false
-    type: :development
-  - !ruby/object:Gem::Dependency 
-    name: test-unit
-    version_requirements: &id003 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "2.4"
-    requirement: *id003
-    prerelease: false
-    type: :development
-description: a rails hook that allows one to handle request parameter parsing exceptions (invalid XML, JSON) with a rescue block
-email: 
-  - self@kares.org
+date: 2014-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+description: rails hook that allows one to handle request parameter parsing exceptions
+  (e.g. invalid JSON) with a rescue block
+email:
+- self@kares.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-  - README.md
-files: 
-  - lib/request_exception_handler.rb
-  - LICENSE
-  - README.md
-  - Rakefile
-  - test/test_helper.rb
-  - test/request_exception_handler_test.rb
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/request_exception_handler.rb
+- test/_test-unit-rails4.rb
+- test/request_exception_handler_test.rb
+- test/test_helper.rb
 homepage: http://github.com/kares/request_exception_handler
-licenses: []
-
+licenses:
+- Apache-2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 2
-        segments: 
-          - 0
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 2
-        segments: 
-          - 0
-        version: "0"
+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: "[none]"
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
-summary: handler for all request (parsing) related exceptions
-test_files: 
-  - test/test_helper.rb
-  - test/request_exception_handler_test.rb
+specification_version: 4
+summary: a handler for all request (parsing) related exceptions
+test_files:
+- test/test_helper.rb
+- test/_test-unit-rails4.rb
+- test/request_exception_handler_test.rb