human_error 2.0.0 → 3.0.0

data/lib/human_error/errors/request_errors/parameter_missing_error.rb

@@ -0,0 +1,40 @@
+class   HumanError
+module  Errors
+class   ParameterMissingError < RuntimeError
+  include Error
+
+  attr_accessor :parameter
+
+  def self.convert(original_error, overrides = {})
+    initialization_parameters = {}
+
+    case original_error.class.name
+    when 'ActionController::ParameterMissing'
+      initialization_parameters = {
+        parameter: original_error.param,
+      }
+    end
+
+    new(initialization_parameters.merge(overrides))
+  end
+
+  def http_status
+    400
+  end
+
+  def title
+    'Missing Parameter'
+  end
+
+  def detail
+    "#{parameter} is a required parameter, but you did not supply it."
+  end
+
+  def source
+    {
+      'required_parameter' => parameter,
+    }
+  end
+end
+end
+end

data/lib/human_error/errors/request_errors/unpermitted_parameters_error.rb

@@ -0,0 +1,46 @@
+class   HumanError
+module  Errors
+class   UnpermittedParametersError < RuntimeError
+  include Error
+
+  attr_accessor :parameters
+
+  def self.convert(original_error, overrides = {})
+    initialization_parameters = {}
+
+    case original_error.class.name
+    when 'ActionController::UnpermittedParameters'
+      initialization_parameters = {
+        parameters: Array(original_error.params),
+      }
+    end
+
+    new(initialization_parameters.merge(overrides))
+  end
+
+  def initialize(**attrs)
+    self.parameters = Array(attrs.delete(:parameters))
+
+    super(**attrs)
+  end
+
+  def http_status
+    400
+  end
+
+  def title
+    'Unpermitted Parameters'
+  end
+
+  def detail
+    "The following parameters passed are not allowed: #{parameters.join(', ')}"
+  end
+
+  def source
+    {
+      'unpermitted_parameters' => parameters,
+    }
+  end
+end
+end
+end

data/lib/human_error/rescuable_resource.rb

@@ -1,59 +1,42 @@
-require 'human_error/errors/crud_errors/resource_persistence_error'
-require 'human_error/errors/crud_errors/resource_not_found_error'
-require 'human_error/errors/crud_errors/association_error'
-
 class   HumanError
 module  RescuableResource
   module ClassMethods
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
-    def rescue_resource(resource_name, from:, via:)
-      nice_resource_name = resource_name.humanize.downcase
-      lookup_library     = via
-
-      if from.include? 'persistence'
-        rescue_from 'ActiveRecord::RecordInvalid',
-                    'ActiveRecord::RecordNotSaved' do |exception|
-          human_error = lookup_library.convert(exception,
-                                               resource_name: nice_resource_name,
-                                               action:        action_name)
-
-          render json:   human_error,
-                 status: human_error.http_status
-        end
-      end
-
-      if from.include? 'not_found'
-        rescue_from 'ActiveRecord::RecordNotFound' do |exception|
-          human_error = lookup_library.convert(exception,
-                                               resource_name: nice_resource_name,
-                                               action:        action_name)
-
-          render json:   human_error,
-                 status: human_error.http_status
-        end
-      end
-
-      if from.include? 'association'
-        rescue_from 'ActiveRecord::InvalidForeignKey' do |exception|
-          human_error = lookup_library.convert(exception,
-                                               resource_name: nice_resource_name,
-                                               action:        action_name)
-
-          render json:   human_error,
-                 status: human_error.http_status
-        end
-      end
+    def plural_resource_name
+      name[/(\w+)Controller\z/, 1].
+      underscore.
+      pluralize.
+      downcase
+    end
 
-      rescue_from 'HumanError::Error' do |exception|
-        render json:   exception,
-               status: exception.http_status
-      end
+    def singular_resource_name
+      name[/(\w+)Controller\z/, 1].
+      underscore.
+      singularize.
+      downcase
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
   end
 
   def self.included(base)
     base.extend ClassMethods
+
+    base.rescue_from 'ActiveRecord::RecordInvalid',
+                     'ActiveRecord::RecordNotSaved',
+                     'ActiveRecord::RecordNotFound',
+                     'ActiveRecord::InvalidForeignKey',
+                     'ActionController::ParameterMissing',
+                     'ActionController::UnpermittedParameters' do |exception|
+      human_error = HumanError.convert(exception,
+                                       resource_name: self.class.singular_resource_name,
+                                       action:        action_name)
+
+      render json:   human_error,
+             status: human_error.http_status
+    end
+
+    base.rescue_from 'HumanError::Error' do |exception|
+      render json:   exception,
+             status: exception.http_status
+    end
   end
 end
 end

data/lib/human_error/verifiable_resource.rb

@@ -0,0 +1,36 @@
+class   HumanError
+module  VerifiableResource
+  module ClassMethods
+    def plural_resource_name
+      name[/(\w+)Controller\z/, 1].
+      underscore.
+      pluralize.
+      downcase
+    end
+
+    def singular_resource_name
+      name[/(\w+)Controller\z/, 1].
+      underscore.
+      singularize.
+      downcase
+    end
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+
+    base.before_action except: %i{index create} do
+      model = public_send(self.class.singular_resource_name)
+
+      resource_not_found_error = HumanError.build(
+        'ResourceNotFoundError',
+        resource_name: self.class.singular_resource_name,
+        resource_id:   [params[:id]],
+        action:        action_name,
+      )
+
+      fail resource_not_found_error unless model.persisted?
+    end
+  end
+end
+end

data/lib/human_error/version.rb

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

data/spec/lib/human_error/configuration_spec.rb

@@ -2,38 +2,25 @@ require 'rspectacular'
 require 'human_error/configuration'
 
 class     HumanError
-describe  Configuration do
-  it 'can set the API version' do
-    configuration = Configuration.new
-    configuration.api_version = 'whateeeeeever'
+describe  Configuration, singletons: true do
+  it 'can set the url mappings' do
+    configuration = Configuration.instance
+    configuration.url_mappings = 'whateeeeeever'
 
-    expect(configuration.api_version).to eql 'whateeeeeever'
-  end
-
-  it 'can set the API error documentation URL' do
-    configuration = Configuration.new
-    configuration.api_error_documentation_url = 'whateeeeeever'
-
-    expect(configuration.api_error_documentation_url).to eql 'whateeeeeever'
-  end
-
-  it 'can set the knowledgebase URL' do
-    configuration = Configuration.new
-    configuration.knowledgebase_url = 'whateeeeeever'
-
-    expect(configuration.knowledgebase_url).to eql 'whateeeeeever'
+    expect(configuration.url_mappings).to eql 'whateeeeeever'
   end
 
   it 'can convert itself into a hash' do
-    configuration                             = Configuration.new
-    configuration.knowledgebase_url           = 'knowledgebase_url'
-    configuration.api_error_documentation_url = 'api_error_documentation_url'
-    configuration.api_version                 = 'api_version'
+    configuration              = Configuration.instance
+    configuration.url_mappings = {
+      'external_documentation_urls'  => 'blah',
+      'developer_documentation_urls' => 'asdf',
+    }
 
     expect(configuration.to_h).to eql(
-      knowledgebase_url:           'knowledgebase_url',
-      api_error_documentation_url: 'api_error_documentation_url',
-      api_version:                 'api_version')
+      external_documentation_urls:  'blah',
+      developer_documentation_urls: 'asdf',
+    )
   end
 end
 end

data/spec/lib/human_error/error_spec.rb

@@ -37,10 +37,144 @@ describe  Error do
 
   it 'can have its message explicitly set when it is generated' do
     error = CustomError.new
-    allow(error).to receive(:developer_message).
+    allow(error).to receive(:detail).
                     and_return('My Developer Message')
 
     expect(error.message).to eql 'My Developer Message'
   end
+
+  it 'can generate error data' do
+    custom_error = CustomError.new(
+      id:                          'identifier',
+      http_status:                 'flibbity',
+      code:                        'jibbit',
+      title:                       'roll dem bones and stones',
+      detail:                      'I cannot receive any satisfaction',
+      source:                      'But perhaps if I attempt it one more time, I can',
+      developer_documentation_url: 'asimof/jibbit?version=janky',
+      external_documentation_url:  'jinkies/87654321')
+
+    expect(custom_error.as_json).to eql(
+      errors: [
+        {
+          id:     'identifier',
+          links:  {
+            about:         'jinkies/87654321',
+            documentation: 'asimof/jibbit?version=janky',
+          },
+          status: 'flibbity',
+          code:   'jibbit',
+          title:  'roll dem bones and stones',
+          detail: 'I cannot receive any satisfaction',
+          source: 'But perhaps if I attempt it one more time, I can',
+        },
+      ])
+  end
+
+  it 'can extract configuration from the global config if it is not passed in',
+     singletons: HumanError::Configuration do
+
+    HumanError.configure do |config|
+      config.url_mappings = {
+        'external_documentation_urls'  => {
+          'jibbit' => 'http://example.com/edu',
+        },
+        'developer_documentation_urls' => {
+          'jibbit' => 'http://example.com/ddu',
+        },
+      }
+    end
+
+    custom_error = CustomError.new(
+      id:          'identifier',
+      http_status: 'flibbity',
+      code:        'jibbit',
+      title:       'roll dem bones and stones',
+      detail:      'I cannot receive any satisfaction',
+      source:      'But perhaps if I attempt it one more time, I can')
+
+    expect(custom_error.as_json).to eql(
+      errors: [
+        {
+          id:     'identifier',
+          links:  {
+            about:         'http://example.com/edu',
+            documentation: 'http://example.com/ddu',
+          },
+          status: 'flibbity',
+          code:   'jibbit',
+          title:  'roll dem bones and stones',
+          detail: 'I cannot receive any satisfaction',
+          source: 'But perhaps if I attempt it one more time, I can',
+        },
+      ])
+  end
+
+  it 'can override the global config if it is set, but an explicit value is passed in',
+     singletons: HumanError::Configuration do
+
+    HumanError.configure do |config|
+      config.url_mappings = {
+        'external_documentation_urls'  => {
+          'jibbit' => 'http://example.com/edu',
+        },
+        'developer_documentation_urls' => {
+          'jibbit' => 'http://example.com/ddu',
+        },
+      }
+    end
+
+    custom_error = CustomError.new(
+      id:                          'identifier',
+      http_status:                 'flibbity',
+      code:                        'jibbit',
+      title:                       'roll dem bones and stones',
+      detail:                      'I cannot receive any satisfaction',
+      source:                      'But perhaps if I attempt it one more time, I can',
+      developer_documentation_url: 'hasimof/jibbit?version=hanky',
+      external_documentation_url:  'hinkies/87654321')
+
+    expect(custom_error.as_json).to eql(
+      errors: [
+        {
+          id:     'identifier',
+          links:  {
+            about:         'hinkies/87654321',
+            documentation: 'hasimof/jibbit?version=hanky',
+          },
+          status: 'flibbity',
+          code:   'jibbit',
+          title:  'roll dem bones and stones',
+          detail: 'I cannot receive any satisfaction',
+          source: 'But perhaps if I attempt it one more time, I can',
+        },
+      ])
+  end
+
+  it 'can handle if it finds no URL mappings' do
+    custom_error = CustomError.new(
+      id:          'identifier',
+      http_status: 'flibbity',
+      code:        'jibbit',
+      title:       'roll dem bones and stones',
+      detail:      'I cannot receive any satisfaction',
+      source:      'But perhaps if I attempt it one more time, I can')
+
+    expect(custom_error.as_json).to eql(
+      errors: [
+        {
+          id:     'identifier',
+          links:  {
+            about:         nil,
+            documentation: nil,
+          },
+          status: 'flibbity',
+          code:   'jibbit',
+          title:  'roll dem bones and stones',
+          detail: 'I cannot receive any satisfaction',
+          source: 'But perhaps if I attempt it one more time, I can',
+        },
+      ])
+  end
 end
 end

data/spec/lib/human_error/errors/authentication_errors/duplicate_authentication_error_spec.rb

@@ -14,34 +14,29 @@ describe  DuplicateAuthenticationError do
     expect(error.http_status).to eql 409
   end
 
-  it 'has a code of 1008' do
-    expect(error.code).to eql 1008
+  it 'has a code' do
+    expect(error.code).to eql 'errors.duplicate_authentication_error'
   end
 
-  it 'has a knowledgebase article ID of 1234567890' do
-    expect(error.knowledgebase_article_id).to eql '1234567890'
+  it 'has a title' do
+    expect(error.title).to eql 'Duplicate Authentication'
   end
 
-  it 'can output the developer message' do
-    expect(error.developer_message).to eql 'The authentication you attempted to ' \
+  it 'can output the detail' do
+    expect(error.detail).to eql 'The authentication you attempted to ' \
                                            'register has already been registered by ' \
                                            'another user. We do not currently support ' \
                                            'allowing multiple users to be connected to ' \
                                            'the same authentication.'
   end
 
-  it 'can output the developer details' do
-    expect(error.developer_details).to eql(
+  it 'can output the source' do
+    expect(error.source).to eql(
               'provider'         => 'flibbity',
               'provider_user_id' => '12345',
               'user_id'          => '54321',
     )
   end
-
-  it 'can output the friendly message' do
-    expect(error.friendly_message).to eql 'Sorry! Someone else has already registered ' \
-                                          'this flibbity login.'
-  end
 end
 end
 end