request_exception_handler 0.3

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2009 Karol Bucek
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,69 @@
+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).
+
+This will hopefully change someday, but until then I have created this biutiful 
+monkey-patch for request parameter parsing to allow more flexibility when
+an invalid request body is received.
+
+Code has been tested on 2.3, 2.2.3 and 2.1 as well as on Rails 3.0 / 3.1.
+
+
+Install
+=======
+
+    gem 'request_exception_handler'
+
+or as a plain-old 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) :
+
+    class MyController < ApplicationController
+
+      skip_before_filter :check_request_exception # filter the plugin installed
+
+      # 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 re = request_exception && re.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
+
+      rescue_from 'REXML::ParseException' do |exception|
+        render :text => exception.to_s, :status => 422
+      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

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the request_exception_handler plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the request_exception_handler plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RequestExceptionHandler'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/request_exception_handler.rb

@@ -0,0 +1,120 @@
+
+module RequestExceptionHandler
+
+  @@parse_request_parameters_exception_handler = lambda do |request, exception|
+    Thread.current[:request_exception] = exception
+    request_body = request.respond_to?(:body) ? request.body : request.raw_post
+
+    logger = RequestExceptionHandler.logger
+    if logger.info?
+      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"
+      request_body.pos = pos if pos
+    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
+    end
+    { "body" => request_body, "content_type" => content_type, "content_length" => request.content_length }
+  end
+  
+  mattr_accessor :parse_request_parameters_exception_handler
+
+  def self.reset_request_exception
+    Thread.current[:request_exception] = nil
+  end
+
+  def self.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
+
+  def check_request_exception
+    e = request_exception
+    raise e if e && e.is_a?(Exception)
+  end
+
+  def request_exception
+    return @_request_exception if defined? @_request_exception
+    @_request_exception = Thread.current[:request_exception]
+    RequestExceptionHandler.reset_request_exception
+    @_request_exception
+  end
+
+end
+
+require 'action_controller/base'
+ActionController::Base.send :include, RequestExceptionHandler
+
+# NOTE: Rails monkey patching follows :
+
+if defined? ActionDispatch::ParamsParser # Rails 3.x
+
+  ActionDispatch::ParamsParser.class_eval do
+
+    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 Exception => e # YAML, XML or Ruby code block errors
+        handler = RequestExceptionHandler.parse_request_parameters_exception_handler
+        handler ? handler.call(ActionDispatch::Request.new(env), e) : raise
+      end
+    end
+
+    alias_method_chain :parse_formatted_parameters, :exception_handler
+
+  end
+
+elsif defined? ActionController::ParamsParser # Rails 2.3.x
+
+  ActionController::ParamsParser.class_eval do
+
+    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 Exception => e # YAML, XML or Ruby code block errors
+        handler = RequestExceptionHandler.parse_request_parameters_exception_handler
+        handler ? handler.call(ActionController::Request.new(env), e) : raise
+      end
+    end
+
+    alias_method_chain :parse_formatted_parameters, :exception_handler
+
+  end
+
+else # old-style Rails < 2.3
+
+  ActionController::AbstractRequest.class_eval do
+
+    def parse_formatted_request_parameters_with_exception_handler
+      begin
+        out = parse_formatted_request_parameters_without_exception_handler
+        RequestExceptionHandler.reset_request_exception # make sure it's nil
+        out
+      rescue Exception => e # YAML, XML or Ruby code block errors
+        handler = RequestExceptionHandler.parse_request_parameters_exception_handler
+        handler ? handler.call(self, e) : raise
+      end
+    end
+
+    alias_method_chain :parse_formatted_request_parameters, :exception_handler
+
+  end
+
+end

data/test/request_exception_handler_test.rb

@@ -0,0 +1,201 @@
+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_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
+
+  before_filter :return_501_on_request_exception, :only => [ :parse_with_check_request_exception_replaced ]
+
+  def return_501_on_request_exception
+    head 501 if request_exception
+  end
+
+end
+
+class TestWithRexmlRescueController < ActionController::Base
+
+  rescue_from 'REXML::ParseException' do |exception|
+    render :text => exception.class.name, :status => 405
+  end
+
+  def index
+    head :ok
+  end
+
+end
+
+class TestWithNokogiriRescueController < ActionController::Base
+
+  rescue_from 'Nokogiri::XML::SyntaxError' do |exception|
+    render :text => exception.class.name, :status => 505
+  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"
+  end
+else
+  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'
+    match '/parse' => "test#parse"
+    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
+end
+
+class RequestExceptionHandlerJsonTest < ActionController::IntegrationTest
+
+  def test_parse_valid_json
+    post "/parse", '{"cicinbrus": {"name": "Ferko"}}', 'CONTENT_TYPE' => 'application/json'
+    assert_response 200
+  end
+
+  def test_parse_invalid_json_returns_500_by_default
+    post "/parse", '{"cicinbrus": {"name": "Ferko"}', 'CONTENT_TYPE' => 'application/json'
+    assert_response 500
+  end
+
+  def test_request_exception_returns_parse_exception_on_invalid_json_request
+    post "/parse", "{\"cicinbrus\": {\"name: \"Ferko\"}}", 'CONTENT_TYPE' => 'application/json'
+    assert_not_nil controller.request_exception
+    assert_json_parse_exception controller.request_exception
+  end
+
+  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
+    end
+
+end
+
+class RequestExceptionHandlerXmlTest < ActionController::IntegrationTest
+
+  def test_parse_valid_xml
+    post "/parse", "<cicinbrus> <name>Ferko</name> </cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
+    assert_response 200
+  end
+
+  def test_parse_invalid_xml_returns_500_by_default
+    post "/parse", "<cicinbrus> <name>Ferko<name> </cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
+    assert_response 500
+  end
+
+  def test_controller_responds_to_request_exception_and_returns_nil_on_valid_request
+    post "/parse"
+    assert controller.respond_to? :request_exception
+    assert_nil controller.request_exception
+  end
+
+  def test_controller_returns_nil_on_request_exception_with_check_request_exception_skipped
+    post "/parse_with_check_request_exception_skipped"
+    assert_nil controller.request_exception
+  end
+
+  def test_request_exception_returns_parse_exception_on_invalid_xml_request
+    post "/parse", "<cicinbrus> <name>Ferko</namee> </cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
+    assert_not_nil controller.request_exception
+    assert_xml_parse_exception controller.request_exception
+  end
+
+  def test_request_exception_gets_cleared_for_another_valid_request
+    post "/parse", "<cicinbrus> <name>Ferko</name> </cicinbrus ", 'CONTENT_TYPE' => 'application/xml'
+    post "/parse", "<cicinbrus> <name>Ferko</name> </cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
+    assert_nil controller.request_exception
+  end
+
+  def test_request_exception_gets_cleared_for_another_valid_request_with_check_request_exception_skipped
+    post "/parse_with_check_request_exception_skipped",
+         "<cicinbrus> <name>Ferko</name> </cicinbrus ", 'CONTENT_TYPE' => 'application/xml'
+    post "/parse_with_check_request_exception_skipped",
+         "<cicinbrus> <name>Ferko</name> </cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
+    assert_nil controller.request_exception
+  end
+
+  def test_parse_with_check_request_exception_skipped_does_not_reraise_parse_exception
+    post "/parse_with_check_request_exception_skipped",
+         "<cicinbrus> <name>Ferko</name> </cicinbrus ", 'CONTENT_TYPE' => 'application/xml'
+
+    assert_not_nil controller.request_exception
+    assert_response 200
+  end
+
+  def test_parse_with_check_request_exception_replaced_does_return_501_on_parse_exception
+    post "/parse_with_check_request_exception_replaced",
+         "<cicinbrus> <name>Ferko</name> <cicinbrus>", 'CONTENT_TYPE' => 'application/xml'
+    assert_response 501
+  end
+
+  def test_on_parse_error_custom_rescue_handler_gets_called
+    post "/parse_with_rexml_rescue_block", "<cicinbrus> <name>Ferko</name>", 'CONTENT_TYPE' => 'application/xml'
+    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
+
+  end
+
+  private
+
+    def assert_xml_parse_exception(error)
+      assert_instance_of REXML::ParseException, error
+    end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,153 @@
+require 'rubygems'
+require 'test/unit'
+
+# enable testing with different version of rails via argv :
+# ruby request_exception_handler_test.rb RAILS_VERSION=2.2.2
+
+version =
+  if ARGV.find { |opt| /RAILS_VERSION=([\d\.]+)/ =~ opt }
+    $~[1]
+  else
+    # rake test RAILS_VERSION=2.3.5
+    ENV['RAILS_VERSION']
+  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}"
+else
+  gem 'activesupport'
+  gem 'activerecord'
+  gem 'actionpack'
+  gem 'actionmailer'
+  gem 'rails'
+end
+
+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
+
+if Rails::VERSION::MAJOR >= 3
+  ActiveSupport::Deprecation.behavior = :stderr
+else
+  ActiveSupport::Deprecation.debug = true
+end
+
+if 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
+
+      def initialized=(initialized)
+        @initialized ||= initialized
+      end
+
+      def backtrace_cleaner
+        @@backtrace_cleaner ||=
+          begin
+            require 'rails/gem_dependency' # backtrace_cleaner depends on this !
+            require 'rails/backtrace_cleaner'
+            Rails::BacktraceCleaner.new
+          rescue LoadError
+            nil
+          end
+      end
+
+      def root
+        require 'pathname'
+        Pathname.new(RAILS_ROOT)
+      end
+
+      def env
+        @_env ||= ActiveSupport::StringInquirer.new(RAILS_ENV)
+      end
+
+      def cache
+        RAILS_CACHE
+      end
+
+      def version
+        VERSION::STRING
+      end
+
+      def public_path
+        @@public_path ||= self.root ? File.join(self.root, "public") : "public"
+      end
+
+      def public_path=(path)
+        @@public_path = path
+      end
+      
+    end
+  end
+end
+
+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" }
+
+Rails.backtrace_cleaner.remove_silencers! if Rails.backtrace_cleaner
+
+module Rails # make sure we can set the logger
+  class << self
+    attr_accessor :logger
+  end
+end
+
+File.open(File.join(File.dirname(__FILE__), 'test.log'), 'w') do |file|
+  Rails.logger = Logger.new(file.path)
+end
+
+if ActionController::Base.respond_to? :session_options # Rails 2.x
+
+  skey = Rails.version < '2.3' ? :session_key : :key
+  ActionController::Base.session_options[skey] = '_request_exception_handler_test'
+  ActionController::Base.session_options[:secret] = 'x' * 30
+
+else # since Rails 3.0.0 :
+  
+  module RequestExceptionHandlerTest
+    class Application < Rails::Application
+      config.secret_token = 'x' * 30
+    end
+  end
+  
+  # Initialize the rails application
+  RequestExceptionHandlerTest::Application.initialize!
+
+end
+
+ActiveSupport::TestCase.class_eval do
+
+  def setup_fixtures
+    return nil # Rails 3 load hooks !
+  end
+  
+end
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+require 'request_exception_handler'

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: request_exception_handler
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  version: "0.3"
+platform: ruby
+authors: 
+- Karol Bucek
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-31 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  type: :runtime
+  version_requirements: *id001
+description: a rails hook that allows one to handle request parameter parsing exceptions (invalid XML, 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/request_exception_handler_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/kares/request_exception_handler
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: handler for all the request (parsing) related exceptions
+test_files: 
+- test/request_exception_handler_test.rb
+- test/test_helper.rb