jets-responders 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d3a01e41bd6fe4be4e5302b20b73fe91585aab6e92d72a285947d2ce561b94f
+  data.tar.gz: 834e78db1644e8c86dc959e3966091b9e0bcf3f128812de98bb7d4b0d87ad1dd
+SHA512:
+  metadata.gz: 4be0dd3874fddd4bfe1ac5ec9e486d41c621e6da244e71b1aef34c29aed8911f9d7d6d97a0f64f99aad7737d5c78a8cb8693ae65412524753af05a2f68a4d524
+  data.tar.gz: ffb85dc800ebd0ab1c86238ec46e5312a01f4f70271eb12104e9699a358b66c4660032fed771be0f5d16d6e3b3348cd6101fecc63cb7589344788d9bffccc845

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+/.bundle
+/.config
+/.yardoc
+/_yardoc
+/coverage
+/doc/
+/Gemfile.lock
+/InstalledFiles
+/lib/bundler/man
+/pkg
+/rdoc
+/spec/reports
+/test/tmp
+/test/version_tmp
+/tmp

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+This project *loosely tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
+
+## [0.1.0]
+- Initial release.

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem dependencies in gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,19 @@
+guard "bundler", cmd: "bundle" do
+  watch("Gemfile")
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Tung Nguyen
+
+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/README.md

@@ -0,0 +1,11 @@
+# Responders
+
+[![Gem Version](https://badge.fury.io/rb/jets-responders.png)](http://badge.fury.io/rb/jets-responders)
+
+[![BoltOps Badge](https://img.boltops.com/boltops/badges/boltops-badge.png)](https://www.boltops.com)
+
+[![BoltOps Learn Badge](https://img.boltops.com/boltops-learn/boltops-learn.png)](https://learn.boltops.com)
+
+A set of responders modules to dry up your Jets app.
+
+This is a humble port of the original [responders](https://github.com/heartcombo/responders) to support the [Ruby on Jets](https://rubyonjets.com/) framework. A big thanks to the original authors of responders.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task default: :spec
+
+RSpec::Core::RakeTask.new

data/jets-responders.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "responders/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "jets-responders"
+  spec.version       = Responders::VERSION
+  spec.authors       = ["Tung Nguyen"]
+  spec.email         = ["tung@boltops.com"]
+  spec.summary       = "A set of Jets responders to dry up your application"
+  spec.homepage      = "https://github.com/rubyonjets/jets-responders"
+  spec.license       = "MIT"
+
+  spec.files         = File.directory?('.git') ? `git ls-files`.split($/) : Dir.glob("**/*")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "memoist"
+  spec.add_dependency "rainbow"
+  spec.add_dependency "zeitwerk"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/jets/controller/respond_with.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract_options"
+require "action_controller/metal/mime_responds"
+
+module Jets::Controller # :nodoc:
+  module RespondWith
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :responder, :mimes_for_respond_to
+      self.responder = Jets::Controller::Responder
+      clear_respond_to
+    end
+
+    module ClassMethods
+      # Defines mime types that are rendered by default when invoking
+      # <tt>respond_with</tt>.
+      #
+      #   respond_to :html, :xml, :json
+      #
+      # Specifies that all actions in the controller respond to requests
+      # for <tt>:html</tt>, <tt>:xml</tt> and <tt>:json</tt>.
+      #
+      # To specify on per-action basis, use <tt>:only</tt> and
+      # <tt>:except</tt> with an array of actions or a single action:
+      #
+      #   respond_to :html
+      #   respond_to :xml, :json, except: [ :edit ]
+      #
+      # This specifies that all actions respond to <tt>:html</tt>
+      # and all actions except <tt>:edit</tt> respond to <tt>:xml</tt> and
+      # <tt>:json</tt>.
+      #
+      #   respond_to :json, only: :create
+      #
+      # This specifies that the <tt>:create</tt> action and no other responds
+      # to <tt>:json</tt>.
+      def respond_to(*mimes)
+        options = mimes.extract_options!
+
+        only_actions   = Array(options.delete(:only)).map(&:to_sym)
+        except_actions = Array(options.delete(:except)).map(&:to_sym)
+
+        hash = mimes_for_respond_to.dup
+        mimes.each do |mime|
+          mime = mime.to_sym
+          hash[mime]          = {}
+          hash[mime][:only]   = only_actions   unless only_actions.empty?
+          hash[mime][:except] = except_actions unless except_actions.empty?
+        end
+        self.mimes_for_respond_to = hash.freeze
+      end
+
+      # Clear all mime types in <tt>respond_to</tt>.
+      #
+      def clear_respond_to
+        self.mimes_for_respond_to = Hash.new.freeze
+      end
+    end
+
+    # For a given controller action, respond_with generates an appropriate
+    # response based on the mime-type requested by the client.
+    #
+    # If the method is called with just a resource, as in this example -
+    #
+    #   class PeopleController < ApplicationController
+    #     respond_to :html, :xml, :json
+    #
+    #     def index
+    #       @people = Person.all
+    #       respond_with @people
+    #     end
+    #   end
+    #
+    # then the mime-type of the response is typically selected based on the
+    # request's Accept header and the set of available formats declared
+    # by previous calls to the controller's class method +respond_to+. Alternatively
+    # the mime-type can be selected by explicitly setting <tt>request.format</tt> in
+    # the controller.
+    #
+    # If an acceptable format is not identified, the application returns a
+    # '406 - not acceptable' status. Otherwise, the default response is to render
+    # a template named after the current action and the selected format,
+    # e.g. <tt>index.html.erb</tt>. If no template is available, the behavior
+    # depends on the selected format:
+    #
+    # * for an html response - if the request method is +get+, an exception
+    #   is raised but for other requests such as +post+ the response
+    #   depends on whether the resource has any validation errors (i.e.
+    #   assuming that an attempt has been made to save the resource,
+    #   e.g. by a +create+ action) -
+    #   1. If there are no errors, i.e. the resource
+    #      was saved successfully, the response +redirect+'s to the resource
+    #      i.e. its +show+ action.
+    #   2. If there are validation errors, the response
+    #      renders a default action, which is <tt>:new</tt> for a
+    #      +post+ request or <tt>:edit</tt> for +patch+ or +put+,
+    #      and the status is set based on the configured `error_status`.
+    #      (defaults to `422 Unprocessable Entity` on new apps,
+    #       `200 OK` for compatibility reasons on old apps.)
+    #   Thus an example like this -
+    #
+    #     respond_to :html, :xml
+    #
+    #     def create
+    #       @user = User.new(params[:user])
+    #       flash[:notice] = 'User was successfully created.' if @user.save
+    #       respond_with(@user)
+    #     end
+    #
+    #   is equivalent, in the absence of <tt>create.html.erb</tt>, to -
+    #
+    #     def create
+    #       @user = User.new(params[:user])
+    #       respond_to do |format|
+    #         if @user.save
+    #           flash[:notice] = 'User was successfully created.'
+    #           format.html { redirect_to(@user) }
+    #           format.xml { render xml: @user }
+    #         else
+    #           format.html { render action: "new", status: :unprocessable_entity }
+    #           format.xml { render xml: @user, status: :unprocessable_entity }
+    #         end
+    #       end
+    #     end
+    #
+    # * for a JavaScript request - if the template isn't found, an exception is
+    #   raised.
+    # * for other requests - i.e. data formats such as xml, json, csv etc, if
+    #   the resource passed to +respond_with+ responds to <code>to_<format></code>,
+    #   the method attempts to render the resource in the requested format
+    #   directly, e.g. for an xml request, the response is equivalent to calling
+    #   <code>render xml: resource</code>.
+    #
+    # === Nested resources
+    #
+    # As outlined above, the +resources+ argument passed to +respond_with+
+    # can play two roles. It can be used to generate the redirect url
+    # for successful html requests (e.g. for +create+ actions when
+    # no template exists), while for formats other than html and JavaScript
+    # it is the object that gets rendered, by being converted directly to the
+    # required format (again assuming no template exists).
+    #
+    # For redirecting successful html requests, +respond_with+ also supports
+    # the use of nested resources, which are supplied in the same way as
+    # in <code>form_for</code> and <code>polymorphic_url</code>. For example -
+    #
+    #   def create
+    #     @project = Project.find(params[:project_id])
+    #     @task = @project.comments.build(params[:task])
+    #     flash[:notice] = 'Task was successfully created.' if @task.save
+    #     respond_with(@project, @task)
+    #   end
+    #
+    # This would cause +respond_with+ to redirect to <code>project_task_url</code>
+    # instead of <code>task_url</code>. For request formats other than html or
+    # JavaScript, if multiple resources are passed in this way, it is the last
+    # one specified that is rendered.
+    #
+    # === Customizing response behavior
+    #
+    # Like +respond_to+, +respond_with+ may also be called with a block that
+    # can be used to overwrite any of the default responses, e.g. -
+    #
+    #   def create
+    #     @user = User.new(params[:user])
+    #     flash[:notice] = "User was successfully created." if @user.save
+    #
+    #     respond_with(@user) do |format|
+    #       format.html { render }
+    #     end
+    #   end
+    #
+    # The argument passed to the block is an ActionController::MimeResponds::Collector
+    # object which stores the responses for the formats defined within the
+    # block. Note that formats with responses defined explicitly in this way
+    # do not have to first be declared using the class method +respond_to+.
+    #
+    # Also, a hash passed to +respond_with+ immediately after the specified
+    # resource(s) is interpreted as a set of options relevant to all
+    # formats. Any option accepted by +render+ can be used, e.g.
+    #
+    #   respond_with @people, status: 200
+    #
+    # However, note that these options are ignored after an unsuccessful attempt
+    # to save a resource, e.g. when automatically rendering <tt>:new</tt>
+    # after a post request.
+    #
+    # Three additional options are relevant specifically to +respond_with+ -
+    # 1. <tt>:location</tt> - overwrites the default redirect location used after
+    #    a successful html +post+ request.
+    # 2. <tt>:action</tt> - overwrites the default render action used after an
+    #    unsuccessful html +post+ request.
+    # 3. <tt>:render</tt> - allows to pass any options directly to the <tt>:render<tt/>
+    #    call after unsuccessful html +post+ request. Useful if for example you
+    #    need to render a template which is outside of controller's path or you
+    #    want to override the default http <tt>:status</tt> code, e.g.
+    #
+    #    respond_with(resource, render: { template: 'path/to/template', status: 418 })
+    def respond_with(*resources, &block)
+      if self.class.mimes_for_respond_to.empty?
+        raise "In order to use respond_with, first you need to declare the " \
+          "formats your controller responds to in the class level."
+      end
+
+      mimes = collect_mimes_from_class_level
+      collector = ActionController::MimeResponds::Collector.new(mimes, request.variant)
+      block.call(collector) if block_given?
+
+      if format = collector.negotiate_format(request)
+        _process_format(format)
+        options = resources.size == 1 ? {} : resources.extract_options!
+        options = options.clone
+
+        options[:default_response] = collector.response
+        (options.delete(:responder) || self.class.responder).call(self, resources, options)
+      else
+        raise ActionController::UnknownFormat
+      end
+    end
+
+    protected
+
+    # Before action callback that can be used to prevent requests that do not
+    # match the mime types defined through <tt>respond_to</tt> from being executed.
+    #
+    #   class PeopleController < ApplicationController
+    #     respond_to :html, :xml, :json
+    #
+    #     before_action :verify_requested_format!
+    #   end
+    def verify_requested_format!
+      mimes = collect_mimes_from_class_level
+      collector = ActionController::MimeResponds::Collector.new(mimes, request.variant)
+
+      unless collector.negotiate_format(request)
+        raise ActionController::UnknownFormat
+      end
+    end
+
+    alias :verify_request_format! :verify_requested_format!
+
+    # Collect mimes declared in the class method respond_to valid for the
+    # current action.
+    def collect_mimes_from_class_level # :nodoc:
+      action = action_name.to_sym
+
+      self.class.mimes_for_respond_to.keys.select do |mime|
+        config = self.class.mimes_for_respond_to[mime]
+
+        if config[:except]
+          !config[:except].include?(action)
+        elsif config[:only]
+          config[:only].include?(action)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/jets/controller/responder.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "active_support/json"
+
+module Jets::Controller # :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:
+  #
+  #   class PeopleController < ApplicationController
+  #     respond_to :html, :xml, :json
+  #
+  #     def index
+  #       @people = Person.all
+  #       respond_with(@people)
+  #     end
+  #   end
+  #
+  # When a request comes in, for example for an XML response, three steps happen:
+  #
+  #   1) the responder searches for a template at people/index.xml;
+  #
+  #   2) if the template is not available, it will invoke <code>#to_xml</code> on the given resource;
+  #
+  #   3) if the responder does not <code>respond_to :to_xml</code>, call <code>#to_format</code> on it.
+  #
+  # === Built-in HTTP verb semantics
+  #
+  # The default \Rails responder holds semantics for each HTTP verb. Depending on the
+  # content type, verb and the resource status, it will behave differently.
+  #
+  # Using \Rails default responder, a POST request for creating an object could
+  # be written as:
+  #
+  #   def create
+  #     @user = User.new(params[:user])
+  #     flash[:notice] = 'User was successfully created.' if @user.save
+  #     respond_with(@user)
+  #   end
+  #
+  # Which is exactly the same as:
+  #
+  #   def create
+  #     @user = User.new(params[:user])
+  #
+  #     respond_to do |format|
+  #       if @user.save
+  #         flash[:notice] = 'User was successfully created.'
+  #         format.html { redirect_to(@user) }
+  #         format.xml { render xml: @user, status: :created, location: @user }
+  #       else
+  #         format.html { render action: "new", status: :unprocessable_entity }
+  #         format.xml { render xml: @user.errors, status: :unprocessable_entity }
+  #       end
+  #     end
+  #   end
+  #
+  # The same happens for PATCH/PUT and DELETE requests.
+  #
+  # === Nested resources
+  #
+  # You can supply nested resources as you do in <code>form_for</code> and <code>polymorphic_url</code>.
+  # Consider the project has many tasks example. The create action for
+  # TasksController would be like:
+  #
+  #   def create
+  #     @project = Project.find(params[:project_id])
+  #     @task = @project.tasks.build(params[:task])
+  #     flash[:notice] = 'Task was successfully created.' if @task.save
+  #     respond_with(@project, @task)
+  #   end
+  #
+  # Giving several resources ensures that the responder will redirect to
+  # <code>project_task_url</code> instead of <code>task_url</code>.
+  #
+  # Namespaced and singleton resources require a symbol to be given, as in
+  # polymorphic urls. If a project has one manager which has many tasks, it
+  # should be invoked as:
+  #
+  #   respond_with(@project, :manager, @task)
+  #
+  # Note that if you give an array, it will be treated as a collection,
+  # so the following is not equivalent:
+  #
+  #   respond_with [@project, :manager, @task]
+  #
+  # === Custom options
+  #
+  # <code>respond_with</code> also allows you to pass options that are forwarded
+  # to the underlying render call. Those options are only applied for success
+  # scenarios. For instance, you can do the following in the create method above:
+  #
+  #   def create
+  #     @project = Project.find(params[:project_id])
+  #     @task = @project.tasks.build(params[:task])
+  #     flash[:notice] = 'Task was successfully created.' if @task.save
+  #     respond_with(@project, @task, status: 201)
+  #   end
+  #
+  # This will return status 201 if the task was saved successfully. If not,
+  # it will simply ignore the given options and return status 422 and the
+  # resource errors. You can also override the location to redirect to:
+  #
+  #   respond_with(@project, location: root_path)
+  #
+  # To customize the failure scenario, you can pass a block to
+  # <code>respond_with</code>:
+  #
+  #   def create
+  #     @project = Project.find(params[:project_id])
+  #     @task = @project.tasks.build(params[:task])
+  #     respond_with(@project, @task, status: 201) do |format|
+  #       if @task.save
+  #         flash[:notice] = 'Task was successfully created.'
+  #       else
+  #         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
+    }
+
+    def initialize(controller, resources, options = {})
+      @controller = controller
+      @request = @controller.request
+      @format = @controller.formats.first
+      @resource = resources.last
+      @resources = resources
+      @options = options
+      @action = options.delete(:action)
+      @default_response = options.delete(:default_response)
+
+      if options[:location].respond_to?(:call)
+        location = options.delete(:location)
+        options[:location] = location.call unless has_errors?
+      end
+    end
+
+    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)
+    undef_method(:to_yaml) if method_defined?(:to_yaml)
+
+    # Initializes a new responder and invokes the proper format. If the format is
+    # not defined, call to_format.
+    #
+    def self.call(*args)
+      new(*args).respond
+    end
+
+    # Main entry point for responder responsible to dispatch to the proper format.
+    #
+    def respond
+      method = "to_#{format}"
+      respond_to?(method) ? send(method) : to_format
+    end
+
+    # HTML format does not render the resource, it always attempt to render a
+    # template.
+    #
+    def to_html
+      default_render
+    rescue ActionView::MissingTemplate => e
+      navigation_behavior(e)
+    end
+
+    # to_js simply tries to render a template. If no template is found, raises the error.
+    def to_js
+      default_render
+    end
+
+    # All other formats follow the procedure below. First we try to render a
+    # template, if the template is not available, we verify if the resource
+    # responds to :to_format and display it.
+    #
+    def to_format
+      if !get? && has_errors? && !response_overridden?
+        display_errors
+      elsif has_view_rendering? || response_overridden?
+        default_render
+      else
+        api_behavior
+      end
+    rescue ActionView::MissingTemplate
+      api_behavior
+    end
+
+  protected
+
+    # This is the common behavior for formats associated with browsing, like :html, :iphone and so forth.
+    def navigation_behavior(error)
+      if get?
+        raise error
+      elsif has_errors? && default_action
+        render error_rendering_options
+      else
+        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
+      raise MissingRenderer.new(format) unless has_renderer?
+
+      if get?
+        display resource
+      elsif post?
+        display resource, status: :created, location: api_location
+      else
+        head :no_content
+      end
+    end
+
+    # Returns the resource location by retrieving it from the options or
+    # returning the resources array.
+    #
+    def resource_location
+      options[:location] || resources
+    end
+    alias :navigation_location :resource_location
+    alias :api_location :resource_location
+
+    # If a response block was given, use it, otherwise call render on
+    # controller.
+    #
+    def default_render
+      if @default_response
+        @default_response.call(options)
+      elsif !get? && has_errors?
+        controller.render({ status: error_status }.merge!(options))
+      else
+        controller.render(options)
+      end
+    end
+
+    # Display is just a shortcut to render a resource with the current format.
+    #
+    #   display @user, status: :ok
+    #
+    # For XML requests it's equivalent to:
+    #
+    #   render xml: @user, status: :ok
+    #
+    # Options sent by the user are also used:
+    #
+    #   respond_with(@user, status: :created)
+    #   display(@user, status: :ok)
+    #
+    # Results in:
+    #
+    #   render xml: @user, status: :created
+    #
+    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
+
+    # Check whether the resource has errors.
+    #
+    def has_errors?
+      resource.respond_to?(:errors) && !resource.errors.empty?
+    end
+
+    # Check whether the necessary Renderer is available
+    def has_renderer?
+      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.
+    #
+    def default_action
+      @action ||= DEFAULT_ACTIONS_FOR_VERBS[request.request_method_symbol]
+    end
+
+    def resource_errors
+      respond_to?("#{format}_resource_errors", true) ? send("#{format}_resource_errors") : resource.errors
+    end
+
+    def json_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/jets-responders.rb

@@ -0,0 +1 @@
+require_relative "responders"

data/lib/responders/autoloader.rb

@@ -0,0 +1,23 @@
+require "zeitwerk"
+
+module Responders
+  class Autoloader
+    class Inflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = { version: "VERSION" }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      def setup
+        loader = Zeitwerk::Loader.new
+        loader.inflector = Inflector.new
+        lib = File.dirname(__dir__)
+        loader.push_dir(lib)
+        loader.ignore("#{lib}/jets-responders.rb")
+        loader.setup
+      end
+    end
+  end
+end

data/lib/responders/collection_responder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Responders
+  # This responder modifies your current responder to redirect
+  # to the collection page on POST/PUT/DELETE.
+  module CollectionResponder
+    protected
+
+    # Returns the collection location for redirecting after POST/PUT/DELETE.
+    # This method, converts the following resources array to the following:
+    #
+    #   [:admin, @post] #=> [:admin, :posts]
+    #   [@user, @post]  #=> [@user, :posts]
+    #
+    # When these new arrays are given to redirect_to, it will generate the
+    # proper URL pointing to the index action.
+    #
+    #   [:admin, @post] #=> admin_posts_url
+    #   [@user, @post]  #=> user_posts_url(@user.to_param)
+    #
+    def navigation_location
+      return options[:location] if options[:location]
+
+      klass = resources.last.class
+
+      if klass.respond_to?(:model_name)
+        resources[0...-1] << klass.model_name.route_key.to_sym
+      else
+        resources
+      end
+    end
+  end
+end

data/lib/responders/controller_method.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Responders
+  module ControllerMethod
+    # Adds the given responders to the current controller's responder, allowing you to cherry-pick
+    # which responders you want per controller.
+    #
+    #   class InvitationsController < ApplicationController
+    #     responders :flash, :http_cache
+    #   end
+    #
+    # Takes symbols and strings and translates them to VariableResponder (eg. :flash becomes FlashResponder).
+    # Also allows passing in the responders modules in directly, so you could do:
+    #
+    #    responders FlashResponder, HttpCacheResponder
+    #
+    # Or a mix of both methods:
+    #
+    #    responders :flash, MyCustomResponder
+    #
+    def responders(*responders)
+      self.responder = responders.inject(Class.new(responder)) do |klass, responder|
+        responder = \
+          case responder
+          when Module
+            responder
+          when String, Symbol
+            Responders.const_get("#{responder.to_s.camelize}Responder")
+          else
+            raise "responder has to be a string, a symbol or a module"
+          end
+
+        klass.send(:include, responder)
+        klass
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_controller_base) do
+  Jets::Controller::Base.extend Responders::ControllerMethod
+end

data/lib/responders/engine.rb

@@ -0,0 +1,22 @@
+module Responders
+  require "responders/controller_method"
+
+  class Engine < ::Jets::Engine
+    config.responders = ActiveSupport::OrderedOptions.new
+    config.responders.flash_keys = [:notice, :alert]
+    config.responders.namespace_lookup = false
+    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", __dir__)
+
+    initializer "responders.flash_responder" do |app|
+      Responders::FlashResponder.flash_keys = app.config.responders.flash_keys
+      Responders::FlashResponder.namespace_lookup = app.config.responders.namespace_lookup
+      Jets::Controller::Responder.error_status = app.config.responders.error_status
+      Jets::Controller::Responder.redirect_status = app.config.responders.redirect_status
+    end
+  end
+end

data/lib/responders/flash_responder.rb

@@ -0,0 +1,197 @@
+# 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
+  # the following order:
+  #
+  #   flash.controller_name.action_name.status
+  #   flash.actions.action_name.status
+  #
+  # So, if you have a CarsController, create action, it will check for:
+  #
+  #   flash.cars.create.status
+  #   flash.actions.create.status
+  #
+  # The statuses by default are :notice (when the object can be created, updated
+  # or destroyed with success) and :alert (when the object cannot be created
+  # or updated).
+  #
+  # On I18n, the resource_name given is available as interpolation option,
+  # this means you can set:
+  #
+  #   flash:
+  #     actions:
+  #       create:
+  #         notice: "Hooray! %{resource_name} was successfully created!"
+  #
+  # But sometimes, flash messages are not that simple. Going back
+  # to cars example, you might want to say the brand of the car when it's
+  # updated. Well, that's easy also:
+  #
+  #   flash:
+  #     cars:
+  #       update:
+  #         notice: "Hooray! You just tuned your %{car_brand}!"
+  #
+  # Since :car_name is not available for interpolation by default, you have
+  # to overwrite `flash_interpolation_options` in your controller.
+  #
+  #   def flash_interpolation_options
+  #     { :car_brand => @car.brand }
+  #   end
+  #
+  # Then you will finally have:
+  #
+  #   'Hooray! You just tuned your Aston Martin!'
+  #
+  # If your controller is namespaced, for example Admin::CarsController,
+  # the messages will be checked in the following order:
+  #
+  #   flash.admin.cars.create.status
+  #   flash.admin.actions.create.status
+  #   flash.cars.create.status
+  #   flash.actions.create.status
+  #
+  # You can also have flash messages with embedded HTML. Just create a scope that
+  # ends with <tt>_html</tt> as the scopes below:
+  #
+  #   flash.actions.create.notice_html
+  #   flash.cars.create.notice_html
+  #
+  # == Options
+  #
+  # FlashResponder also accepts some options through respond_with API.
+  #
+  # * :flash - When set to false, no flash message is set.
+  #
+  #     respond_with(@user, :flash => true)
+  #
+  # * :notice - Supply the message to be set if the record has no errors.
+  # * :alert - Supply the message to be set if the record has errors.
+  #
+  #     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_success.
+  #
+  # == Configure status keys
+  #
+  # As said previously, FlashResponder by default use :notice and :alert
+  # keys. You can change that by setting the status_keys:
+  #
+  #   Responders::FlashResponder.flash_keys = [ :success, :failure ]
+  #
+  # However, the options :notice and :alert to respond_with are kept :notice
+  # and :alert.
+  #
+  module FlashResponder
+    class << self
+      attr_accessor :flash_keys, :namespace_lookup
+    end
+
+    self.flash_keys = [ :notice, :alert ]
+    self.namespace_lookup = false
+
+    def initialize(controller, resources, options = {})
+      super
+      @flash     = options.delete(:flash)
+      @notice    = options.delete(:notice)
+      @alert     = options.delete(:alert)
+      @flash_now = options.delete(:flash_now) { :on_failure }
+    end
+
+    def to_html
+      set_flash_message! if set_flash_message?
+      super
+    end
+
+    def to_js
+      set_flash_message! if set_flash_message?
+      defined?(super) ? super : to_format
+    end
+
+  protected
+
+    def set_flash_message!
+      if has_errors?
+        status = Responders::FlashResponder.flash_keys.last
+        set_flash(status, @alert)
+      else
+        status = Responders::FlashResponder.flash_keys.first
+        set_flash(status, @notice)
+      end
+
+      return if controller.flash[status].present?
+
+      options = mount_i18n_options(status)
+      message = controller.helpers.t options[:default].shift, **options
+      set_flash(status, message)
+    end
+
+    def set_flash(key, value)
+      return if value.blank?
+      flash = controller.flash
+      flash = flash.now if set_flash_now?
+      flash[key] ||= value
+    end
+
+    def set_flash_now?
+      @flash_now == true || format == :js ||
+        (default_action && (has_errors? ? @flash_now == :on_failure : @flash_now == :on_success))
+    end
+
+    def set_flash_message? # :nodoc:
+      !get? && @flash != false
+    end
+
+    def mount_i18n_options(status) # :nodoc:
+      options = {
+        default: flash_defaults_by_namespace(status),
+        resource_name: resource_name,
+        downcase_resource_name: resource_name.downcase
+      }
+
+      controller_options = controller_interpolation_options
+      if controller_options
+        options.merge!(controller_options)
+      end
+
+      options
+    end
+
+    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("/")
+      lookup   = Responders::FlashResponder.namespace_lookup
+
+      begin
+        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 = :"flash.#{actions_scope}.#{controller.action_name}.#{status}"
+
+        defaults << :"#{controller_scope}_html"
+        defaults << controller_scope
+
+        defaults << :"#{actions_scope}_html"
+        defaults << actions_scope
+
+        slices.shift
+      end while slices.size > 0 && lookup
+
+      defaults << ""
+    end
+  end
+end

data/lib/responders/http_cache_responder.rb

@@ -0,0 +1,46 @@
+# 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
+  # if a resource changed after a specific date or not.
+  #
+  # This is not usually not used in html requests because pages contains a lot
+  # information besides the resource information, as current_user, flash messages,
+  # widgets... that are better handled with other strategies, as fragment caches and
+  # the digest of the body.
+  #
+  module HttpCacheResponder
+    def initialize(controller, resources, options = {})
+      super
+      @http_cache = options.delete(:http_cache)
+    end
+
+    def to_format
+      return if do_http_cache? && do_http_cache!
+      super
+    end
+
+  protected
+
+    def do_http_cache!
+      timestamp = resources.map do |resource|
+        resource.updated_at.try(:utc) if resource.respond_to?(:updated_at)
+      end.compact.max
+
+      controller.response.last_modified ||= timestamp if timestamp
+
+      head :not_modified if fresh = request.fresh?(controller.response)
+      fresh
+    end
+
+    def do_http_cache?
+      get? && @http_cache != false && Jets::Controller::Base.perform_caching &&
+        persisted? && resource.respond_to?(:updated_at)
+    end
+
+    def persisted?
+      resource.respond_to?(:persisted?) ? resource.persisted? : true
+    end
+  end
+end

data/lib/responders/locales/en.yml

@@ -0,0 +1,12 @@
+en:
+  flash:
+    actions:
+      create:
+        notice: '%{resource_name} was successfully created.'
+        # alert: '%{resource_name} could not be created.'
+      update:
+        notice: '%{resource_name} was successfully updated.'
+        # alert: '%{resource_name} could not be updated.'
+      destroy:
+        notice: '%{resource_name} was successfully destroyed.'
+        alert: '%{resource_name} could not be destroyed.'

data/lib/responders/version.rb

@@ -0,0 +1,3 @@
+module Responders
+  VERSION = "0.1.0"
+end

data/lib/responders.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.expand_path("../", __FILE__))
+
+require "responders/autoloader"
+Responders::Autoloader.setup
+
+require "memoist"
+require "rainbow/ext/string"
+
+module Responders
+  class Error < StandardError; end
+end
+
+ActiveSupport.on_load(:jets_controller) do
+  include Jets::Controller::RespondWith
+end
+
+require "responders/engine"

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: jets-responders
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tung Nguyen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: memoist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: 
+email:
+- tung@boltops.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- jets-responders.gemspec
+- lib/jets-responders.rb
+- lib/jets/controller/respond_with.rb
+- lib/jets/controller/responder.rb
+- lib/responders.rb
+- lib/responders/autoloader.rb
+- lib/responders/collection_responder.rb
+- lib/responders/controller_method.rb
+- lib/responders/engine.rb
+- lib/responders/flash_responder.rb
+- lib/responders/http_cache_responder.rb
+- lib/responders/locales/en.yml
+- lib/responders/version.rb
+homepage: https://github.com/rubyonjets/jets-responders
+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.4.20
+signing_key: 
+specification_version: 4
+summary: A set of Jets responders to dry up your application
+test_files: []