human_error 1.13.4 → 2.0.0beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ec632d4d98534bf56ffb31036e08757bc571329
-  data.tar.gz: 0ccf6401fb434ed5439bd950cea70e19538c25a5
+  metadata.gz: 38bd2094b46916777e66209fd09752aec12782c6
+  data.tar.gz: 5e8539f5cf3898079f28f3a6014aca66f7d09d79
 SHA512:
-  metadata.gz: 659545cf72c6db3d1cea151d9516d00c5c6c4d9e27bde9403cf352dfda4591a838476cb435f81344d5525ba8436032969a329c24cbfd7db95ad93b582dc25d9c
-  data.tar.gz: 9f54d8085cdf37151658b1ac6112b4c5b2da2057f8707251443ea29f9525d889b415247dcbf738ec954840bd1b3842a7061a4cd0efba0e62273a535307026fdb
+  metadata.gz: 7395626c161f3012d42c7cf0de4d934bf77cf34447bb192d4b06f004efc80e11dfbd6f910cb7b1efb4a5c53759f4a114e5f535242d32073a3e2714eb83cea386
+  data.tar.gz: b1dbf433d0e8725ef3ac2192dc2bb6afc8e3bc49078eb43fd5309334959d0ac76b58fa41f1b9426189309304c4ca391686c32d9a62ea207f2654c9c51a74aa50

data/lib/human_error/errors/crud_errors/association_error.rb

@@ -10,6 +10,25 @@ class   AssociationError < RequestError
                 :association_id,
                 :attributes
 
+  def self.convert(original_error, overrides = {})
+    initialization_parameters = {}
+
+    case original_error.class.name
+    when 'ActiveRecord::InvalidForeignKey'
+      message_info_pattern = /DETAIL:  Key \((.*)_id\)=\(([a-f0-9\-]+)\)/
+      message_info         = original_error.
+                               message.
+                               match(message_info_pattern)[1..-1]
+
+      initialization_parameters = {
+        association_name: message_info[0],
+        association_id:   message_info[1],
+      }
+    end
+
+    new(initialization_parameters.merge(overrides))
+  end
+
   def http_status
     422
   end

data/lib/human_error/errors/crud_errors/resource_not_found_error.rb

@@ -6,6 +6,26 @@ module  Errors
 class   ResourceNotFoundError < RequestError
   include CrudError
 
+  def self.convert(original_error, overrides = {})
+    initialization_parameters = {}
+
+    case original_error.class.name
+    when 'ActiveRecord::RecordNotFound'
+      initialization_parameters = {
+        resource_id: case original_error.message
+                     when /\ACouldn't find .* without an ID\z/
+                       []
+                     when /\ACouldn't find .* with \'.*\'=([a-f0-9\-]+)/
+                       [Regexp.last_match(1)]
+                     when /\ACouldn't find all .* with \'.*\': ((?:[a-f0-9\-]+(?:, )?)+)/
+                       Array(Regexp.last_match(1).split(', '))
+                     end,
+      }
+    end
+
+    new(initialization_parameters.merge(overrides))
+  end
+
   def http_status
     404
   end

data/lib/human_error/errors/crud_errors/resource_persistence_error.rb

@@ -9,6 +9,22 @@ class   ResourcePersistenceError < RequestError
   attr_accessor :errors,
                 :attributes
 
+  def self.convert(original_error, overrides = {})
+    initialization_parameters = {}
+
+    case original_error.class.name
+    when 'ActiveRecord::RecordInvalid',
+         'ActiveRecord::RecordNotSaved'
+
+      initialization_parameters = {
+        attributes: original_error.record.attributes,
+        errors:     original_error.record.errors.full_messages,
+      }
+    end
+
+    new(initialization_parameters.merge(overrides))
+  end
+
   def http_status
     422
   end

data/lib/human_error/rescuable_resource.rb

@@ -6,49 +6,41 @@ class   HumanError
 module  RescuableResource
   module ClassMethods
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
-    def rescue_resource(_resource_name, from:, via:)
-      lookup_library = via
+    def rescue_resource(resource_name, from:, via:)
+      resource_class_name = resource_name.classify
+      lookup_library      = via
 
       if from.include? 'persistence'
-        rescue_from HumanError::Errors::ResourcePersistenceError do |e|
-          error = lookup_library.fetch(
-                  'ResourcePersistenceError',
-                  resource_name: e.resource_name,
-                  attributes:    e.attributes,
-                  errors:        e.errors,
-                  action:        action_name)
-
-          render json:   error,
-                 status: error.http_status
+        rescue_from 'ActiveRecord::RecordInvalid',
+                    'ActiveRecord::RecordNotSaved' do |exception|
+          human_error = lookup_library.convert(exception,
+                                               resource_name: resource_class_name,
+                                               action:        action_name)
+
+          render json:   human_error,
+                 status: human_error.http_status
         end
       end
 
       if from.include? 'not_found'
-        rescue_from HumanError::Errors::ResourceNotFoundError do |e|
-          resource_id = e.resource_id.is_a?(Array) ? e.resource_id : [e.resource_id]
+        rescue_from 'ActiveRecord::RecordNotFound' do |exception|
+          human_error = lookup_library.convert(exception,
+                                               resource_name: resource_class_name,
+                                               action:        action_name)
 
-          error = lookup_library.fetch(
-                  'ResourceNotFoundError',
-                  resource_name: e.resource_name,
-                  resource_id:   resource_id,
-                  action:        action_name)
-
-          render json:   error,
-                 status: error.http_status
+          render json:   human_error,
+                 status: human_error.http_status
         end
       end
 
       if from.include? 'association'
-        rescue_from HumanError::Errors::AssociationError do |e|
-          error = lookup_library.fetch(
-                  'AssociationError',
-                  resource_name:    e.resource_name,
-                  association_name: e.association_name,
-                  association_id:   e.association_id,
-                  attributes:       e.attributes)
-
-          render json:   error,
-                 status: error.http_status
+        rescue_from 'ActiveRecord::InvalidForeignKey' do |exception|
+          human_error = lookup_library.convert(exception,
+                                               resource_name: resource_class_name,
+                                               action:        action_name)
+
+          render json:   human_error,
+                 status: human_error.http_status
         end
       end
     end

data/lib/human_error/version.rb

@@ -1,3 +1,3 @@
 class HumanError
-  VERSION = '1.13.4'
+  VERSION = '2.0.0beta2'
 end

data/lib/human_error.rb

@@ -11,9 +11,19 @@ class   HumanError
     yield configuration if block_given?
   end
 
-  def fetch(error_type, **args)
-    Object.const_get("HumanError::Errors::#{error_type}").
-      new(configuration.to_h.merge(**args))
+  def fetch(error_type, **_args)
+    Object.const_get("HumanError::Errors::#{error_type}")
+  end
+
+  def convert(original_error, overrides = {})
+    overrides = configuration.to_h.merge(overrides)
+
+    case original_error.class.name
+    when 'ActiveRecord::InvalidForeignKey'
+      fetch('AssociationError').convert(original_error, overrides)
+    when 'ActiveRecord::RecordNotFound'
+      fetch('ResourceNotFoundError').convert(original_error, overrides)
+    end
   end
 
   def raise(error_type, **args)

data/spec/lib/human_error/errors/crud_errors/association_error_spec.rb

@@ -1,20 +1,29 @@
 require 'rspectacular'
 require 'human_error/errors/crud_errors/association_error'
+require 'active_record/errors'
 
 class     HumanError
 module    Errors
 describe  AssociationError do
-  let(:error) { AssociationError.new }
+  let(:foreign_key_error) do
+    ActiveRecord::InvalidForeignKey.new('DETAIL:  Key (resource_id)=(123)')
+  end
 
   it 'has a status of 422' do
+    error = AssociationError.new
+
     expect(error.http_status).to eql 422
   end
 
   it 'has a code of 1009' do
+    error = AssociationError.new
+
     expect(error.code).to eql 1009
   end
 
   it 'has a knowledgebase article ID of 1234567890' do
+    error = AssociationError.new
+
     expect(error.knowledgebase_article_id).to eql '1234567890'
   end
 
@@ -46,6 +55,22 @@ describe  AssociationError do
     expect(error.friendly_message).to eql 'Sorry! There was a problem when we tried to ' \
                                           'set the black leather trenchcoat on that Neo.'
   end
+
+  it 'can convert an "ActiveRecord::InvalidForeignKey"' do
+    error = AssociationError.convert(foreign_key_error)
+
+    expect(error.resource_name).to    eql nil
+    expect(error.association_name).to eql 'resource'
+    expect(error.association_id).to   eql '123'
+  end
+
+  it 'can convert an "ActiveRecord::InvalidForeignKey" while overriding attributes' do
+    error = AssociationError.convert(foreign_key_error, resource_name: 'my_resource')
+
+    expect(error.resource_name).to    eql 'my_resource'
+    expect(error.association_name).to eql 'resource'
+    expect(error.association_id).to   eql '123'
+  end
 end
 end
 end

data/spec/lib/human_error/errors/crud_errors/resource_not_found_error_spec.rb

@@ -1,20 +1,25 @@
 require 'rspectacular'
 require 'human_error/errors/crud_errors/resource_not_found_error'
+require 'active_record/errors'
 
 class     HumanError
 module    Errors
 describe  ResourceNotFoundError do
-  let(:error) { ResourceNotFoundError.new }
-
   it 'has a status of 404' do
+    error = ResourceNotFoundError.new
+
     expect(error.http_status).to eql 404
   end
 
   it 'has a code of 1005' do
+    error = ResourceNotFoundError.new
+
     expect(error.code).to eql 1005
   end
 
   it 'has a knowledgebase article ID of 1234567890' do
+    error = ResourceNotFoundError.new
+
     expect(error.knowledgebase_article_id).to eql '1234567890'
   end
 
@@ -49,6 +54,43 @@ describe  ResourceNotFoundError do
     expect(error.friendly_message).to eql 'Sorry! The black leather trenchcoat you ' \
                                           'tried to bullet time does not exist.'
   end
+
+  it 'can convert an "ActiveRecord::RecordNotFound" with no IDs' do
+    record_not_found_error = ActiveRecord::RecordNotFound.new \
+                               "Couldn't find resource without an ID"
+    error                  = ResourceNotFoundError.convert(record_not_found_error)
+
+    expect(error.resource_name).to eql nil
+    expect(error.resource_id).to   eql []
+  end
+
+  it 'can convert an "ActiveRecord::RecordNotFound" with one ID' do
+    record_not_found_error = ActiveRecord::RecordNotFound.new \
+                               "Couldn't find resource with 'id'=123"
+    error                  = ResourceNotFoundError.convert(record_not_found_error)
+
+    expect(error.resource_name).to eql nil
+    expect(error.resource_id).to   eql %w{123}
+  end
+
+  it 'can convert an "ActiveRecord::RecordNotFound" with multiple IDs' do
+    record_not_found_error = ActiveRecord::RecordNotFound.new \
+                               "Couldn't find all resource with 'id': 123, 456, 789"
+    error                  = ResourceNotFoundError.convert(record_not_found_error)
+
+    expect(error.resource_name).to eql nil
+    expect(error.resource_id).to   eql %w{123 456 789}
+  end
+
+  it 'can convert an "ActiveRecord::RecordNotFound" while overriding attributes' do
+    record_not_found_error = ActiveRecord::RecordNotFound.new \
+                               "Couldn't find resource with 'id'=123"
+    error                  = ResourceNotFoundError.convert(record_not_found_error,
+                                                           resource_name: 'my_resource')
+
+    expect(error.resource_name).to eql 'my_resource'
+    expect(error.resource_id).to   eql %w{123}
+  end
 end
 end
 end

data/spec/lib/human_error/errors/crud_errors/resource_persistence_error_spec.rb

@@ -1,20 +1,43 @@
 require 'rspectacular'
 require 'human_error/errors/crud_errors/resource_persistence_error'
+require 'active_support'
+require 'active_model'
+require 'active_record/errors'
+require 'active_record/validations'
+
+class HumanErrorTestModel
+  include ActiveModel::Model
+  include ActiveModel::AttributeMethods
+
+  attr_accessor :some_attribute
+
+  validates_presence_of :some_attribute
+
+  def attributes
+    {
+      'some_attribute' => @some_attribute,
+    }
+  end
+end
 
 class     HumanError
 module    Errors
 describe  ResourcePersistenceError do
-  let(:error) { ResourcePersistenceError.new }
-
   it 'has a status of 422' do
+    error = ResourcePersistenceError.new
+
     expect(error.http_status).to eql 422
   end
 
   it 'has a code of 1006' do
+    error = ResourcePersistenceError.new
+
     expect(error.code).to eql 1006
   end
 
   it 'has a knowledgebase article ID of 1234567890' do
+    error = ResourcePersistenceError.new
+
     expect(error.knowledgebase_article_id).to eql '1234567890'
   end
 
@@ -42,6 +65,28 @@ describe  ResourcePersistenceError do
     expect(error.friendly_message).to eql 'Sorry! We had a problem when tried to ' \
                                           'bullet time that black leather trenchcoat.'
   end
+
+  it 'can convert an "ActiveRecord::RecordNotSaved"' do
+    record                     = HumanErrorTestModel.new
+    record.valid?
+    resource_persistence_error = ActiveRecord::RecordNotSaved.new('message', record)
+    error                      = ResourcePersistenceError.
+                                   convert(resource_persistence_error)
+
+    expect(error.attributes).to eql('some_attribute' => nil)
+    expect(error.errors).to     eql ["Some attribute can't be blank"]
+  end
+
+  it 'can convert an "ActiveRecord::RecordInvalid"' do
+    record                     = HumanErrorTestModel.new
+    record.valid?
+    resource_persistence_error = ActiveRecord::RecordInvalid.new(record)
+    error                      = ResourcePersistenceError.
+                                   convert(resource_persistence_error)
+
+    expect(error.attributes).to eql('some_attribute' => nil)
+    expect(error.errors).to     eql ["Some attribute can't be blank"]
+  end
 end
 end
 end

data/spec/lib/human_error_spec.rb

@@ -1,7 +1,12 @@
 require 'rspectacular'
 require 'human_error'
+require 'active_record/errors'
 
 describe HumanError do
+  let(:original_error) do
+    ActiveRecord::RecordNotFound.new("Couldn't find resource with 'id'=3")
+  end
+
   it 'can create an instance of HumanError' do
     expect(HumanError.new).to be_a HumanError
   end
@@ -17,7 +22,7 @@ describe HumanError do
   it 'can lookup errors' do
     human_error = HumanError.new
 
-    expect(human_error.fetch('RequestError')).to be_a HumanError::Errors::RequestError
+    expect(human_error.fetch('RequestError')).to eql HumanError::Errors::RequestError
   end
 
   it 'can lookup errors based on the local configuration' do
@@ -25,7 +30,7 @@ describe HumanError do
       config.api_version = 'foo'
     end
 
-    fetched_error = human_error.fetch('RequestError')
+    fetched_error = human_error.convert(original_error)
 
     expect(fetched_error.api_version).to eql 'foo'
   end
@@ -41,7 +46,7 @@ describe HumanError do
       config.api_version = 'foo'
     end
 
-    fetched_error = human_error.fetch('RequestError')
+    fetched_error = human_error.convert(original_error)
 
     expect(fetched_error.api_version).to eql 'foo'
   end
@@ -53,7 +58,7 @@ describe HumanError do
       config.api_version = 'foo'
     end
 
-    fetched_error = human_error.fetch('RequestError', api_version: 'bar')
+    fetched_error = human_error.convert(original_error, api_version: 'bar')
 
     expect(fetched_error.api_version).to eql 'bar'
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: human_error
 version: !ruby/object:Gem::Version
-  version: 1.13.4
+  version: 2.0.0beta2
 platform: ruby
 authors:
 - jfelchner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.50'
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '4.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '4.1'
 description: ''
 email: accounts+git@thekompanee.com
 executables: []
@@ -76,7 +76,6 @@ files:
 - lib/human_error/errors/crud_errors/resource_persistence_error.rb
 - lib/human_error/errors/request_error.rb
 - lib/human_error/knowledgebase_id_directory.rb
-- lib/human_error/persistable.rb
 - lib/human_error/rescuable_resource.rb
 - lib/human_error/utilities/string.rb
 - lib/human_error/version.rb
@@ -106,9 +105,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.6

data/lib/human_error/persistable.rb

@@ -1,56 +0,0 @@
-class   HumanError
-module  Persistable
-  module ClassMethods
-    def find(*ids)
-      super
-    rescue ActiveRecord::RecordNotFound => e
-      ids = case e.message
-            when /\ACouldn't find .* without an ID\z/
-              []
-            when /\ACouldn't find .* with \'.*\'=([a-f0-9\-]+)/
-              [Regexp.last_match(1)]
-            when /\ACouldn't find all .* with \'.*\': ((?:[a-f0-9\-]+(?:, )?)+)/
-              Regexp.last_match(1).split(', ')
-            end
-
-      raise HumanError::Errors::ResourceNotFoundError.new(
-        resource_name: Persistable.human_error_resource_name(self),
-        resource_id:   ids)
-    end
-  end
-
-  def save!(*args)
-    super
-  rescue ActiveRecord::InvalidForeignKey => e
-    association_info_pattern = /DETAIL:  Key \((.*)_id\)=\(([a-f0-9\-]+)\)/
-    association_name, association_id = e.message.
-                                         match(association_info_pattern) \
-                                         [1..-1]
-
-    raise HumanError::Errors::AssociationError.new(
-      resource_name:    Persistable.human_error_resource_name(self.class),
-      association_name: association_name,
-      association_id:   association_id,
-      attributes:       attributes)
-  rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved
-    raise HumanError::Errors::ResourcePersistenceError.new(
-      resource_name: Persistable.human_error_resource_name(self.class),
-      attributes:    attributes,
-      errors:        errors.full_messages)
-  end
-
-  def self.human_error_resource_name(klass)
-    last_part_of_class_name = /::(\w+)\z/
-
-    klass.
-      name[last_part_of_class_name, 1].
-      underscore.
-      humanize.
-      downcase
-  end
-
-  def self.included(base)
-    base.extend ClassMethods
-  end
-end
-end