rack-rescue 0.1.0

data/Users/dneighman/Projects/rack-rescue/lib/rack/rescue/handler.rb

@@ -0,0 +1,124 @@
+module Rack
+  class Rescue
+    class Handler
+      include Pancake::Mixins::Render
+
+      # Setup the default root for the error templates
+      roots << ::File.join(::File.expand_path(::File.dirname(__FILE__)), "templates")
+      push_paths(:error_templates, "rack_rescue_templates", "**/*")
+
+      attr_accessor :exception, :status, :default_template, :default_format
+      attr_reader   :name
+
+      # Rack::Rescue::Handler looks for templates in the form
+      #   <template_name>.<format>.<engine_name>
+      #
+      # By default, the format is :text, but you can configure this to be any format you like
+      # @see Rack::Rescue::Handler.default_format=
+      # @api public
+      def self.default_format
+        @default_format ||= :text
+      end
+
+      # Set the default format to format of your chosing
+      #
+      # @example
+      #   Rack::Rescue::Handler.default_format = :html
+      #
+      # @see Rack::Rescue::Handler.default_format
+      # @api public
+      def self.default_format=(format)
+        @default_format = format
+      end
+
+      # Looks to se if a template is avaialble
+      #
+      # @example
+      #   Rack::Rescue::Handler.template?(:obscure_error, :format => :html)
+      #
+      # @see Pancake::Mixins::Render::ClassMethods#template
+      def self.template?(name, opts = {})
+        !!template(name, opts)
+      rescue Pancake::Mixins::Render::TemplateNotFound
+        false
+      end
+
+      # The defaule path name for the paths_for label
+      #
+      # @example
+      #   Rack::Rescue::Handler.push_paths(:error_templates, ".", "**/*")
+      #   Rack::Rescue::Handler._template_path_name should return :error_templates
+      #
+      # @see Pancake::Mixins::Render::ClassMethods._template_path_name
+      # @api overwritable
+      def self._template_path_name(opts = {})
+        :error_templates
+      end
+
+      # Provides the name for the template with the relevant options
+      #
+      # The template name should be the filename of the template up and until the extension for the template engine.
+      #
+      # The template name can be one of two forms.
+      # The first preference includes the format, and the rack environment.
+      #
+      # @example
+      #   # ENV['RACK_ENV'] == "test" && format == :html
+      #   my_template.test.html.haml
+      #
+      #   # The second preference is to use simply the format
+      #   my_template.html.haml
+      #
+      # @example
+      #   # To find a template: my_template.html.erb
+      #
+      # Rack::Rescue::Handler._template_name_for("my_template", :format => :html) #=> "my_template.html"
+      # @see Pancake::Mixins::Render::ClassMethods._template_name_for
+      # @api overwritable
+      def self._template_name_for(name,opts)
+        @template_names ||= {}
+        format = opts.fetch(:format, default_format)
+        env = ENV['RACK_ENV']
+        key = [name, env, format]
+        @template_names[key] ||= begin
+          names = []
+          names << "#{name}.#{env}.#{format}" if env && format
+          names << "#{name}.#{format}" if format
+          names << "#{name}"
+          names
+        end
+      end
+
+      def initialize(exception, opts = {}, &blk)
+        @exception  = exception
+        @name       = Exceptions.exception_name(exception)
+        @status     = opts.fetch(:status, 500)
+        @default_template   = opts.fetch(:template, 'error')
+        @default_format     = opts[:format] if opts[:format]
+      end
+
+      # The main workhorse of the handler
+      # This should be called with the error you want to render.
+      # The error will be provided to the template in the local "error" variable
+      # @api private
+      def render_error(error, opts = {})
+        opts = opts.dup
+        template_name = opts.fetch(:template_name, default_template)
+        opts[:format] ||= default_format || self.class.default_format
+        opts[:error]  ||= error
+        opts[:status] = self.status
+
+        if self.class.template?(template_name, opts)
+          tn = template_name
+        else
+          tn = 'error'
+          unless self.class.template?(tn, opts)
+            opts[:format] = :text
+          end
+        end
+
+        render(tn, opts)
+      end
+    end
+  end
+end

data/Users/dneighman/Projects/rack-rescue/lib/rack/rescue/responder.rb

@@ -0,0 +1,21 @@
+module Rack
+  class Rescue
+    class Responder
+      include Pancake::Mixins::RequestHelper
+      include Pancake::Mixins::ResponseHelper
+
+      def initialize(env, rescuer)
+        @rescuer = rescuer
+        @env = env
+      end
+
+      def negotiate!(opts = {})
+        negotiate_content_type!(@rescuer.formats, opts)
+      rescue Pancake::Errors::NotAcceptable
+        mt = Pancake::MimeTypes.group(:text).first
+        headers["Content-Type"] = mt.type_strings.first
+        :text
+      end
+    end
+  end
+end

data/Users/dneighman/Projects/rack-rescue/lib/rack/rescue/templates/rack_rescue_templates/error.development.html.erb

@@ -0,0 +1,19 @@
+<div class='exception'>
+  <% content_block :error_header do %>
+    <h1>Error: <%= error.class %></h1>
+  <% end %>
+
+  <% content_block :error_message do %>
+    <div class='error'>
+      <%= error.message %>
+    </div>
+  <% end %>
+
+  <% content_block :error_backtrace do %>
+    <ul class='error backtrace'>
+      <% error.backtrace.each do |line| %>
+        <li><%= line %></li>
+      <% end %>
+    </ul>
+  <% end %>
+</div>

data/Users/dneighman/Projects/rack-rescue/lib/rack/rescue/templates/rack_rescue_templates/error.html.erb

@@ -0,0 +1,15 @@
+<div class='exception'>
+  <% content_block :error_header do %>
+    <h1><%= status %> Error</h1>
+  <% end %>
+
+  <% content_block :error_message do %>
+    <div class='error'>
+      <%= error.message %>
+    </div>
+  <% end %>
+
+  <% content_block :error_backtrace do %>
+    &nbsp;
+  <% end %>
+</div>

data/Users/dneighman/Projects/rack-rescue/lib/rack/rescue/templates/rack_rescue_templates/error.text.erb

@@ -0,0 +1,14 @@
+<% content_block :error_header do %>
+  Error: <%= error.class %>
+<% end %>
+
+<% content_block :error_message do %>
+  Error Message: <%= error.message %>
+<% end %>
+
+<% content_block :error_backtrace do %>
+  Error Backtrace:
+  <% if error && error.backtrace %>
+    <%= error.backtrace.join("\n") %>
+  <% end %>
+<% end %>

data/Users/dneighman/Projects/rack-rescue/lib/rack/rescue/templates/rack_rescue_templates/not_found.text.erb

@@ -0,0 +1,4 @@
+<% inherits_from :error %>
+<% content_block :error_header do %>
+  Not Found: <%= error.class %>
+<% end %>

data/Users/dneighman/Projects/rack-rescue/rack-rescue.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require 'bundler'
+
+Gem::Specification.new do |s|
+  s.name = 'rack-rescue'
+  s.version = '0.1.0'
+  s.homepage = %q{http://github.com/hassox/rack-rescue}
+  s.authors = ["Daniel Neighman"]
+  s.autorequire = %q{rack/rescue}
+  s.date = Date.today
+  s.description = %q{Rescue Handler for Rack}
+  s.summary =%q{Rescue Handler for Rack}
+  s.email = %q{has.sox@gmail.com}
+
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.files = Dir[File.join(Dir.pwd, "**/*")]
+
+  s.add_bundler_dependencies
+
+end
+
+

data/Users/dneighman/Projects/rack-rescue/spec/rack-rescue_spec.rb

@@ -0,0 +1,151 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RackRescue" do
+  class RRUnknownException < RuntimeError; end
+
+  after do
+    Rack::Rescue.error_handlers.clear
+  end
+
+  def safe_endpoint(msg = "OK")
+    lambda{|e| Rack::Response.new(msg)}
+  end
+
+  def raise_endpoint(exception, msg)
+    lambda{|e| raise exception, msg }
+  end
+
+  def build_stack(endpoint = safe_endpoint)
+    Rack::Builder.new do
+      use Rack::Rescue
+      run endpoint
+    end
+  end
+
+  before do
+    @env = Rack::MockRequest.env_for("/")
+  end
+
+  it "should do nothing if there is no downstream exception" do
+    result = build_stack.call(@env)
+    result.body.map.join.should == "OK"
+  end
+
+  it "should render the error with the defautl text error handler if it's an unkonwn exception" do
+    @env['HTTP_ACCEPT'] =  "text/plain"
+    bad_app = raise_endpoint(RRUnknownException, "Unknown Brew")
+    stack = build_stack(bad_app)
+    r = stack.call(@env)
+    r[0].should == 500
+    body = r[2].body.map.join
+    body.should include("Error")
+    body.should include("Unknown Brew")
+  end
+
+  describe "A known exception" do
+    it "should render the template for the error" do
+      bad_app = raise_endpoint(Pancake::Errors::NotFound, "Action Not Found")
+      stack = build_stack(bad_app)
+      @env['HTTP_ACCEPT'] = 'text/plain'
+      r = stack.call(@env)
+
+      body = r[2].body.map.join
+      body.should include("Pancake::Errors::NotFound")
+    end
+
+    it "should set the correct status code" do
+      bad_app = raise_endpoint(Pancake::Errors::NotFound, "Action Not Found")
+      stack = build_stack(bad_app)
+      @env['HTTP_ACCEPT'] = "text/plain"
+      r = stack.call(@env)
+
+      status = r[0]
+      status.should == 404
+      body = r[2].body.map.join
+      body.should include("Action Not Found")
+    end
+  end
+
+  it "should provide a list of default formats" do
+    Rack::Rescue.default_formats.should == Pancake::MimeTypes.groups.keys.map(&:to_sym)
+    rr = Rack::Rescue.new SUCCESS_APP
+    rr.formats.should == Pancake::MimeTypes.groups.keys.map(&:to_sym)
+  end
+
+  it "should let me overwrite the formats avaiable" do
+    rr = Rack::Rescue.new(SUCCESS_APP, :formats => [:text, :html])
+    rr.formats.should == [:text, :html]
+  end
+
+  it "should inspect the rack env and negotiate the content" do
+    env = Rack::MockRequest.env_for("/")
+    env['HTTP_ACCEPT'] = "text/xml"
+
+    rr = Rack::Rescue.new(raise_endpoint(RuntimeError, "Boo"))
+    result = rr.call(env)
+    result[0].should == 500
+    result[2].body.to_s.should include("XML Error Template")
+  end
+
+  it "should inspect the extension of the " do
+    env = Rack::MockRequest.env_for("/")
+    env['HTTP_ACCEPT'] = "text/xml"
+
+    rr = Rack::Rescue.new(raise_endpoint(RuntimeError, "Boo"))
+    result = rr.call(env)
+    result[0].should == 500
+    result[2].body.to_s.should include("XML Error Template")
+  end
+
+  it "should wrap the error in a layout if there's one present" do
+    endpoint = raise_endpoint(RuntimeError, "Bad Error")
+
+    layout_dir = File.join(File.expand_path(File.dirname(__FILE__)), 'rack', 'rescue', 'fixtures', 'layouts')
+
+    File.exists?(File.join(layout_dir, "error.html.erb")).should be_true
+
+    app = Rack::Builder.new do
+      use Wrapt do |wrapt|
+        wrapt.layout_dirs << layout_dir
+      end
+
+      use Rack::Rescue
+      run endpoint
+    end
+
+    env = Rack::MockRequest.env_for("/foo.html")
+    r = app.call(env)
+    r[0].should == 500
+    body = r[2].body.to_s
+    body.should include("<h1>Error Layout</h1>")
+  end
+
+  it "should allow me to add error handlers and they should execute on each exception" do
+    layout_dir = File.join(File.expand_path(File.dirname(__FILE__)), 'rack', 'rescue', 'fixtures', 'layouts')
+    Rack::Rescue.add_handler do |exception, env, options|
+      options[:format].should == :html
+      options[:layout].should == 'error'
+    end
+    Rack::Rescue.add_handler do |exception, env, options|
+      options[:format] = :xml
+      options[:layout] = 'custom_error_layout'
+    end
+    Rack::Rescue.add_handler do |exception, env, options|
+      options[:format].should == :xml
+      options[:layout].should == 'custom_error_layout'
+    end
+
+    app = Rack::Builder.new do
+      use Wrapt do |wrapt|
+        wrapt.layout_dirs << layout_dir
+      end
+      use Rack::Rescue
+      the_app = lambda{|e| raise "Halp"}
+      run the_app
+    end
+
+    result = app.call(Rack::MockRequest.env_for("/"))
+    result[2].body.join.should include("Custom Error Layout")
+  end
+
+end

data/Users/dneighman/Projects/rack-rescue/spec/rack/rescue/exceptions_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+describe Rack::Rescue::Exceptions do
+  subject { Rack::Rescue::Exceptions.new(false) }
+
+  before do
+    subject.add("MyNotFoundException")
+  end
+
+  it "should allow me to access the exception" do
+    subject["MyNotFoundException"].should be_an_instance_of(Rack::Rescue::Handler)
+  end
+
+  it "should provide me with a hash of all handlers" do
+    handler = subject.exception_handlers["MyNotFoundException"]
+    subject.exception_handlers.should == {"MyNotFoundException" => handler}
+  end
+
+  it "should allow me to remove handling of an exception" do
+    subject.delete("MyNotFoundException")
+    subject["MyNotFoundHandler"].should be_nil
+  end
+
+  it "should set the status of the exception to 500 by default" do
+    subject["MyNotFoundException"].status.should == 500
+  end
+
+  it "should allow me to change the status of an exception" do
+    handler = subject["MyNotFoundException"]
+    handler.status = 404
+    handler.status.should == 404
+  end
+
+  describe "accessing handlers" do
+    before do
+      @handler = subject["MyNotFoundException"]
+    end
+
+    it "should allow me to access the exception with the constnat" do
+      subject[MyNotFoundException].should == @handler
+    end
+
+    it "should allow me to access the exception with an instance" do
+      subject[MyNotFoundException.new].should == @handler
+    end
+  end
+
+  it "should add to the default list" do
+    e = Rack::Rescue::Exceptions
+    lambda do
+      e.add_defaults("MyException", :status => 400)
+    end.should change(e::DEFAULT_HANDLERS, :size).by(1)
+  end
+
+  it "should add to the default list with a string" do
+    e = Rack::Rescue::Exceptions
+    e.add_defaults("MyException", "SomethingElse", "Another")
+    lambda do
+      e.remove_defaults("SomethingElse", "Another")
+    end.should change(Rack::Rescue::Exceptions::DEFAULT_HANDLERS, :size).by(-2)
+  end
+
+  it "should add to the default list with a string" do
+    e = Rack::Rescue::Exceptions
+    e.add_defaults("Foo::MyException", "Foo::SomethingElse", "Another")
+    lambda do
+      e.remove_defaults(/^Foo/)
+    end.should change(Rack::Rescue::Exceptions::DEFAULT_HANDLERS, :size).by(-2)
+  end
+
+  describe "Pre-Packaged Exceptions" do
+    subject{ Rack::Rescue::Exceptions.new }
+    describe "Not found errors" do
+      it{ subject["DataMapper::ObjectNotFoundError"         ].status.should == 404 }
+      it{ subject["ActiveRecord::RecordNotFound"            ].status.should == 404 }
+      it{ subject["Pancake::Errors::NotFound"               ].status.should == 404 }
+      it{ subject["Pancake::Errors::UnknownRouter"          ].status.should == 500 }
+      it{ subject["Pancake::Errors::UnknownConfiguration"   ].status.should == 500 }
+      it{ subject["Pancake::Errors::Unauthorized"           ].status.should == 401 }
+      it{ subject["Pancake::Errors::Forbidden"              ].status.should == 403 }
+      it{ subject["Pancake::Errors::Server"                 ].status.should == 500 }
+      it{ subject["Pancake::Errors::NotAcceptable"          ].status.should == 406 }
+    end
+  end
+end