api_error_handler 0.1.0.rc → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 136050d80b1f4f57e427a7b6d626d898824a09ab
-  data.tar.gz: eef41026be0cf4ec1db00bce32f368d52cda3863
+  metadata.gz: 9be82ce1e320cfcf1a01d61211f628087cc67ea5
+  data.tar.gz: c1ba01e3184c4e1b02aa44da16c9a48ba27be409
 SHA512:
-  metadata.gz: d1e3dad2f964a603860c5cbd8d106d47060e2c43735653dd5fda161daff4b2f9708ea77985abf29efea4af14fda20f7c369192edcd749a1f48a6a5b3beedfd85
-  data.tar.gz: ee295410c74e4dcf66f6e6dc4a34a485f342a6fc35ddacb37667e05ba2a01350a9dfda2bb2ec450310b707f4f371028e2b4e41771de6d4d3105bca6429c55021
+  metadata.gz: 417b51a2dec65912d6e0ff9b8e3865aa59d14897b54ee3cbaa07f6f3de987a92023210602d7480627eff200438e4a91b654e798859480b78c5d9a0617d0065a2
+  data.tar.gz: 3d06ed46fbc62e48b8601f416298edfaa80d9c6a0aac75038c63f9da94d42e9fb3242ff05b3f86c70569eee7a539c5fa64a839dd232cab3e55eab90934234652

data/.gitignore

@@ -7,8 +7,13 @@
 /spec/reports/
 /tmp/
 
+/Gemfile.lock
+
 # rspec failure tracking
 .rspec_status
 
 # Stuff to ignore in the test_app
 test_app/tmp
+test_app/log
+test_app/.byebug_history
+test_app/log/development.log

data/.travis.yml

@@ -1,7 +1,10 @@
 ---
 sudo: false
 language: ruby
-cache: bundler
 rvm:
-  - 2.6.3
-before_install: gem install bundler -v 2.0.1
+  - 2.4
+cache: bundler
+before_install:
+  - gem update --system
+  - gem install bundler
+script: ./bin/test.sh

data/README.md

@@ -1,8 +1,26 @@
 # ApiErrorHandler
+[![Build Status](https://travis-ci.org/jamesstonehill/api_error_handler.svg?branch=master)](https://travis-ci.org/jamesstonehill/api_error_handler)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/api_error_handler`. To experiment with that code, run `bin/console` for an interactive prompt.
+Are your API error responses not all that you want them to be? If so, you've
+found the right gem! `api_error_handler` handles all aspects of returning
+informative, spec-compliant responses to clients when your application
+encounters an error in the course of processing a response.
 
-TODO: Delete this and the text above, and describe your gem
+This "handling" includes:
+- __Error serialization__: each response will include a response body that
+    gives some information on the type of error that your application
+    encountered. See the [Responses Body Options](#response-body-options)
+    section for details and configuration options.
+- __Status code setting__: `api_error_handler` will set the HTTP status code of
+    the response based on the type of error that is raised. For example, when an
+    `ActiveRecord::RecordNotFound` error is raised, it will set the response
+    status to 404. See the [HTTP Status Mapping](#http-status-mapping) section
+    for details and configuration options.
+- __Error reporting__: If you use a 3rd party bug tracking
+    tool like Honeybadger or Sentry, `api_error_handler` will notify this
+    service of the error for you so you don't have to!
+- __Content type setting__: `api_error_handler` will set the content type of the
+    response based on the format of response body.
 
 ## Installation
 
@@ -14,25 +32,260 @@ gem 'api_error_handler'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
-Or install it yourself as:
+## Usage
 
-    $ gem install api_error_handler
+To get started, all you need to do is invoke `handle_api_errors` inside your
+controller like so:
 
-## Usage
+```ruby
+class MyController < ActionController::API
+  handle_api_errors()
+
+  def index
+    raise "Something is very very wrong!"
+  end
+end
+```
+
+Now when you go to `MyController#index`, your API will return the following
+response:
+
+```json
+HTTP/1.1 500 Internal Server Error
+Content-Type: application/json
+
+{
+  "error": {
+    "title":"Internal Server Error",
+    "detail":"Something is very very wrong!"
+  }
+}
+```
+
+### Error handling options
+
+`handle_api_errors` implements a bunch of (hopefully) sensible defaults so that
+all you need to do is invoke `handle_api_errors()` in your controller to get
+useful error handling! However, in all likelihood you'll want to override some
+of these options. This section gives details on the various options available
+for configuring the `api_error_handler`.
+
+#### Response Body Options
+By default, `handle_api_errors` picks the `:json` format for serializing errors.
+However, this gem comes with a number of other formats for serializing your
+errors.
+
+##### JSON (the default)
+```ruby
+  handle_api_errors(format: :json)
+  # Or
+  handle_api_errors()
+```
+
+```json
+HTTP/1.1 500 Internal Server Error
+Content-Type: application/json
+
+{
+  "error": {
+    "title":"Internal Server Error",
+    "detail":"Something is very very wrong!"
+  }
+}
+```
 
-TODO: Write usage instructions here
+##### JSON:API
+If your API follows the `JSON:API` spec, you'll want to use the `:json_api`
+format option.
 
-## Development
+```ruby
+  handle_api_errors(format: :json_api)
+```
 
-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.
+Responses with this format will follow the `JSON:API` [specification for error
+objects](https://jsonapi.org/format/#error-objects). This will look something
+like this:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```json
+HTTP/1.1 500 Internal Server Error
+Content-Type: application/vnd.api+json
+
+{
+  "errors": [
+    {
+      "status":"500",
+      "title":"Internal Server Error",
+      "detail":"Something is very very wrong!"
+    }
+  ]
+}
+```
 
-## Contributing
+##### XML
+```ruby
+  handle_api_errors(format: :xml)
+```
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<Error>
+  <Title>Internal Server Error</title>
+  <Detail>Something is very very wrong!</detail>
+</Error>
+```
+
+##### Custom Error Responses
+If none of the out-of-the-box options suit you then you can pass in your own
+error serializer like so:
+
+```ruby
+  handle_api_errors(serializer: MyCustomErrorSerializer)
+```
+
+The custom serializer must implement two instance methods, `serialize` and
+`render_format`. The `serialize` method should return the body of the response
+you want to render. The `render_format` should be the format that you want to
+render the response in (e.g `:json`, `:xml`, `:plain`), which will be passed to
+Rails' `render` method.
+
+It is recommended you inherit your serializer from
+`ApiErrorHandler::Serializers::BaseSerializer` to gain some helpful instance
+methods and defaults.
+
+```ruby
+class MyCustomErrorSerializer < ApiErrorHandler::Serializers::BaseSerializer
+  def serialize(serializer_options)
+    # The `title` and `status_code` come from the BaseSerializer.
+    "Error! Title: #{title} Status Code: #{status_code}"
+  end
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/api_error_handler.
+  def render_format
+    :plain
+  end
+end
+```
+##### Backtraces
+If you want to include the error's backtrace in the response body:
+
+```ruby
+  handle_api_errors(backtrace: true)
+```
+
+```json
+{
+  "error": {
+    "title":"Internal Server Error",
+    "detail":"Something is very very wrong!",
+    "backtrace": [
+      # The backtrace
+    ]
+  }
+}
+```
+
+### HTTP Status Mapping
+
+Most of the time, you'll want to set the HTTP status code based on the type of
+error being raised. To determine which errors map to which status codes,
+`api_error_handler` uses `ActionDispatch::ExceptionWrapper.rescue_responses`. If
+you're using Rails with ActiveRecord, by default this includes:
+
+```ruby
+{
+  "ActionController::RoutingError"               => :not_found,
+  "AbstractController::ActionNotFound"           => :not_found,
+  "ActionController::MethodNotAllowed"           => :method_not_allowed,
+  "ActionController::UnknownHttpMethod"          => :method_not_allowed,
+  "ActionController::NotImplemented"             => :not_implemented,
+  "ActionController::UnknownFormat"              => :not_acceptable,
+  "Mime::Type::InvalidMimeType"                  => :not_acceptable,
+  "ActionController::MissingExactTemplate"       => :not_acceptable,
+  "ActionController::InvalidAuthenticityToken"   => :unprocessable_entity,
+  "ActionController::InvalidCrossOriginRequest"  => :unprocessable_entity,
+  "ActionDispatch::Http::Parameters::ParseError" => :bad_request,
+  "ActionController::BadRequest"                 => :bad_request,
+  "ActionController::ParameterMissing"           => :bad_request,
+  "Rack::QueryParser::ParameterTypeError"        => :bad_request,
+  "Rack::QueryParser::InvalidParameterError"     => :bad_request
+  "ActiveRecord::RecordNotFound"                 => :not_found,
+  "ActiveRecord::StaleObjectError"               => :conflict,
+  "ActiveRecord::RecordInvalid"                  => :unprocessable_entity,
+  "ActiveRecord::RecordNotSaved"                 => :unprocessable_entity
+}
+```
+- https://guides.rubyonrails.org/configuring.html#configuring-action-dispatch
+
+You can add to this mapping on an application level by doing the following:
+```ruby
+config.action_dispatch.rescue_responses.merge!(
+  "AuthenticationError" => :not_authorized
+)
+```
+
+Now when an you raise an `AuthenticationError` in one of your actions, the
+status code of the response will be 401.
+
+### Error Reporting
+If you use an external error tracking software like Sentry or Honeybadger you'll
+want to report all errors to that service.
+
+You can do so by passing in a `Proc` to the `error_reporter` option. The first
+argument provided to the Proc will be the error. The second argument will be the
+`error_id` if you have one. See the section below for more details on error IDs.
+
+```ruby
+handle_api_errors(
+  error_reporter: Proc.new do |error, error_id|
+    Raven.capture_exception(error, error_id: error_id)
+  end
+)
+```
+
+### Error IDs
+Sometimes it's helpful to include IDs with your error responses so that you can
+correlate a specific error with a record in your logs or bug tracking software.
+
+```ruby
+handle_api_errors(
+  error_id: Proc.new { |error| SecureRandom.uuid }
+)
+```
+
+```json
+{
+  "error": {
+    "title": "Internal Server Error",
+    "detail": "Something is very very wrong!",
+    "id": "4ab520f2-ae33-4539-9371-ea21aada5582"
+  }
+}
+```
+
+### Setting Content Type
+The api_error_handler will set the content type of your error based on the
+`format` option you pick. However, you can override this by setting the
+`content_type` option if you wish.
+
+```ruby
+handle_api_errors(
+  format: :json,
+  content_type: 'application/vnd.api+json'
+)
+```
+
+```json
+HTTP/1.1 500 Internal Server Error
+Content-Type: application/vnd.api+json
+
+{
+  "error": {
+    "title":"Internal Server Error",
+    "detail":"Something is very very wrong!"
+  }
+}
+```
 
 ## License
 

data/api_error_handler.gemspec

@@ -7,10 +7,11 @@ Gem::Specification.new do |spec|
   spec.name          = "api_error_handler"
   spec.version       = ApiErrorHandler::VERSION
   spec.authors       = ["James Stonehill"]
-  spec.email         = ["jamesstonehill@gmail.com"]
+  spec.email         = ["james.stonehill@gmail.com"]
+  spec.required_ruby_version = '~> 2.2'
 
-  spec.summary       = %q{A gem that helps you easily handle exptions in your Rails API and return informative responses to the client.}
-  spec.description   = %q{A gem that helps you easily handle exptions in your Ruby on Rails API and return informative responses to the client by serializing exceptions into JSON and other popular API formats and returning a response with a status code that makes sense based on the exception.}
+  spec.summary       = %q{A gem that helps you easily handle exceptions in your Rails API and return informative responses to the client.}
+  spec.description   = %q{A gem that helps you easily handle exceptions in your Ruby on Rails API and return informative responses to the client by serializing exceptions into JSON and other popular API formats and returning a response with a status code that makes sense based on the exception.}
   spec.homepage      = "https://github.com/jamesstonehill/api_error_handler"
   spec.license       = "MIT"
 
@@ -23,11 +24,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", ">= 4.1.0"
-  spec.add_dependency "actionpack"
+  spec.add_dependency "activesupport", ">= 4.0"
+  spec.add_dependency "actionpack", ">= 4.0"
+  spec.add_dependency "rack", ">= 1.0"
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec-rails", "~> 3.0"
-  spec.add_development_dependency "pry"
 end

data/bin/test.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+bundle install && bundle exec rspec
+bundle install --gemfile ./test_app/Gemfile && bundle exec --gemfile ./test_app/Gemfile rspec

data/lib/api_error_handler.rb

@@ -1,11 +1,54 @@
-require "api_error_handler/version"
-require "api_error_handler/action_controller"
+require_relative "./api_error_handler/version"
+require_relative "./api_error_handler/action_controller"
+Dir[File.join(__dir__, 'api_error_handler', 'serializers', "*.rb")].each { |file| require file }
 
 module ApiErrorHandler
-  def handle_api_errors(format: :json)
+  SERIALIZERS_BY_FORMAT = {
+    json: Serializers::Json,
+    json_api: Serializers::JsonApi,
+    xml: Serializers::Xml,
+  }.freeze
 
-    rescue_from StandardError do |exception|
-      render json: "caught!"
+  SERIALIZER_OPTIONS = {
+    backtrace: false,
+  }.freeze
+
+  CONTENT_TYPE_BY_FORMAT = {
+    json_api: "application/vnd.api+json"
+  }.freeze
+
+  def handle_api_errors(options = {})
+    format = options.fetch(:format, :json)
+    status_mapping = ActionDispatch::ExceptionWrapper.rescue_responses
+    error_reporter = options[:error_reporter]
+    serializer_options = SERIALIZER_OPTIONS.merge(
+      options.slice(*SERIALIZER_OPTIONS.keys)
+    )
+
+    serializer_class = options[:serializer] || SERIALIZERS_BY_FORMAT.fetch(format)
+    content_type = options[:content_type] || CONTENT_TYPE_BY_FORMAT[format]
+
+    rescue_from StandardError do |error|
+      begin
+        status = status_mapping[error.class.to_s]
+
+        error_id = nil
+        error_id = options[:error_id].call(error) if options[:error_id]
+        error_reporter.call(error, error_id) if error_reporter
+
+        serializer = serializer_class.new(error, status)
+        response_body = serializer.serialize(
+          serializer_options.merge(error_id: error_id)
+        )
+
+        render(
+          serializer.render_format => response_body,
+          content_type: content_type,
+          status: status
+        )
+      rescue
+        raise error
+      end
     end
   end
 end

data/lib/api_error_handler/errors.rb

@@ -0,0 +1,3 @@
+module ApiErrorHandler
+  # class UnknownSerializerError < ArgumentError; end
+end

data/lib/api_error_handler/serializers/base_serializer.rb

@@ -0,0 +1,22 @@
+require 'rack/utils'
+
+module ApiErrorHandler
+  module Serializers
+    class BaseSerializer
+      DEFAULT_STATUS_CODE = "500".freeze
+
+      def initialize(error, status)
+        @error = error
+        @status = status
+      end
+
+      def status_code
+        Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(@status, DEFAULT_STATUS_CODE).to_s
+      end
+
+      def title
+        Rack::Utils::HTTP_STATUS_CODES.fetch(status_code.to_i)
+      end
+    end
+  end
+end

data/lib/api_error_handler/serializers/json.rb

@@ -1,6 +1,32 @@
+require_relative './base_serializer'
+
 module ApiErrorHandler
   module Serializers
-    class Json
+    class Json < BaseSerializer
+      # There is no official spec that governs this error response format so
+      # this serializer is just trying to impliment a simple response with
+      # sensible defaults.
+      #
+      # I borrowed heavily from Facebook's error response format since it seems
+      # to be a reasonable approach for a simple light-weight error response.
+
+      def serialize(options = {})
+        body = {
+          error: {
+            title: title,
+            detail: @error.message,
+          }
+        }
+
+        body[:error][:id] = options[:error_id] if options[:error_id]
+        body[:error][:backtrace] = @error.backtrace if options[:backtrace]
+
+        body.to_json
+      end
+
+      def render_format
+        :json
+      end
     end
   end
 end

data/lib/api_error_handler/serializers/json_api.rb

@@ -0,0 +1,28 @@
+require_relative './base_serializer'
+
+module ApiErrorHandler
+  module Serializers
+    class JsonApi < BaseSerializer
+      def serialize(options = {})
+        body = {
+          errors: [
+            {
+              status: status_code,
+              title: title,
+              detail: @error.message,
+            }
+          ]
+        }
+
+        body[:errors].first[:id] = options[:error_id] if options[:error_id]
+        body[:errors].first[:meta] = { backtrace: @error.backtrace } if options[:backtrace]
+
+        body.to_json
+      end
+
+      def render_format
+        :json
+      end
+    end
+  end
+end

data/lib/api_error_handler/serializers/xml.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/hash/conversions'
+require_relative './base_serializer'
+
+module ApiErrorHandler
+  module Serializers
+    class Xml < BaseSerializer
+      def serialize(options = {})
+        body = {
+          Title: title,
+          Detail: @error.message,
+        }
+
+        body[:Id] = options[:error_id] if options[:error_id]
+        body[:Backtrace] = @error.backtrace if options[:backtrace]
+
+        body.to_xml(root: "Error")
+      end
+
+      def render_format
+        :xml
+      end
+    end
+  end
+end

data/lib/api_error_handler/version.rb

@@ -1,3 +1,3 @@
 module ApiErrorHandler
-  VERSION = "0.1.0.rc"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_error_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc
+  version: 0.1.0
 platform: ruby
 authors:
 - James Stonehill
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-20 00:00:00.000000000 Z
+date: 2019-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,26 +94,12 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  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: A gem that helps you easily handle exptions in your Ruby on Rails API
+description: A gem that helps you easily handle exceptions in your Ruby on Rails API
   and return informative responses to the client by serializing exceptions into JSON
   and other popular API formats and returning a response with a status code that makes
   sense based on the exception.
 email:
-- jamesstonehill@gmail.com
+- james.stonehill@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -108,19 +108,21 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - api_error_handler.gemspec
 - bin/console
 - bin/setup
+- bin/test.sh
 - lib/api_error_handler.rb
 - lib/api_error_handler/action_controller.rb
-- lib/api_error_handler/error_serializer.rb
+- lib/api_error_handler/errors.rb
+- lib/api_error_handler/serializers/base_serializer.rb
 - lib/api_error_handler/serializers/json.rb
+- lib/api_error_handler/serializers/json_api.rb
+- lib/api_error_handler/serializers/xml.rb
 - lib/api_error_handler/version.rb
-- lib/serializers/json.rb
 homepage: https://github.com/jamesstonehill/api_error_handler
 licenses:
 - MIT
@@ -131,19 +133,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.14.4
 signing_key: 
 specification_version: 4
-summary: A gem that helps you easily handle exptions in your Rails API and return
+summary: A gem that helps you easily handle exceptions in your Rails API and return
   informative responses to the client.
 test_files: []

data/Gemfile.lock

@@ -1,96 +0,0 @@
-PATH
-  remote: .
-  specs:
-    api_error_handler (0.1.0)
-      actionpack
-      activesupport (>= 4.1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    actionpack (5.2.3)
-      actionview (= 5.2.3)
-      activesupport (= 5.2.3)
-      rack (~> 2.0)
-      rack-test (>= 0.6.3)
-      rails-dom-testing (~> 2.0)
-      rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (5.2.3)
-      activesupport (= 5.2.3)
-      builder (~> 3.1)
-      erubi (~> 1.4)
-      rails-dom-testing (~> 2.0)
-      rails-html-sanitizer (~> 1.0, >= 1.0.3)
-    activesupport (5.2.3)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    builder (3.2.3)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    crass (1.0.4)
-    diff-lcs (1.3)
-    erubi (1.8.0)
-    i18n (1.6.0)
-      concurrent-ruby (~> 1.0)
-    loofah (2.2.3)
-      crass (~> 1.0.2)
-      nokogiri (>= 1.5.9)
-    method_source (0.9.2)
-    mini_portile2 (2.4.0)
-    minitest (5.11.3)
-    nokogiri (1.10.3)
-      mini_portile2 (~> 2.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rack (2.0.7)
-    rack-test (1.1.0)
-      rack (>= 1.0, < 3)
-    rails-dom-testing (2.0.3)
-      activesupport (>= 4.2.0)
-      nokogiri (>= 1.6)
-    rails-html-sanitizer (1.0.4)
-      loofah (~> 2.2, >= 2.2.2)
-    railties (5.2.3)
-      actionpack (= 5.2.3)
-      activesupport (= 5.2.3)
-      method_source
-      rake (>= 0.8.7)
-      thor (>= 0.19.0, < 2.0)
-    rake (10.5.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-rails (3.8.2)
-      actionpack (>= 3.0)
-      activesupport (>= 3.0)
-      railties (>= 3.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    thor (0.20.3)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  api_error_handler!
-  bundler (~> 2.0)
-  pry
-  rake (~> 10.0)
-  rspec-rails (~> 3.0)
-
-BUNDLED WITH
-   2.0.2

data/lib/api_error_handler/error_serializer.rb

@@ -1,25 +0,0 @@
-require_relative 'serializers/json'
-
-module ApiErrorHandler
-  class ErrorSerializer
-    SERIALIZERS_BY_FORMAT = {
-      json: Serializers::Json
-    }
-
-    def initialize(error, format, status)
-      @error = error
-      @format = format
-      @status = status
-    end
-
-    def serialize
-
-    end
-
-    private
-
-    def serializer
-
-    end
-  end
-end

data/lib/serializers/json.rb

@@ -1,9 +0,0 @@
-class ApiErrorHandler
-  module Serializers
-    class Json
-      def self.serialize(error)
-        { message: error.message }.to_json
-      end
-    end
-  end
-end