hanami-controller 2.0.0.beta4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a363029b7df3ddc560e2975862f72548788a2a2910c2d32519f073556b4bfbb2
-  data.tar.gz: e7d67505e3b0161a656d24e1ff634bd02c11d4fad1e217a1ee482271be6dbbd9
+  metadata.gz: '03586fe42cbe2496c8433bb50cf8b176d1edd75ecd2848d89e28e9d6b2cd735e'
+  data.tar.gz: 3a5e3a900db6918d9c3f74e49509efb5e33afcf9843ac76aa837fa193f6eb748
 SHA512:
-  metadata.gz: 0a9aeb4ea44db1fe6f137dee8f3e5e05bda318a8c53f1f57c30204a0077b5dcfd82aefab569fd7169c2c728de2331fcaa52f1fcdec2e3adb6d4679c38791edf6
-  data.tar.gz: 726de07b87cd8055da9973ea0365c00bde1f8808a1593ef3830051e196c722f001f6dc13615182f067542c605c9437259d1d36028031867edf3abd8d9612e817
+  metadata.gz: de6142be19fc0a9d18e8a27260ab94729d2103f72589e9c36db8226d9cf9bb19b9cec9193e0c7e00659afd5f8aee775abda2af0ed21e1962315d77c6b789bd89
+  data.tar.gz: 98927780e4bfd2e31de03b3d2bb01441aad6405743ff68991d80a76c92647191bd929e2a345554cf5146097cf3dd222717451b7f93d326cf0fb49ef5ce7905f8

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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
+
+- [Tim Riley] Simplify assignment of response format: `response.format = :json` (was `response.format = format(:json)`)
+
 ## v2.0.0.beta4 - 2022-10-24
 
 ### Added

data/README.md

@@ -744,7 +744,7 @@ However, you can force this value:
 class Show < Hanami::Action
   def handle(*, res)
     # ...
-    res.format = format(:json)
+    res.format = :json
   end
 end
 
@@ -820,7 +820,7 @@ response.format                                                   # => :custom
 class Show < Hanami::Action
   def handle(*, res)
     # ...
-    res.format = format(:custom)
+    res.format = :custom
   end
 end
 
@@ -841,7 +841,7 @@ end
 
 class Csv < Hanami::Action
   def handle(*, res)
-    res.format = format(:csv)
+    res.format = :csv
     res.body = Enumerator.new do |yielder|
       yielder << csv_header
 
@@ -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.beta"
-  spec.add_dependency "dry-configurable", "~> 0.13", ">= 0.13.0"
+  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/base_params.rb

@@ -5,6 +5,19 @@ require "hanami/utils/hash"
 
 module Hanami
   class Action
+    # Provides access to params included in a Rack request.
+    #
+    # Offers useful access to params via methods like {#[]}, {#get} and {#to_h}.
+    #
+    # These params are available via {Request#params}.
+    #
+    # This class is used by default when {Hanami::Action::Validatable} is not included, or when no
+    # {Validatable::ClassMethods#params params} validation schema is defined.
+    #
+    # @see Hanami::Action::Request#params
+    #
+    # @api private
+    # @since 0.7.0
     class BaseParams
       # @attr_reader env [Hash] the Rack env
       #
@@ -18,12 +31,10 @@ module Hanami
       # @api private
       attr_reader :raw
 
-      # Initialize the params and freeze them.
+      # Returns a new frozen params object for the Rack env.
       #
       # @param env [Hash] a Rack env or an hash of params.
       #
-      # @return [Params]
-      #
       # @since 0.7.0
       # @api private
       def initialize(env)
@@ -33,26 +44,27 @@ module Hanami
         freeze
       end
 
-      # Returns the object associated with the given key
+      # Returns the value for the given params key.
       #
       # @param key [Symbol] the key
       #
-      # @return [Object,nil] return the associated object, if found
+      # @return [Object,nil] the associated value, if found
       #
       # @since 0.7.0
+      # @api public
       def [](key)
         @params[key]
       end
 
-      # Get an attribute value associated with the given key.
-      # Nested attributes are reached by listing all the keys to get to the value.
+      # Returns an value associated with the given params key.
+      #
+      # You can access nested attributes by listing all the keys in the path. This uses the same key
+      # path semantics as `Hash#dig`.
       #
       # @param keys [Array<Symbol,Integer>] the key
       #
       # @return [Object,NilClass] return the associated value, if found
       #
-      # @since 0.7.0
-      #
       # @example
       #   require "hanami/controller"
       #
@@ -73,6 +85,9 @@ module Hanami
       #       end
       #     end
       #   end
+      #
+      # @since 0.7.0
+      # @api public
       def get(*keys)
         @params.dig(*keys)
       end
@@ -83,32 +98,40 @@ module Hanami
       # @since 0.8.0
       alias_method :dig, :get
 
-      # Provide a common interface with Params
+      # Returns true at all times, providing a common interface with {Params}.
       #
       # @return [TrueClass] always returns true
       #
-      # @since 0.7.0
-      #
       # @see Hanami::Action::Params#valid?
+      #
+      # @api public
+      # @since 0.7.0
       def valid?
         true
       end
 
-      # Serialize params to Hash
+      # Returns a hash of the parsed request params.
       #
-      # @return [::Hash]
+      # @return [Hash]
       #
       # @since 0.7.0
+      # @api public
       def to_h
         @params
       end
       alias_method :to_hash, :to_h
 
-      # Iterates through params
+      # Iterates over the params.
+      #
+      # Calls the given block with each param key-value pair; returns the full hash of params.
+      #
+      # @yieldparam key [Symbol]
+      # @yieldparam value [Object]
       #
-      # @param blk [Proc]
+      # @return [to_h]
       #
       # @since 0.7.1
+      # @api public
       def each(&blk)
         to_h.each(&blk)
       end

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,21 +1,16 @@
 # frozen_string_literal: true
 
 require "dry/configurable"
-require_relative "mime"
 
 module Hanami
   class Action
+    # Config for `Hanami::Action` classes.
+    #
+    # @see Hanami::Action.config
+    #
+    # @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
@@ -63,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::Controller::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::Controller::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/constants.rb

@@ -116,12 +116,6 @@ module Hanami
     # @api private
     HTTP_ACCEPT = "HTTP_ACCEPT"
 
-    # The header key to set the mime type of the response
-    #
-    # @since 0.1.0
-    # @api private
-    CONTENT_TYPE = ::Rack::CONTENT_TYPE
-
     # The default mime type for an incoming HTTP request
     #
     # @since 0.1.0

data/lib/hanami/action/csrf_protection.rb

@@ -1,19 +1,13 @@
 # frozen_string_literal: true
 
 require "hanami/utils/blank"
-require "hanami/controller/error"
 require "rack/utils"
 require "securerandom"
+require_relative "errors"
 
 module Hanami
   # @api private
   class Action
-    # Invalid CSRF Token
-    #
-    # @since 0.4.0
-    class InvalidCSRFTokenError < Controller::Error
-    end
-
     # CSRF Protection
     #
     # This security mechanism is enabled automatically if sessions are turned on.