jsonapi_errors_handler 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b564d9bbd8895bf69bb4fe9529179adf982161ed5487b9ab25020aedc8f2156
-  data.tar.gz: faa8c8ceac35f80350aa3c0ec9a4388acf9896f80e492fdb5db8d120c14b0b13
+  metadata.gz: 4a2f52ab77c66d7116cda41a5cb4e087a94621967689382b7de9466fa270c0ac
+  data.tar.gz: 9efb9e2a227bc6efe491573ca8b675cf53c770b8b437ed5e9523dffbc60e9628
 SHA512:
-  metadata.gz: 8c60a80673165135c28ecb6b5c99321100702db140c90450c3db58a5e52d66c3369d7521f33a925263ec940d9a88c4d605d5ea111811d2d9283bce31d92c57ba
-  data.tar.gz: 84882a23b85bb539d8375bb651a019a27fcbff37eba86339b374e5e5a67ca2140361f2eba2cadf4af67cdc435556a35027490a6309a22116a873b99041c60e4a
+  metadata.gz: 0f0e2fedb96b9cef8d8f606bf3bd76cb0e40909ce6b82d707fa95ad853188cb196e814ad97af089c9f3780831c148edd971da0df3b11f76b26776fc8c7359098
+  data.tar.gz: 6014da1d66dbb431b944b44f74d249510c7236db2802ee728d21ddb337b259a41d7a96bbcf0a0893e98bf009094ba78c5d1061d8d1485847e74a6d0da2e8c0cb

data/.gitignore

@@ -3,6 +3,7 @@
 /_yardoc/
 /coverage/
 /doc/
+/node_modules
 /pkg/
 /spec/reports/
 /tmp/

data/.ruby-version

@@ -0,0 +1 @@
+2.6.1

data/CONTRIBUTING.md

@@ -0,0 +1,21 @@
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/driggl/jsonapi_errors_handler.
+
+**How to contribute:**
+
+1. Create Issue on Github.
+2. Fork repository
+3. Install [Rubocop](https://github.com/rubocop-hq/rubocop) - make sure you run it before commiting changes
+4. Commit changes
+  - Keep commits small and atomic
+  - Start commit message from keywords (Add/Remove/Change/Refactor/Move/Rename/Upgrade/Downgrade)
+  - Keep commits imperative style
+  - Mention issue number (i.e "Resolves: #3")
+5. Make sure you cover your change with tests.
+6. Create Pull Request
+
+**Coding Guidelines**
+
+- We use [Rubocop](https://github.com/rubocop-hq/rubocop) and Ruby style guides for linting `*.rb` files.
+- We use [Remark Lint](https://github.com/remarkjs/remark-lint) for linting `*.md` files.

data/Gemfile

@@ -1,6 +1,8 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in jsonapi_errors_handler.gemspec
 gemspec

data/README.md

@@ -1,16 +1,17 @@
-
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/542259a14a8f4b2894a39850c5031ffa)](https://app.codacy.com/app/swilgosz/jsonapi_errors_handler?utm_source=github.com&utm_medium=referral&utm_content=driggl/jsonapi_errors_handler&utm_campaign=Badge_Grade_Dashboard)
+[![Gem Version](https://badge.fury.io/rb/jsonapi_errors_handler.svg)](https://badge.fury.io/rb/jsonapi_errors_handler)
 [![CircleCI](https://circleci.com/gh/driggl/jsonapi_errors_handler/tree/master.svg?style=svg)](https://circleci.com/gh/driggl/jsonapi_errors_handler/tree/master)
 
 # JsonapiErrorsHandler
 
-A convienient way to serialize errors in JsonAPI format (https://jsonapi.org)
+A convienient way to serialize errors in [Jsonapi standard](https://jsonapi.org)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'jsonapi_errors_handler'
+  gem 'jsonapi_errors_handler'
 ```
 
 And then execute:
@@ -25,16 +26,17 @@ Or install it yourself as:
 
 In your controller:
 
-```
-include JsonapiErrorsHandler
-rescue_from ::StandardError, with: lambda { |e| handle_error(e) }
+```ruby
+  include JsonapiErrorsHandler
+  rescue_from ::StandardError, with: lambda { |e| handle_error(e) }
 ```
 
 From this point you'll have default html errors being serialized. JsonapiErrorsHandler offers 4 predefined errors:
-- JsonapiErrorsHandler::Errors::Invalid
-- JsonapiErrorsHandler::Errors::Forbidden
-- JsonapiErrorsHandler::Errors::NotFound
-- JsonapiErrorsHandler::Errors::Unauthorized
+
+*   [JsonapiErrorsHandler::Errors::Invalid](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/invalid.rb)
+*   [JsonapiErrorsHandler::Errors::Forbidden](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/forbidden.rb)
+*   [JsonapiErrorsHandler::Errors::NotFound](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/not_found.rb)
+*   [JsonapiErrorsHandler::Errors::Unauthorized](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/not_found.rb)
 
 If you rise any of errors above in any place of your application, client gets the nicely formatted error message instead of 500
 
@@ -42,15 +44,66 @@ If you rise any of errors above in any place of your application, client gets th
 
 If you want your custom errors being handled by default, just add them to the mapper
 
+```ruby
+  include JsonapiErrorsHandler
+  ErrorsMapper.map_errors!({
+      'ActiveRecord::RecordNotFound' => 'JsonapiErrorsHandler::Errors::NotFound',
+      'ActiveRecord::RecordInvalid' => 'JsonapiErrorsHandler::Errors::Invalid',
+  })
+  rescue_from ::StandardError, with: lambda { |e| handle_error(e) }
+```
+
+###Custom error logging
+
+When you'll include the `jsonapi_errors_handler` to your controller, all errors will be handled and delivered to the client in the nice, formatted
+way.
+
+However, you'd probably like to have a way to log the risen error on your own to send notifications to developers that
+something unexpected happened.
+
+To do so, just implement the `log_error` method in your controller, that accepts the risen error as an argument.
+
 ```
-include JsonapiErrorsHandler
-ErrorsMapper.map_errors!({
-    'ActiveRecord::RecordNotFound' => 'JsonapiErrorsHandler::Errors::NotFound',
-    'ActiveRecord::RecordInvalid' => 'JsonapiErrorsHandler::Errors::Invalid',
-})
-rescue_from ::StandardError, with: lambda { |e| handle_error(e) }
+  def log_error(error)
+    #do the fancy logging here
+  end
 ```
 
+### Custom error responses
+
+By default, we deliver hardcoded responses. You can check out the defined error classes for details
+
+*   [JsonapiErrorsHandler::Errors::Invalid](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/invalid.rb)
+*   [JsonapiErrorsHandler::Errors::Forbidden](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/forbidden.rb)
+*   [JsonapiErrorsHandler::Errors::NotFound](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/not_found.rb)
+*   [JsonapiErrorsHandler::Errors::Unauthorized](https://github.com/driggl/jsonapi_errors_handler/blob/master/lib/jsonapi_errors_handler/errors/not_found.rb)
+
+If you want to have custom error responses being delivered, just create your own `Api::Errors` that inherits from `JsonapiErrorsHandler::StandardError`
+
+### Localization example
+
+If you want to localize your responses, just create a class:
+
+```
+  module Api::Errors
+    class Forbidden < ::JsonapiErrorsHandler::Errors::StandardError
+      def initialize(*)
+        super(
+          title: I18n.t('api.errors.forbidden.title'),
+          status: 403,
+          detail: I18n.t('api.errors.forbidden.detail'),
+          source: { pointer: '/request/headers/authorization' }
+        )
+      end
+    end
+  end
+```
+
+## Guides & tutorials
+
+*   [Handling Exceptions in Rails Applications](https://driggl.com/blog/a/handling-exceptions-in-rails-applications) - Gem's concept explained in details
+*   [JsonApi Errors Handler Guide](https://driggl.com/blog/a/json-api-errors-handler)
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -59,16 +112,17 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/driggl/jsonapi_errors_handler.
+Bug reports and pull requests are welcome on GitHub at [https://github.com/driggl/jsonapi_errors_handler](https://github.com/driggl/jsonapi_errors_handler).
 
 **How to contribute:**
 
-1. Fork repository
-2. Commit changes
-    - Keep commits small and atomic
-    - Start commit message from keywords (Add/Remove/Change/Refactor/Move/Rename/Upgrade/Downgrade)
-    - Keep commits imperative style
-3. Create Pull Request
+1.  Fork repository
+2.  Install [Rubocop](https://github.com/rubocop-hq/rubocop) - make sure you run it before commiting changes
+3.  Commit changes
+  *   Keep commits small and atomic
+  *   Start commit message from keywords (Add/Remove/Change/Refactor/Move/Rename/Upgrade/Downgrade)
+  *   Keep commits imperative style
+4.  Create Pull Request
 
 ## License
 

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "jsonapi_errors_handler"
+require 'bundler/setup'
+require 'jsonapi_errors_handler'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "jsonapi_errors_handler"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/jsonapi_errors_handler.gemspec

@@ -1,41 +1,46 @@
-lib = File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "jsonapi_errors_handler/version"
+require 'jsonapi_errors_handler/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "jsonapi_errors_handler"
+  spec.name          = 'jsonapi_errors_handler'
   spec.version       = JsonapiErrorsHandler::VERSION
-  spec.authors       = ["Sebastian Wilgosz"]
-  spec.email         = ["sebastian@driggl.com"]
+  spec.authors       = ['Sebastian Wilgosz']
+  spec.email         = ['sebastian@driggl.com']
 
-  spec.summary       = %q{A JSON API error handler for ruby applications.}
-  spec.description   = %q{This gem is a convienient wrapper for your application errors. It allows you to map any error to a nicely formatted standard HTTP error response. }
-  spec.homepage      = "https://github.com/driggl/jsonapi_errors_handler"
-  spec.license       = "MIT"
+  spec.summary       = 'A JSON API error handler for ruby applications.'
+  spec.description   = <<~STRING
+    This gem is a convienient wrapper for your application errors.
+    It allows you to map any error to a nicely formatted standard HTTP error response.
+  STRING
+  spec.homepage      = 'https://github.com/driggl/jsonapi_errors_handler'
+  spec.license       = 'MIT'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
     # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 
-    spec.metadata["homepage_uri"] = spec.homepage
-    spec.metadata["source_code_uri"] = "https://github.com/driggl/jsonapi_errors_handler"
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/driggl/jsonapi_errors_handler'
     # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
   else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
   end
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

data/lib/jsonapi_errors_handler.rb

@@ -1,41 +1,38 @@
+# frozen_string_literal: true
+
 require 'irb'
-require "jsonapi_errors_handler/version"
-require "jsonapi_errors_handler/errors"
-require "jsonapi_errors_handler/error_mapper"
-require "jsonapi_errors_handler/error_serializer"
+require 'jsonapi_errors_handler/version'
+require 'jsonapi_errors_handler/errors'
+require 'jsonapi_errors_handler/error_mapper'
+require 'jsonapi_errors_handler/error_serializer'
 
 module JsonapiErrorsHandler
   def self.included(base)
     base.class_eval do
-      ErrorMapper.map_errors!({
+      ErrorMapper.map_errors!(
         'JsonapiErrorsHandler::Errors::Invalid' => 'JsonapiErrorsHandler::Errors::Invalid',
         'JsonapiErrorsHandler::Errors::Forbidden' => 'JsonapiErrorsHandler::Errors::Forbidden',
         'JsonapiErrorsHandler::Errors::NotFound' => 'JsonapiErrorsHandler::Errors::NotFound',
         'JsonapiErrorsHandler::Errors::Unauthorized' => 'JsonapiErrorsHandler::Errors::Unauthorized'
-      })
+      )
+    end
+  end
 
-      def handle_error(e)
-        mapped = map_error(e)
-        unless Rails.env.development?
-          # notify about unexpected_error unless mapped
-          mapped ||= ::JsonapiErrorsHandler::Errors::StandardError.new
-        end
-        if mapped
-          render_error(mapped)
-        else
-          raise e
-        end
-      end
+  def handle_error(error)
+    mapped = map_error(error)
+    log_error(error) if respond_to?(:log_error) && !mapped
+    mapped ||= ::JsonapiErrorsHandler::Errors::StandardError.new
+    render_error(mapped)
+  end
 
-      def map_error(e)
-        error_klass = e.class.name
-        return e if ErrorMapper.mapped_error?(error_klass)
-        ErrorMapper.mapped_errors[error_klass]&.constantize&.new
-      end
+  def map_error(error)
+    error_klass = error.class.name
+    return nil unless ErrorMapper.mapped_error?(error_klass)
 
-      def render_error(error)
-        render json: ::JsonapiErrorsHandler::ErrorSerializer.new(error), status: error.status
-      end
-    end
+    Object.const_get(ErrorMapper.mapped_errors[error_klass]).new
+  end
+
+  def render_error(error)
+    render json: ::JsonapiErrorsHandler::ErrorSerializer.new(error), status: error.status
   end
 end

data/lib/jsonapi_errors_handler/error_mapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JsonapiErrorsHandler
   class ErrorMapper
     @@mapped_errors = {}
@@ -5,13 +7,12 @@ module JsonapiErrorsHandler
       @@mapped_errors
     end
 
-    def self.map_errors!(errors_hash={})
+    def self.map_errors!(errors_hash = {})
       @@mapped_errors.merge!(errors_hash)
     end
 
     def self.mapped_error?(error_klass)
-      mapped_errors.values.include?(error_klass)
+      mapped_errors.value?(error_klass)
     end
   end
 end
-

data/lib/jsonapi_errors_handler/error_serializer.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'json'
+
 module JsonapiErrorsHandler
   class ErrorSerializer
     def initialize(error)
@@ -8,7 +12,7 @@ module JsonapiErrorsHandler
       serializable_hash
     end
 
-    def to_json(_payload=nil)
+    def to_json(_payload = nil)
       to_h.to_json
     end
 
@@ -16,11 +20,10 @@ module JsonapiErrorsHandler
 
     def serializable_hash
       {
-        errors: Array.wrap(error.serializable_hash)
+        errors: [error.serializable_hash]
       }
     end
 
     attr_reader :error
   end
 end
-

data/lib/jsonapi_errors_handler/errors.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module JsonapiErrorsHandler
   module Errors
-
   end
 end
 

data/lib/jsonapi_errors_handler/errors/forbidden.rb

@@ -5,10 +5,10 @@ module JsonapiErrorsHandler
     class Forbidden < ::JsonapiErrorsHandler::Errors::StandardError
       def initialize(message: nil)
         super(
-          title: "Forbidden request",
+          title: 'Forbidden request',
           status: 403,
-          detail: message || "You have no rights to access this resource",
-          source: { pointer: "/request/headers/authorization" }
+          detail: message || 'You have no rights to access this resource',
+          source: { pointer: '/request/headers/authorization' }
         )
       end
     end

data/lib/jsonapi_errors_handler/errors/invalid.rb

@@ -6,7 +6,7 @@ module JsonapiErrorsHandler
       def initialize(errors: {})
         @errors = errors
         @status = 422
-        @title = "Invalid request"
+        @title = 'Invalid request'
       end
 
       def serializable_hash