hanami-controller 2.0.0.rc1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a5d623c09e8ecb8c267de856196333c5da74e066b55501af2acc706349d0d73
-  data.tar.gz: '0786076a81b7a11ca79aedba2ff0318f207683e71ba931293dcc1f585a191e0b'
+  metadata.gz: '03586fe42cbe2496c8433bb50cf8b176d1edd75ecd2848d89e28e9d6b2cd735e'
+  data.tar.gz: 3a5e3a900db6918d9c3f74e49509efb5e33afcf9843ac76aa837fa193f6eb748
 SHA512:
-  metadata.gz: 81f1cddefe11892d05ccb63e8649bc9fb6e50f2258eb02503044577e9c0e445c57cbf2318046a4002e3c9b107f9df530463cbeb10460bb3339bb52b747deb0eb
-  data.tar.gz: eb26f557543e0d345580b9160ec4123def85b4a4ec5a1ad0a17f8a8d15d05dc34f12e13705082e21b95a5cc3095d36677b099a319a1c2472c7180e413f5c5faf
+  metadata.gz: de6142be19fc0a9d18e8a27260ab94729d2103f72589e9c36db8226d9cf9bb19b9cec9193e0c7e00659afd5f8aee775abda2af0ed21e1962315d77c6b789bd89
+  data.tar.gz: 98927780e4bfd2e31de03b3d2bb01441aad6405743ff68991d80a76c92647191bd929e2a345554cf5146097cf3dd222717451b7f93d326cf0fb49ef5ce7905f8

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 Complete, fast and testable actions for Rack
 
+## v2.0.0 - 2022-11-22
+
+### Added
+
+- [Tim Riley] Use Zeitwerk to autoload the gem
+- [Tim Riley] Introduce `Hanami::Action::Config#formats`. Use `config.actions.formats.add(:json)`. Custom formats can use `config.actions.formats.add(:graphql, ["application/graphql"])`
+
+### Changed
+
+- [Tim Riley] Changed `Hanami::Action::Config#format` semantic: it's no longer used to add custom MIME Types, but as a macro to setup the wanted format for action(s)
+- [Tim Riley] Removed `Hanami::Action::Config#default_request_format` and `#default_response_format`, use `#format` for both
+- [Tim Riley] Removed `Hanami::Action::Config#accept`, use `#format`
+
 ## v2.0.0.rc1 - 2022-11-08
 
 ### Changed

data/README.md

@@ -928,12 +928,6 @@ configuration = Hanami::Controller::Configuration.new do |config|
   #
   config.format custom: "application/custom"
 
-  # Define a fallback format to detect in case of HTTP request with `Accept: */*`
-  # If not defined here, it will return Rack's default: `application/octet-stream`
-  # Argument: symbol, it should be already known. defaults to `nil`
-  #
-  config.default_request_format = :html
-
   # Define a default format to set as `Content-Type` header for response,
   # unless otherwise specified.
   # If not defined here, it will return Rack's default: `application/octet-stream`

data/hanami-controller.gemspec

@@ -20,9 +20,11 @@ Gem::Specification.new do |spec|
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.required_ruby_version = ">= 3.0"
 
-  spec.add_dependency "rack",         "~> 2.0"
-  spec.add_dependency "hanami-utils", "~> 2.0.0.rc1"
+  spec.add_dependency "rack", "~> 2.0"
+  spec.add_dependency "hanami-utils", "~> 2.0"
   spec.add_dependency "dry-configurable", "~> 1.0", "< 2"
+  spec.add_dependency "dry-core", "~> 1.0"
+  spec.add_dependency "zeitwerk", "~> 2.6"
 
   spec.add_development_dependency "bundler",   ">= 1.6", "< 3"
   spec.add_development_dependency "rack-test", "~> 2.0"

data/lib/hanami/action/cache/cache_control.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/action/cache/directives"
-
 module Hanami
   class Action
     module Cache

data/lib/hanami/action/cache/expires.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/action/cache/cache_control"
-
 module Hanami
   class Action
     module Cache

data/lib/hanami/action/cache.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/action/cache/cache_control"
-require "hanami/action/cache/expires"
-require "hanami/action/cache/conditional_get"
-
 module Hanami
   class Action
     # Cache type API

data/lib/hanami/action/config/formats.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "hanami/utils/kernel"
+require "dry/core"
+
+module Hanami
+  class Action
+    class Config
+      # Action format configuration.
+      #
+      # @since 2.0.0
+      # @api private
+      class Formats
+        include Dry.Equalizer(:values, :mapping)
+
+        # Default MIME type to format mapping
+        #
+        # @since 2.0.0
+        # @api private
+        DEFAULT_MAPPING = {
+          "application/octet-stream" => :all,
+          "*/*" => :all
+        }.freeze
+
+        # @since 2.0.0
+        # @api private
+        attr_reader :mapping
+
+        # The array of enabled formats.
+        #
+        # @example
+        #   config.formats.values = [:html, :json]
+        #   config.formats.values # => [:html, :json]
+        #
+        # @since 2.0.0
+        # @api public
+        attr_reader :values
+
+        # @since 2.0.0
+        # @api private
+        def initialize(values: [], mapping: DEFAULT_MAPPING.dup)
+          @values = values
+          @mapping = mapping
+        end
+
+        # @since 2.0.0
+        # @api private
+        private def initialize_copy(original) # rubocop:disable Style/AccessModifierDeclarations
+          super
+          @values = original.values.dup
+          @mapping = original.mapping.dup
+        end
+
+        # !@attribute [w] values
+        #   @since 2.0.0
+        #   @api public
+        def values=(formats)
+          @values = formats.map { |f| Utils::Kernel.Symbol(f) }
+        end
+
+        # @overload add(format)
+        #   Adds and enables a format.
+        #
+        #   @param format [Symbol]
+        #
+        #   @example
+        #     config.formats.add(:json)
+        #
+        # @overload add(format, mime_type)
+        #   Adds a custom format to MIME type mapping and enables the format.
+        #   Adds a format mapping to a single MIME type.
+        #
+        #   @param format [Symbol]
+        #   @param mime_type [String]
+        #
+        #   @example
+        #     config.formats.add(:json, "application/json")
+        #
+        # @overload add(format, mime_types)
+        #   Adds a format mapping to multiple MIME types.
+        #
+        #   @param format [Symbol]
+        #   @param mime_types [Array<String>]
+        #
+        #   @example
+        #     config.formats.add(:json, ["application/json+scim", "application/json"])
+        #
+        # @return [self]
+        #
+        # @since 2.0.0
+        # @api public
+        def add(format, mime_types = [])
+          format = Utils::Kernel.Symbol(format)
+
+          Array(mime_types).each do |mime_type|
+            @mapping[Utils::Kernel.String(mime_type)] = format
+          end
+
+          @values << format unless @values.include?(format)
+
+          self
+        end
+
+        # @since 2.0.0
+        # @api private
+        def empty?
+          @values.empty?
+        end
+
+        # @since 2.0.0
+        # @api private
+        def any?
+          @values.any?
+        end
+
+        # @since 2.0.0
+        # @api private
+        def map(&blk)
+          @values.map(&blk)
+        end
+
+        # @since 2.0.0
+        # @api private
+        def mapping=(mappings)
+          @mapping = {}
+
+          mappings.each do |format_name, mime_types|
+            Array(mime_types).each do |mime_type|
+              add(format_name, mime_type)
+            end
+          end
+        end
+
+        # Clears any previously added mappings and format values.
+        #
+        # @return [self]
+        #
+        # @since 2.0.0
+        # @api public
+        def clear
+          @mapping = DEFAULT_MAPPING.dup
+          @values = []
+
+          self
+        end
+
+        # Retrieve the format name associated with the given MIME Type
+        #
+        # @param mime_type [String] the MIME Type
+        #
+        # @return [Symbol,NilClass] the associated format name, if any
+        #
+        # @example
+        #   @config.formats.format_for("application/json") # => :json
+        #
+        # @see #mime_type_for
+        #
+        # @since 2.0.0
+        # @api public
+        def format_for(mime_type)
+          @mapping[mime_type]
+        end
+
+        # Returns the primary MIME type associated with the given format.
+        #
+        # @param format [Symbol] the format name
+        #
+        # @return [String, nil] the associated MIME type, if any
+        #
+        # @example
+        #   @config.formats.mime_type_for(:json) # => "application/json"
+        #
+        # @see #format_for
+        #
+        # @since 2.0.0
+        # @api public
+        def mime_type_for(format)
+          @mapping.key(format)
+        end
+
+        # Returns an array of all MIME types associated with the given format.
+        #
+        # Returns an empty array if no such format is configured.
+        #
+        # @param format [Symbol] the format name
+        #
+        # @return [Array<String>] the associated MIME types
+        #
+        # @since 2.0.0
+        # @api public
+        def mime_types_for(format)
+          @mapping.each_with_object([]) { |(mime_type, f), arr| arr << mime_type if format == f }
+        end
+
+        # Returns the default format name
+        #
+        # @return [Symbol, nil] the default format name, if any
+        #
+        # @example
+        #   @config.formats.default # => :json
+        #
+        # @since 2.0.0
+        # @api public
+        def default
+          @values.first
+        end
+
+        # @since 2.0.0
+        # @api private
+        def keys
+          @mapping.keys
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/config.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "dry/configurable"
-require_relative "mime"
 
 module Hanami
   class Action
@@ -12,16 +11,6 @@ module Hanami
     # @api public
     # @since 2.0.0
     class Config < Dry::Configurable::Config
-      # Default MIME type to format mapping
-      #
-      # @since 0.2.0
-      # @api private
-      DEFAULT_FORMATS = {
-        "application/octet-stream" => :all,
-        "*/*" => :all,
-        "text/html" => :html
-      }.freeze
-
       # Default public directory
       #
       # This serves as the root directory for file downloads
@@ -69,121 +58,37 @@ module Hanami
           .to_h
       end
 
-      # @!attribute [rw] formats
-      #
-      #   Specifies the MIME type to format mapping
-      #
-      #   @return [Hash{String=>Symbol}] MIME type strings as keys and format symbols as values
-      #
-      #   @see format
-      #   @see Hanami::Action::Mime
+      # @!attribute [r] formats
+      #   Returns the format config for the action.
       #
-      #   @example
-      #     config.formats = {"text/html" => :html}
+      #   @return [Config::Formats]
       #
-      #   @since 0.2.0
+      #   @since 2.0.0
+      #   @api public
 
-      # Registers a MIME type to format mapping
+      # Sets the format (or formats) for the action.
       #
-      # @param hash [Hash{Symbol=>String}] format symbols as keys and the MIME
-      #   type strings must as values
-      #
-      # @return [void]
-      #
-      # @see formats
-      # @see Hanami::Action::Mime
+      # To configure custom formats and MIME type mappings, call {Formats#add formats.add} first.
       #
       # @example
-      #   config.format html: "text/html"
-      #
-      # @since 0.2.0
-      def format(hash)
-        symbol, mime_type = *Utils::Kernel.Array(hash)
-        formats[Utils::Kernel.String(mime_type)] = Utils::Kernel.Symbol(symbol)
-      end
-
-      # Returns the configured format for the given MIME type
-      #
-      # @param mime_type [#to_s,#to_str] A mime type
-      #
-      # @return [Symbol,nil] the corresponding format, nil if not found
-      #
-      # @see format
-      #
-      # @since 0.2.0
-      # @api private
-      def format_for(mime_type)
-        formats[mime_type]
-      end
-
-      # Returns the configured format's MIME types
-      #
-      # @return [Array<String>] the format's MIME types
-      #
-      # @see formats=
-      # @see format
+      #   config.format :html, :json
       #
-      # @since 0.8.0
+      # @param formats [Array<Symbol>] the format names
       #
-      # @api private
-      def mime_types
-        # FIXME: this isn't efficient. speed it up!
-        ((formats.keys - DEFAULT_FORMATS.keys) +
-          Hanami::Action::Mime::TYPES.values).freeze
-      end
-
-      # Returns a MIME type for the given format
-      #
-      # @param format [#to_sym] a format
+      # @return [Array<Symbol>] the given format names
       #
-      # @return [String,nil] the corresponding MIME type, if present
+      # @see #formats
       #
-      # @since 0.2.0
-      # @api private
-      def mime_type_for(format)
-        formats.key(format)
-      end
-
       # @since 2.0.0
-      # @api private
-      def accepted_mime_types
-        accepted_formats.any? ? Mime.restrict_mime_types(self) : mime_types
+      # @api public
+      def format(*formats)
+        if formats.empty?
+          self.formats.values
+        else
+          self.formats.values = formats
+        end
       end
 
-      # @!attribute [rw] default_request_format
-      #
-      #   Sets a format as default fallback for all the requests without a strict
-      #   requirement for the MIME type.
-      #
-      #   The given format must be coercible to a symbol, and be a valid MIME
-      #   type alias. If it isn't, at runtime the framework will raise an
-      #   `Hanami::Action::UnknownFormatError`.
-      #
-      #   By default, this value is nil.
-      #
-      #   @return [Symbol]
-      #
-      #   @see Hanami::Action::Mime
-      #
-      #   @since 0.5.0
-
-      # @!attribute [rw] default_response_format
-      #
-      #   Sets a format to be used for all responses regardless of the request
-      #   type.
-      #
-      #   The given format must be coercible to a symbol, and be a valid MIME
-      #   type alias. If it isn't, at the runtime the framework will raise an
-      #   `Hanami::Action::UnknownFormatError`.
-      #
-      #   By default, this value is nil.
-      #
-      #   @return [Symbol]
-      #
-      #   @see Hanami::Action::Mime
-      #
-      #   @since 0.5.0
-
       # @!attribute [rw] default_charset
       #
       #   Sets a charset (character set) as default fallback for all the requests

data/lib/hanami/action/errors.rb

@@ -21,7 +21,14 @@ module Hanami
       # @since 2.0.0
       # @api private
       def initialize(format)
-        super("Cannot find a corresponding Mime type for '#{format}'. Please configure it with Hanami::Controller::Configuration#format.") # rubocop:disable Layout/LineLength
+        msg =
+          if format.to_s != "" # rubocop:disable Style/NegatedIfElseCondition
+            "Cannot find a corresponding MIME type for format #{format.inspect}. Configure one via `config.formats.add(#{format}: \"MIME_TYPE_HERE\")`." # rubocop:disable Layout/LineLength
+          else
+            "Cannot find a corresponding MIME type for `nil` format."
+          end
+
+        super(msg)
       end
     end
 

data/lib/hanami/action/mime/request_mime_weight.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Action
+    module Mime
+      # @since 1.0.1
+      # @api private
+      class RequestMimeWeight
+        # @since 2.0.0
+        # @api private
+        MIME_SEPARATOR = "/"
+        private_constant :MIME_SEPARATOR
+
+        # @since 2.0.0
+        # @api private
+        MIME_WILDCARD = "*"
+        private_constant :MIME_WILDCARD
+
+        include Comparable
+
+        # @since 1.0.1
+        # @api private
+        attr_reader :quality
+
+        # @since 1.0.1
+        # @api private
+        attr_reader :index
+
+        # @since 1.0.1
+        # @api private
+        attr_reader :mime
+
+        # @since 1.0.1
+        # @api private
+        attr_reader :format
+
+        # @since 1.0.1
+        # @api private
+        attr_reader :priority
+
+        # @since 1.0.1
+        # @api private
+        def initialize(mime, quality, index, format = mime)
+          @quality, @index, @format = quality, index, format
+          calculate_priority(mime)
+        end
+
+        # @since 1.0.1
+        # @api private
+        def <=>(other)
+          return priority <=> other.priority unless priority == other.priority
+
+          other.index <=> index
+        end
+
+        private
+
+        # @since 1.0.1
+        # @api private
+        def calculate_priority(mime)
+          @priority ||= (mime.split(MIME_SEPARATOR, 2).count(MIME_WILDCARD) * -10) + quality
+        end
+      end
+    end
+  end
+end