egregious 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in egregious.gemspec
+gemspec
+

data/README

@@ -0,0 +1,47 @@
+Egregious is a rails based exception handling gem for well defined http exception handling for json, xml and html.
+
+If you have a json or xml api into your rails application, you probably have added your own exception handling to map
+exceptions to a http status and formatting your json and xml output.  We did to. We were tired of doing it over and
+over. We decided to create egregious. One of the major goals is to start providing a more consistent api error
+experience for all rails applications. As of the creation of egregious the behavior of rails was to return html when an
+exception is thrown with the status code of 500.  With egregious proper json and html of the error will be returned
+with a good default mapping of exceptions to http status codes.  This allows api developers to respond to the status
+code properly, instead of scratching their head with 500's coming back all the time. If the problem was yours then the
+result codes are in the 300 range. If the problem was the server then the status codes are in the 500's.  With the
+message and exception type providing more context information.
+
+ What egregious can do:
+
+ * Defines default exception handling for most common ruby, rails, warden and cancan exceptions.
+   (warden and cancan are optional)
+ * Catches defined exceptions using a rescue_with returning the status code defined for each exception
+   and well structured json, xml
+ * For html production requests attempts to load the html error pages for the mapped status code,
+   falling back to the 500.html page.
+ * Defines exceptions for all http status codes allowing you to throw these exceptions anywhere in your code.
+ * Allows you to change the exception mapping to fit your needs, adding exceptions and changing status mapping.
+
+
+REQUIRES:
+  Rails 3.x
+
+USAGE:
+1) Add to your Gemfile:
+gem 'egregious'
+
+2) In your ApplicationController add:
+include Egregious
+
+Optionally, to configure create an initializer and add:
+
+Egregious.exception_codes.merge!({NameError => :bad_request})
+
+This will either add a new mapping or replace the existing mapping to a new status code.
+You can pass the status code as a symbol, integer or string.
+
+In your code if you want to send an error back just throw an exception. For example:
+
+raise Egregious::BadRequest.new("You can not created an order without a customer.") unless customer_id
+
+All the http status codes have exception classes named after them in the Egregious module. You can throw any exception,
+or define your own exceptions. You can find a list in the Rack::Utils::HTTP_STATUS_CODES class.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/egregious.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "egregious/version"
+
+Gem::Specification.new do |s|
+  s.name        = "egregious"
+  s.version     = Egregious::VERSION
+  s.authors     = ["Russell Edens"]
+  s.email       = ["rx@voomify.com"]
+  s.homepage    = "http://github.com/voomify/egregious"
+  s.summary     = %q{Egregious is a rails based exception handling gem for well defined http exception handling for json, xml and html}
+  s.description = %q{Requires Rails 3.x.}
+
+  s.rubyforge_project = "egregious"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "json"
+  s.add_development_dependency "hpricot"
+  s.add_development_dependency "rails", '~> 3.1.0'
+  s.add_development_dependency "rails", '~> 3.1.0'
+  s.add_development_dependency "warden"
+  s.add_development_dependency "cancan"
+
+  s.add_runtime_dependency "rack"
+end

data/lib/egregious.rb

@@ -0,0 +1,159 @@
+require "egregious/version"
+require "egregious/extensions/exception"
+require 'rack'
+
+
+module Egregious
+
+  # use these exception to control the code you are throwing from you code
+  # all http statuses have an exception defined for them
+  Rack::Utils::HTTP_STATUS_CODES.each do |key, value|
+    class_eval "class #{value.gsub(/\s|-/,'')} < StandardError; end"
+  end
+
+  def self.status_code(status)
+    if status.is_a?(Symbol)
+      Rack::Utils::HTTP_STATUS_CODES[status] || 500
+    else
+      status.to_i
+    end
+  end
+
+  # internal method that loads the exception codes
+  def self._load_exception_codes
+
+    # by default if there is not mapping they map to 500/internal server error
+    exception_codes = {
+        SecurityError=>status_code(:forbidden)
+    }
+    # all status codes have a exception class defined
+    Rack::Utils::HTTP_STATUS_CODES.each do |key, value|
+      exception_codes.merge!(eval("Egregious::#{value.gsub(/\s|-/,'')}")=>value.downcase.gsub(/\s|-/, '_').to_sym)
+    end
+
+    if defined?(ActionController)
+      exception_codes.merge!({
+                               AbstractController::ActionNotFound=>status_code(:bad_request),
+                               ActionController::InvalidAuthenticityToken=>status_code(:bad_request),
+                               ActionController::MethodNotAllowed=>status_code(:not_allowed),
+                               ActionController::MissingFile=>status_code(:not_found),
+                               ActionController::RoutingError=>status_code(:bad_request),
+                               ActionController::UnknownController=>status_code(:bad_request),
+                               ActionController::UnknownHttpMethod=>status_code(:not_allowed)
+                               #ActionController::MissingTemplate=>status_code(:not_found)
+                             })
+    end
+
+    if defined?(ActiveModel)
+      exception_codes.merge!({
+                                 ActiveModel::MissingAttributeError=>status_code(:bad_request)})
+    end
+
+    if defined?(ActiveRecord)
+      exception_codes.merge!({
+                               ActiveRecord::AttributeAssignmentError=>status_code(:bad_request),
+                               ActiveRecord::HasAndBelongsToManyAssociationForeignKeyNeeded=>status_code(:bad_request),
+                               ActiveRecord::MultiparameterAssignmentErrors=>status_code(:bad_request),
+                               ActiveRecord::ReadOnlyAssociation=>status_code(:forbidden),
+                               ActiveRecord::ReadOnlyRecord=>status_code(:forbidden),
+                               ActiveRecord::RecordInvalid=>status_code(:bad_request),
+                               ActiveRecord::RecordNotFound=>status_code(:not_found),
+                               ActiveRecord::UnknownAttributeError=>status_code(:bad_request)
+                             })
+    end
+
+    if defined?(Warden)
+      exception_codes.merge!({
+                                 Warden::NotAuthenticated=>status_code(:unauthorized),
+                             })
+    end
+
+    if defined?(CanCan)
+      # technically this should be forbidden, but for some reason cancan returns AccessDenied when you are not logged in
+      exception_codes.merge!({CanCan::AccessDenied=>status_code(:unauthorized)})
+      exception_codes.merge!({CanCan::AuthorizationNotPerformed => status_code(:unauthorized)})
+    end
+
+    @@exception_codes = exception_codes
+  end
+
+  @@exception_codes = self._load_exception_codes
+  @@root = defined?(Rail) ? Rails.root : nil
+
+  # exposes the root of the app
+  def self.root
+    @@root
+  end
+
+  # set the root directory and stack traces will be cleaned up
+  def self.root=(root)
+    @@root=root
+  end
+
+  # a little helper to help us clean up the backtrace
+  # if root is defined it removes that, for rails it takes care of that
+  def clean_backtrace(exception)
+    if backtrace = exception.backtrace
+      if Egregious.root
+        backtrace.map { |line| line.sub Egregious.root, '' }
+      else
+        backtrace
+      end
+    end
+  end
+
+  # this method exposes the @@exception_codes class variable
+  # allowing someone to re-configure the mapping. For example in a rails initializer:
+  # Egregious.exception_codes = {NameError => "503"}   or
+  # If you want the default mapping and then want to modify it you should call the following:
+  # Egregious.exception_codes.merge!({MyCustomException=>"500"})
+  def self.exception_codes
+    @@exception_codes
+  end
+
+  # this method exposes the @@exception_codes class variable
+  # allowing someone to re-configure the mapping. For example in a rails initializer:
+  # Egregious.exception_codes = {NameError => "503"}   or
+  # If you want the default mapping and then want to modify it you should call the following:
+  # Egregious.exception_codes.merge!({MyCustomException=>"500"})
+  def self.exception_codes=(exception_codes)
+    @@exception_codes=exception_codes
+  end
+
+  # this method will auto load the exception codes if they are not set
+  # by an external configuration call to self.exception_code already
+  # it is called by the status_code_for_exception method
+  def exception_codes
+    return Egregious.exception_codes
+  end
+
+  # this method will lookup the exception code for a given exception class
+  # if the exception is not in our map then it will return 500
+  def status_code_for_exception(exception)
+    self.exception_codes[exception.class] ? self.exception_codes[exception.class] : '500'
+  end
+
+  def egregious_exception_handler(exception)
+    flash.now[:alert] = exception.message
+    logger.fatal(
+        "\n\n" + exception.class.to_s + ' (' + exception.message.to_s + '):\n    ' +
+            clean_backtrace(exception).join("\n    ") +
+            "\n\n")
+    HoptoadNotifier.notify(exception) if defined?(HoptoadNotifier)
+    respond_to do |format|
+      status = status_code_for_exception(exception)
+      format.xml { render :xml=> exception.to_xml, :status => status }
+      format.json { render :json=> exception.to_json, :status => status }
+      # render the html page for the status we are returning it exists...if not then render the 500.html page.
+      format.html { render :file => File.exists?(Rails.root + '/public/' + status + '.html') ?
+                                      Rails.root + '/public/' + status + '.html' : Rails.root + '/public/500.html'}
+    end
+  end
+
+
+  def self.included(base)
+    base.class_eval do
+      rescue_from 'Exception' , :with => :egregious_exception_handler
+    end
+  end
+end

data/lib/egregious/extensions/exception.rb

@@ -0,0 +1,17 @@
+#
+# We are opening up Exception and adding to_xml and to_json.
+#
+class Exception
+
+  def exception_type
+    self.class.to_s ? self.class.to_s.split("::").last : 'None'
+  end
+
+  def to_xml
+    "<errors><error>#{self.message}</error><type>#{self.exception_type}</type></errors>"
+  end
+
+  def to_json
+    "{\"error\":\"#{self.message.gsub(/\r/, ' ').gsub(/\n/, ' ').squeeze(' ')}\", \"type\":\"#{self.exception_type}\"}"
+  end
+end

data/lib/egregious/version.rb

@@ -0,0 +1,3 @@
+module Egregious
+  VERSION = "0.1.0"
+end

data/spec/egregious_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+def rescue_from(exception, options)
+end
+
+include Egregious
+
+describe Egregious do
+  describe 'clean_backtrace ' do
+    it "should return nil" do
+      clean_backtrace(Exception.new).should == nil
+    end
+
+    it "should return a stack trace" do
+      begin
+        raise Exception.new
+      rescue Exception=>exception
+        clean_backtrace(exception).size.should be > 0
+      end
+    end
+
+    it "should remove the beginning of the backtrace" do
+      begin
+        raise Exception.new
+      rescue Exception=>exception
+        class Rails
+          def self.root
+            __FILE__
+          end
+        end
+        clean_backtrace(exception)[0].should match /:\d/
+      end
+    end
+  end
+
+  #
+  # Once these codes are published and used in the gem, they should not change.
+  # it will break other peoples apis.  This test ensures that.
+  # client should use a configuration file to change the mappings themselves
+  #
+  describe 'exception_codes' do
+
+    it "should return forbidden for SecurityError's'" do
+      exception_codes[SecurityError].should ==  Egregious.status_code(:forbidden)
+    end
+
+    if defined?(ActionController)
+      it "should return expected errors for ActionController" do
+         exception_codes[AbstractController::ActionNotFound].should ==  Egregious.status_code(:forbidden)
+         exception_codes[AbstractController::ActionNotFound].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActionController::InvalidAuthenticityToken].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActionController::MethodNotAllowed].should ==  Egregious.status_code(:not_allowed)
+         exception_codes[ActionController::MissingFile].should ==  Egregious.status_code(:not_found)
+         exception_codes[ActionController::RoutingError].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActionController::UnknownController].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActionController::UnknownHttpMethod].should ==  Egregious.status_code(:not_allowed)
+         exception_codes[ActionController::MissingTemplate].should ==  Egregious.status_code(:not_found)
+      end
+    end
+
+    if defined?(ActiveModel)
+      it "should return expected errors for ActiveModel" do
+        exception_codes[ActiveModel::MissingAttributeError].should ==  Egregious.status_code(:bad_request)
+      end
+    end
+
+    if defined?(ActiveRecord)
+      it "should return expected errors for ActiveRecord" do
+         exception_codes[ActiveRecord::AttributeAssignmentError].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActiveRecord::HasAndBelongsToManyAssociationForeignKeyNeeded].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActiveRecord::MultiparameterAssignmentErrors].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActiveRecord::ReadOnlyAssociation].should ==  Egregious.status_code(:forbidden)
+         exception_codes[ActiveRecord::ReadOnlyRecord].should ==  Egregious.status_code(:forbidden)
+         exception_codes[ActiveRecord::RecordInvalid].should ==  Egregious.status_code(:bad_request)
+         exception_codes[ActiveRecord::RecordNotFound].should ==  Egregious.status_code(:not_found)
+         exception_codes[ActiveRecord::UnknownAttributeError].should ==  Egregious.status_code(:bad_request)
+      end
+    end
+
+    if defined?(Warden)
+      it "should return expected errors for Warden" do
+        exception_codes[Warden::NotAuthenticated].should ==  Egregious.status_code(:unauthorized)
+      end
+    end
+
+    if defined?(CanCan)
+      it "should return expected errors for CanCan" do
+        # technically this should be forbidden, but for some reason cancan returns AccessDenied when you are not logged in
+        exception_codes[CanCan::AccessDenied].should ==  Egregious.status_code(:unauthorized)
+        exception_codes[CanCan::AuthorizationNotPerformed].should ==  Egregious.status_code(:unauthorized)
+      end
+    end
+  end
+
+  describe "status_code_for_exception" do
+    it 'should return 500 for non-mapped exceptions'do
+      exception_codes[Exception].should == nil
+      status_code_for_exception(Exception.new).should=='500'
+    end
+    it 'should allow configuration of exception codes' do
+      Egregious.exception_codes.merge!({NameError => "999"})
+      status_code_for_exception(NameError.new).should=="999"
+    end
+    end
+end

data/spec/exceptions_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'json'
+require 'hpricot'
+
+describe Exception do
+  it "should output valid xml on to_xml" do
+    doc = Hpricot.XML(Exception.new("Yes").to_xml)
+    (doc/:errors).each do |error|
+       (error/:error).inner_html.should=='Yes'
+      (error/:type).inner_html.should=='Exception'
+    end
+  end
+
+  it "should output be valid json on to_json" do
+    result = JSON.parse(Exception.new("Yes").to_json)
+    result['error'].should == "Yes"
+    result['type'].should == "Exception"
+  end
+
+  it "should parse module names out" do
+    module X
+      module Y
+        class Z < Exception
+        end
+      end
+    end
+    X::Y::Z.new.exception_type.should == 'Z'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'bundler'
+Bundler.setup
+
+ENV["RAILS_ENV"] ||= "test"
+require 'active_support'
+require 'active_support/test_case'
+require 'warden'
+require 'cancan'
+
+require 'egregious' # and any other gems you need
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification 
+name: egregious
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Russell Edens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-27 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 3
+        - 1
+        - 0
+        version: 3.1.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 3
+        - 1
+        - 0
+        version: 3.1.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: warden
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: cancan
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id008
+description: Requires Rails 3.x.
+email: 
+- rx@voomify.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- egregious.gemspec
+- lib/egregious.rb
+- lib/egregious/extensions/exception.rb
+- lib/egregious/version.rb
+- spec/egregious_spec.rb
+- spec/exceptions_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/voomify/egregious
+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: egregious
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Egregious is a rails based exception handling gem for well defined http exception handling for json, xml and html
+test_files: 
+- spec/egregious_spec.rb
+- spec/exceptions_spec.rb
+- spec/spec_helper.rb