rack-robustness 1.0.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# 1.0.0 / 2013-02-26
+
+* Enhancements
+
+  * Birthday!

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem "rack", "~> 1.5"
+  gem "rake", "~> 10.0"
+  gem "rspec", "~> 2.12"
+  gem "rack-test", "~> 0.6"
+end

data/Gemfile.lock

@@ -0,0 +1,25 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rack (~> 1.5)
+  rack-test (~> 0.6)
+  rake (~> 10.0)
+  rspec (~> 2.12)

data/LICENCE.md

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

data/Manifest.txt

@@ -0,0 +1,15 @@
+rack-robustness.gemspec
+rack-robustness.noespec
+.gemtest
+CHANGELOG.md
+Gemfile
+Gemfile.lock
+bin/**/*
+lib/**/*
+LICENCE.md
+Manifest.txt
+Rakefile
+README.md
+spec/**/*
+tasks/**/*
+test/**/*

data/README.md

@@ -0,0 +1,219 @@
+# Rack::Robustness, the rescue clause of your Rack stack.
+
+Rack::Robustness is the rescue clause of your Rack's call stack. In other words, a middleware that ensures the robustness of your web stack, because exceptions occur either intentionally or unintentionally. It scales from zero configuration (a default shield) to specific rescue clauses for specific errors.
+
+[![Build Status](https://secure.travis-ci.org/blambeau/rack-robustness.png)](http://travis-ci.org/blambeau/rack-robustness)
+[![Dependency Status](https://gemnasium.com/blambeau/rack-robustness.png)](https://gemnasium.com/blambeau/rack-robustness)
+
+## Links
+
+https://github.com/blambeau/rack-robustness
+
+## Why? 
+
+In my opinion, Sinatra's error handling is sometimes a bit limited for real-case needs. So I came up with something a bit more Rack-ish, that allows handling exceptions actively, because exceptions occur and that you'll handle them... enventually. A more theoretic argumentation would be:
+
+* Exceptions occur, because you can't always test/control boundary conditions. E.g. your code can pro-actively test that a file exists before reading it, but it cannot pro-actively test that the user removes the network cable in the middle of a download.
+* The behavior to adopt when obstacles occur is not necessary defined where the exception is thrown, but often higher in the call stack.
+* In ruby web apps, the Rack's call stack is a very important part of your stack. Middlewares, routes and controllers do rarely rescue all errors, so it's still your job to rescue errors higher in the call stack.
+
+Rack::Robustness is therefore a try/catch mechanism as a middleware, to be used along the Rack call stack as you would use a standard one in a more conventional call stack:
+
+```java
+try {
+  // main shield, typically in a main
+  
+  try {
+    // try to achieve a goal here
+  } catch (...) {
+    // fallback to an alternative
+  }
+  
+  // continue your flow
+  
+} catch (...) {
+  // something goes really wrong, inform the user as you can
+}
+```
+
+becomes:
+
+```ruby
+class Main < Sinatra::Base
+
+  # main shield, main = rack top level
+  use Rack::Robustness do
+    # something goes really wrong, inform the user as you can
+    # probably a 5xx http status here
+  end
+
+  # continue your flow
+  use Other::Useful::Middlewares
+
+  use Rack::Robustness do
+    # fallback to an alternative
+    # 3xx, 4xx errors maybe
+  end
+
+  # try to achieve your goal through standard routes
+
+end
+```
+
+## Examples
+
+```ruby
+class App < Sinatra::Base
+
+  ##
+  # Catch everything but hide root causes, for security reasons, for instance.
+  #
+  # This handler should never be fired unless the application has a bug...
+  #
+  use Rack::Robustness do |g|
+    g.status 500
+    g.content_type 'text/plain'
+    g.body 'A fatal error occured.'
+  end
+
+  ##
+  # Some middleware here for logging, content length of whatever.
+  #
+  # Those middleware might fail, even if unlikely.
+  #
+  use ...
+  use ...
+
+  ##
+  # Catch some exceptions that denote client errors by convention in our app.
+  #
+  # Those exceptions are considered safe, so the message is sent to the user.
+  #
+  use Rack::Robustness do |g|
+    g.no_catch_all                 # do not catch all errors
+
+    g.status 400                   # default status to 400, client error
+    g.content_type 'text/plain'    # a default content-type, maybe
+    g.body{|ex| ex.message }       # by default, send the message
+
+    # catch ArgumentError, it denotes a coercion error in our app
+    g.on(ArgumentError)
+
+    # we use SecurityError for handling forbidden accesses.
+    # The default status is 403 here
+    g.on(SecurityError){|ex| 403 }
+  end
+
+  get '/some/route/:id' do |id|
+    id = Integer(id) # will raise an ArgumentError if +id+ not an integer
+
+    ...
+  end
+
+  get '/private' do |id|
+    raise SecurityError unless logged?
+
+    ...
+  end
+
+end
+```
+
+## Without configuration
+
+```ruby
+##
+# Catches all errors.
+#
+# Respond with
+#   status:  500,
+#   headers: {'Content-Type' => 'text/plain'}
+#   body:    [ "Sorry, an error occured." ]
+#
+use Rack::Robustness
+```
+
+## Specifying static status, headers and/or body
+
+```ruby
+##
+# Catches all errors.
+#
+# Respond as specified.
+#
+use Rack::Robustness do |g|
+  g.status 400
+  g.headers 'Content-Type' => 'text/html'
+  g.content_type 'text/html'               # shortcut over headers
+  g.body "<p>an error occured</p>"
+end
+```
+
+## Specifying dynamic status, content_type and/or body
+
+```ruby
+##
+# Catches all errors.
+#
+# Respond as specified.
+#
+use Rack::Robustness do |g|
+  g.status{|ex| ArgumentError===ex ? 400 : 500 }
+
+  # global dynamic headers
+  g.headers{|ex| {'Content-Type' => 'text/plain', ...} }
+
+  # local dynamic and/or static headers
+  g.headers 'Content-Type' => lambda{|ex| ... },
+            'Foo' => 'Bar'
+
+  # dynamic content type
+  g.content_type{|ex| ...}
+
+  # dynamic body (String allowed here)
+  g.body{|ex| ex.message }
+end
+```
+
+## Specific behavior for specific errors
+
+```ruby
+##
+# Catches all errors using defaults as above
+#
+# Respond to specific errors as specified by 'on' clauses.
+#
+use Rack::Robustness do |g|
+  g.status 500                    # this is the default behavior, as above
+  g.content_type 'text/plain'     # ...
+
+  # Override status on TypeError and descendants
+  g.on(TypeError){|ex| 400 }
+
+  # Override body on ArgumentError and descendants
+  g.on(ArgumentError){|ex| ex.message }
+
+  # Override everything on SecurityError and descendants
+  # Default headers will be merged with returned ones so content-type will be
+  # "text/plain" unless specified below
+  g.on(SecurityError){|ex|
+    [ 403, { ... }, [ "Forbidden, sorry" ] ]
+  }
+end
+```
+
+## Don't catch all!
+
+```ruby
+##
+# Catches only errors specified in 'on' clauses, using defaults as above
+#
+# Re-raise unrecognized errors
+#
+use Rack::Robustness do |g|
+  g.no_catch_all
+
+  g.on(TypeError){|ex| 400 }
+  ...
+end
+```

data/Rakefile

@@ -0,0 +1,11 @@
+# We run tests by default
+task :default => :test
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end

data/lib/rack/robustness.rb

@@ -0,0 +1,96 @@
+module Rack
+  class Robustness
+
+    VERSION = "1.0.0".freeze
+
+    NIL_HANDLER = lambda{|ex| nil }
+
+    def initialize(app)
+      @app       = app
+      @handlers  = {}
+      @status    = 500
+      @headers   = {'Content-Type' => "text/plain"}
+      @body      = ["Sorry, a fatal error occured."]
+      @catch_all = true
+      yield self if block_given?
+      on(Object){|ex| [@status, {}, @body]} if @catch_all
+      @headers.freeze
+      @body.freeze
+      @handlers.freeze
+    end
+
+    ##
+    # Configuration
+
+    def no_catch_all
+      @catch_all = false
+    end
+
+    def on(ex_class, &bl)
+      @handlers[ex_class] = bl || NIL_HANDLER
+    end
+
+    def status(s=nil, &bl)
+      @status = s || bl
+    end
+
+    def headers(h=nil, &bl)
+      if h.nil?
+        @headers = bl
+      else
+        @headers.merge!(h)
+      end
+    end
+
+    def content_type(ct=nil, &bl)
+      headers('Content-Type' => ct || bl)
+    end
+
+    def body(b=nil, &bl)
+      @body = b.nil? ? bl : (String===b ? [ b ] : b)
+    end
+
+    ##
+    # Rack's call
+
+    def call(env)
+      @app.call(env)
+    rescue => ex
+      handler = error_handler(ex.class)
+      raise unless handler
+      handle_response(handler, ex)
+    end
+
+  private
+
+    def handle_response(response, ex)
+      case response
+      when NilClass then handle_response([@status,  {},       @body], ex)
+      when Fixnum   then handle_response([response, {},       @body], ex)
+      when String   then handle_response([@status,  {},       response], ex)
+      when Hash     then handle_response([@status,  response, @body], ex)
+      when Proc     then handle_response(response.call(ex), ex)
+      else
+        status, headers, body = response.map{|x| handle_value(x, ex) }
+        [ status,
+          handle_value(@headers, ex).merge(headers),
+          body ]
+      end
+    end
+
+    def handle_value(value, ex)
+      case value
+      when Proc then value.call(ex)
+      when Hash then value.each_with_object({}){|(k,v),h| h[k] = handle_value(v, ex)}
+      else
+        value
+      end
+    end
+
+    def error_handler(ex_class)
+      return nil if ex_class.nil?
+      @handlers.fetch(ex_class){ error_handler(ex_class.superclass) }
+    end
+
+ end # class Robustness
+end # module Rack

data/rack-robustness.gemspec

@@ -0,0 +1,188 @@
+# We require your library, mainly to have access to the VERSION number.
+# Feel free to set $version manually.
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require "rack/robustness"
+$version = Rack::Robustness::VERSION.dup.to_s
+
+#
+# This is your Gem specification. Default values are provided so that your library
+# should be correctly packaged given what you have described in the .noespec file.
+#
+Gem::Specification.new do |s|
+
+  ################################################################### ABOUT YOUR GEM
+
+  # Gem name (required)
+  s.name = "rack-robustness"
+
+  # Gem version (required)
+  s.version = $version
+
+  # A short summary of this gem
+  #
+  # This is displayed in `gem list -d`.
+  s.summary = "Rack::Robustness, the rescue clause of your Rack stack."
+
+  # A long description of this gem (required)
+  #
+  # The description should be more detailed than the summary.  For example,
+  # you might wish to copy the entire README into the description.
+  s.description = "Rack::Robustness provides you with an easy way to handle errors in your stack, for making web applications more robust."
+
+  # The URL of this gem home page (optional)
+  s.homepage = "https://github.com/blambeau/rack-robustness"
+
+  # Gem publication date (required but auto)
+  #
+  # Today is automatically used by default, uncomment only if
+  # you know what you do!
+  #
+  # s.date = Time.now.strftime('%Y-%m-%d')
+
+  # The license(s) for the library.  Each license must be a short name, no
+  # more than 64 characters.
+  #
+  # s.licences = %w{}
+
+  # The rubyforge project this gem lives under (optional)
+  #
+  # s.rubyforge_project = nil
+
+  ################################################################### ABOUT THE AUTHORS
+
+  # The list of author names who wrote this gem.
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  s.authors = ["Bernard Lambeau"]
+
+  # Contact emails for this gem
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  # NOTE: Somewhat strangly this attribute is always singular!
+  #       Don't replace by s.emails = ...
+  s.email  = ["blambeau@gmail.com"]
+
+  ################################################################### PATHS, FILES, BINARIES
+
+  # Paths in the gem to add to $LOAD_PATH when this gem is
+  # activated (required).
+  #
+  # The default 'lib' is typically sufficient.
+  s.require_paths = ["lib"]
+
+  # Files included in this gem.
+  #
+  # By default, we take all files included in the Manifest.txt file on root
+  # of the project. Entries of the manifest are interpreted as Dir[...]
+  # patterns so that lazy people may use wilcards like lib/**/*
+  #
+  here = File.expand_path(File.dirname(__FILE__))
+  s.files = File.readlines(File.join(here, 'Manifest.txt')).
+                 inject([]){|files, pattern| files + Dir[File.join(here, pattern.strip)]}.
+                 collect{|x| x[(1+here.size)..-1]}
+
+  # Test files included in this gem.
+  #
+  s.test_files = Dir["test/**/*"] + Dir["spec/**/*"]
+
+  # The path in the gem for executable scripts (optional)
+  #
+  s.bindir = "bin"
+
+  # Executables included in the gem.
+  #
+  s.executables = (Dir["bin/*"]).collect{|f| File.basename(f)}
+
+  ################################################################### REQUIREMENTS & INSTALL
+  # Remember the gem version requirements operators and schemes:
+  #   =  Equals version
+  #   != Not equal to version
+  #   >  Greater than version
+  #   <  Less than version
+  #   >= Greater than or equal to
+  #   <= Less than or equal to
+  #   ~> Approximately greater than
+  #
+  # Don't forget to have a look at http://lmgtfy.com/?q=Ruby+Versioning+Policies
+  # for setting your gem version.
+  #
+  # For your requirements to other gems, remember that
+  #   ">= 2.2.0"              (optimistic:  specify minimal version)
+  #   ">= 2.2.0", "< 3.0"     (pessimistic: not greater than the next major)
+  #   "~> 2.2"                (shortcut for ">= 2.2.0", "< 3.0")
+  #   "~> 2.2.0"              (shortcut for ">= 2.2.0", "< 2.3.0")
+  #
+
+  #
+  # One call to add_dependency('gem_name', 'gem version requirement') for each
+  # runtime dependency. These gems will be installed with your gem.
+  # One call to add_development_dependency('gem_name', 'gem version requirement')
+  # for each development dependency. These gems are required for developers
+  #
+  s.add_development_dependency("rake", "~> 10.0")
+  s.add_development_dependency("rspec", "~> 2.12")
+  s.add_development_dependency("rack", "~> 1.5")
+  s.add_development_dependency("rack-test", "~> 0.6")
+  
+
+  # The version of ruby required by this gem
+  #
+  # Uncomment and set this if your gem requires specific ruby versions.
+  #
+  # s.required_ruby_version = ">= 0"
+
+  # The RubyGems version required by this gem
+  #
+  # s.required_rubygems_version = ">= 0"
+
+  # The platform this gem runs on.  See Gem::Platform for details.
+  #
+  # s.platform = nil
+
+  # Extensions to build when installing the gem.
+  #
+  # Valid types of extensions are extconf.rb files, configure scripts
+  # and rakefiles or mkrf_conf files.
+  #
+  s.extensions = []
+
+  # External (to RubyGems) requirements that must be met for this gem to work.
+  # It’s simply information for the user.
+  #
+  s.requirements = nil
+
+  # A message that gets displayed after the gem is installed
+  #
+  # Uncomment and set this if you want to say something to the user
+  # after gem installation
+  #
+  s.post_install_message = nil
+
+  ################################################################### SECURITY
+
+  # The key used to sign this gem.  See Gem::Security for details.
+  #
+  # s.signing_key = nil
+
+  # The certificate chain used to sign this gem.  See Gem::Security for
+  # details.
+  #
+  # s.cert_chain = []
+
+  ################################################################### RDOC
+
+  # An ARGV style array of options to RDoc
+  #
+  # See 'rdoc --help' about this
+  #
+  s.rdoc_options = []
+
+  # Extra files to add to RDoc such as README
+  #
+  s.extra_rdoc_files = Dir["README.md"] + Dir["CHANGELOG.md"] + Dir["LICENCE.md"]
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rack'
+require 'rack/robustness'
+require 'rack/test'
+
+module SpecHelpers
+end
+
+RSpec.configure do |c|
+  c.include SpecHelpers
+end

data/spec/test_robustness.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+describe Rack::Robustness do
+  include Rack::Test::Methods
+
+  def mock_app(&bl)
+    Rack::Builder.new do
+      use Rack::Robustness, &bl
+      map '/happy' do
+        run lambda{|env| [200, {'Content-Type' => 'text/plain'}, ['happy']]}
+      end
+      map "/argument-error" do
+        run lambda{|env| raise ArgumentError, "an argument error" }
+      end
+      map "/type-error" do
+        run lambda{|env| raise TypeError, "a type error" }
+      end
+    end
+  end
+
+  shared_examples_for 'A transparent middleware for happy paths' do
+
+    it 'let happy responses unchanged' do
+      get '/happy'
+      last_response.status.should eq(200)
+      last_response.content_type.should eq('text/plain')
+      last_response.body.should eq('happy')
+    end
+  end
+
+  context 'with the default configuration' do
+    let(:app){
+      mock_app
+    }
+
+    it_should_behave_like 'A transparent middleware for happy paths'
+
+    it 'set a status 500 with a standard error message by default' do
+      get '/argument-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq("text/plain")
+      last_response.body.should eq("Sorry, a fatal error occured.")
+    end
+  end
+
+  context 'with a status, content_type and body constants' do
+    let(:app){
+      mock_app do |g|
+        g.status 501
+        g.content_type "text/test"
+        g.body "An error occured"
+      end
+    }
+
+    it_should_behave_like 'A transparent middleware for happy paths'
+
+    it 'set the specified status and body on errors' do
+      get '/argument-error'
+      last_response.status.should eq(501)
+      last_response.content_type.should eq("text/test")
+      last_response.body.should eq("An error occured")
+    end
+  end
+
+  context 'with headers' do
+    let(:app){
+      mock_app do |g|
+        g.headers 'Content-Type' => 'text/test',
+                  'Foo' => 'Bar'
+      end
+    }
+
+    it_should_behave_like 'A transparent middleware for happy paths'
+
+    it 'set the specified headers on error' do
+      get '/argument-error'
+      last_response.headers['Foo'].should eq('Bar')
+      last_response.content_type.should eq("text/test")
+    end
+  end
+
+  context 'with a dynamic status, content_type and body' do
+    let(:app){
+      mock_app do |g|
+        g.status      {|ex| ArgumentError===ex ? 400 : 500}
+        g.content_type{|ex| ArgumentError===ex ? "text/arg" : 'text/other'}
+        g.body        {|ex| ex.message }
+      end
+    }
+
+    it_should_behave_like 'A transparent middleware for happy paths'
+
+    it 'correctly sets the status, content_type and body on ArgumentError' do
+      get '/argument-error'
+      last_response.status.should eq(400)
+      last_response.content_type.should eq('text/arg')
+      last_response.body.should eq('an argument error')
+    end
+
+    it 'correctly sets the status, content_type and body on TypeError' do
+      get '/type-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq('text/other')
+      last_response.body.should eq('a type error')
+    end
+  end
+
+  context 'with dynamic headers I' do
+    let(:app){
+      mock_app do |g|
+        g.headers{|ex|
+          {'Content-Type' => ArgumentError===ex ? "text/arg" : 'text/other' }
+        }
+      end
+    }
+
+    it_should_behave_like 'A transparent middleware for happy paths'
+
+    it 'correctly sets the specified headers on an ArgumentError' do
+      get '/argument-error'
+      last_response.content_type.should eq("text/arg")
+    end
+
+    it 'correctly sets the specified headers on a TypeError' do
+      get '/type-error'
+      last_response.content_type.should eq("text/other")
+    end
+  end
+
+  context 'with dynamic headers II' do
+    let(:app){
+      mock_app do |g|
+        g.headers 'Content-Type' => lambda{|ex| ArgumentError===ex ? "text/arg" : 'text/other'},
+                  'Foo' => 'Bar'
+      end
+    }
+
+    it_should_behave_like 'A transparent middleware for happy paths'
+
+    it 'correctly sets the specified headers on an ArgumentError' do
+      get '/argument-error'
+      last_response.headers['Foo'].should eq('Bar')
+      last_response.content_type.should eq("text/arg")
+    end
+
+    it 'correctly sets the specified headers on a TypeError' do
+      get '/type-error'
+      last_response.headers['Foo'].should eq('Bar')
+      last_response.content_type.should eq("text/other")
+    end
+  end
+
+  context 'when responding to specific errors with a full response' do
+    let(:app){
+      mock_app do |g|
+        g.headers 'Foo' => 'Bar', 'Content-Type' => 'default/one'
+        g.on(ArgumentError){|ex| [401, {'Content-Type' => 'text/arg'}, [ ex.message ] ] }
+        g.on(TypeError){|ex| [402, {}, [ ex.message ] ] }
+      end
+    }
+
+    after do
+      # if merges the default headers in any way
+      last_response.headers['Foo'].should eq('Bar')
+    end
+
+    it 'uses the response on ArgumentError' do
+      get '/argument-error'
+      last_response.status.should eq(401)
+      last_response.content_type.should eq('text/arg')
+      last_response.body.should eq("an argument error")
+    end
+
+    it 'uses the response on TypeError' do
+      get '/type-error'
+      last_response.status.should eq(402)
+      last_response.content_type.should eq('default/one')
+      last_response.body.should eq("a type error")
+    end
+  end
+
+  context 'when responding to specific errors with a single status' do
+    let(:app){
+      mock_app do |g|
+        g.on(ArgumentError){|ex| 401 }
+      end
+    }
+
+    it 'uses the status and fallback to defaults for the rest' do
+      get '/argument-error'
+      last_response.status.should eq(401)
+      last_response.content_type.should eq('text/plain')
+      last_response.body.should eq("Sorry, a fatal error occured.")
+    end
+  end
+
+  context 'when responding to specific errors with a single body' do
+    let(:app){
+      mock_app do |g|
+        g.on(ArgumentError){|ex| ex.message }
+      end
+    }
+
+    it 'uses it as body and fallback to defaults for the rest' do
+      get '/argument-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq('text/plain')
+      last_response.body.should eq("an argument error")
+    end
+  end
+
+  context 'when configured with no_catch_all' do
+    let(:app){
+      mock_app do |g|
+        g.no_catch_all
+        g.on(ArgumentError){|ex| 401 }
+      end
+    }
+
+    it 'matches known errors' do
+      get '/argument-error'
+      last_response.status.should eq(401)
+    end
+
+    it 'raises on unknown error' do
+      lambda{
+        get '/type-error'
+      }.should raise_error(TypeError)
+    end
+  end
+
+  context 'when responding to specific errors without body' do
+    let(:app){
+      mock_app do |g|
+        g.no_catch_all
+        g.status(401)
+        g.on(ArgumentError)
+      end
+    }
+
+    it 'matches known errors' do
+      get '/argument-error'
+      last_response.status.should eq(401)
+      last_response.body.should eq("Sorry, a fatal error occured.")
+    end
+
+    it 'raises on unknown error' do
+      lambda{
+        get '/type-error'
+      }.should raise_error(TypeError)
+    end
+  end
+
+end

data/tasks/gem.rake

@@ -0,0 +1,73 @@
+# Installs rake tasks for gemming and packaging
+#
+# This file installs the 'rake package', 'rake gem' tasks and associates
+# (clobber_package, repackage, ...). It is automatically generated by Noe
+# from your .noespec file, and should therefore be configured there, under
+# the variables/rake_tasks/gem entry, as illustrated below:
+#
+# variables:
+#   rake_tasks:
+#     gem:
+#       package_dir: pkg
+#       need_tar: false
+#       need_tar_gz: false
+#       need_tar_bz2: false
+#       need_zip: false
+#       ...
+#
+# If you have specific needs requiring manual intervention on this file,
+# don't forget to set safe-override to false in your noe specification:
+#
+# template-info:
+#   manifest:
+#     tasks/gem.rake:
+#       safe-override: false
+#
+begin
+  require 'rubygems/package_task'
+
+  # Dynamically load the gem spec
+  gemspec_file = File.expand_path('../../rack-robustness.gemspec', __FILE__)
+  gemspec      = Kernel.eval(File.read(gemspec_file))
+
+  Gem::PackageTask.new(gemspec) do |t|
+
+    # Name of the package
+    t.name = gemspec.name
+
+    # Version of the package
+    t.version = gemspec.version
+
+    # Directory used to store the package files
+    t.package_dir = "pkg"
+
+    # True if a gzipped tar file (tgz) should be produced
+    t.need_tar = false
+
+    # True if a gzipped tar file (tar.gz) should be produced
+    t.need_tar_gz = false
+
+    # True if a bzip2'd tar file (tar.bz2) should be produced
+    t.need_tar_bz2 = false
+
+    # True if a zip file should be produced (default is false)
+    t.need_zip = false
+
+    # List of files to be included in the package.
+    t.package_files = gemspec.files
+
+    # Tar command for gzipped or bzip2ed archives.
+    t.tar_command = "tar"
+
+    # Zip command for zipped archives.
+    t.zip_command = "zip"
+
+  end
+rescue LoadError
+  task :gem do
+    abort 'rubygems/package_task is not available. You should verify your rubygems installation'
+  end
+  task :package do
+    abort 'rubygems/package_task is not available. You should verify your rubygems installation'
+  end
+end

data/tasks/spec_test.rake

@@ -0,0 +1,71 @@
+# Installs a rake task for for running examples written using rspec.
+#
+# This file installs the 'rake spec_test' (aliased as 'rake spec') as well as
+# extends 'rake test' to run spec tests, if any. It is automatically generated
+# by Noe from your .noespec file, and should therefore be configured there,
+# under the variables/rake_tasks/spec_test entry, as illustrated below:
+#
+# variables:
+#   rake_tasks:
+#     spec_test:
+#       pattern: spec/**/*_spec.rb
+#       verbose: true
+#       rspec_opts: [--color, --backtrace]
+#       ...
+#
+# If you have specific needs requiring manual intervention on this file,
+# don't forget to set safe-override to false in your noe specification:
+#
+# template-info:
+#   manifest:
+#     tasks/spec_test.rake:
+#       safe-override: false
+#
+# This file has been written to conform to RSpec v2.4.0. More information about
+# rspec and options of the rake task defined below can be found on
+# http://relishapp.com/rspec
+#
+begin
+  require "rspec/core/rake_task"
+  desc "Run RSpec code examples"
+  RSpec::Core::RakeTask.new(:spec_test) do |t|
+    # Glob pattern to match files.
+    t.pattern = "spec/**/test_*.rb"
+
+    # Whether or not to fail Rake when an error occurs (typically when
+    # examples fail).
+    t.fail_on_error = true
+
+    # A message to print to stderr when there are failures.
+    t.failure_message = nil
+
+    # Use verbose output. If this is set to true, the task will print the
+    # executed spec command to stdout.
+    t.verbose = true
+
+    # Use rcov for code coverage?
+    t.rcov = false
+
+    # Path to rcov.
+    t.rcov_path = "rcov"
+
+    # Command line options to pass to rcov. See 'rcov --help' about this
+    t.rcov_opts = []
+
+    # Command line options to pass to ruby. See 'ruby --help' about this
+    t.ruby_opts = []
+
+    # Path to rspec
+    t.rspec_path = "rspec"
+
+    # Command line options to pass to rspec. See 'rspec --help' about this
+    t.rspec_opts = ["--color", "--backtrace"]
+  end
+rescue LoadError => ex
+  task :spec_test do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+ensure
+  task :spec => [:spec_test]
+  task :test => [:spec_test]
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: rack-robustness
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Bernard Lambeau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: Rack::Robustness provides you with an easy way to handle errors in your
+  stack, for making web applications more robust.
+email:
+- blambeau@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+- LICENCE.md
+files:
+- rack-robustness.gemspec
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- lib/rack/robustness.rb
+- LICENCE.md
+- Manifest.txt
+- Rakefile
+- README.md
+- spec/spec_helper.rb
+- spec/test_robustness.rb
+- tasks/gem.rake
+- tasks/spec_test.rake
+homepage: https://github.com/blambeau/rack-robustness
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2934394792950840478
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rack::Robustness, the rescue clause of your Rack stack.
+test_files:
+- spec/spec_helper.rb
+- spec/test_robustness.rb