hanami-controller 2.0.0.rc1 → 2.0.0

data/lib/hanami/action/mime.rb

@@ -68,260 +68,217 @@ module Hanami
         zip: "application/zip"
       }.freeze
 
-      # @since 2.0.0
-      # @api private
-      def self.content_type_with_charset(content_type, charset)
-        "#{content_type}; charset=#{charset}"
-      end
+      ANY_TYPE = "*/*"
+
+      class << self
+        # Returns a format name for the given content type.
+        #
+        # The format name will come from the configured formats, if such a format is configured
+        # there, or instead from the default list of formats in `Mime::TYPES`.
+        #
+        # Returns nil if no matching format can be found.
+        #
+        # This is used to return the format name a {Response}.
+        #
+        # @example
+        #   detect_format("application/jsonl charset=utf-8", config) # => :json
+        #
+        # @return [Symbol, nil]
+        #
+        # @see Response#format
+        # @see Action#finish
+        #
+        # @since 2.0.0
+        # @api private
+        def detect_format(content_type, config)
+          return if content_type.nil?
 
-      # Use for setting Content-Type
-      # If the request has the ACCEPT header it will try to return the best Content-Type based
-      # on the content of the ACCEPT header taking in consideration the weights
-      #
-      # If no ACCEPT header it will check the default response_format, then the default request format and
-      # lastly it will fallback to DEFAULT_CONTENT_TYPE
-      #
-      # @return [String]
-      #
-      # @since 2.0.0
-      # @api private
-      def self.content_type(config, request, accepted_mime_types)
-        if request.accept_header?
-          type = best_q_match(request.accept, accepted_mime_types)
-          return type if type
+          ct = content_type.split(";").first
+          config.formats.format_for(ct) || TYPES.key(ct)
         end
 
-        default_response_type(config) || default_content_type(config) || Action::DEFAULT_CONTENT_TYPE
-      end
-
-      # @since 2.0.0
-      # @api private
-      def self.charset(default_charset)
-        default_charset || Action::DEFAULT_CHARSET
-      end
-
-      # @since 2.0.0
-      # @api private
-      def self.default_response_type(config)
-        format_to_mime_type(config.default_response_format, config)
-      end
-
-      # @since 2.0.0
-      # @api private
-      def self.default_content_type(config)
-        format_to_mime_type(config.default_request_format, config)
-      end
-
-      # @since 2.0.0
-      # @api private
-      def self.format_to_mime_type(format, config)
-        return if format.nil?
-
-        config.mime_type_for(format) ||
-          TYPES.fetch(format) { raise Hanami::Action::UnknownFormatError.new(format) }
-      end
-
-      # Transforms MIME Types to symbol
-      # Used for setting the format of the response
-      #
-      # @see Hanami::Action::Mime#finish
-      # @example
-      #   detect_format("text/html; charset=utf-8", config)  #=> :html
-      #
-      # @return [Symbol, nil]
-      #
-      # @since 2.0.0
-      # @api private
-      def self.detect_format(content_type, config)
-        return if content_type.nil?
-
-        ct = content_type.split(";").first
-        config.format_for(ct) || format_for(ct)
-      end
-
-      # @since 2.0.0
-      # @api private
-      def self.format_for(content_type)
-        TYPES.key(content_type)
-      end
-
-      # @since 2.0.0
-      # @api private
-      def self.detect_format_and_content_type(value, config)
-        case value
-        when Symbol
-          [value, format_to_mime_type(value, config)]
-        when String
-          [detect_format(value, config), value]
-        else
-          raise UnknownFormatError.new(value)
+        # Returns a format name and content type pair for a given format name or content type
+        # string.
+        #
+        # @example
+        #   detect_format_and_content_type(:json, config)
+        #   # => [:json, "application/json"]
+        #
+        #   detect_format_and_content_type("application/json", config)
+        #   # => [:json, "application/json"]
+        #
+        # @example Unknown format name
+        #   detect_format_and_content_type(:unknown, config)
+        #   # raises Hanami::Action::UnknownFormatError
+        #
+        # @example Unknown content type
+        #   detect_format_and_content_type("application/unknown", config)
+        #   # => [nil, "application/unknown"]
+        #
+        # @return [Array<(Symbol, String)>]
+        #
+        # @raise [Hanami::Action::UnknownFormatError] if an unknown format name is given
+        #
+        # @since 2.0.0
+        # @api private
+        def detect_format_and_content_type(value, config)
+          case value
+          when Symbol
+            [value, format_to_mime_type(value, config)]
+          when String
+            [detect_format(value, config), value]
+          else
+            raise UnknownFormatError.new(value)
+          end
         end
-      end
 
-      # Transforms symbols to MIME Types
-      # @example
-      #   restrict_mime_types(config, [:json])  #=> ["application/json"]
-      #
-      # @return [Array<String>, nil]
-      #
-      # @raise [Hanami::Action::UnknownFormatError] if the format is invalid
-      #
-      # @since 2.0.0
-      # @api private
-      def self.restrict_mime_types(config)
-        return if config.accepted_formats.empty?
-
-        mime_types = config.accepted_formats.map do |format|
-          format_to_mime_type(format, config)
+        # Returns a string combining the given content type and charset, intended for setting as a
+        # `Content-Type` header.
+        #
+        # @example
+        #   Mime.content_type_with_charset("application/json", "utf-8")
+        #   # => "application/json; charset=utf-8"
+        #
+        # @param content_type [String]
+        # @param charset [String]
+        #
+        # @return [String]
+        #
+        # @since 2.0.0
+        # @api private
+        def content_type_with_charset(content_type, charset)
+          "#{content_type}; charset=#{charset}"
         end
 
-        accepted_mime_types = mime_types & config.mime_types
-
-        return if accepted_mime_types.empty?
-
-        accepted_mime_types
-      end
-
-      # Yields if an action is configured with `accepted_formats`, the request has an `Accept`
-      # header, and none of the Accept types matches the accepted formats. The given block is
-      # expected to halt the request handling.
-      #
-      # If any of these conditions are not met, then the request is acceptable and the method
-      # returns without yielding.
-      #
-      # @see Action#enforce_accepted_mime_types
-      # @see Action.accept
-      # @see Config#accepted_formats
-      #
-      # @since 2.0.0
-      # @api private
-      def self.enforce_accept(request, config)
-        return unless request.accept_header?
-
-        accept_types = ::Rack::Utils.q_values(request.accept).map(&:first)
-        return if accept_types.any? { |mime_type| accepted_mime_type?(mime_type, config) }
+        # Returns a string combining a MIME type and charset, intended for setting as the
+        # `Content-Type` header for the response to the given request.
+        #
+        # This uses the request's `Accept` header (if present) along with the configured formats to
+        # determine the best content type to return.
+        #
+        # @return [String]
+        #
+        # @see Action#call
+        #
+        # @since 2.0.0
+        # @api private
+        def response_content_type_with_charset(request, config)
+          content_type_with_charset(
+            response_content_type(request, config),
+            config.default_charset || Action::DEFAULT_CHARSET
+          )
+        end
 
-        yield
-      end
+        # Patched version of <tt>Rack::Utils.best_q_match</tt>.
+        #
+        # @since 2.0.0
+        # @api private
+        #
+        # @see http://www.rubydoc.info/gems/rack/Rack/Utils#best_q_match-class_method
+        # @see https://github.com/rack/rack/pull/659
+        # @see https://github.com/hanami/controller/issues/59
+        # @see https://github.com/hanami/controller/issues/104
+        # @see https://github.com/hanami/controller/issues/275
+        def best_q_match(q_value_header, available_mimes = TYPES.values)
+          ::Rack::Utils.q_values(q_value_header).each_with_index.map { |(req_mime, quality), index|
+            match = available_mimes.find { |am| ::Rack::Mime.match?(am, req_mime) }
+            next unless match
+
+            RequestMimeWeight.new(req_mime, quality, index, match)
+          }.compact.max&.format
+        end
 
-      # Yields if an action is configured with `accepted_formats`, the request has a `Content-Type`
-      # header (or a `default_requst_format` is configured), and the content type does not match the
-      # accepted formats. The given block is expected to halt the request handling.
-      #
-      # If any of these conditions are not met, then the request is acceptable and the method
-      # returns without yielding.
-      #
-      # @see Action#enforce_accepted_mime_types
-      # @see Action.accept
-      # @see Config#accepted_formats
-      #
-      # @since 2.0.0
-      # @api private
-      def self.enforce_content_type(request, config)
-        content_type = request.content_type || default_content_type(config)
+        # Yields if an action is configured with `formats`, the request has an `Accept` header, an
+        # none of the Accept types matches the accepted formats. The given block is expected to halt
+        # the request handling.
+        #
+        # If any of these conditions are not met, then the request is acceptable and the method
+        # returns without yielding.
+        #
+        # @see Action#enforce_accepted_mime_types
+        # @see Config#formats
+        #
+        # @since 2.0.0
+        # @api private
+        def enforce_accept(request, config)
+          return unless request.accept_header?
 
-        return if content_type.nil?
+          accept_types = ::Rack::Utils.q_values(request.accept).map(&:first)
+          return if accept_types.any? { |mime_type| accepted_mime_type?(mime_type, config) }
 
-        return if accepted_mime_type?(content_type, config)
+          yield
+        end
 
-        yield
-      end
+        # Yields if an action is configured with `formats`, the request has a `Content-Type` header
+        # (or a `default_requst_format` is configured), and the content type does not match the
+        # accepted formats. The given block is expected to halt the request handling.
+        #
+        # If any of these conditions are not met, then the request is acceptable and the method
+        # returns without yielding.
+        #
+        # @see Action#enforce_accepted_mime_types
+        # @see Config#formats
+        #
+        # @since 2.0.0
+        # @api private
+        def enforce_content_type(request, config)
+          content_type = request.content_type
 
-      # @since 2.0.0
-      # @api private
-      def self.accepted_mime_type?(mime_type, config)
-        config.accepted_mime_types.any? { |accepted_mime_type|
-          ::Rack::Mime.match?(accepted_mime_type, mime_type)
-        }
-      end
+          return if content_type.nil?
 
-      # Use for setting the content_type and charset if the response
-      #
-      # @return [String]
-      #
-      # @since 2.0.0
-      # @api private
-      def self.calculate_content_type_with_charset(config, request, accepted_mime_types)
-        charset = self.charset(config.default_charset)
-        content_type = self.content_type(config, request, accepted_mime_types)
-        content_type_with_charset(content_type, charset)
-      end
+          return if accepted_mime_type?(content_type, config)
 
-      # Patched version of <tt>Rack::Utils.best_q_match</tt>.
-      #
-      # @since 2.0.0
-      # @api private
-      #
-      # @see http://www.rubydoc.info/gems/rack/Rack/Utils#best_q_match-class_method
-      # @see https://github.com/rack/rack/pull/659
-      # @see https://github.com/hanami/controller/issues/59
-      # @see https://github.com/hanami/controller/issues/104
-      # @see https://github.com/hanami/controller/issues/275
-      def self.best_q_match(q_value_header, available_mimes = TYPES.values)
-        ::Rack::Utils.q_values(q_value_header).each_with_index.map do |(req_mime, quality), index|
-          match = available_mimes.find { |am| ::Rack::Mime.match?(am, req_mime) }
-          next unless match
+          yield
+        end
 
-          RequestMimeWeight.new(req_mime, quality, index, match)
-        end.compact.max&.format
-      end
+        private
 
-      # @since 1.0.1
-      # @api private
-      class RequestMimeWeight
         # @since 2.0.0
         # @api private
-        MIME_SEPARATOR = "/"
-        private_constant :MIME_SEPARATOR
+        def accepted_mime_type?(mime_type, config)
+          accepted_mime_types(config).any? { |accepted_mime_type|
+            ::Rack::Mime.match?(accepted_mime_type, mime_type)
+          }
+        end
 
         # @since 2.0.0
         # @api private
-        MIME_WILDCARD = "*"
-        private_constant :MIME_WILDCARD
-
-        include Comparable
-
-        # @since 1.0.1
-        # @api private
-        attr_reader :quality
+        def accepted_mime_types(config)
+          return [ANY_TYPE] if config.formats.empty?
 
-        # @since 1.0.1
-        # @api private
-        attr_reader :index
+          config.formats.map { |format| format_to_mime_types(format, config) }.flatten(1)
+        end
 
-        # @since 1.0.1
+        # @since 2.0.0
         # @api private
-        attr_reader :mime
+        def response_content_type(request, config)
+          if request.accept_header?
+            all_mime_types = TYPES.values + config.formats.mapping.keys
+            content_type = best_q_match(request.accept, all_mime_types)
 
-        # @since 1.0.1
-        # @api private
-        attr_reader :format
+            return content_type if content_type
+          end
 
-        # @since 1.0.1
-        # @api private
-        attr_reader :priority
+          if config.formats.default
+            return format_to_mime_type(config.formats.default, config)
+          end
 
-        # @since 1.0.1
-        # @api private
-        def initialize(mime, quality, index, format = mime)
-          @quality, @index, @format = quality, index, format
-          calculate_priority(mime)
+          Action::DEFAULT_CONTENT_TYPE
         end
 
-        # @since 1.0.1
+        # @since 2.0.0
         # @api private
-        def <=>(other)
-          return priority <=> other.priority unless priority == other.priority
-
-          other.index <=> index
+        def format_to_mime_type(format, config)
+          config.formats.mime_type_for(format) ||
+            TYPES.fetch(format) { raise Hanami::Action::UnknownFormatError.new(format) }
         end
 
-        private
-
-        # @since 1.0.1
+        # @since 2.0.0
         # @api private
-        def calculate_priority(mime)
-          @priority ||= (mime.split(MIME_SEPARATOR, 2).count(MIME_WILDCARD) * -10) + quality
+        def format_to_mime_types(format, config)
+          config.formats.mime_types_for(format).tap { |types|
+            types << TYPES[format] if TYPES.key?(format)
+          }
         end
       end
     end

data/lib/hanami/action/params.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/action/base_params"
 require "hanami/validations/form"
 
 module Hanami

data/lib/hanami/action/request.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/action/flash"
 require "rack/mime"
 require "rack/request"
 require "rack/utils"

data/lib/hanami/action/response.rb

@@ -3,11 +3,6 @@
 require "rack"
 require "rack/response"
 require "hanami/utils/kernel"
-require "hanami/action/halt"
-require "hanami/action/cookie_jar"
-require "hanami/action/cache/cache_control"
-require "hanami/action/cache/expires"
-require "hanami/action/cache/conditional_get"
 require_relative "errors"
 
 module Hanami
@@ -44,10 +39,10 @@ module Hanami
       # @since 2.0.0
       # @api private
       def self.build(status, env)
-        new(config: nil, content_type: Mime.best_q_match(env[Action::HTTP_ACCEPT]), env: env).tap do |r|
+        new(config: Action.config.dup, content_type: Mime.best_q_match(env[Action::HTTP_ACCEPT]), env: env).tap do |r|
           r.status = status
           r.body   = Http::Status.message_for(status)
-          r.set_format(Mime.format_for(r.content_type))
+          r.set_format(Mime.detect_format(r.content_type), config)
         end
       end
 
@@ -111,9 +106,12 @@ module Hanami
 
       # Sets the format and associated content type for the response.
       #
-      # Either a format name (`:json`) or a content type string (`"application/json"`) may be given.
-      # In either case, the format or content type will be derived from the given value, and both
-      # will be set.
+      # Either a format name (`:json`) or a MIME type (`"application/json"`) may be given. In either
+      # case, the format or content type will be derived from the given value, and both will be set.
+      #
+      # Providing an unknown format name will raise an {Hanami::Action::UnknownFormatError}.
+      #
+      # Providing an unknown MIME type will set the content type and set the format as nil.
       #
       # @example Assigning via a format name symbol
       #   response.format = :json
@@ -127,6 +125,8 @@ module Hanami
       #
       # @param value [Symbol, String] the format name or content type
       #
+      # @raise [Hanami::Action::UnknownFormatError] if an unknown format name is given
+      #
       # @see Config#formats
       #
       # @since 2.0.0

data/lib/hanami/action/session.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/action/flash"
-
 module Hanami
   class Action
     # Session support for actions.

data/lib/hanami/action/validatable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "hanami/action/params"
+require_relative "params"
 
 module Hanami
   class Action

data/lib/hanami/action.rb

@@ -1,29 +1,15 @@
 # frozen_string_literal: true
 
-begin
-  require "dry/core"
-  require "dry/types"
-  require "hanami/validations"
-  require "hanami/action/validatable"
-rescue LoadError # rubocop:disable Lint/SuppressedException
-end
-
 require "dry/configurable"
-require "hanami/utils/callbacks"
 require "hanami/utils"
-require "hanami/utils/string"
+require "hanami/utils/callbacks"
 require "hanami/utils/kernel"
+require "hanami/utils/string"
 require "rack"
 require "rack/utils"
+require "zeitwerk"
 
-require_relative "action/config"
 require_relative "action/constants"
-require_relative "action/base_params"
-require_relative "action/halt"
-require_relative "action/mime"
-require_relative "action/rack/file"
-require_relative "action/request"
-require_relative "action/response"
 require_relative "action/errors"
 
 module Hanami
@@ -42,18 +28,37 @@ module Hanami
   #
   # @api public
   class Action
+    # @since 2.0.0
+    # @api private
+    def self.gem_loader
+      @gem_loader ||= Zeitwerk::Loader.new.tap do |loader|
+        root = File.expand_path("..", __dir__)
+        loader.tag = "hanami-controller"
+        loader.inflector = Zeitwerk::GemInflector.new("#{root}/hanami-controller.rb")
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/hanami-controller.rb",
+          "#{root}/hanami/controller/version.rb",
+          "#{root}/hanami/action/{constants,errors,params,validatable}.rb"
+        )
+        loader.inflector.inflect("csrf_protection" => "CSRFProtection")
+      end
+    end
+
+    gem_loader.setup
+
+    # Make conditional requires after Zeitwerk setup so any internal autoloading works as expected
+    begin
+      require "hanami/validations"
+      require_relative "action/validatable"
+    rescue LoadError # rubocop:disable Lint/SuppressedException
+    end
+
     extend Dry::Configurable(config_class: Config)
 
     # See {Config} for individual setting accessor API docs
     setting :handled_exceptions, default: {}
-    setting :formats, default: Config::DEFAULT_FORMATS
-    setting :default_request_format, constructor: -> (format) {
-      Utils::Kernel.Symbol(format) unless format.nil?
-    }
-    setting :default_response_format, constructor: -> (format) {
-      Utils::Kernel.Symbol(format) unless format.nil?
-    }
-    setting :accepted_formats, default: []
+    setting :formats, default: Config::Formats.new, mutable: true
     setting :default_charset
     setting :default_headers, default: {}, constructor: -> (headers) { headers.compact }
     setting :cookies, default: {}, constructor: -> (cookie_options) {
@@ -65,8 +70,8 @@ module Hanami
       Pathname(File.expand_path(dir || Dir.pwd)).realpath
     }
     setting :public_directory, default: Config::DEFAULT_PUBLIC_DIRECTORY
-    setting :before_callbacks, default: Utils::Callbacks::Chain.new, cloneable: true
-    setting :after_callbacks, default: Utils::Callbacks::Chain.new, cloneable: true
+    setting :before_callbacks, default: Utils::Callbacks::Chain.new, mutable: true
+    setting :after_callbacks, default: Utils::Callbacks::Chain.new, mutable: true
 
     # @!scope class
 
@@ -75,7 +80,7 @@ module Hanami
     #
     #   @example Access inside class body
     #     class Show < Hanami::Action
-    #       config.default_response_format = :json
+    #       config.format :json
     #     end
     #
     #   @return [Config]
@@ -266,34 +271,12 @@ module Hanami
       config.after_callbacks.prepend(...)
     end
 
-    # Restrict the access to the specified mime type symbols.
-    #
-    # @param formats[Array<Symbol>] one or more symbols representing mime type(s)
-    #
-    # @raise [Hanami::Action::UnknownFormatError] if the symbol cannot
-    #   be converted into a mime type
-    #
-    # @since 0.1.0
-    #
     # @see Config#format
     #
-    # @example
-    #   require "hanami/controller"
-    #
-    #   class Show < Hanami::Action
-    #     accept :html, :json
-    #
-    #     def handle(req, res)
-    #       # ...
-    #     end
-    #   end
-    #
-    #   # When called with "*/*"              => 200
-    #   # When called with "text/html"        => 200
-    #   # When called with "application/json" => 200
-    #   # When called with "application/xml"  => 415
-    def self.accept(*formats)
-      config.accepted_formats = formats
+    # @since 2.0.0
+    # @api public
+    def self.format(...)
+      config.format(...)
     end
 
     # @see Config#handle_exception
@@ -331,7 +314,7 @@ module Hanami
         response = build_response(
           request: request,
           config: config,
-          content_type: Mime.calculate_content_type_with_charset(config, request, config.accepted_mime_types),
+          content_type: Mime.response_content_type_with_charset(request, config),
           env: env,
           headers: config.default_headers,
           sessions_enabled: sessions_enabled?
@@ -425,7 +408,7 @@ module Hanami
     # @since 2.0.0
     # @api private
     def enforce_accepted_mime_types(request)
-      return if config.accepted_formats.empty?
+      return if config.formats.empty?
 
       Mime.enforce_accept(request, config) { return halt 406 }
       Mime.enforce_content_type(request, config) { return halt 415 }