daredevil 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5623a1c5349dd39821379641f01f69c99f8b15ae
+  data.tar.gz: fac4157ad72ed070c87415203c454966e033d501
+SHA512:
+  metadata.gz: 96b82a00fed7c5fa4e50da77aa0214b1547565fee8746c5d8d4ee9317a80b76ffe4289445ac8dd2db08a6a91739ae82a6af8fd6efbc502259e975a39ee2db4be
+  data.tar.gz: 689b7b1d628f8a15a5037f2e72f7442ba88c3d9a914e7ade1d4d4b4a79a3be88639d0d7ed0788cd73659cf88c0a924130ac355dd58a55536ae1d05202ce8a387

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 ProctorU
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/config/locales/daredevil.yml

@@ -0,0 +1,14 @@
+en:
+  daredevil:
+    errors:
+      not_found:
+        reason: Not found
+      forbidden:
+        reason: Unauthorized
+      unprocessable_entity:
+        reason: Unprocessable Entity
+      conflict:
+        reason: Invalid Attribute
+      parameter_missing:
+        reason: Missing Parameter
+        detail: Please supply the %{parameter} param

data/lib/daredevil.rb

@@ -0,0 +1,60 @@
+require 'active_support'
+require 'daredevil/engine'
+require 'daredevil/errors'
+require 'daredevil/responder'
+
+module Daredevil
+  def self.included(base)
+    base.rescue_from ActiveRecord::RecordNotFound, with: :record_not_found!
+    base.rescue_from ActionController::ParameterMissing, with: :parameter_missing!
+    redefine_authorization(base)
+  end
+
+  def self.redefine_authorization(base)
+    return unless base.instance_methods.include?(:authenticate_user_from_token!)
+
+    base.class_eval do
+      alias_method(:_authenticate_from_token!, :authenticate_user_from_token!)
+
+      define_method :authenticate_user_from_token! do
+        result = catch(:warden) { _authenticate_from_token! }
+
+        return unless result
+        respond_with_error(:unauthorized)
+      end
+    end
+  end
+
+  private
+
+  def respond_with_error(error_type, resource = nil)
+    case error_type
+    when :unauthorized
+      Responder.new(nil, controller: self, status: :forbidden).unauthorized
+    when :not_found
+      Responder.new(resource, controller: self, status: :not_found).not_found
+    when :parameter_missing
+      Responder.new(resource, controller: self, status: :unprocessable_entity).
+        parameter_missing
+    end
+  end
+
+  def respond_with(resource, options = {})
+    options = {
+      namespace: self.class.parent,
+      status: :ok,
+      params: params,
+      controller: self
+    }.merge(options)
+
+    Responder.new(resource, options).respond!
+  end
+
+  def record_not_found!(error)
+    respond_with_error(:not_found, error)
+  end
+
+  def parameter_missing!(error)
+    respond_with_error(:parameter_missing, error)
+  end
+end

data/lib/daredevil/configuration.rb

@@ -0,0 +1,22 @@
+require 'active_support/configurable'
+
+module Daredevil
+  def self.configure(&block)
+    yield @config ||= Daredevil::Configuration.new
+  end
+
+  # Global settings for Daredevil
+  def self.config
+    @config
+  end
+
+  class Configuration
+    include ActiveSupport::Configurable
+
+    config_accessor :responder_type
+  end
+
+  configure do |config|
+    config.responder_type = :jbuilder
+  end
+end

data/lib/daredevil/engine.rb

@@ -0,0 +1,6 @@
+module Daredevil
+  class Engine < ::Rails::Engine
+    isolate_namespace Daredevil
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+  end
+end

data/lib/daredevil/errors.rb

@@ -0,0 +1,41 @@
+require_relative 'utils/rack_helper'
+
+module Daredevil
+  module Errors
+    class UnknownHTTPStatus < StandardError
+      include Utils::RackHelper
+
+      attr_reader :status
+
+      def initialize(status)
+        @status = status
+        super(message)
+      end
+
+      def message
+        "Unknown HTTP status code '#{status}'.\n"\
+        "Available status codes and symbols are: #{statuses}"
+      end
+
+      private
+
+      def statuses
+        (status_symbols + status_codes).join(', ')
+      end
+    end
+
+    class UnknownAction < StandardError
+      attr_reader :action
+
+      def initialize(action)
+        @action = action
+        super(message)
+      end
+
+      def message
+        "Unknown controller action '#{action}'.\n"\
+        "Accepted actions are #{Daredevil::Responder::ACTIONS.join(', ')}"
+      end
+    end
+  end
+end

data/lib/daredevil/responder.rb

@@ -0,0 +1,126 @@
+require 'daredevil/configuration'
+require 'daredevil/responder/actions'
+require 'daredevil/responder/responses'
+require 'daredevil/responder/sanitizers'
+
+module Daredevil
+  class Responder
+    include Actions
+    include Responses
+    include Sanitizers
+
+    attr_accessor :errors
+    attr_accessor :status
+    attr_reader :resource
+    attr_reader :options
+    attr_reader :params
+    attr_reader :controller
+    attr_reader :namespace
+
+    def initialize(resource, options = {})
+      @resource = resource
+      @options = options
+      self.status = @options[:status]
+      @params = @options[:params]
+      @controller = @options[:controller]
+      @namespace = @options[:namespace]
+    end
+
+    def respond!
+      render_response
+    end
+
+    def render_response
+      return send("respond_to_#{action}_action") if action.in?(ACTIONS)
+      raise(Daredevil::Errors::UnknownAction, action)
+    end
+
+    def render_error
+      controller.render(error_render_options)
+    end
+
+    private
+
+    def status=(status)
+      @status = Sanitizers.status_symbol(status)
+    end
+
+    def status_code
+      Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
+    end
+
+    def action
+      params[:action]
+    end
+
+    def render_error
+      controller.render(error_render_options)
+    end
+
+    def error_render_options
+      render_options.merge(
+        json: {
+          status: status_code,
+          message: general_error_message
+        }.tap do |added_errors|
+          added_errors_obj(added_errors)
+          added_resource(added_errors)
+          added_message(added_errors)
+        end
+      )
+    end
+
+    def render_options
+      {
+        status: status,
+        content_type: 'application/vnd.api+json'
+      }
+    end
+
+    def error_response
+      return if errors
+      resource.errors.inject([]) do |new_errors, (attribute, message)|
+        new_errors << {
+          resource: resource_name.titleize,
+          field: attribute,
+          reason: message,
+          detail: resource.errors.full_message(attribute, message)
+        }
+      end
+    end
+
+    def resource_name
+      return resource.object.class.name if resource.respond_to?(:decorated?) &&
+        resource.decorated?
+      resource.class.name
+    end
+
+    def general_error_message
+      I18n.t('daredevil.errors.conflict.reason')
+    end
+
+    def added_errors_obj(error_obj)
+      error_obj[:errors] = error_response unless errors
+    end
+
+    def added_resource(error_obj)
+      return unless errors
+      error_obj[:resource] = resource_model_or_param
+      error_obj[:detail] = errors[:detail]
+    end
+
+    def resource_model_or_param
+      return resource.model if resource.try(:model).present?
+      resource_param
+    end
+
+    def resource_param
+      resource.param if
+        resource.class.name.eql?('ActionController::ParameterMissing')
+    end
+
+    def added_message(error_obj)
+      error_obj[:message] = errors[:reason] if errors
+    end
+  end
+end

data/lib/daredevil/responder/actions.rb

@@ -0,0 +1,92 @@
+module Daredevil
+  class Responder
+    module Actions
+      ACTIONS = %w(index show create update destroy).freeze
+
+      %w(index show).each do |method|
+        define_method("respond_to_#{method}_action") do
+          self.status ||= :ok
+          render_resource
+        end
+      end
+
+      def respond_to_create_action
+        if resource.persisted? && resource.valid?
+          self.status ||= :created
+          render_resource
+        else
+          self.status ||= :conflict
+          render_error
+        end
+      end
+
+      def respond_to_update_action
+        if resource.valid?
+          self.status ||= :ok
+          render_resource
+        else
+          self.status ||= :conflict
+          render_error
+        end
+      end
+
+      def respond_to_destroy_action
+        self.status ||= :no_content
+        controller.head(status, render_options)
+      end
+
+      def render_resource
+        controller.render(resource_render_options)
+      end
+
+      def resource_render_options
+        self.send(:"#{Daredevil.config.responder_type.to_s}_resource_render_options")
+      end
+
+      def jbuilder_resource_render_options
+        render_options
+      end
+
+      def serializers_resource_render_options
+        serializer_key = relation? ? :each_serializer : :serializer
+
+        render_options.merge(
+          json: resource,
+          serializer_key => serializer_class
+        )
+      end
+
+      def serializer_class
+        options[:serializer] ||=
+          [
+            namespace,
+            "#{resource_class}Serializer"
+          ].compact.join('::').safe_constantize
+        options[:serializer] ||= "#{resource_class}Serializer".safe_constantize
+      end
+
+      def resource_class
+        return resource.model if relation?
+        resource.class
+      end
+
+      def relation?
+        resource.is_a?(ActiveRecord::Relation)
+      end
+
+      def responder_type
+        supported_responders.each do |type, klass|
+          return type.to_sym if defined?(klass.safe_constantize).eql?('constant')
+        end
+      end
+
+      def supported_responders
+        {
+          jbuilder: 'Jbuilder',
+          serializers: 'ActiveModel::Serializers',
+          rabl: 'RABL'
+        }
+      end
+    end
+  end
+end

data/lib/daredevil/responder/responses.rb

@@ -0,0 +1,30 @@
+module Daredevil
+  class Responder
+    module Responses
+      def not_found
+        self.errors = {
+          reason: I18n.t('daredevil.errors.not_found.reason')
+        }
+        render_error
+      end
+
+      def parameter_missing
+        self.errors = {
+          reason: I18n.t('daredevil.errors.parameter_missing.reason'),
+          detail: I18n.t(
+            'daredevil.errors.parameter_missing.detail',
+            parameter: resource.param
+          )
+        }
+        render_error
+      end
+
+      def unauthorized
+        self.errors = {
+          reason: I18n.t('daredevil.errors.forbidden.reason')
+        }
+        render_error
+      end
+    end
+  end
+end