hanami-controller 2.0.0.beta1 → 2.0.0.rc1

data/lib/hanami/action.rb

@@ -1,12 +1,14 @@
 # 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 "hanami/utils/class_attribute"
+require "dry/configurable"
 require "hanami/utils/callbacks"
 require "hanami/utils"
 require "hanami/utils/string"
@@ -14,14 +16,15 @@ require "hanami/utils/kernel"
 require "rack"
 require "rack/utils"
 
+require_relative "action/config"
 require_relative "action/constants"
 require_relative "action/base_params"
-require_relative "action/configuration"
 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
   # An HTTP endpoint
@@ -36,7 +39,52 @@ module Hanami
   #       # ...
   #     end
   #   end
+  #
+  # @api public
   class Action
+    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 :default_charset
+    setting :default_headers, default: {}, constructor: -> (headers) { headers.compact }
+    setting :cookies, default: {}, constructor: -> (cookie_options) {
+      # Call `to_h` here to permit `ApplicationConfiguration::Cookies` object to be
+      # provided when application actions are configured
+      cookie_options.to_h.compact
+    }
+    setting :root_directory, constructor: -> (dir) {
+      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
+
+    # @!scope class
+
+    # @!method config
+    #   Returns the action's config. Use this to configure your action.
+    #
+    #   @example Access inside class body
+    #     class Show < Hanami::Action
+    #       config.default_response_format = :json
+    #     end
+    #
+    #   @return [Config]
+    #
+    #   @api public
+    #   @since 2.0.0
+
+    # @!scope instance
+
     # Override Ruby's hook for modules.
     # It includes basic Hanami::Action modules to the given class.
     #
@@ -49,31 +97,13 @@ module Hanami
 
       if subclass.superclass == Action
         subclass.class_eval do
-          include Utils::ClassAttribute
-
-          class_attribute :before_callbacks
-          self.before_callbacks = Utils::Callbacks::Chain.new
-
-          class_attribute :after_callbacks
-          self.after_callbacks = Utils::Callbacks::Chain.new
-
           include Validatable if defined?(Validatable)
         end
       end
 
-      subclass.instance_variable_set "@configuration", configuration.dup
-    end
-
-    # @since 2.0.0
-    # @api private
-    def self.configuration
-      @configuration ||= Configuration.new
-    end
-
-    class << self
-      # @since 2.0.0
-      # @api private
-      alias_method :config, :configuration
+      if instance_variable_defined?(:@params_class)
+        subclass.instance_variable_set(:@params_class, @params_class)
+      end
     end
 
     # Returns the class which defines the params
@@ -87,12 +117,7 @@ module Hanami
     # @api private
     # @since 0.7.0
     def self.params_class
-      @params_class ||= BaseParams
-    end
-
-    # FIXME: make this thread-safe
-    def self.accepted_formats
-      @accepted_formats ||= []
+      @params_class || BaseParams
     end
 
     # Placeholder implementation for params class method
@@ -101,73 +126,74 @@ module Hanami
     #
     # @raise [NoMethodError]
     #
-    # @api private
+    # @api public
     # @since 2.0.0
     def self.params(_klass = nil)
       raise NoMethodError,
             "To use `params`, please add 'hanami/validations' gem to your Gemfile"
     end
 
-    # Define a callback for an Action.
-    # The callback will be executed **before** the action is called, in the
-    # order they are added.
+    # @overload self.append_before(*callbacks, &block)
+    #   Define a callback for an Action.
+    #   The callback will be executed **before** the action is called, in the
+    #   order they are added.
     #
-    # @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
-    #   each of them is representing a name of a method available in the
-    #   context of the Action.
+    #   @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
+    #     each of them is representing a name of a method available in the
+    #     context of the Action.
     #
-    # @param blk [Proc] an anonymous function to be executed
+    #   @param blk [Proc] an anonymous function to be executed
     #
-    # @return [void]
+    #   @return [void]
     #
-    # @since 0.3.2
+    #   @since 0.3.2
     #
-    # @see Hanami::Action::Callbacks::ClassMethods#append_after
+    #   @see Hanami::Action::Callbacks::ClassMethods#append_after
     #
-    # @example Method names (symbols)
-    #   require "hanami/controller"
+    #   @example Method names (symbols)
+    #     require "hanami/controller"
     #
-    #   class Show < Hanami::Action
-    #     before :authenticate, :set_article
+    #     class Show < Hanami::Action
+    #       before :authenticate, :set_article
     #
-    #     def handle(req, res)
-    #     end
+    #       def handle(req, res)
+    #       end
     #
-    #     private
-    #     def authenticate
-    #       # ...
-    #     end
+    #       private
+    #       def authenticate
+    #         # ...
+    #       end
     #
-    #     # `params` in the method signature is optional
-    #     def set_article(params)
-    #       @article = Article.find params[:id]
+    #       # `params` in the method signature is optional
+    #       def set_article(params)
+    #         @article = Article.find params[:id]
+    #       end
     #     end
-    #   end
     #
-    #   # The order of execution will be:
-    #   #
-    #   # 1. #authenticate
-    #   # 2. #set_article
-    #   # 3. #call
+    #     # The order of execution will be:
+    #     #
+    #     # 1. #authenticate
+    #     # 2. #set_article
+    #     # 3. #call
     #
-    # @example Anonymous functions (Procs)
-    #   require "hanami/controller"
+    #   @example Anonymous functions (Procs)
+    #     require "hanami/controller"
     #
-    #   class Show < Hanami::Action
-    #     before { ... } # 1 do some authentication stuff
-    #     before {|req, res| @article = Article.find params[:id] } # 2
+    #     class Show < Hanami::Action
+    #       before { ... } # 1 do some authentication stuff
+    #       before {|req, res| @article = Article.find params[:id] } # 2
     #
-    #     def handle(req, res)
+    #       def handle(req, res)
+    #       end
     #     end
-    #   end
     #
-    #   # The order of execution will be:
-    #   #
-    #   # 1. authentication
-    #   # 2. set the article
-    #   # 3. `#handle`
+    #     # The order of execution will be:
+    #     #
+    #     # 1. authentication
+    #     # 2. set the article
+    #     # 3. `#handle`
     def self.append_before(...)
-      before_callbacks.append(...)
+      config.before_callbacks.append(...)
     end
 
     class << self
@@ -175,23 +201,24 @@ module Hanami
       alias_method :before, :append_before
     end
 
-    # Define a callback for an Action.
-    # The callback will be executed **after** the action is called, in the
-    # order they are added.
+    # @overload self.append_after(*callbacks, &block)
+    #   Define a callback for an Action.
+    #   The callback will be executed **after** the action is called, in the
+    #   order they are added.
     #
-    # @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
-    #   each of them is representing a name of a method available in the
-    #   context of the Action.
+    #   @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
+    #     each of them is representing a name of a method available in the
+    #     context of the Action.
     #
-    # @param blk [Proc] an anonymous function to be executed
+    #   @param blk [Proc] an anonymous function to be executed
     #
-    # @return [void]
+    #   @return [void]
     #
-    # @since 0.3.2
+    #   @since 0.3.2
     #
-    # @see Hanami::Action::Callbacks::ClassMethods#append_before
+    #   @see Hanami::Action::Callbacks::ClassMethods#append_before
     def self.append_after(...)
-      after_callbacks.append(...)
+      config.after_callbacks.append(...)
     end
 
     class << self
@@ -199,54 +226,56 @@ module Hanami
       alias_method :after, :append_after
     end
 
-    # Define a callback for an Action.
-    # The callback will be executed **before** the action is called.
-    # It will add the callback at the beginning of the callbacks' chain.
+    # @overload self.prepend_before(*callbacks, &block)
+    #   Define a callback for an Action.
+    #   The callback will be executed **before** the action is called.
+    #   It will add the callback at the beginning of the callbacks' chain.
     #
-    # @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
-    #   each of them is representing a name of a method available in the
-    #   context of the Action.
+    #   @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
+    #     each of them is representing a name of a method available in the
+    #     context of the Action.
     #
-    # @param blk [Proc] an anonymous function to be executed
+    #   @param blk [Proc] an anonymous function to be executed
     #
-    # @return [void]
+    #   @return [void]
     #
-    # @since 0.3.2
+    #   @since 0.3.2
     #
-    # @see Hanami::Action::Callbacks::ClassMethods#prepend_after
+    #   @see Hanami::Action::Callbacks::ClassMethods#prepend_after
     def self.prepend_before(...)
-      before_callbacks.prepend(...)
+      config.before_callbacks.prepend(...)
     end
 
-    # Define a callback for an Action.
-    # The callback will be executed **after** the action is called.
-    # It will add the callback at the beginning of the callbacks' chain.
+    # @overload self.prepend_after(*callbacks, &block)
+    #   Define a callback for an Action.
+    #   The callback will be executed **after** the action is called.
+    #   It will add the callback at the beginning of the callbacks' chain.
     #
-    # @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
-    #   each of them is representing a name of a method available in the
-    #   context of the Action.
+    #   @param callbacks [Symbol, Array<Symbol>] a single or multiple symbol(s)
+    #     each of them is representing a name of a method available in the
+    #     context of the Action.
     #
-    # @param blk [Proc] an anonymous function to be executed
+    #   @param blk [Proc] an anonymous function to be executed
     #
-    # @return [void]
+    #   @return [void]
     #
-    # @since 0.3.2
+    #   @since 0.3.2
     #
-    # @see Hanami::Action::Callbacks::ClassMethods#prepend_before
+    #   @see Hanami::Action::Callbacks::ClassMethods#prepend_before
     def self.prepend_after(...)
-      after_callbacks.prepend(...)
+      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::Controller::UnknownFormatError] if the symbol cannot
+    # @raise [Hanami::Action::UnknownFormatError] if the symbol cannot
     #   be converted into a mime type
     #
     # @since 0.1.0
     #
-    # @see Hanami::Action::Configuration#format
+    # @see Config#format
     #
     # @example
     #   require "hanami/controller"
@@ -262,58 +291,28 @@ module Hanami
     #   # When called with "*/*"              => 200
     #   # When called with "text/html"        => 200
     #   # When called with "application/json" => 200
-    #   # When called with "application/xml"  => 406
+    #   # When called with "application/xml"  => 415
     def self.accept(*formats)
-      @accepted_formats = *formats
-      before :enforce_accepted_mime_types
+      config.accepted_formats = formats
     end
 
-    # Returns a new action
-    #
-    # @overload new(**deps, ...)
-    #   @param deps [Hash] action dependencies
-    #
-    # @overload new(configuration:, **deps, ...)
-    #   @param configuration [Hanami::Action::Configuration] action configuration
-    #   @param deps [Hash] action dependencies
-    #
-    # @return [Hanami::Action] Action object
+    # @see Config#handle_exception
     #
     # @since 2.0.0
-    def self.new(*args, configuration: self.configuration, **kwargs, &block)
-      allocate.tap do |obj|
-        obj.instance_variable_set(:@name, Name[name])
-        obj.instance_variable_set(:@configuration, configuration.dup.finalize!)
-        obj.instance_variable_set(:@accepted_mime_types, Mime.restrict_mime_types(configuration, accepted_formats))
-        obj.send(:initialize, *args, **kwargs, &block)
-        obj.freeze
-      end
+    # @api public
+    def self.handle_exception(...)
+      config.handle_exception(...)
     end
 
+    # Returns a new action
+    #
     # @since 2.0.0
-    # @api private
-    module Name
-      # @since 2.0.0
-      # @api private
-      MODULE_SEPARATOR_TRANSFORMER = [:gsub, "::", "."].freeze
-
-      # @since 2.0.0
-      # @api private
-      def self.call(name)
-        Utils::String.transform(name, MODULE_SEPARATOR_TRANSFORMER, :underscore) unless name.nil?
-      end
-
-      class << self
-        # @since 2.0.0
-        # @api private
-        alias_method :[], :call
-      end
+    # @api public
+    def initialize(config: self.class.config)
+      @config = config
+      freeze
     end
 
-    # @since 2.0.0
-    # @api private
-    attr_reader :name
-
     # Implements the Rack/Hanami::Action protocol
     #
     # @since 0.1.0
@@ -324,16 +323,22 @@ module Hanami
 
       halted = catch :halt do
         params   = self.class.params_class.new(env)
-        request  = build_request(env, params)
+        request  = build_request(
+          env: env,
+          params: params,
+          sessions_enabled: sessions_enabled?
+        )
         response = build_response(
           request: request,
-          action: name,
-          configuration: configuration,
-          content_type: Mime.calculate_content_type_with_charset(configuration, request, accepted_mime_types),
+          config: config,
+          content_type: Mime.calculate_content_type_with_charset(config, request, config.accepted_mime_types),
           env: env,
-          headers: configuration.default_headers
+          headers: config.default_headers,
+          sessions_enabled: sessions_enabled?
         )
 
+        enforce_accepted_mime_types(request)
+
         _run_before_callbacks(request, response)
         handle(request, response)
         _run_after_callbacks(request, response)
@@ -344,12 +349,6 @@ module Hanami
       finish(request, response, halted)
     end
 
-    # @since 2.0.0
-    # @api public
-    def initialize(**deps)
-      @_deps = deps
-    end
-
     protected
 
     # Hook for subclasses to apply behavior as part of action invocation
@@ -421,36 +420,44 @@ module Hanami
 
     # @since 2.0.0
     # @api private
-    attr_reader :configuration
+    attr_reader :config
 
     # @since 2.0.0
     # @api private
-    def accepted_mime_types
-      @accepted_mime_types || configuration.mime_types
-    end
+    def enforce_accepted_mime_types(request)
+      return if config.accepted_formats.empty?
 
-    # @since 2.0.0
-    # @api private
-    def enforce_accepted_mime_types(req, *)
-      Mime.accepted_mime_type?(req, accepted_mime_types, configuration) or halt 406
+      Mime.enforce_accept(request, config) { return halt 406 }
+      Mime.enforce_content_type(request, config) { return halt 415 }
     end
 
     # @since 2.0.0
     # @api private
     def exception_handler(exception)
-      configuration.handled_exceptions.each do |exception_class, handler|
+      config.handled_exceptions.each do |exception_class, handler|
         return handler if exception.is_a?(exception_class)
       end
 
       nil
     end
 
+    # @see Session#sessions_enabled?
+    # @since 2.0.0
+    # @api private
+    def sessions_enabled?
+      false
+    end
+
+    # Hook to be overridden by `Hanami::Extensions::Action` for integrated actions
+    #
     # @since 2.0.0
     # @api private
-    def build_request(env, params)
-      Request.new(env, params)
+    def build_request(**options)
+      Request.new(**options)
     end
 
+    # Hook to be overridden by `Hanami::Extensions::Action` for integrated actions
+    #
     # @since 2.0.0
     # @api private
     def build_response(**options)
@@ -507,14 +514,14 @@ module Hanami
     # @since 0.1.0
     # @api private
     def _run_before_callbacks(*args)
-      self.class.before_callbacks.run(self, *args)
+      config.before_callbacks.run(self, *args)
       nil
     end
 
     # @since 0.1.0
     # @api private
     def _run_after_callbacks(*args)
-      self.class.after_callbacks.run(self, *args)
+      config.after_callbacks.run(self, *args)
       nil
     end
 
@@ -583,20 +590,6 @@ module Hanami
       res.body = Response::EMPTY_BODY
     end
 
-    # @since 2.0.0
-    # @api private
-    def format(value)
-      case value
-      when Symbol
-        format = Utils::Kernel.Symbol(value)
-        [format, Action::Mime.format_to_mime_type(format, configuration)]
-      when String
-        [Action::Mime.detect_format(value, configuration), value]
-      else
-        raise Hanami::Controller::UnknownFormatError.new(value)
-      end
-    end
-
     # Finalize the response
     #
     # Prepare the data before the response will be returned to the webserver
@@ -614,7 +607,7 @@ module Hanami
       _empty_headers(res) if _requires_empty_headers?(res)
       _empty_body(res) if res.head?
 
-      res.set_format(Action::Mime.detect_format(res.content_type, configuration))
+      res.set_format(Action::Mime.detect_format(res.content_type, config))
       res[:params] = req.params
       res[:format] = res.format
       res

data/lib/hanami/controller/version.rb

@@ -2,9 +2,7 @@
 
 module Hanami
   module Controller
-    # Defines the version
-    #
-    # @since 0.1.0
-    VERSION = "2.0.0.beta1"
+    # @api public
+    VERSION = "2.0.0.rc1"
   end
 end

data/lib/hanami/controller.rb

@@ -2,7 +2,6 @@
 
 require "hanami/action"
 require "hanami/controller/version"
-require "hanami/controller/error"
 
 # Hanami
 #
@@ -27,20 +26,5 @@ module Hanami
   #     end
   #   end
   module Controller
-    # Unknown format error
-    #
-    # This error is raised when a action sets a format that it isn't recognized
-    # both by `Hanami::Action::Configuration` and the list of Rack mime types
-    #
-    # @since 0.2.0
-    #
-    # @see Hanami::Action::Mime#format=
-    class UnknownFormatError < Hanami::Controller::Error
-      # @since 0.2.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
-      end
-    end
   end
 end

data/lib/hanami/http/status.rb

@@ -3,6 +3,8 @@
 require "rack/utils"
 
 module Hanami
+  # @since 0.1.0
+  # @api private
   module Http
     # An HTTP status
     #