active_response 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84258f703a2b8a0d27572d8c88b7680900a8839dc75d142cba9dd1a10e996069
+  data.tar.gz: d37a387ec872cdc12d4902fc2d895aea56848a41072820f54e77c66eb045f249
+SHA512:
+  metadata.gz: 58f65299722bf90c02023e7774a3830ca59ec3452b9b837ad24dc0a43f20d591bdbea893e3aac43ed8416bc8065332ea388dd064c0ddda536eab347c80083d36
+  data.tar.gz: 648800aa8e5b1079a6e0822a24ef7c6a5a84adabe2e6430a82d0e6bd160374fcb4c8626861f8a14a68b435d00777d2a528b6340ee95afe1b535fcebd709d2f0f

data/lib/active_response.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_response/controller'
+require 'active_response/responders/base'
+require 'active_response/railtie' if defined?(Rails::Railtie)
+
+module ActiveResponse
+  cattr_accessor :responders
+  self.responders = {}
+
+  def self.responder_for(format)
+    responders[format] ||=
+      registered_responders
+        .sort_by { |d| -d.ancestors.count }
+        .detect { |responder| responder.formats.include?(format) }
+  end
+
+  def self.registered_responders
+    return @registered_responders if @registered_responders.present?
+    Dir[Rails.root.join('app', 'responders', '*.rb')].each { |file| require_dependency file }
+    @registered_responders = ActiveResponse::Responders::Base.descendants
+  end
+end

data/lib/active_response/controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_response/controller/core'
+require 'active_response/controller/crud_defaults'
+require 'active_response/controller/default_responses'
+require 'active_response/controller/resource_helper'
+
+module ActiveResponse
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      include Controller::Core
+      include Controller::CrudDefaults
+      include Controller::DefaultResponses
+      include Controller::ResourceHelper
+    end
+  end
+end

data/lib/active_response/controller/core.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :active_responder
+      end
+
+      module ClassMethods
+        def active_response(*actions)
+          active_response(:create, :destroy, :edit, :index, :new, :show, :update) if actions.include?(:crud)
+          actions.without(:crud).each { |action| define_active_response_action(action) }
+        end
+
+        private
+
+        def define_active_response_action(action)
+          define_method action do
+            active_response_block do
+              execute_action
+            end
+          end
+        end
+      end
+
+      private
+
+      def active_response_block
+        respond_to do |format|
+          ActiveResponse::Responders::Base.available_formats.each do |symbol|
+            format.send(symbol) do
+              find_active_responder(format)
+              yield
+            end
+          end
+        end
+      end
+
+      def active_response_type
+        @active_responder.type
+      end
+
+      def active_response_options
+        base = "#{action_name}_#{@active_response_resolution}_options"
+        if respond_to?("#{base}_#{active_response_type}", true)
+          send("#{base}_#{active_response_type}")
+        else
+          send(base)
+        end
+      end
+
+      def active_response_handle_failure(_resource = nil)
+        respond_with_failure!
+        if respond_to?("#{action_name}_failure_#{active_response_type}", true)
+          return send("#{action_name}_failure_#{active_response_type}")
+        end
+        send("#{action_name}_failure")
+      end
+
+      def active_response_handle_success(_resource = nil)
+        respond_with_success!
+        if respond_to?("#{action_name}_success_#{active_response_type}", true)
+          return send("#{action_name}_success_#{active_response_type}")
+        end
+        send("#{action_name}_success")
+      end
+
+      def active_response_success?
+        @active_response_resolution == :success
+      end
+
+      def execute_action
+        return active_response_handle_success unless respond_to?("#{action_name}_execute", true)
+        send("#{action_name}_execute") ? active_response_handle_success : active_response_handle_failure
+      end
+
+      def find_active_responder(format)
+        format_symbol = format.format.symbol
+        @active_responder = ActiveResponse.responder_for(format_symbol).new(self, format_symbol)
+      end
+
+      def respond_with_failure!
+        @active_response_resolution = :failure
+      end
+
+      def respond_with_success!
+        @active_response_resolution = :success
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_response/controller/crud_defaults/create'
+require 'active_response/controller/crud_defaults/destroy'
+require 'active_response/controller/crud_defaults/edit'
+require 'active_response/controller/crud_defaults/index'
+require 'active_response/controller/crud_defaults/new'
+require 'active_response/controller/crud_defaults/show'
+require 'active_response/controller/crud_defaults/update'
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      include Create
+      include Destroy
+      include Edit
+      include Index
+      include New
+      include Show
+      include Update
+
+      def default_form_options(action)
+        {
+          locals: form_view_locals_for(action),
+          resource: current_resource,
+          view: form_view_for(action)
+        }
+      end
+
+      def form_view_for(action)
+        return send("#{action}_view") if respond_to?("#{action}_view", true)
+        default_form_view(action)
+      end
+
+      def default_form_view(action)
+        action
+      end
+
+      def form_view_locals_for(action)
+        return send("#{action}_view_locals") if respond_to?("#{action}_view_locals", true)
+        default_form_view_locals(action)
+      end
+
+      def default_form_view_locals(_action)
+        {}
+      end
+
+      def active_response_success_message
+        return send("#{action_name}_success_message") if respond_to?("#{action_name}_success_message", true)
+        I18n.t(success_message_translation_key, success_message_translation_opts)
+      end
+
+      def success_message_translation_key
+        "active_response.actions.#{action_name}.success"
+      end
+
+      def success_message_translation_opts
+        {type: current_resource.class.to_s.humanize}
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/create.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module Create
+        private
+
+        def create_execute
+          current_resource.assign_attributes(permit_params)
+          current_resource.save
+        end
+
+        def create_failure
+          respond_with_invalid_resource(active_response_options)
+        end
+
+        def create_failure_options
+          {
+            resource: current_resource
+          }
+        end
+
+        def create_includes
+          {}
+        end
+
+        def create_success
+          respond_with_new_resource(active_response_options)
+        end
+
+        def create_success_options
+          {
+            include: create_includes,
+            location: create_success_location,
+            notice: active_response_success_message,
+            resource: current_resource
+          }
+        end
+
+        def create_success_location
+          url_for(current_resource)
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/destroy.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module Destroy
+        private
+
+        def destroy_execute
+          current_resource.destroy
+        end
+
+        def destroy_failure
+          respond_with_invalid_resource(active_response_options)
+        end
+
+        def destroy_failure_options
+          {
+            resource: current_resource
+          }
+        end
+
+        def destroy_success
+          respond_with_destroyed(active_response_options)
+        end
+
+        def destroy_success_options
+          {
+            location: destroy_success_location,
+            notice: active_response_success_message,
+            resource: current_resource
+          }
+        end
+
+        def destroy_success_location
+          url_for("/#{controller_name}")
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/edit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module Edit
+        private
+
+        def edit_success
+          respond_with_form(active_response_options)
+        end
+
+        def edit_success_options
+          default_form_options(:edit)
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/index.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module Index
+        private
+
+        def index_association
+          var = :"@#{controller_name}"
+          return instance_variable_get(var) if instance_variable_defined?(var)
+          instance_variable_set(:"@#{controller_name}", controller_class.all)
+        end
+
+        def index_success
+          respond_with_collection(active_response_options)
+        end
+
+        def index_success_options
+          {
+            collection: index_association,
+            include: index_includes,
+            locals: index_locals
+          }
+        end
+
+        def index_locals
+          {}
+        end
+
+        def index_includes
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/new.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module New
+        private
+
+        def new_success
+          respond_with_form(active_response_options)
+        end
+
+        def new_success_options
+          default_form_options(:new)
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/show.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module Show
+        private
+
+        def show_success
+          respond_with_resource(active_response_options)
+        end
+
+        def show_success_options
+          {
+            include: show_includes,
+            locals: show_view_locals,
+            resource: current_resource
+          }
+        end
+
+        def show_includes
+          {}
+        end
+
+        def show_view_locals
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/crud_defaults/update.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module CrudDefaults
+      module Update
+        private
+
+        def update_execute
+          current_resource.update permit_params
+        end
+
+        def update_failure
+          respond_with_invalid_resource(active_response_options)
+        end
+
+        def update_failure_options
+          {
+            resource: current_resource
+          }
+        end
+
+        def update_success
+          respond_with_updated_resource(active_response_options)
+        end
+
+        def update_success_options
+          {
+            location: update_success_location,
+            notice: active_response_success_message,
+            resource: current_resource
+          }
+        end
+
+        def update_success_location
+          url_for(current_resource)
+        end
+      end
+    end
+  end
+end

data/lib/active_response/controller/default_responses.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module DefaultResponses
+      def respond_with_collection(opts)
+        active_responder.collection(opts)
+      end
+
+      def respond_with_destroyed(opts)
+        active_responder.destroyed(opts)
+      end
+
+      def respond_with_form(opts)
+        active_responder.form(opts)
+      end
+
+      def respond_with_invalid_resource(opts)
+        active_responder.invalid_resource(opts)
+      end
+
+      def respond_with_new_resource(opts)
+        active_responder.new_resource(opts)
+      end
+
+      def respond_with_redirect(opts)
+        active_responder.redirect(opts)
+      end
+
+      def respond_with_resource(opts)
+        active_responder.resource(opts)
+      end
+
+      def respond_with_updated_resource(opts)
+        active_responder.updated_resource(opts)
+      end
+    end
+  end
+end

data/lib/active_response/controller/resource_helper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Controller
+    module ResourceHelper
+      private
+
+      def current_resource
+        var = :"@#{controller_name.singularize}"
+        return instance_variable_get(var) if instance_variable_defined?(var)
+        instance_variable_set(var, resolve_current_resource)
+      end
+
+      def controller_class
+        @controller_class ||= controller_name.classify.safe_constantize
+      end
+
+      def requested_resource
+        @requested_resource ||= controller_class.find_by(id: resource_id)
+      end
+
+      # Instantiates a new record of the current controller type
+      # @return [ActiveRecord::Base] A fresh model instance
+      def new_resource
+        controller_class.new
+      end
+
+      def resolve_current_resource
+        case action_name
+        when 'create', 'new'
+          new_resource
+        when 'index'
+          nil
+        else
+          requested_resource
+        end
+      end
+
+      def resource_id
+        params[:id]
+      end
+    end
+  end
+end

data/lib/active_response/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  class Railtie < ::Rails::Railtie
+    initializer 'active_response.insert_middleware' do |_app|
+      ActiveSupport::Reloader.to_prepare do
+        ActiveResponse.responders = {}
+        ActiveResponse.instance_variable_set(:@registered_responders, nil)
+      end
+    end
+  end
+end

data/lib/active_response/responders/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  module Responders
+    class Base
+      attr_accessor :controller
+      attr_accessor :format
+
+      class_attribute :formats
+      self.formats = []
+
+      def initialize(controller, format)
+        self.controller = controller
+        self.format = format
+      end
+
+      def type
+        self.class.type
+      end
+
+      class << self
+        def respond_to(*formats)
+          self.formats = formats
+        end
+
+        def type
+          @type ||= name.gsub('Responder', '').underscore.to_sym
+        end
+
+        def available_formats
+          return @available_formats if @available_formats.present?
+          @available_formats =
+            ActiveResponse.registered_responders.map(&:formats).flatten.sort { |format| format == :html ? 0 : 1 }
+        end
+      end
+    end
+  end
+end

data/lib/active_response/responders/html.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_response/responders/base'
+
+module ActiveResponse
+  module Responders
+    class HTML < Base
+      def collection(**opts)
+        controller.render opts
+      end
+
+      def destroyed(**opts)
+        opts[:status] = 303
+        controller.respond_with_redirect(opts)
+      end
+
+      def form(**opts)
+        controller.render opts[:view], opts.except(:view)
+      end
+
+      def invalid_resource(**opts)
+        if controller.action_name == 'destroy'
+          controller.respond_with_redirect(location: opts[:resource])
+        else
+          controller.respond_with_form(controller.default_form_options(form_for_invalid(opts)))
+        end
+      end
+
+      def new_resource(**opts)
+        controller.respond_with_redirect(opts)
+      end
+
+      def redirect(**opts)
+        controller.send(:redirect_to, opts[:location], opts.except(:location))
+      end
+
+      def resource(**opts)
+        controller.render :show, opts
+      end
+
+      def updated_resource(**opts)
+        controller.respond_with_redirect(opts)
+      end
+
+      private
+
+      def form_for_invalid(opts)
+        return opts[:form] if opts[:form].present?
+        return 'new' if controller.action_name == 'create'
+        'edit'
+      end
+    end
+  end
+end

data/lib/active_response/responders/js.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'active_response/responders/html'
+
+module ActiveResponse
+  module Responders
+    class JS < HTML
+      def redirect(**opts)
+        controller.render js: "window.location = '#{opts[:location]}'"
+      end
+    end
+  end
+end

data/lib/active_response/responders/json.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_response/responders/html'
+
+module ActiveResponse
+  module Responders
+    class JSON < HTML
+      def collection(**opts)
+        opts[:json] = opts.delete(:collection)
+        controller.render opts
+      end
+
+      def destroyed(_opts)
+        controller.head :no_content
+      end
+
+      def form(**_opts)
+        raise NotImplementedError, 'Forms are not available in JSON'
+      end
+
+      def invalid_resource(**opts)
+        opts[:json] = opts.delete(:resource).errors
+        opts[:status] ||= :unprocessable_entity
+        controller.render opts
+      end
+
+      def new_resource(**opts)
+        opts[:status] = :created
+        controller.respond_with_resource(opts)
+      end
+
+      def resource(**opts)
+        opts[:json] = opts.delete(:resource)
+        controller.render opts
+      end
+
+      def updated_resource(**opts)
+        controller.respond_with_resource(opts)
+      end
+    end
+  end
+end

data/lib/active_response/responders/json_api.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_response/responders/json'
+
+module ActiveResponse
+  module Responders
+    class JsonApi < JSON
+      def collection(**opts)
+        opts[:adapter] = :json_api
+        super
+      end
+
+      def invalid_resource(**opts)
+        controller.render json: {errors: formatted_errors(opts[:resource].errors)}, status: :unprocessable_entity
+      end
+
+      def resource(**opts)
+        opts[:adapter] = :json_api
+        super
+      end
+
+      private
+
+      def error_code(errors, key, index)
+        "value_#{errors.details[key][index][:error]}".upcase
+      end
+
+      def formatted_error(errors, key)
+        errors.full_messages_for(key).map.with_index { |m, i| formatted_error_hash(key, error_code(errors, key, i), m) }
+      end
+
+      def formatted_error_hash(key, code, message)
+        {
+          code: code,
+          message: message,
+          status: Rack::Utils::HTTP_STATUS_CODES[422],
+          source: {parameter: key}
+        }
+      end
+
+      def formatted_errors(errors)
+        case errors
+        when Array
+          errors.map { |error| formatted_errors(error) }.flatten
+        when ActiveModel::Errors
+          errors.keys.reduce([]) do |array, key|
+            array.concat(formatted_error(errors, key))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_response/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveResponse
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: active_response
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Arthur Dingemans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.7.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.7.2
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.58.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.58.2
+description: DRY your controllers and make your API more predictable by defining responders
+  for different formats. E.g. Posting an invalid resource in HTML should render a
+  form with errors, while in JSON you expect serialized errors.
+email:
+- arthur@argu.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_response.rb
+- lib/active_response/controller.rb
+- lib/active_response/controller/core.rb
+- lib/active_response/controller/crud_defaults.rb
+- lib/active_response/controller/crud_defaults/create.rb
+- lib/active_response/controller/crud_defaults/destroy.rb
+- lib/active_response/controller/crud_defaults/edit.rb
+- lib/active_response/controller/crud_defaults/index.rb
+- lib/active_response/controller/crud_defaults/new.rb
+- lib/active_response/controller/crud_defaults/show.rb
+- lib/active_response/controller/crud_defaults/update.rb
+- lib/active_response/controller/default_responses.rb
+- lib/active_response/controller/resource_helper.rb
+- lib/active_response/railtie.rb
+- lib/active_response/responders/base.rb
+- lib/active_response/responders/html.rb
+- lib/active_response/responders/js.rb
+- lib/active_response/responders/json.rb
+- lib/active_response/responders/json_api.rb
+- lib/active_response/version.rb
+homepage: https://github.com/ontola/active_response
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Define Responders to handle different kind of responses in different formats
+test_files: []