wvanbergen-http_status_exceptions 0.1.6 → 0.1.7

data/README.rdoc

@@ -4,14 +4,14 @@ This simple plugin will register exception classes for all HTTP status. These ex
 which a response will be send back to the client with the desired HTTP status, possible with some other content.
 
 You can use this plugin to access control mechanisms. You can simply raise a HTTPStatus::Forbidden if a user is not allowed to
-perform a certain action. A nice looking error page will be the result. See the example below 
+perform a certain action. A nice looking error page will be the result. See the example below:
 
 See the project wiki (http://github.com/wvanbergen/http_status_exceptions/wikis) for additional documentation.
 
 == Installation
 
 Installation is simple. Simply add the gem in your <tt>environment.rb</tt>:
-  
+
   Rails::Initializer.run do |config|
     ...
     config.gem 'wvanbergen-http_status_exceptions', :lib => 'http_status_exceptions', :source => 'http://gems.github.com'
@@ -22,12 +22,12 @@ Run <tt>rake gems:install</tt> to install the gem if needed.
 == Configuration
 
 You can modify where HTTP status exception looks for its template files like so:
-  
+
   class ApplicationController < ActionController::Base
     ...
     HTTPStatus::Base.template_path = 'path_to/http_status_templates'
   end
-  
+
 You can also modify which layout is used when rendering a template by setting the <tt>template_layout</tt>:
 
   class ApplicationController < ActionController::Base
@@ -56,5 +56,5 @@ to the response as well, create the following view: <tt>shared/http_status/forbi
   <hr />
   <p>HTTP status code <small> <%= @exception.status_code %>: <%= @exception.status.to_s.humanize %></small></p>
 
-The response will only be sent if the request format is HTML because of the name of the view file. In theory you 
+The response will only be sent if the request format is HTML because of the name of the view file. In theory you
 could make a response for XML requests as well by using <tt>shared/http_status/forbidden.xml.builder</tt> as filename

data/Rakefile

@@ -1,5 +1,5 @@
 Dir[File.dirname(__FILE__) + "/tasks/*.rake"].each { |file| load(file) }
 
-GithubGem::RakeTasks.new(:gem) 
+GithubGem::RakeTasks.new(:gem)
 
 task :default => :spec

data/http_status_exceptions.gemspec

@@ -1,17 +1,18 @@
 Gem::Specification.new do |s|
   s.name    = 'http_status_exceptions'
-  s.version = "0.1.6"
+  s.version = "0.1.7"
   s.date    = "2009-09-26"
-  
+
   s.summary     = "A Rails plugin to use exceptions for generating HTTP status responses"
   s.description = "Clean up your controller code by raising exceptions that generate responses with different HTTP status codes."
-  
+
   s.add_runtime_dependency('action_controller')
   s.add_development_dependency('rspec')
-  
+
   s.authors  = ['Willem van Bergen']
   s.email    = ['willem@vanbergen.org']
   s.homepage = 'http://github.com/wvanbergen/http_status_exceptions/wikis'
-  
-  s.files = %w(spec/spec_helper.rb http_status_exceptions.gemspec .gitignore init.rb lib/http_status_exceptions.rb Rakefile MIT-LICENSE tasks/github-gem.rake README.rdoc spec/http_status_exception_spec.rb)
+
+  s.files      = %w(spec/spec_helper.rb http_status_exceptions.gemspec .gitignore init.rb lib/http_status_exceptions.rb Rakefile MIT-LICENSE tasks/github-gem.rake README.rdoc spec/http_status_exception_spec.rb)
+  s.test_files = %w(spec/http_status_exception_spec.rb)
 end

data/lib/http_status_exceptions.rb

@@ -1,5 +1,8 @@
 module HTTPStatus
-  
+
+  # The Base HTTP status exception class is used as superclass for every
+  # exception class that is constructed. It implements some shared functionality
+  # for finding the status code and determining the template path to render.
   class Base < StandardError
 
     # The path from which the error documents are loaded.
@@ -8,38 +11,70 @@ module HTTPStatus
 
     # The layout in which the error documents are rendered
     cattr_accessor :template_layout
+    @@template_path = nil # Use the standard layout template setting by default.
+
+    attr_reader :details
 
-    attr_reader :status, :details
-    
     # Creates the exception with a message and some optional other info.
     def initialize(message = nil, details = nil)
-      @status = self.class.to_s.split("::").last.underscore.to_sym rescue :internal_server_error
       @details = details
       super(message)
     end
-    
-    # The numeric status code corresponding to this exception
+
+    # Returns the HTTP status symbol (as defined by Rails) corresponding to this class.
+    # This method should be overridden by subclasses
+    def self.status
+      :internal_server_error
+    end
+
+    # Returns the HTTP status symbol (as defined by Rails) corresponding to this instance.
+    # By default, it calls the class method of the same name.
+    def status
+      self.class.status
+    end
+
+    # The numeric status code corresponding to this exception class.
+    # Uses the status code map provided by Rails.
+    def self.status_code
+      ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[self.status]
+    end
+
+    # The numeric status code corresponding to this exception.
+    # By default, it calls the class method of the same name.
     def status_code
-      ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@status]
+      self.class.status_code
+    end
+
+    # The name of the template that should be used as error page for this exception class.
+    def self.template
+      "#{template_path}/#{status}"
     end
-    
-    # The name of the template that should be used as error page for this exception
+
+    # The name of the template that should be used as error page for this exception.
+    # By default, it calls the class method of the same name.
     def template
-      "#{@@template_path}/#{@status}"
+      self.class.template
     end
   end
 
   # Creates all the exception classes based on Rails's list of available status code and
   # registers the exception handler using the rescue_from method.
   def self.included(base)
-    ActionController::StatusCodes::STATUS_CODES.each do |code, name|
-      const_set(name.to_s.gsub(/[^A-Za-z]/, '').camelize, Class.new(HTTPStatus::Base)) if code >= 400
-    end
-    
     base.send(:rescue_from, HTTPStatus::Base, :with => :http_status_exception)
   end
 
-  # The default handler for raised HTTP status exceptions. 
+  # Generates a HTTPStatus::Base subclass for every subclass that is found
+  def self.const_missing(const)
+    status_symbol = const.to_s.underscore.to_sym
+    raise "Unrecognized HTTP Status name!" unless ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.has_key?(status_symbol)
+    klass = Class.new(HTTPStatus::Base)
+    klass.cattr_accessor(:status)
+    klass.status = status_symbol
+    const_set(const, klass)
+    return const_get(const)
+  end
+
+  # The default handler for raised HTTP status exceptions.
   # It will render a template if available, or respond with an empty response
   # with the HTTP status correspodning to the exception.
   def http_status_exception(exception)
@@ -52,4 +87,5 @@ module HTTPStatus
   end
 end
 
+# Include the HTTPStatus module into ActionController to enable its functionality
 ActionController::Base.send(:include, HTTPStatus)

data/spec/http_status_exception_spec.rb

@@ -1,51 +1,93 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe 'HTTPStatus#http_status_exception' do
+describe HTTPStatus::Base do
   before(:each) do
-    @controller_class = Class.new(ActionController::Base)
-    @controller       = @controller_class.new
+    ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.stub!(:has_key?).with(:testing_status).and_return(true)
+    @status_exception_class = HTTPStatus::TestingStatus
   end
-  
-  it "should respond to the :http_status_exception method" do
-    @controller.should respond_to(:http_status_exception)
+
+  after(:each) do
+    HTTPStatus::Base.template_path = 'shared/http_status'
+    HTTPStatus.send :remove_const, 'TestingStatus'
+  end
+
+  it "should set the status symbol based on the class name" do
+    @status_exception_class.status.should == :testing_status
+  end
+
+  it "should check ActionController's status code list for the status code based on the class name" do
+    ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.should_receive(:[]).with(:testing_status)
+    @status_exception_class.status_code
+  end
+
+  it "should use the HTTPStatus::Base.template_path setting to determine the error template" do
+    HTTPStatus::Base.template_path = 'testing'
+    @status_exception_class.template.should == 'testing/testing_status'
   end
   
-  ['NotFound', 'Forbidden', 'PaymentRequired'].each do |status_class|
-    status_symbol = status_class.underscore.downcase.to_sym
-    
-    it "should create the HTTPStatus::#{status_class} class" do
-      HTTPStatus.const_defined?(status_class).should be_true
+  it "should raise an exception when the class name does not correspond to a HTTP status code" do
+    lambda { HTTPStatus::Nonsense }.should raise_error
+  end
+end
+
+# Run some tests for different valid subclasses.
+{ 'NotFound' => 404, 'Forbidden' => 403, 'PaymentRequired' => 402, 'InternalServerError' => 500}.each do |status_class, status_code|
+
+  describe "HTTPStatus::#{status_class}" do
+    it "should generate the HTTPStatus::#{status_class} class successfully" do
+      lambda { HTTPStatus.const_get(status_class) }.should_not raise_error
     end
-    
+
     it "should create a subclass of HTTPStatus::Base for the #{status_class.underscore.humanize.downcase} status" do
       HTTPStatus.const_get(status_class).ancestors.should include(HTTPStatus::Base)
     end
-    
-    it "should call render with the correct #{status_class.underscore.humanize.downcase} view and correct HTTP status" do
-      @controller.should_receive(:render).with(hash_including(
-            :status => status_symbol, 
-            :template => "shared/http_status/#{status_symbol}"))
 
-      @controller.http_status_exception(HTTPStatus.const_get(status_class).new('test'))
+    it "should return the correct status code (#{status_code}) when using the class" do
+      HTTPStatus.const_get(status_class).status_code.should == status_code
     end
+    
+    it "should return the correct status code (#{status_code}) when using the instance" do
+      HTTPStatus.const_get(status_class).new.status_code.should == status_code
+    end    
   end
 end
 
-describe HTTPStatus::Base do
-  before(:each) { @status = HTTPStatus::Base.new }
-  
-  it "should set the status symbol bases on the class name" do
-    @status.status.should == :base
+describe 'HTTPStatus#http_status_exception' do
+  before(:each) { @controller = Class.new(ActionController::Base).new }
+  after(:each)  { HTTPStatus::Base.template_layout = nil}
+
+  it "should create the :http_status_exception method in ActionController" do
+    @controller.should respond_to(:http_status_exception)
   end
-  
-  it "should check ActionController's status code list for the status code based on the class name" do
-    ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.should_receive(:[]).with(:base)
-    @status.status_code
+
+  it "should call :http_status_exception when an exception is raised when handling the action" do
+    exception = HTTPStatus::Base.new('test')
+    @controller.stub!(:perform_action_without_rescue).and_raise(exception)
+    @controller.should_receive(:http_status_exception).with(exception)
+    @controller.send(:perform_action)
   end
-  
-  it "should use the HTTPStatus::Base.template_path setting to determine the error template" do
-    HTTPStatus::Base.template_path = 'testing'
-    @status.template.should == 'testing/base'
+
+  it "should call render with the correct view and correct HTTP status" do
+    @controller.should_receive(:render).with(hash_including(
+          :status => :internal_server_error, :template => "shared/http_status/internal_server_error"))
+
+    @controller.http_status_exception(HTTPStatus::Base.new('test'))
   end
-end
 
+  it "should not call render with a layout by default" do
+    @controller.should_not_receive(:render).with(hash_including(:layout => 'testing'))
+    @controller.http_status_exception(HTTPStatus::Base.new('test'))
+  end
+
+  it "should call render with a layout set when this property is set on the exception class" do
+    @controller.should_receive(:render).with(hash_including(:layout => 'testing'))
+    HTTPStatus::Base.template_layout = 'testing'
+    @controller.http_status_exception(HTTPStatus::Base.new('test'))
+  end
+  
+  it "should call head with the correct status code if render cannot found a template" do
+    @controller.stub!(:render).and_raise(ActionView::MissingTemplate.new([], 'template.htm.erb'))
+    @controller.should_receive(:head).with(:internal_server_error)
+    @controller.http_status_exception(HTTPStatus::Base.new('test'))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wvanbergen-http_status_exceptions
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -79,5 +79,5 @@ rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: A Rails plugin to use exceptions for generating HTTP status responses
-test_files: []
-
+test_files: 
+- spec/http_status_exception_spec.rb