egregious 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74b9d8d3b64d8c2ab878e23b18eb2c28f73fd6c6
-  data.tar.gz: 8d4b0939f3140b103168b09a82b86e6889996eb5
+  metadata.gz: 9f054b5425e665f2ebda249fb5df5e8f89b39f96
+  data.tar.gz: a0b34cdbdd5fbd5938c9436c8d62b0f0c454033b
 SHA512:
-  metadata.gz: 91c5341f2896b83a227f1a7565034ab4bc79d26b0beb242667323c20f24001cf6431fa0dfe972b8b662c8c714a6d0e82cf26379f731a3ae5c24c9b14891ab64a
-  data.tar.gz: 77c99d9f971799355983b5ab290a177fd365a534b4f1304fc113d295e55a959fd35aff4720f3332d959baaeaf208b58a357d5a9ac0a356ee696a413cab53b8a1
+  metadata.gz: c782e63e62b4cf4013beee5d097ed70f4c304e3893edfbdaf58a519240d6621c363fe88370e38e52f15b74f290b2fcc92e19c0245c43d9f54f95f8c3f74937a1
+  data.tar.gz: 653ae2c6121911c6c46f6931450b8ff0141d532676b4003372fe557e332ab6066ad38ca8a603507b4410a1e560103d48f080be666113e0f55e212df57e5ea4ee

data/.gitignore

@@ -4,3 +4,6 @@ Gemfile.lock
 pkg/*
 .idea
 .ruby-version
+*.gemfile.lock
+log/test.log
+

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+gemfile:
+  - gemfiles/rails_3.gemfile
+  - gemfiles/rails_4.gemfile
+rvm:
+  - "1.9.3"
+  - "2.2.3"
+
+#matrix:
+#  allow_failures:
+#    - env: "RAILS_VERSION=master"
+#    - rvm: ruby-head
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Appraisals

@@ -0,0 +1,8 @@
+appraise "rails-3" do
+  gem "rails", "3.2.22"
+  gem 'test-unit', '~> 3.0'
+end
+
+appraise "rails-4" do
+  gem "rails", "4.2.5"
+end

data/Gemfile

@@ -2,10 +2,3 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in egregious.gemspec
 gemspec
-
-if RUBY_VERSION < '1.9'
-  gem 'mongoid', '< 3'
-  gem 'bson_ext'
-else
-  gem 'mongoid', '>= 3'
-end

data/README.md

@@ -0,0 +1,265 @@
+[![Build Status](https://travis-ci.org/voomify/egregious.svg?branch=master)](https://travis-ci.org/voomify/egregious)
+##### Update Log:
+
+  * Version 0.2.12 Added support for Airbrake 5
+
+  * Version 0.2.11 Fixed the development behavior that does not show the debugging screens when exceptions
+  are thrown. Now when in development you will get the rails default exception handling screens for html requests.
+
+  * Version 0.2.10 released to https://rubygems.org/gems/egregious on 10.28.2015
+        Fixed bug where an exception defines http_status but returns nil.
+        This was resulting in a status of 200 being returned, when it should be a 500.
+
+If you would like to contribute take a look at the issues feature list, fork and issue a pull request!
+
+##### What is Egregious?
+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 decided to create egregious. One of the 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 the api caller then the result codes are in the 300 range. If the problem
+was on the server then the status codes are in the 500 range.  The returned exception message and exception type
+provide the caller context information.
+
+ What egregious can do:
+
+ * Defines default exception handling for most common ruby, rails, warden, cancan and mongoid exceptions.
+   (warden, cancan and mongoid 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.
+ * If Airbrake is defined it will send the errors to Airbrake.
+ * The error will be logged with stack trace
+
+
+##### REQUIRES:
+  rails > 3.0, < 5.0
+  rack  >= 1.3.6
+
+##### USAGE:
+1) Add to your Gemfile:
+```ruby
+gem 'egregious'
+```
+
+2) In your ApplicationController add:
+```ruby
+include Egregious
+```
+
+##### KNOWN ISSUES:
+* If you use Mongoid, CanCan or Devise you must have Egregious after CanCan/Devise in your Gemfile, if not it will not handle those errors correctly.
+
+##### Implementation Notes
+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.
+
+
+You probably have code sprinkled about like this:
+
+```ruby
+rescue_from CanCan::AccessDenied do |exception|
+ flash[:alert] = exception.message
+ respond_to do |format|
+ format.html { redirect_to dashboard_path }
+ format.xml {
+      render :xml => exception.to_xml, :status => :forbidden }
+ format.json { render :json=>
+      exception.to_json, :status => :forbidden }
+ end
+end
+```
+
+This example is straight from the CanCan docs. You'll notice a couple of things here. This handles the
+CanCan::AccessDenied exception only. It then will redirect to the startup page, or render xml and json returning
+the http status code of :forbidden (403). You can see one of the first features of the Egregious gem. We extend
+Exception to add the to_xml and to_json methods. These return a well structured error that can be consumed by the
+API client.
+```ruby
+Exception.new("Hi Mom").to_xml
+```
+returns:
+```xml
+<errors>
+    <error>Hi Mom</error>
+    <type>Exception</type>
+</errors>
+```
+```ruby
+Exception.new("Hi Dad").to_json
+```
+returns:
+```json
+{"error":"Hi Dad", "type":"Exception"}
+```
+
+So that's pretty handy in itself. Now all exceptions have a json and xml api that describe them. It happens to be the same
+xml and json that is returned from the errors active record object, with the addition of the type element. That
+allows you to mix and match validations and exceptions. Wow, big deal. We'll it is. If you are writing a client
+then you need to have a very well defined error handling. I'd like to see all of rails do this by default. So that
+anyone interacting with a rails resource has a consistent error handling experience. (Expect more on being a good
+REST API in future posts.) As a client we can now handle errors in a consistent way.
+
+Besides the error message we would like a well defined mapping of classes of exceptions to http status codes. The idea is
+that if I get back a specific http status code then I can program against that 'class' of problems. For example if
+I know that what I did was because of invalid input from my user, I can display that message back to the user.
+They can correct it and continue down the path. But if the Http status code says that it was a problem with the
+server, then I know that I need to log it and notify someone to see how to resolve it.
+
+We handle all exceptions of a given class with a mapping to an http status code. With all the most common Ruby,
+Rails, Devise, Warden and CanCan exceptions having reasonable defaults. (Devise, Warden and CanCan are all
+optional and ignored if their gems are not installed.)
+
+As of 0.2.9 you can also define a
+method named 'http_status' on the exception and it will be used as the status code. This is a nice pattern that
+allows you to raise an exception and specify the status code. The Egregious::Error allows you to do this as a
+second parameter to initialize:
+
+```ruby
+raise Egregious::Error.new("My very bad error", :payment_required)
+```
+
+
+ If the problem
+was the api caller then the result codes are in the 300 range. If the problem was on the server then the status
+codes are in the 500 range.
+
+I'm guessing if you bother to read this far, you are probably
+interested in using Egregious. Its simple to use and configure. To install:
+
+In you Gemfile
+add the following:
+
+```ruby
+gem 'egregious'
+```
+
+
+
+In
+your ApplicationController class add the following at or near the top:
+
+```ruby
+class ApplicationController < ActionController::Base
+    include Egregious
+    # your code ...
+end
+```
+
+
+
+That's it. You will now get
+reasonable api error handling.
+
+If you want to add your own exceptions to http status codes
+    end
+mappings, or change the defaults add an initializer and put the following into it:
+
+
+```ruby
+Egregious.exception_codes.merge!({NameError => :bad_request})
+```
+
+
+Here
+you can re-map anything and you can add new mappings.
+
+Note: If you think the default
+exception mappings should be different, please contact me @rx via the
+https://github.com/voomify/egregious project.
+
+We also
+created exceptions for each of the http status codes, so that you can throw those exceptions in your code. Its an
+easy way to throw the right status code and setup a good message for it. If you want to provide more context, you
+can derive you own exceptions and add mappings for them.
+
+Here is an example of throwing a
+bad request exception:
+
+```ruby
+raise Egregious::BadRequest.new("You can not created an order without a customer.") unless customer_id
+```
+
+
+
+Egregious adds
+mapping of many exceptions, if you have your own rescue_from handlers those will get invoked. You will not lose
+any existing behavior, but you also might not see the changes you expect until you remove or modify those
+rescue_from calls. At a minimum I suggest using the .to_xml and .to_json calls io your existing rescue_from
+methods/blocks.
+
+And finally if you don't like the default behavior. You can override any
+portion of it and change it to meet your needs.
+
+If you want to change the behavior then you
+can override the following methods in your ApplicationController.
+
+```ruby
+# override this if you want your flash to behave differently
+def egregious_flash(exception)
+    flash.now[:alert] = exception.message
+end
+```
+
+
+```ruby
+# override this if you want your logging to behave differently
+def
+      egregious_log(exception)
+ 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)
+end
+```
+
+```ruby
+# override this if you want to change your respond_to behavior
+def egregious_respond_to(exception)
+ 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?(build_html_file_path(status)) ?
+    build_html_file_path(status) : build_html_file_path('500')}
+ end
+end
+```
+```ruby
+# override this if you want to change what html static file gets returned.
+def build_html_file_path(status)
+    File.expand_path(Rails.root, 'public', status + '.html')
+end
+```
+
+
+
+```ruby
+# override this if you want to control what gets sent to airbrake
+# optionally you can configure the airbrake ignore list
+def notify_airbrake(exception)
+  # tested with airbrake 3.1.15, 4.2.1 and 5.0.5
+  if defined?(Airbrake)
+    if(Airbrake.respond_to?(:notify_or_ignore))
+      env['airbrake.error_id'] = Airbrake.notify_or_ignore(exception) # V4
+    else
+      env['airbrake.error_id'] = Airbrake.notify(exception) # V5
+    end
+  end
+end
+```
+
+We are using this gem in all our Rails projects.
+
+Go forth and be egregious!

data/Rakefile

@@ -1 +1,12 @@
+require "rubygems"
+require "bundler/setup"
 require "bundler/gem_tasks"
+
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+t.pattern = Dir.glob('spec/**/*_spec.rb')
+t.rspec_opts = '--format documentation'
+end
+task :default => :spec

data/egregious.gemspec

@@ -20,17 +20,17 @@ Gem::Specification.new do |s|
 
 
   s.add_runtime_dependency "rails", '> 3.0', '< 5'
-  s.add_runtime_dependency "rack", '>= 1.3.6'
+  s.add_runtime_dependency "rack", '>= 1.2.5'
   s.add_runtime_dependency "htmlentities"
 
   # specify any dependencies here; for example:
   s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-rails"
   s.add_development_dependency "json"
   s.add_development_dependency "hpricot"
   s.add_development_dependency "warden"
   s.add_development_dependency "cancan"
   s.add_development_dependency "mongoid"
-  s.add_development_dependency "bson_ext"
-
+  s.add_development_dependency "appraisal"
 
 end

data/gemfiles/rails_3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "3.2.22"
+gem "test-unit", "~> 3.0"
+
+gemspec :path => "../"

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "4.2.5"
+
+gemspec :path => "../"

data/lib/egregious.rb

@@ -96,7 +96,7 @@ module Egregious
                                Mongoid::Errors::Validations=>status_code(:unprocessable_entity)
                              })
       
-      if Mongoid::VERSION > '3'
+      if defined?(Mongoid::VERSION) && Mongoid::VERSION > '3'
         exception_codes.merge!({
                                  Mongoid::Errors::ReadonlyAttribute=>status_code(:forbidden),
                                  Mongoid::Errors::UnknownAttribute=>status_code(:bad_request)
@@ -137,7 +137,9 @@ module Egregious
   def clean_backtrace(exception)
     if backtrace = exception.backtrace
       if Egregious.root
-        backtrace.map { |line| line.sub Egregious.root, '' }
+        backtrace.map { |line|
+          line.sub Egregious.root.to_s, ''
+        }
       else
         backtrace
       end
@@ -173,7 +175,7 @@ module Egregious
   # if the exception is not in our map then see if the class responds to :http_status
   # if not it will return 500
   def status_code_for_exception(exception)
-    Egregious.status_code_for_exception(exception)
+      Egregious.status_code_for_exception(exception)
   end
 
   def self.status_code_for_exception(exception)
@@ -204,10 +206,14 @@ module Egregious
 
    # override this if you want to control what gets sent to airbrake
   def notify_airbrake(exception)
-    # for ancient clients - can probably remove
-    HoptoadNotifier.notify(exception) if defined?(HoptoadNotifier)
-    # tested with airbrake 3.1.15 and 4.2.1
-    env['airbrake.error_id'] = Airbrake.notify_or_ignore(exception) if defined?(Airbrake)
+    # tested with airbrake 3.1.15, 4.2.1 and 5.0.5
+    if defined?(Airbrake)
+      if(Airbrake.respond_to?(:notify_or_ignore))
+        env['airbrake.error_id'] = Airbrake.notify_or_ignore(exception) # V4
+      else
+        env['airbrake.error_id'] = Airbrake.notify(exception) # V5
+      end
+    end
   end
   
   # override this if you want to change your respond_to behavior
@@ -217,9 +223,16 @@ module Egregious
       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?(build_html_file_path(status)) ?
+      format.html {
+        # render the rails exception page if we are local/debugging
+        if(Rails.application.config.consider_all_requests_local || request.local?)
+          raise exception
+        else
+          render :file => File.exists?(build_html_file_path(status)) ?
                                       build_html_file_path(status) : build_html_file_path('500'),
-                           :status => status }
+                           :status => status
+        end
+      }
     end
   end
 
@@ -230,25 +243,6 @@ module Egregious
   def self.included(base)
     base.class_eval do
       rescue_from 'Exception' , :with => :egregious_exception_handler
-      
-      unless respond_to?(:flash)
-        def egregious_flash(exception)
-        end
-      end
-      
-      unless respond_to?(:respond_to)
-        def egregious_respond_to(exception)
-          status = status_code_for_exception(exception)
-          case params[:format]
-          when 'xml' then render :xml=> exception.to_xml, :status => status
-          when 'json' then 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.
-          else render :file => File.exists?(build_html_file_path(status)) ?
-                                            build_html_file_path(status) : build_html_file_path('500'),
-                                 :status => status
-          end
-        end
-      end
     end
   end
 end

data/lib/egregious/version.rb

@@ -1,3 +1,3 @@
 module Egregious
-  VERSION = "0.2.10"
+  VERSION = "0.2.12"
 end

data/spec/apps/rails3_2.rb

@@ -0,0 +1,52 @@
+# http://www.rubytutorial.io/how-to-test-your-gem-against-multiple-rails/
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "active_resource/railtie"
+require "rails/test_unit/railtie"
+require "sprockets/railtie"
+require 'action_view/testing/resolvers'
+require 'rails/test_help'
+
+require 'egregious' # our gem
+
+class Rails3_2 < Rails::Application
+  config.root = File.expand_path("../../..", __FILE__)
+  config.cache_classes = true
+
+  config.eager_load = false
+  config.serve_static_assets  = true
+  config.static_cache_control = "public, max-age=3600"
+
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  config.action_dispatch.show_exceptions = false
+
+  config.action_controller.allow_forgery_protection = false
+
+  config.active_support.deprecation = :stderr
+
+  config.middleware.delete "Rack::Lock"
+  config.middleware.delete "ActionDispatch::Flash"
+  config.middleware.delete "ActionDispatch::BestStandardsSupport"
+  config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
+  routes.append do
+    get "/" => "welcome#index"
+    get "/" => "fake#test"
+  end
+end
+
+class WelcomeController < ActionController::Base
+  include Rails.application.routes.url_helpers
+  layout 'application'
+  self.view_paths = [ActionView::FixtureResolver.new(
+    "layouts/application.html.erb" => '<%= yield %>',
+    "welcome/index.html.erb"=> 'Hello from index.html.erb',
+  )]
+
+  def index
+  end
+
+end
+
+Rails3_2.initialize!

data/spec/apps/rails4.rb

@@ -0,0 +1,69 @@
+#http://www.rubytutorial.io/how-to-test-your-gem-against-multiple-rails/
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "sprockets/railtie"
+require "rails/test_unit/railtie"
+require 'action_view/testing/resolvers'
+
+require 'egregious' # our gem
+
+# monkey patch - we don't want fixtures loaded, because we don't configure or test ActiveRecord
+# https://github.com/rspec/rspec-rails/issues/1416
+module ActiveRecord
+  module TestFixtures
+    def before_setup
+      super
+    end
+    def after_teardown
+      super
+
+    end
+  end
+end
+
+module Rails4
+  class Application < Rails::Application
+    config.root = File.expand_path("../../..", __FILE__)
+    config.cache_classes = true
+
+    config.eager_load = false
+    config.serve_static_assets  = true
+    config.static_cache_control = "public, max-age=3600"
+
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    config.action_dispatch.show_exceptions = false
+
+    config.action_controller.allow_forgery_protection = false
+
+    config.active_support.deprecation = :stderr
+
+    config.middleware.delete "Rack::Lock"
+    config.middleware.delete "ActionDispatch::Flash"
+    config.middleware.delete "ActionDispatch::BestStandardsSupport"
+    config.middleware.delete ActiveRecord::Migration::CheckPending
+    config.middleware.delete ActiveRecord::ConnectionAdapters::ConnectionManagement
+    config.middleware.delete ActiveRecord::QueryCache
+    config.secret_key_base = '49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk'
+    routes.append do
+      get "/" => "welcome#index"
+      get "/" => "fake#test"
+    end
+  end
+end
+
+class WelcomeController < ActionController::Base
+  include Rails.application.routes.url_helpers
+  layout 'application'
+  self.view_paths = [ActionView::FixtureResolver.new(
+    "layouts/application.html.erb" => '<%= yield %>',
+    "welcome/index.html.erb"=> 'Hello from index.html.erb',
+  )]
+
+  def index
+  end
+
+end
+
+Rails4::Application.initialize!

data/spec/controllers/controller_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+class FakeController < ActionController::Base
+  include Egregious
+  def test
+    head :ok
+  end
+end
+
+#ActionDispatch::Routing::Routes.add_route('fake_page/test', :controller => 'fake_page', :action => 'test')
+
+describe 'ShowPageModules', ' included in a ' do
+  describe FakeController do
+
+    it "declares a before filter that sets the variable" do
+      get :test
+      expect(assigns(:fancy_page)).to be nil
+    end
+  end
+end

data/spec/egregious_spec.rb

@@ -105,7 +105,7 @@ describe Egregious do
         expect(exception_codes[Mongoid::Errors::Validations]).to eq(Egregious.status_code(:unprocessable_entity))
       end
 
-      if Mongoid::VERSION > '3'
+      if defined?(Mongoid::VERSION) && Mongoid::VERSION > '3'
         it "should return expected errors for Mongoid 3+" do
           expect(exception_codes[Mongoid::Errors::ReadonlyAttribute]).to eq(Egregious.status_code(:forbidden))
           expect(exception_codes[Mongoid::Errors::UnknownAttribute]).to eq(Egregious.status_code(:bad_request))

data/spec/notify_airbrake_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+
+def rescue_from(exception, options)
+end
+def env
+  {}
+end
+include Egregious
+
+describe Egregious do
+
+  context "notify_airbrake 4" do
+    class Airbrake
+          def self.notify_or_ignore(*params)
+          end
+    end
+    it "should call notify_or_ignore" do
+      expect(Airbrake).to receive(:notify_or_ignore)
+      notify_airbrake(nil)
+    end
+  end
+  context "notify_airbrake 5" do
+      class << Airbrake
+        remove_method :notify_or_ignore
+        def self.notify(*params)
+        end
+      end
+      it "should call notify" do
+        expect(Airbrake).to receive(:notify)
+        notify_airbrake(nil)
+      end
+    end
+end

data/spec/spec_helper.rb

@@ -1,18 +1,37 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+ENV["RAILS_ENV"] ||= "test"
+
 require 'rubygems'
 require 'bundler/setup'
 require 'bundler'
 Bundler.setup
 
-ENV["RAILS_ENV"] ||= "test"
 require 'active_support'
-require 'active_support/test_case'
+#require 'active_support/test_case'
 require 'action_controller'
 require 'warden'
 require 'cancan'
 require 'mongoid'
 
-require 'egregious' # and any other gems you need
+#root = File.expand_path(File.dirname(__FILE__))
+
+ENV["RAILS_ENV"] = "test"
+require "rails"
+case Rails.version
+when '3.2.22'
+  require "apps/rails3_2"
+when '4.2.5'
+  require "apps/rails4"
+end
+
+require 'rspec/rails'
 
 RSpec.configure do |config|
-  # some (optional) config here
-end
+  #config.rspec_opts = '--format documentation'
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+end
+
+Test::Unit::AutoRunner.need_auto_run = false if defined?(Test::Unit::AutoRunner)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: egregious
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.12
 platform: ruby
 authors:
 - Russell Edens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2016-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: 1.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: 1.2.5
 - !ruby/object:Gem::Dependency
   name: htmlentities
   requirement: !ruby/object:Gem::Requirement
@@ -72,6 +72,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -143,7 +157,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bson_ext
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -165,17 +179,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
+- Appraisals
 - Gemfile
 - LICENSE
-- README
+- README.md
 - Rakefile
 - egregious.gemspec
+- gemfiles/rails_3.gemfile
+- gemfiles/rails_4.gemfile
 - lib/egregious.rb
 - lib/egregious/extensions/exception.rb
 - lib/egregious/extensions/mongoid.rb
 - lib/egregious/version.rb
+- spec/apps/rails3_2.rb
+- spec/apps/rails4.rb
+- spec/controllers/controller_spec.rb
 - spec/egregious_spec.rb
 - spec/exceptions_spec.rb
+- spec/notify_airbrake_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/voomify/egregious
 licenses:
@@ -203,6 +225,10 @@ specification_version: 4
 summary: Egregious is a rails based exception handling gem for well defined http exception
   handling for json, xml and html. Requires Rails.
 test_files:
+- spec/apps/rails3_2.rb
+- spec/apps/rails4.rb
+- spec/controllers/controller_spec.rb
 - spec/egregious_spec.rb
 - spec/exceptions_spec.rb
+- spec/notify_airbrake_spec.rb
 - spec/spec_helper.rb

data/README

@@ -1,146 +0,0 @@
-Update Log:
-
-  Version 0.2.10 released to https://rubygems.org/gems/egregious on 10.23.2015
-        Fixed bug where an exception defines http_status but returns nil.
-        This was resulting in a status of 200 being returned, when it should be a 500.
-
-  Version 0.2.9 released to https://rubygems.org/gems/egregious on 10.23.2015
-        Added support for exceptions that define a http_status. The exception map can override this.
-        This is a good way to allow a raise to specify a http_status using a custom exception.
-        The idea for this came from the Stripe::Error exception classes.
-        You can now use: raise Egregious::Error.new("My very bad error", :payment_required)  or
-        define your own exceptions that implement http_status
-
-        Also updated Gemfile.lock to ruby 2.2.1 and latest dependencies. This is for specs only.
-
-  Version 0.2.8 released to https://rubygems.org/gems/egregious on 6.5.2015
-        Added Airbrake notifications. If this is too chatty, you can configure it by overriding: notify_airbrake
-
-  Version 0.2.7 released to https://rubygems.org/gems/egregious on 5.28.2015
-        Merged pull request:
-        Compatibility with Rails 4.2 #13
-
-  Version 0.2.6 released to https://rubygems.org/gems/egregious on 7.22.2014
-        Merged pull request:
-          Rails 4 support (#11,#12)
-
-  Version 0.2.4 released to https://rubygems.org/gems/egregious on 7.23.2013
-        Added MIT License
-
-  Version 0.2.3 released to https://rubygems.org/gems/egregious on 7.23.2013
-        Merged pull requests:
-          Mongoid integration (#6)
-        Bug Fix: Bad Rails test
-        Updated rails and rack dependencies
-
-  Version 0.2.2 released to https://rubygems.org/gems/egregious on 2.15.2013
-      Merged pull requests:
-        Compatibility with Rails::API (#5)
-
-  Version 0.2.1 released to https://rubygems.org/gems/egregious on 9.21.2012
-    Merged pull requests:
-      Bug Fix: should translate status code Symbol to right HTTP STATUS CODE -  avinasha
-      Fixes teapot bug with rails 3.2.8. -  kbrown 
-      Note: version 0.2.0 does not work with rails 3.2.8 you should update to 0.2.1
-
-If you would like to contribute take a look at the issues feature list, fork and issue a pull request!
-
-An earlier version of these instructions with some formatting can be found @ http://railsindirection.blogspot.com/2011/09/rails-exception-handling-egregious.html
-
-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 decided to create egregious. One of the 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 the api caller then the result codes are in the 300 range. If the problem
-was on the server then the status codes are in the 500 range.  The returned exception message and exception type
-provide the caller context information.
-
- What egregious can do:
-
- * Defines default exception handling for most common ruby, rails, warden, cancan and mongoid exceptions.
-   (warden, cancan and mongoid 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.
- * If Hoptoad is defined it will send the errors to Hoptoad/Airbrake.
- * The error will be logged with stack trace
-
-
-REQUIRES:
-  rails ~> 3.1.12
-  rack  >= 1.3.6
-
-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.
-
-If you want to change the behavior then you can override the following methods in your ApplicationController.
-
-# override this if you want your flash to behave differently
-def egregious_flash(exception)
-    flash.now[:alert] = exception.message
-end
-
-# override this if you want your logging to behave differently
-def egregious_log(exception)
-    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)
-end
-
-# override this if you want to change your respond_to behavior
-def egregious_respond_to(exception)
-    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?(build_html_file_path(status)) ?
-                                          build_html_file_path(status) : build_html_file_path('500')}
-    end
-end
-
-
-
-# override this if you want to change what html static file gets returned.
-def build_html_file_path(status)
-    File.expand_path(Rails.root, 'public', status + '.html')
-end
-
-# override this if you want to control what gets sent to airbrake
-# optionally you can configure the airbrake ignore list
-def notify_airbrake(exception)
-    # for ancient clients - can probably remove
-    HoptoadNotifier.notify(exception) if defined?(HoptoadNotifier)
-    # tested with airbrake 3.1.15 and 4.2.1
-    env['airbrake.error_id'] = Airbrake.notify_or_ignore(exception) if defined?(Airbrake)
-end
-
-KNOWN ISSUES:
-* If you use Mongoid, CanCan or Devise you must have Egregious after CanCan/Devise in your Gemfile, if not it will not handle those errors correctly.