omg-actionpack 8.0.0.alpha1

data/lib/action_controller/metal/etag_with_template_digest.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  # # Action Controller Etag With Template Digest
+  #
+  # When our views change, they should bubble up into HTTP cache freshness and
+  # bust browser caches. So the template digest for the current action is
+  # automatically included in the ETag.
+  #
+  # Enabled by default for apps that use Action View. Disable by setting
+  #
+  #     config.action_controller.etag_with_template_digest = false
+  #
+  # Override the template to digest by passing `:template` to `fresh_when` and
+  # `stale?` calls. For example:
+  #
+  #     # We're going to render widgets/show, not posts/show
+  #     fresh_when @post, template: 'widgets/show'
+  #
+  #     # We're not going to render a template, so omit it from the ETag.
+  #     fresh_when @post, template: false
+  #
+  module EtagWithTemplateDigest
+    extend ActiveSupport::Concern
+
+    include ActionController::ConditionalGet
+
+    included do
+      class_attribute :etag_with_template_digest, default: true
+
+      etag do |options|
+        determine_template_etag(options) if etag_with_template_digest
+      end
+    end
+
+    private
+      def determine_template_etag(options)
+        if template = pick_template_for_etag(options)
+          lookup_and_digest_template(template)
+        end
+      end
+
+      # Pick the template digest to include in the ETag. If the `:template` option is
+      # present, use the named template. If `:template` is `nil` or absent, use the
+      # default controller/action template. If `:template` is false, omit the template
+      # digest from the ETag.
+      def pick_template_for_etag(options)
+        unless options[:template] == false
+          options[:template] || lookup_context.find_all(action_name, _prefixes).first&.virtual_path
+        end
+      end
+
+      def lookup_and_digest_template(template)
+        ActionView::Digestor.digest name: template, format: nil, finder: lookup_context
+      end
+  end
+end

data/lib/action_controller/metal/exceptions.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  class ActionControllerError < StandardError # :nodoc:
+  end
+
+  class BadRequest < ActionControllerError # :nodoc:
+    def initialize(msg = nil)
+      super(msg)
+      set_backtrace $!.backtrace if $!
+    end
+  end
+
+  class RenderError < ActionControllerError # :nodoc:
+  end
+
+  class RoutingError < ActionControllerError # :nodoc:
+    attr_reader :failures
+    def initialize(message, failures = [])
+      super(message)
+      @failures = failures
+    end
+  end
+
+  class UrlGenerationError < ActionControllerError # :nodoc:
+    attr_reader :routes, :route_name, :method_name
+
+    def initialize(message, routes = nil, route_name = nil, method_name = nil)
+      @routes      = routes
+      @route_name  = route_name
+      @method_name = method_name
+
+      super(message)
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable
+
+      def corrections
+        @corrections ||= begin
+          maybe_these = routes&.named_routes&.helper_names&.grep(/#{route_name}/) || []
+          maybe_these -= [method_name.to_s] # remove exact match
+
+          DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(route_name)
+        end
+      end
+    end
+  end
+
+  class MethodNotAllowed < ActionControllerError # :nodoc:
+    def initialize(*allowed_methods)
+      super("Only #{allowed_methods.to_sentence} requests are allowed.")
+    end
+  end
+
+  class NotImplemented < MethodNotAllowed # :nodoc:
+  end
+
+  class MissingFile < ActionControllerError # :nodoc:
+  end
+
+  class SessionOverflowError < ActionControllerError # :nodoc:
+    DEFAULT_MESSAGE = "Your session data is larger than the data column in which it is to be stored. You must increase the size of your data column if you intend to store large data."
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
+  class UnknownHttpMethod < ActionControllerError # :nodoc:
+  end
+
+  class UnknownFormat < ActionControllerError # :nodoc:
+  end
+
+  # Raised when a nested respond_to is triggered and the content types of each are
+  # incompatible. For example:
+  #
+  #     respond_to do |outer_type|
+  #       outer_type.js do
+  #         respond_to do |inner_type|
+  #           inner_type.html { render body: "HTML" }
+  #         end
+  #       end
+  #     end
+  class RespondToMismatchError < ActionControllerError
+    DEFAULT_MESSAGE = "respond_to was called multiple times and matched with conflicting formats in this action. Please note that you may only call respond_to and match on a single format per action."
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
+  class MissingExactTemplate < UnknownFormat # :nodoc:
+    attr_reader :controller, :action_name
+
+    def initialize(message, controller, action_name)
+      @controller  = controller
+      @action_name = action_name
+
+      super(message)
+    end
+  end
+end

data/lib/action_controller/metal/flash.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController # :nodoc:
+  module Flash
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_flash_types, instance_accessor: false, default: []
+
+      delegate :flash, to: :request
+      add_flash_types(:alert, :notice)
+    end
+
+    module ClassMethods
+      # Creates new flash types. You can pass as many types as you want to create
+      # flash types other than the default `alert` and `notice` in your controllers
+      # and views. For instance:
+      #
+      #     # in application_controller.rb
+      #     class ApplicationController < ActionController::Base
+      #       add_flash_types :warning
+      #     end
+      #
+      #     # in your controller
+      #     redirect_to user_path(@user), warning: "Incomplete profile"
+      #
+      #     # in your view
+      #     <%= warning %>
+      #
+      # This method will automatically define a new method for each of the given
+      # names, and it will be available in your views.
+      def add_flash_types(*types)
+        types.each do |type|
+          next if _flash_types.include?(type)
+
+          define_method(type) do
+            request.flash[type]
+          end
+          helper_method(type) if respond_to?(:helper_method)
+
+          self._flash_types += [type]
+        end
+      end
+
+      def action_methods # :nodoc:
+        @action_methods ||= super - _flash_types.map(&:to_s).to_set
+      end
+    end
+
+    private
+      def redirect_to(options = {}, response_options_and_flash = {}) # :doc:
+        self.class._flash_types.each do |flash_type|
+          if type = response_options_and_flash.delete(flash_type)
+            flash[flash_type] = type
+          end
+        end
+
+        if other_flashes = response_options_and_flash.delete(:flash)
+          flash.update(other_flashes)
+        end
+
+        super(options, response_options_and_flash)
+      end
+  end
+end

data/lib/action_controller/metal/head.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  module Head
+    # Returns a response that has no content (merely headers). The options argument
+    # is interpreted to be a hash of header names and values. This allows you to
+    # easily return a response that consists only of significant headers:
+    #
+    #     head :created, location: person_path(@person)
+    #
+    #     head :created, location: @person
+    #
+    # It can also be used to return exceptional conditions:
+    #
+    #     return head(:method_not_allowed) unless request.post?
+    #     return head(:bad_request) unless valid_request?
+    #     render
+    #
+    # See `Rack::Utils::SYMBOL_TO_STATUS_CODE` for a full list of valid `status`
+    # symbols.
+    def head(status, options = nil)
+      if status.is_a?(Hash)
+        raise ArgumentError, "#{status.inspect} is not a valid value for `status`."
+      end
+
+      status ||= :ok
+
+      if options
+        location = options.delete(:location)
+        content_type = options.delete(:content_type)
+
+        options.each do |key, value|
+          headers[key.to_s.split(/[-_]/).each { |v| v[0] = v[0].upcase }.join("-")] = value.to_s
+        end
+      end
+
+      self.status = status
+      self.location = url_for(location) if location
+
+      if include_content?(response_code)
+        unless self.media_type
+          self.content_type = content_type || ((f = formats) && Mime[f.first]) || Mime[:html]
+        end
+
+        response.charset = false
+      end
+
+      self.response_body = ""
+
+      true
+    end
+
+    private
+      def include_content?(status)
+        case status
+        when 100..199
+          false
+        when 204, 205, 304
+          false
+        else
+          true
+        end
+      end
+  end
+end

data/lib/action_controller/metal/helpers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  # # Action Controller Helpers
+  #
+  # The Rails framework provides a large number of helpers for working with
+  # assets, dates, forms, numbers and model objects, to name a few. These helpers
+  # are available to all templates by default.
+  #
+  # In addition to using the standard template helpers provided, creating custom
+  # helpers to extract complicated logic or reusable functionality is strongly
+  # encouraged. By default, each controller will include all helpers. These
+  # helpers are only accessible on the controller through `#helpers`
+  #
+  # In previous versions of Rails the controller will include a helper which
+  # matches the name of the controller, e.g., `MyController` will automatically
+  # include `MyHelper`. You can revert to the old behavior with the following:
+  #
+  #     # config/application.rb
+  #     class Application < Rails::Application
+  #       config.action_controller.include_all_helpers = false
+  #     end
+  #
+  # Additional helpers can be specified using the `helper` class method in
+  # ActionController::Base or any controller which inherits from it.
+  #
+  # The `to_s` method from the Time class can be wrapped in a helper method to
+  # display a custom message if a Time object is blank:
+  #
+  #     module FormattedTimeHelper
+  #       def format_time(time, format=:long, blank_message="&nbsp;")
+  #         time.blank? ? blank_message : time.to_fs(format)
+  #       end
+  #     end
+  #
+  # FormattedTimeHelper can now be included in a controller, using the `helper`
+  # class method:
+  #
+  #     class EventsController < ActionController::Base
+  #       helper FormattedTimeHelper
+  #       def index
+  #         @events = Event.all
+  #       end
+  #     end
+  #
+  # Then, in any view rendered by `EventsController`, the `format_time` method can
+  # be called:
+  #
+  #     <% @events.each do |event| -%>
+  #       <p>
+  #         <%= format_time(event.time, :short, "N/A") %> | <%= event.name %>
+  #       </p>
+  #     <% end -%>
+  #
+  # Finally, assuming we have two event instances, one which has a time and one
+  # which does not, the output might look like this:
+  #
+  #     23 Aug 11:30 | Carolina Railhawks Soccer Match
+  #     N/A | Carolina Railhawks Training Workshop
+  #
+  module Helpers
+    extend ActiveSupport::Concern
+
+    class << self; attr_accessor :helpers_path; end
+    include AbstractController::Helpers
+
+    included do
+      class_attribute :helpers_path, default: []
+      class_attribute :include_all_helpers, default: true
+    end
+
+    module ClassMethods
+      # Declares helper accessors for controller attributes. For example, the
+      # following adds new `name` and `name=` instance methods to a controller and
+      # makes them available to the view:
+      #     attr_accessor :name
+      #     helper_attr :name
+      #
+      # #### Parameters
+      # *   `attrs` - Names of attributes to be converted into helpers.
+      #
+      def helper_attr(*attrs)
+        attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
+      end
+
+      # Provides a proxy to access helper methods from outside the view.
+      #
+      # Note that the proxy is rendered under a different view context. This may cause
+      # incorrect behavior with capture methods. Consider using
+      # [helper](rdoc-ref:AbstractController::Helpers::ClassMethods#helper) instead
+      # when using `capture`.
+      def helpers
+        @helper_proxy ||= begin
+          proxy = ActionView::Base.empty
+          proxy.config = config.inheritable_copy
+          proxy.extend(_helpers)
+        end
+      end
+
+      # Override modules_for_helpers to accept `:all` as argument, which loads all
+      # helpers in helpers_path.
+      #
+      # #### Parameters
+      # *   `args` - A list of helpers
+      #
+      #
+      # #### Returns
+      # *   `array` - A normalized list of modules for the list of helpers provided.
+      #
+      def modules_for_helpers(args)
+        args += all_application_helpers if args.delete(:all)
+        super(args)
+      end
+
+      private
+        # Extract helper names from files in `app/helpers/***/**_helper.rb`
+        def all_application_helpers
+          all_helpers_from_path(helpers_path)
+        end
+    end
+
+    # Provides a proxy to access helper methods from outside the view.
+    def helpers
+      @_helper_proxy ||= view_context
+    end
+  end
+end