responders 2.0.0 → 3.1.1

data/lib/action_controller/responder.rb

@@ -1,6 +1,8 @@
-require 'active_support/json'
+# frozen_string_literal: true
 
-module ActionController #:nodoc:
+require "active_support/json"
+
+module ActionController # :nodoc:
   # Responsible for exposing a resource to different mime requests,
   # usually depending on the HTTP verb. The responder is triggered when
   # <code>respond_with</code> is called. The simplest case to study is a GET request:
@@ -47,7 +49,7 @@ module ActionController #:nodoc:
   #         format.html { redirect_to(@user) }
   #         format.xml { render xml: @user, status: :created, location: @user }
   #       else
-  #         format.html { render action: "new" }
+  #         format.html { render action: "new", status: :unprocessable_entity }
   #         format.xml { render xml: @user.errors, status: :unprocessable_entity }
   #       end
   #     end
@@ -111,22 +113,25 @@ module ActionController #:nodoc:
   #       if @task.save
   #         flash[:notice] = 'Task was successfully created.'
   #       else
-  #         format.html { render "some_special_template" }
+  #         format.html { render "some_special_template", status: :unprocessable_entity }
   #       end
   #     end
   #   end
   #
   # Using <code>respond_with</code> with a block follows the same syntax as <code>respond_to</code>.
   class Responder
+    class_attribute :error_status, default: :ok, instance_writer: false, instance_predicate: false
+    class_attribute :redirect_status, default: :found, instance_writer: false, instance_predicate: false
+
     attr_reader :controller, :request, :format, :resource, :resources, :options
 
     DEFAULT_ACTIONS_FOR_VERBS = {
-      :post => :new,
-      :patch => :edit,
-      :put => :edit
+      post: :new,
+      patch: :edit,
+      put: :edit
     }
 
-    def initialize(controller, resources, options={})
+    def initialize(controller, resources, options = {})
       @controller = controller
       @request = @controller.request
       @format = @controller.formats.first
@@ -142,8 +147,8 @@ module ActionController #:nodoc:
       end
     end
 
-    delegate :head, :render, :redirect_to, :to => :controller
-    delegate :get?, :post?, :patch?, :put?, :delete?, :to => :request
+    delegate :head, :render, :redirect_to, to: :controller
+    delegate :get?, :post?, :patch?, :put?, :delete?, to: :request
 
     # Undefine :to_json and :to_yaml since it's defined on Object
     undef_method(:to_json) if method_defined?(:to_json)
@@ -182,13 +187,15 @@ module ActionController #:nodoc:
     # responds to :to_format and display it.
     #
     def to_format
-      if get? || !has_errors? || response_overridden?
+      if !get? && has_errors? && !response_overridden?
+        display_errors
+      elsif has_view_rendering? || response_overridden?
         default_render
       else
-        display_errors
+        api_behavior
       end
-    rescue ActionView::MissingTemplate => e
-      api_behavior(e)
+    rescue ActionView::MissingTemplate
+      api_behavior
     end
 
   protected
@@ -198,32 +205,25 @@ module ActionController #:nodoc:
       if get?
         raise error
       elsif has_errors? && default_action
-        render :action => default_action
+        render error_rendering_options
       else
-        redirect_to navigation_location
+        redirect_to navigation_location, status: redirect_status
       end
     end
 
     # This is the common behavior for formats associated with APIs, such as :xml and :json.
-    def api_behavior(error)
-      raise error unless resourceful?
+    def api_behavior
       raise MissingRenderer.new(format) unless has_renderer?
 
       if get?
         display resource
       elsif post?
-        display resource, :status => :created, :location => api_location
+        display resource, status: :created, location: api_location
       else
         head :no_content
       end
     end
 
-    # Checks whether the resource responds to the current format or not.
-    #
-    def resourceful?
-      resource.respond_to?("to_#{format}")
-    end
-
     # Returns the resource location by retrieving it from the options or
     # returning the resources array.
     #
@@ -239,8 +239,10 @@ module ActionController #:nodoc:
     def default_render
       if @default_response
         @default_response.call(options)
+      elsif !get? && has_errors?
+        controller.render({ status: error_status }.merge!(options))
       else
-        controller.default_render(options)
+        controller.render(options)
       end
     end
 
@@ -261,11 +263,13 @@ module ActionController #:nodoc:
     #
     #   render xml: @user, status: :created
     #
-    def display(resource, given_options={})
+    def display(resource, given_options = {})
       controller.render given_options.merge!(options).merge!(format => resource)
     end
 
     def display_errors
+      # TODO: use `error_status` once we switch the default to be `unprocessable_entity`,
+      # otherwise we'd be changing this behavior here now.
       controller.render format => resource_errors, :status => :unprocessable_entity
     end
 
@@ -280,6 +284,10 @@ module ActionController #:nodoc:
       Renderers::RENDERERS.include?(format)
     end
 
+    def has_view_rendering?
+      controller.class.include? ActionView::Rendering
+    end
+
     # By default, render the <code>:edit</code> action for HTML requests with errors, unless
     # the verb was POST.
     #
@@ -292,11 +300,19 @@ module ActionController #:nodoc:
     end
 
     def json_resource_errors
-      {:errors => resource.errors}
+      { errors: resource.errors }
     end
 
     def response_overridden?
       @default_response.present?
     end
+
+    def error_rendering_options
+      if options[:render]
+        options[:render]
+      else
+        { action: default_action, status: error_status }
+      end
+    end
   end
 end

data/lib/generators/rails/responders_controller_generator.rb

@@ -1,4 +1,6 @@
-require 'rails/generators/rails/scaffold_controller/scaffold_controller_generator'
+# frozen_string_literal: true
+
+require "rails/generators/rails/scaffold_controller/scaffold_controller_generator"
 
 module Rails
   module Generators
@@ -15,32 +17,8 @@ module Rails
         end
       end
 
-      def orm_instance_update(params)
-        if orm_instance.respond_to?(:update)
-          orm_instance.update params
-        else
-          orm_instance.update_attributes params
-        end
-      end
-
-      def controller_before_filter
-        if ActionController::Base.respond_to?(:before_action)
-          "before_action"
-        else
-          "before_filter"
-        end
-      end
-
       def attributes_params
-        if strong_parameters_defined?
-          "#{file_name}_params"
-        else
-          "params[:#{file_name}]"
-        end
-      end
-
-      def strong_parameters_defined?
-        defined?(ActionController::StrongParameters)
+        "#{singular_table_name}_params"
       end
     end
   end

data/lib/generators/rails/templates/api_controller.rb.tt

@@ -0,0 +1,51 @@
+<% if namespaced? -%>
+require_dependency "<%= namespaced_file_path %>/application_controller"
+
+<% end -%>
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  before_action :set_<%= singular_table_name %>, only: [:show, :update, :destroy]
+
+  respond_to :json
+
+<% unless options[:singleton] -%>
+  def index
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
+    respond_with(@<%= plural_table_name %>)
+  end
+<% end -%>
+
+  def show
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def create
+    @<%= singular_table_name %> = <%= orm_class.build(class_name, attributes_params) %>
+    <%= "flash[:notice] = '#{class_name} was successfully created.' if " if flash? %>@<%= orm_instance.save %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def update
+    <%= "flash[:notice] = '#{class_name} was successfully updated.' if " if flash? %>@<%= orm_instance.update(attributes_params) %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def destroy
+    @<%= orm_instance.destroy %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  private
+    def set_<%= singular_table_name %>
+      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    end
+
+    def <%= "#{singular_table_name}_params" %>
+      <%- if attributes_names.empty? -%>
+      params[:<%= singular_table_name %>]
+      <%- else -%>
+      params.require(:<%= singular_table_name %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
+      <%- end -%>
+    end
+end
+<% end -%>

data/lib/generators/rails/templates/controller.rb.tt

@@ -0,0 +1,59 @@
+<% if namespaced? -%>
+require_dependency "<%= namespaced_file_path %>/application_controller"
+
+<% end -%>
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  before_action :set_<%= singular_table_name %>, only: [:show, :edit, :update, :destroy]
+
+  respond_to :html
+
+<% unless options[:singleton] -%>
+  def index
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
+    respond_with(@<%= plural_table_name %>)
+  end
+<% end -%>
+
+  def show
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def new
+    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def edit
+  end
+
+  def create
+    @<%= singular_table_name %> = <%= orm_class.build(class_name, attributes_params) %>
+    <%= "flash[:notice] = '#{class_name} was successfully created.' if " if flash? %>@<%= orm_instance.save %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def update
+    <%= "flash[:notice] = '#{class_name} was successfully updated.' if " if flash? %>@<%= orm_instance.update(attributes_params) %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  def destroy
+    @<%= orm_instance.destroy %>
+    respond_with(@<%= singular_table_name %>)
+  end
+
+  private
+    def set_<%= singular_table_name %>
+      @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    end
+
+    def <%= "#{singular_table_name}_params" %>
+      <%- if attributes_names.empty? -%>
+      params[:<%= singular_table_name %>]
+      <%- else -%>
+      params.require(:<%= singular_table_name %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
+      <%- end -%>
+    end
+end
+<% end -%>

data/lib/generators/responders/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Responders
   module Generators
     class InstallGenerator < Rails::Generators::Base
@@ -6,15 +8,27 @@ module Responders
       desc "Creates an initializer with default responder configuration and copy locale file"
 
       def create_responder_file
-        create_file "lib/application_responder.rb", <<-RUBY
-class ApplicationResponder < ActionController::Responder
-  include Responders::FlashResponder
-  include Responders::HttpCacheResponder
-
-  # Redirects resources to the collection path (index action) instead
-  # of the resource path (show action) for POST/PUT/DELETE requests.
-  # include Responders::CollectionResponder
-end
+        create_file "lib/application_responder.rb", <<~RUBY
+          class ApplicationResponder < ActionController::Responder
+            include Responders::FlashResponder
+            include Responders::HttpCacheResponder
+
+            # Redirects resources to the collection path (index action) instead
+            # of the resource path (show action) for POST/PUT/DELETE requests.
+            # include Responders::CollectionResponder
+
+            # Configure default status codes for responding to errors and redirects.
+            self.error_status = :unprocessable_entity
+            self.redirect_status = :see_other
+          end
+        RUBY
+      end
+
+      def update_application
+        inject_into_class "config/application.rb", "Application", <<-RUBY
+    # Use the responders controller from the responders gem
+    config.app_generators.scaffold_controller :responders_controller
+
         RUBY
       end
 

data/lib/responders/collection_responder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Responders
   # This responder modifies your current responder to redirect
   # to the collection page on POST/PUT/DELETE.
@@ -18,6 +20,7 @@ module Responders
     #
     def navigation_location
       return options[:location] if options[:location]
+
       klass = resources.last.class
 
       if klass.respond_to?(:model_name)

data/lib/responders/controller_method.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Responders
   module ControllerMethod
     # Adds the given responders to the current controller's responder, allowing you to cherry-pick
@@ -18,7 +20,8 @@ module Responders
     #
     def responders(*responders)
       self.responder = responders.inject(Class.new(responder)) do |klass, responder|
-        responder = case responder
+        responder = \
+          case responder
           when Module
             responder
           when String, Symbol
@@ -34,4 +37,6 @@ module Responders
   end
 end
 
-ActionController::Base.extend Responders::ControllerMethod
+ActiveSupport.on_load(:action_controller_base) do
+  ActionController::Base.extend Responders::ControllerMethod
+end

data/lib/responders/flash_responder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Responders
   # Responder to automatically set flash messages based on I18n API. It checks for
   # message based on the current action, but also allows defaults to be set, using
@@ -33,9 +35,9 @@ module Responders
   #         notice: "Hooray! You just tuned your %{car_brand}!"
   #
   # Since :car_name is not available for interpolation by default, you have
-  # to overwrite interpolation_options in your controller.
+  # to overwrite `flash_interpolation_options` in your controller.
   #
-  #   def interpolation_options
+  #   def flash_interpolation_options
   #     { :car_brand => @car.brand }
   #   end
   #
@@ -70,7 +72,7 @@ module Responders
   #
   #     respond_with(@user, :notice => "Hooray! Welcome!", :alert => "Woot! You failed.")
   #
-  # * :flash_now - Sets the flash message using flash.now. Accepts true, :on_failure or :on_sucess.
+  # * :flash_now - Sets the flash message using flash.now. Accepts true, :on_failure or :on_success.
   #
   # == Configure status keys
   #
@@ -84,17 +86,13 @@ module Responders
   #
   module FlashResponder
     class << self
-      attr_accessor :flash_keys, :namespace_lookup, :helper
+      attr_accessor :flash_keys, :namespace_lookup
     end
 
     self.flash_keys = [ :notice, :alert ]
     self.namespace_lookup = false
-    self.helper = Object.new.extend(
-      ActionView::Helpers::TranslationHelper,
-      ActionView::Helpers::TagHelper
-    )
 
-    def initialize(controller, resources, options={})
+    def initialize(controller, resources, options = {})
       super
       @flash     = options.delete(:flash)
       @notice    = options.delete(:notice)
@@ -126,7 +124,7 @@ module Responders
       return if controller.flash[status].present?
 
       options = mount_i18n_options(status)
-      message = Responders::FlashResponder.helper.t options[:default].shift, options
+      message = controller.helpers.t options[:default].shift, **options
       set_flash(status, message)
     end
 
@@ -142,39 +140,46 @@ module Responders
         (default_action && (has_errors? ? @flash_now == :on_failure : @flash_now == :on_success))
     end
 
-    def set_flash_message? #:nodoc:
+    def set_flash_message? # :nodoc:
       !get? && @flash != false
     end
 
-    def mount_i18n_options(status) #:nodoc:
-      resource_name = if resource.class.respond_to?(:model_name)
-        resource.class.model_name.human
-      else
-        resource.class.name.underscore.humanize
-      end
-
+    def mount_i18n_options(status) # :nodoc:
       options = {
-        :default => flash_defaults_by_namespace(status),
-        :resource_name => resource_name,
-        :downcase_resource_name => resource_name.downcase
+        default: flash_defaults_by_namespace(status),
+        resource_name: resource_name,
+        downcase_resource_name: resource_name.downcase
       }
 
-      if controller.respond_to?(:interpolation_options, true)
-        options.merge!(controller.send(:interpolation_options))
+      controller_options = controller_interpolation_options
+      if controller_options
+        options.merge!(controller_options)
       end
 
       options
     end
 
-    def flash_defaults_by_namespace(status) #:nodoc:
+    def controller_interpolation_options
+      controller.send(:flash_interpolation_options) if controller.respond_to?(:flash_interpolation_options, true)
+    end
+
+    def resource_name
+      if resource.class.respond_to?(:model_name)
+        resource.class.model_name.human
+      else
+        resource.class.name.underscore.humanize
+      end
+    end
+
+    def flash_defaults_by_namespace(status) # :nodoc:
       defaults = []
-      slices   = controller.controller_path.split('/')
+      slices   = controller.controller_path.split("/")
       lookup   = Responders::FlashResponder.namespace_lookup
 
       begin
-        controller_scope = :"flash.#{slices.fill(controller.controller_name, -1).join('.')}.#{controller.action_name}.#{status}"
+        controller_scope = :"flash.#{slices.fill(controller.controller_name, -1).join(".")}.#{controller.action_name}.#{status}"
 
-        actions_scope = lookup ? slices.fill('actions', -1).join('.') : :actions
+        actions_scope = lookup ? slices.fill("actions", -1).join(".") : :actions
         actions_scope = :"flash.#{actions_scope}.#{controller.action_name}.#{status}"
 
         defaults << :"#{controller_scope}_html"

data/lib/responders/http_cache_responder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Responders
   # Set HTTP Last-Modified headers based on the given resource. It's used only
   # on API behavior (to_format) and is useful for a client to check in the server
@@ -9,7 +11,7 @@ module Responders
   # the digest of the body.
   #
   module HttpCacheResponder
-    def initialize(controller, resources, options={})
+    def initialize(controller, resources, options = {})
       super
       @http_cache = options.delete(:http_cache)
     end
@@ -34,11 +36,11 @@ module Responders
 
     def do_http_cache?
       get? && @http_cache != false && ActionController::Base.perform_caching &&
-        persisted? && resourceful? && resource.respond_to?(:updated_at)
+        persisted? && resource.respond_to?(:updated_at)
     end
 
     def persisted?
       resource.respond_to?(:persisted?) ? resource.persisted? : true
     end
   end
-end
+end

data/lib/responders/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Responders
-  VERSION = "2.0.0".freeze
+  VERSION = "3.1.1"
 end

data/lib/responders.rb

@@ -1,36 +1,36 @@
-require 'action_controller/base'
+# frozen_string_literal: true
+
+require "action_controller"
+require "rails/railtie"
 
 module ActionController
-  autoload :Responder, 'action_controller/responder'
-  autoload :RespondWith, 'action_controller/respond_with'
+  autoload :Responder, "action_controller/responder"
+  autoload :RespondWith, "action_controller/respond_with"
 end
 
 module Responders
-  autoload :FlashResponder,      'responders/flash_responder'
-  autoload :HttpCacheResponder,  'responders/http_cache_responder'
-  autoload :CollectionResponder, 'responders/collection_responder'
-  autoload :LocationResponder,   'responders/location_responder'
+  autoload :FlashResponder,      "responders/flash_responder"
+  autoload :HttpCacheResponder,  "responders/http_cache_responder"
+  autoload :CollectionResponder, "responders/collection_responder"
 
-  require 'responders/controller_method'
+  require "responders/controller_method"
 
   class Railtie < ::Rails::Railtie
     config.responders = ActiveSupport::OrderedOptions.new
     config.responders.flash_keys = [:notice, :alert]
     config.responders.namespace_lookup = false
-
-    if config.respond_to?(:app_generators)
-      config.app_generators.scaffold_controller = :responders_controller
-    else
-      config.generators.scaffold_controller = :responders_controller
-    end
+    config.responders.error_status = :ok
+    config.responders.redirect_status = :found
 
     # Add load paths straight to I18n, so engines and application can overwrite it.
-    require 'active_support/i18n'
-    I18n.load_path << File.expand_path('../responders/locales/en.yml', __FILE__)
+    require "active_support/i18n"
+    I18n.load_path << File.expand_path("../responders/locales/en.yml", __FILE__)
 
     initializer "responders.flash_responder" do |app|
       Responders::FlashResponder.flash_keys = app.config.responders.flash_keys
       Responders::FlashResponder.namespace_lookup = app.config.responders.namespace_lookup
+      ActionController::Responder.error_status = app.config.responders.error_status
+      ActionController::Responder.redirect_status = app.config.responders.redirect_status
     end
   end
 end