egregious 0.2.8 → 0.2.10

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NmNkZmVlODMzN2NkOWI1NWZhMGU5ZTNmYTgwNDQzMjQ5YTY2NWI1Nw==
-  data.tar.gz: !binary |-
-    NWE3YjNjY2JiYjY5NGRmMjlkNTA2NDRkMzllOGRjMzFhMTRhZTYyMg==
+SHA1:
+  metadata.gz: 74b9d8d3b64d8c2ab878e23b18eb2c28f73fd6c6
+  data.tar.gz: 8d4b0939f3140b103168b09a82b86e6889996eb5
 SHA512:
-  metadata.gz: !binary |-
-    NDMwZjgwOGY3MzM4YzM4Y2I5MWEzM2NlYTkyZDA2ZDMxNDY4MGYxMDE3NjNj
-    MjYwNjA1NjA5NjFjMGE2ZWE0ZDg5NzczNTE5ODhlYzhkNjY0NDczMzMzN2Q2
-    NDBjMDg2MWIzY2U2MzBjZGE4NjQ1MTZkNjI0MTAzNTQ2NzNjODk=
-  data.tar.gz: !binary |-
-    MDY5ODUwNzc1MjdmZjFkMDY0M2E0YWY2ZmUyNTEyNGM4MTc4MThlNTc3NzNk
-    MWQ1Y2QzZDczOTZmZGI1YjNhZWZmYjFjYmEzMTYzMGRkMDNmNDdjZDFhOWFi
-    NDdjMTRmOGVlNTA1NjA1OGQzOTA4ZmU4ZjBkNjk4MjI3ZDY2Y2U=
+  metadata.gz: 91c5341f2896b83a227f1a7565034ab4bc79d26b0beb242667323c20f24001cf6431fa0dfe972b8b662c8c714a6d0e82cf26379f731a3ae5c24c9b14891ab64a
+  data.tar.gz: 77c99d9f971799355983b5ab290a177fd365a534b4f1304fc113d295e55a959fd35aff4720f3332d959baaeaf208b58a357d5a9ac0a356ee696a413cab53b8a1

data/.gitignore

@@ -3,5 +3,4 @@
 Gemfile.lock
 pkg/*
 .idea
-.ruby-gemset
 .ruby-version

data/README

@@ -1,7 +1,20 @@
 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
+        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:
@@ -32,7 +45,7 @@ Update Log:
 
 If you would like to contribute take a look at the issues feature list, fork and issue a pull request!
 
-These instructions with some formatting can be found @ http://railsindirection.blogspot.com/2011/09/rails-exception-handling-egregious.html
+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.
 

data/lib/egregious.rb

@@ -170,9 +170,15 @@ module Egregious
   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
+  # 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)
-    self.exception_codes[exception.class] ? self.exception_codes[exception.class] : '500'
+    Egregious.status_code_for_exception(exception)
+  end
+
+  def self.status_code_for_exception(exception)
+    status_code(self.exception_codes[exception.class]  ||
+               (exception.respond_to?(:http_status) ? (exception.http_status||:internal_server_error) : :internal_server_error))
   end
 
   # this is the method that handles all the exceptions we have mapped

data/lib/egregious/extensions/exception.rb

@@ -16,4 +16,15 @@ class Exception
     "{\"error\":#{ActiveSupport::JSON.encode(self.message.gsub(/\r/, ' ').gsub(/\n/, ' ').squeeze(' '))}, \"type\":\"#{self.exception_type}\"}"
   end
 
+end
+
+module Egregious
+  class Error < StandardError
+    attr_reader :http_status
+    attr_reader :message
+    def initialize(message=nil, http_status=nil)
+         @message = message
+         @http_status = http_status
+    end
+  end
 end

data/lib/egregious/version.rb

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

data/spec/egregious_spec.rb

@@ -9,35 +9,35 @@ describe Egregious do
 
   describe 'status_code' do
     it "should translate Symbol to right HTTP STATUS CODE" do
-      status_code(:bad_request).should == 400
-      status_code(:unauthorized).should == 401
-      status_code(:unprocessable_entity).should == 422
+      expect(status_code(:bad_request)).to eq(400)
+      expect(status_code(:unauthorized)).to eq(401)
+      expect(status_code(:unprocessable_entity)).to eq(422)
     end
   end
 
   describe 'clean_backtrace ' do
     it "should return nil" do
-      clean_backtrace(Exception.new).should == nil
+      expect(clean_backtrace(Exception.new)).to eq(nil)
     end
 
     it "should return a stack trace" do
       begin
         raise Exception.new
-      rescue Exception=>exception
-        clean_backtrace(exception).size.should be > 0
+      rescue Exception => exception
+        expect(clean_backtrace(exception).size).to be > 0
       end
     end
 
     it "should remove the beginning of the backtrace" do
       begin
         raise Exception.new
-      rescue Exception=>exception
+      rescue Exception => exception
         Rails.instance_eval do
           def self.root
             __FILE__
           end
         end
-        clean_backtrace(exception)[0].should match /:\d/
+        expect(clean_backtrace(exception)[0]).to match /:\d/
       end
     end
   end
@@ -50,78 +50,78 @@ describe Egregious do
   describe 'exception_codes' do
 
     it "should return forbidden for SecurityError's'" do
-      exception_codes[SecurityError].should ==  Egregious.status_code(:forbidden)
+      expect(exception_codes[SecurityError]).to eq(Egregious.status_code(:forbidden))
     end
 
     if defined?(ActionController)
       it "should return expected errors for ActionController" do
-         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)
+        expect(exception_codes[AbstractController::ActionNotFound]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActionController::InvalidAuthenticityToken]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActionController::MethodNotAllowed]).to eq(Egregious.status_code(:not_allowed))
+        expect(exception_codes[ActionController::MissingFile]).to eq(Egregious.status_code(:not_found))
+        expect(exception_codes[ActionController::RoutingError]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActionController::UnknownController]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActionController::UnknownHttpMethod]).to eq(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)
+        expect(exception_codes[ActiveModel::MissingAttributeError]).to eq(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::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)
+        expect(exception_codes[ActiveRecord::AttributeAssignmentError]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActiveRecord::MultiparameterAssignmentErrors]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActiveRecord::ReadOnlyAssociation]).to eq(Egregious.status_code(:forbidden))
+        expect(exception_codes[ActiveRecord::ReadOnlyRecord]).to eq(Egregious.status_code(:forbidden))
+        expect(exception_codes[ActiveRecord::RecordInvalid]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[ActiveRecord::RecordNotFound]).to eq(Egregious.status_code(:not_found))
+        expect(exception_codes[ActiveRecord::UnknownAttributeError]).to eq(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)
+        expect(exception_codes[Warden::NotAuthenticated]).to eq(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)
+        expect(exception_codes[CanCan::AccessDenied]).to eq(Egregious.status_code(:unauthorized))
+        expect(exception_codes[CanCan::AuthorizationNotPerformed]).to eq(Egregious.status_code(:unauthorized))
       end
     end
-    
+
     if defined?(Mongoid)
       it "should return expected errors for Mongoid" do
-        exception_codes[Mongoid::Errors::InvalidFind].should == Egregious.status_code(:bad_request)
-        exception_codes[Mongoid::Errors::DocumentNotFound].should == Egregious.status_code(:not_found)
-        exception_codes[Mongoid::Errors::Validations].should == Egregious.status_code(:unprocessable_entity)
+        expect(exception_codes[Mongoid::Errors::InvalidFind]).to eq(Egregious.status_code(:bad_request))
+        expect(exception_codes[Mongoid::Errors::DocumentNotFound]).to eq(Egregious.status_code(:not_found))
+        expect(exception_codes[Mongoid::Errors::Validations]).to eq(Egregious.status_code(:unprocessable_entity))
       end
-      
+
       if Mongoid::VERSION > '3'
         it "should return expected errors for Mongoid 3+" do
-          exception_codes[Mongoid::Errors::ReadonlyAttribute].should ==  Egregious.status_code(:forbidden)
-          exception_codes[Mongoid::Errors::UnknownAttribute].should == Egregious.status_code(:bad_request)
+          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))
         end
       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'
+    it 'should return 500 for non-mapped exceptions' do
+      expect(exception_codes[Exception]).to eq(nil)
+      expect(status_code_for_exception(Exception.new)).to eq(500)
     end
     it 'should allow configuration of exception codes' do
       Egregious.exception_codes.merge!({NameError => "999"})
-      status_code_for_exception(NameError.new).should=="999"
+      expect(status_code_for_exception(NameError.new)).to eq(999)
     end
   end
 
@@ -132,7 +132,7 @@ describe Egregious do
           __FILE__
         end
       end
-      build_html_file_path('500').should == File.join(__FILE__, 'public', '500.html')
+      expect(build_html_file_path('500')).to eq(File.join(__FILE__, 'public', '500.html'))
     end
   end
 end

data/spec/exceptions_spec.rb

@@ -7,28 +7,28 @@ 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'
+      expect((error/:error).inner_html).to eq('Yes')
+      expect((error/:type).inner_html).to eq('Exception')
     end
   end
 
   it "should output valid xml on to_xml with values to escape" do
     doc = Hpricot.XML(Exception.new('<a title="1<2"/>').to_xml)
     (doc/:errors).each do |error|
-       HTMLEntities.new.decode((error/:error).inner_html).should=='<a title="1<2"/>'
+      expect(HTMLEntities.new.decode((error/:error).inner_html)).to eq('<a title="1<2"/>')
     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"
+    expect(result['error']).to eq("Yes")
+    expect(result['type']).to eq("Exception")
   end
 
   it "should output be valid json on to_json with quotes" do
-      result = JSON.parse(Exception.new('Yes "its good"').to_json)
-      result['error'].should == 'Yes "its good"'
-    end
+    result = JSON.parse(Exception.new('Yes "its good"').to_json)
+    expect(result['error']).to eq('Yes "its good"')
+  end
 
 
   it "should parse module names out" do
@@ -38,50 +38,77 @@ describe Exception do
         end
       end
     end
-    X::Y::Z.new.exception_type.should == 'Z'
+    expect(X::Y::Z.new.exception_type).to eq('Z')
+  end
+end
+
+describe "exception with http_status method" do
+  class PartyLikeIts < Egregious::Error
+    def initialize(message=nil)
+      super(message,1999)
+    end
+  end
+  let(:exception_instance) { PartyLikeIts.new }
+
+  it 'should honor if not in exception code map' do
+    expect(Egregious.exception_codes[PartyLikeIts]).to eq(nil)
+    expect(Egregious.status_code_for_exception(exception_instance)).to eq(1999)
+  end
+
+  it 'should be overridden by exception code map' do
+    Egregious.exception_codes.merge!({PartyLikeIts => :bad_request})
+    expect(Egregious.exception_codes[PartyLikeIts]).to eq(:bad_request)
+    expect(Egregious.status_code_for_exception(exception_instance)).to eq(400)
+  end
+
+  it "should throw 500 if nil" do
+    expect(Egregious.status_code_for_exception(Egregious::Error.new)).to eq(500)
+  end
+  it "should throw code for string" do
+      expect(Egregious.status_code_for_exception(Egregious::Error.new("hi","2001"))).to eq(2001)
   end
 end
 
 if defined?(Mongoid)
   class TestModel
     include Mongoid::Document
-    
+
     field :foo
     validates_presence_of :foo
   end
 
-  
+
   describe Mongoid::Errors::MongoidError do
     let(:exception) { Mongoid::Errors::InvalidFind.new }
     let(:error_message) { "Calling Document.find with nil is invalid." }
-    
+
     it "should output json with a short problem description" do
       result = JSON.parse(exception.to_json)
-      result['error'].should =~ /#{error_message}/
+      expect(result['error']).to match(/#{error_message}/)
     end
-    
+
     it "should output xml with a short problem description" do
       doc = Hpricot.XML(exception.to_xml)
       (doc/:errors).each do |error|
-         HTMLEntities.new.decode((error/:error).inner_html).should =~ /#{error_message}/
+        expect(HTMLEntities.new.decode((error/:error).inner_html)).to match(/#{error_message}/)
       end
     end
   end
-  
+
   describe Mongoid::Errors::Validations do
     let(:model) { TestModel.create }
     let(:exception) { Mongoid::Errors::Validations.new(model) }
     let(:error_message) { model.errors.full_messages.first }
-    
+
     it "should output json with a short summary" do
       result = JSON.parse(exception.to_json)
-      result['error'].should == error_message
+      expect(result['error']).to eq(error_message)
     end
-    
+
     it "should output xml with a short problem description" do
       doc = Hpricot.XML(exception.to_xml)
       (doc/:errors).each do |error|
-         HTMLEntities.new.decode((error/:error).inner_html).should == error_message
+        expect(HTMLEntities.new.decode((error/:error).inner_html)).to eq(error_message)
       end
     end
   end

metadata

@@ -1,159 +1,159 @@
 --- !ruby/object:Gem::Specification
 name: egregious
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.10
 platform: ruby
 authors:
 - Russell Edens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-05 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>'
+    - - ">"
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>'
+    - - ">"
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.6
 - !ruby/object:Gem::Dependency
   name: htmlentities
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   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
     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: hpricot
   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: warden
   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: cancan
   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: mongoid
   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: bson_ext
   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'
 description: Egregious is a rails based exception handling gem for well defined http
@@ -164,7 +164,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README
@@ -187,17 +187,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: egregious
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Egregious is a rails based exception handling gem for well defined http exception