hanami-controller 1.3.0 → 2.0.0.alpha2

data/lib/hanami/action/application_configuration/cookies.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Action
+    class ApplicationConfiguration
+      # Wrapper for application-level configuration of HTTP cookies for Hanami actions.
+      # This decorates the hash of cookie options that is otherwise directly configurable
+      # on actions, and adds the `enabled?` method to allow `ApplicationAction` to
+      # determine whether to include the `Action::Cookies` module.
+      #
+      # @since 2.0.0
+      class Cookies
+        attr_reader :options
+
+        def initialize(options)
+          @options = options
+        end
+
+        def enabled?
+          !options.nil?
+        end
+
+        def to_h
+          options.to_h
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/application_configuration/sessions.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+require "hanami/utils/string"
+require "hanami/utils/class"
+
+module Hanami
+  class Action
+    class ApplicationConfiguration
+      # Configuration for HTTP sessions in Hanami actions
+      #
+      # @since 2.0.0
+      class Sessions
+        attr_reader :storage, :options
+
+        def initialize(storage = nil, *options)
+          @storage = storage
+          @options = options
+        end
+
+        def enabled?
+          !storage.nil?
+        end
+
+        def middleware
+          return [] if !enabled?
+
+          [[storage_middleware, options]]
+        end
+
+        private
+
+        def storage_middleware
+          require_storage
+
+          name = Utils::String.classify(storage)
+          Utils::Class.load!(name, ::Rack::Session)
+        end
+
+        def require_storage
+          require "rack/session/#{storage}"
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/base_params.rb

@@ -2,7 +2,7 @@ require 'rack/request'
 require 'hanami/utils/hash'
 
 module Hanami
-  module Action
+  class Action
     class BaseParams
       # The key that returns raw input from the Rack env
       #
@@ -173,7 +173,7 @@ module Hanami
       def _router_params(fallback = {})
         env.fetch(ROUTER_PARAMS) do
           if session = fallback.delete(RACK_SESSION) # rubocop:disable Lint/AssignmentInCondition
-            fallback[RACK_SESSION] = Utils::Hash.new(session).symbolize!.to_hash
+            fallback[RACK_SESSION] = Utils::Hash.deep_symbolize(session)
           end
 
           fallback

data/lib/hanami/action/cache.rb

@@ -3,7 +3,7 @@ require 'hanami/action/cache/expires'
 require 'hanami/action/cache/conditional_get'
 
 module Hanami
-  module Action
+  class Action
     # Cache type API
     #
     # @since 0.3.0
@@ -26,144 +26,6 @@ module Hanami
           include CacheControl, Expires
         end
       end
-
-      protected
-
-      # Specify response freshness policy for HTTP caches (Cache-Control header).
-      # Any number of non-value directives (:public, :private, :no_cache,
-      # :no_store, :must_revalidate, :proxy_revalidate) may be passed along with
-      # a Hash of value directives (:max_age, :min_stale, :s_max_age).
-      #
-      # See RFC 2616 / 14.9 for more on standard cache control directives:
-      # http://tools.ietf.org/html/rfc2616#section-14.9.1
-      #
-      # @param values [Array<Symbols, Hash>] mapped to cache_control directives
-      # @option values [Symbol] :public
-      # @option values [Symbol] :private
-      # @option values [Symbol] :no_cache
-      # @option values [Symbol] :no_store
-      # @option values [Symbol] :must_validate
-      # @option values [Symbol] :proxy_revalidate
-      # @option values [Hash] :max_age
-      # @option values [Hash] :min_stale
-      # @option values [Hash] :s_max_age
-      #
-      # @return void
-      #
-      # @since 0.3.0
-      #
-      # @example
-      #   require 'hanami/controller'
-      #   require 'hanami/action/cache'
-      #
-      #   class Show
-      #     include Hanami::Action
-      #     include Hanami::Action::Cache
-      #
-      #     def call(params)
-      #       # ...
-      #
-      #       # set Cache-Control directives
-      #       cache_control :public, max_age: 900, s_maxage: 86400
-      #
-      #       # overwrite previous Cache-Control directives
-      #       cache_control :private, :no_cache, :no_store
-      #
-      #       => Cache-Control: private, no-store, max-age=900
-      #
-      #     end
-      #   end
-      def cache_control(*values)
-        cache_control = CacheControl::Directives.new(*values)
-        headers.merge!(cache_control.headers)
-      end
-
-      # Set the Expires header and Cache-Control/max-age directive. Amount
-      # can be an integer number of seconds in the future or a Time object
-      # indicating when the response should be considered "stale". The remaining
-      # "values" arguments are passed to the #cache_control helper:
-      #
-      # @param amount [Integer,Time] number of seconds or point in time
-      # @param values [Array<Symbols>] mapped to cache_control directives
-      #
-      # @return void
-      #
-      # @since 0.3.0
-      #
-      # @example
-      #   require 'hanami/controller'
-      #   require 'hanami/action/cache'
-      #
-      #   class Show
-      #     include Hanami::Action
-      #     include Hanami::Action::Cache
-      #
-      #     def call(params)
-      #       # ...
-      #
-      #       # set Cache-Control directives and Expires
-      #       expires 900, :public
-      #
-      #       # overwrite Cache-Control directives and Expires
-      #       expires 300, :private, :no_cache, :no_store
-      #
-      #       => Expires: Thu, 26 Jun 2014 12:00:00 GMT
-      #       => Cache-Control: private, no-cache, no-store max-age=300
-      #
-      #     end
-      #   end
-      def expires(amount, *values)
-        expires = Expires::Directives.new(amount, *values)
-        headers.merge!(expires.headers)
-      end
-
-      # Set the etag, last_modified, or both headers on the response
-      # and halts a 304 Not Modified if the request is still fresh
-      # respecting IfNoneMatch and IfModifiedSince request headers
-      #
-      # @param options [Hash]
-      # @option options [Integer] :etag for testing IfNoneMatch conditions
-      # @option options [Date] :last_modified for testing IfModifiedSince conditions
-      #
-      # @return void
-      #
-      # @since 0.3.0
-      #
-      # @example
-      #   require 'hanami/controller'
-      #   require 'hanami/action/cache'
-      #
-      #   class Show
-      #     include Hanami::Action
-      #     include Hanami::Action::Cache
-      #
-      #     def call(params)
-      #       # ...
-      #
-      #       # set etag response header and halt 304
-      #       # if request matches IF_NONE_MATCH header
-      #       fresh etag: @resource.updated_at.to_i
-      #
-      #       # set last_modified response header and halt 304
-      #       # if request matches IF_MODIFIED_SINCE
-      #       fresh last_modified: @resource.updated_at
-      #
-      #       # set etag and last_modified response header,
-      #       # halt 304 if request matches IF_MODIFIED_SINCE
-      #       # and IF_NONE_MATCH
-      #       fresh last_modified: @resource.updated_at
-      #
-      #     end
-      #   end
-      def fresh(options)
-        conditional_get = ConditionalGet.new(@_env, options)
-
-        headers.merge!(conditional_get.headers)
-
-        conditional_get.fresh? do
-          halt 304
-        end
-      end
     end
   end
 end

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

@@ -1,7 +1,7 @@
 require 'hanami/action/cache/directives'
 
 module Hanami
-  module Action
+  class Action
     module Cache
       # Module with Cache-Control logic
       #
@@ -37,7 +37,7 @@ module Hanami
           def cache_control_directives
             @cache_control_directives || Object.new.tap do |null_object|
               def null_object.headers
-                Hash.new
+                ::Hash.new
               end
             end
           end
@@ -49,9 +49,9 @@ module Hanami
         # @api private
         #
         # @see Hanami::Action#finish
-        def finish
+        def finish(_, res, _)
+          res.headers.merge!(self.class.cache_control_directives.headers) unless res.headers.include? HEADER
           super
-          headers.merge!(self.class.cache_control_directives.headers) unless headers.include? HEADER
         end
 
         # Class which stores CacheControl values

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

@@ -1,5 +1,7 @@
+require "hanami/utils/blank"
+
 module Hanami
-  module Action
+  class Action
     module Cache
       # @since 0.3.0
       # @api private
@@ -67,7 +69,10 @@ module Hanami
         # @since 0.3.0
         # @api private
         def fresh?
-          !Hanami::Utils::Blank.blank?(modified_since) && Time.httpdate(modified_since).to_i >= @value.to_time.to_i
+          return false if Hanami::Utils::Blank.blank?(modified_since)
+          return false if Hanami::Utils::Blank.blank?(@value)
+
+          Time.httpdate(modified_since).to_i >= @value.to_time.to_i
         end
 
         # @since 0.3.0

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

@@ -1,5 +1,5 @@
 module Hanami
-  module Action
+  class Action
     module Cache
       # Cache-Control directives which have values
       #

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

@@ -1,7 +1,7 @@
 require 'hanami/action/cache/cache_control'
 
 module Hanami
-  module Action
+  class Action
     module Cache
       # Module with Expires logic
       #
@@ -49,9 +49,9 @@ module Hanami
         # @api private
         #
         # @see Hanami::Action#finish
-        def finish
+        def finish(_, res, _)
+          res.headers.merge!(self.class.expires_directives.headers) unless res.headers.include? HEADER
           super
-          headers.merge!(self.class.expires_directives.headers) unless headers.include? HEADER
         end
 
         # Class which stores Expires directives

data/lib/hanami/action/configuration.rb

@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/utils/kernel"
+require "pathname"
+require_relative "mime"
+
+module Hanami
+  class Action
+    class Configuration
+      include Dry::Configurable
+
+      # Initialize the Configuration
+      #
+      # @yield [config] the configuration object
+      #
+      # @return [Configuration]
+      #
+      # @since 2.0.0
+      # @api private
+      def initialize(*)
+        super
+        yield self if block_given?
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        self.class.settings
+      end
+
+      # @!method handled_exceptions=(exceptions)
+      #
+      #   Specifies how to handle exceptions with an HTTP status
+      #
+      #   Raised exceptions will return the corresponding HTTP status
+      #
+      #   @param exceptions [Hash{Exception=>Integer}] exception classes as
+      #     keys and HTTP statuses as values
+      #
+      #   @return [void]
+      #
+      #   @since 0.2.0
+      #
+      #   @example
+      #     configuration.handled_exceptions = {ArgumentError => 400}
+      #
+      # @!method handled_exceptions
+      #
+      #   Returns the configured handled exceptions
+      #
+      #   @return [Hash{Exception=>Integer}]
+      #
+      #   @see handled_exceptions=
+      #
+      #   @since 0.2.0
+      setting :handled_exceptions, {}
+
+      # Specifies how to handle exceptions with an HTTP status
+      #
+      # Raised exceptions will return the corresponding HTTP status
+      #
+      # The specified exceptions will be merged with any previously configured
+      # exceptions
+      #
+      # @param exceptions [Hash{Exception=>Integer}] exception classes as keys
+      #   and HTTP statuses as values
+      #
+      # @return [void]
+      #
+      # @since 0.2.0
+      #
+      # @see handled_exceptions=
+      #
+      # @example
+      #   configuration.handle_exceptions(ArgumentError => 400}
+      def handle_exception(exceptions)
+        self.handled_exceptions = handled_exceptions
+          .merge(exceptions)
+          .sort { |(ex1, _), (ex2, _)| ex1.ancestors.include?(ex2) ? -1 : 1 }
+          .to_h
+      end
+
+      # Default MIME type to format mapping
+      #
+      # @since 0.2.0
+      # @api private
+      DEFAULT_FORMATS = {
+        'application/octet-stream' => :all,
+        '*/*'                      => :all,
+        'text/html'                => :html
+      }.freeze
+
+      # @!method formats=(formats)
+      #
+      #   Specifies the MIME type to format mapping
+      #
+      #   @param formats [Hash{String=>Symbol}] MIME type strings as keys and
+      #     format symbols as values
+      #
+      #   @return [void]
+      #
+      #   @since 0.2.0
+      #
+      #   @see format
+      #   @see Hanami::Action::Mime
+      #
+      #   @example
+      #     configuration.formats = {"text/html" => :html}
+      #
+      # @!method formats
+      #
+      #   Returns the configured MIME type to format mapping
+      #
+      #   @return [Symbol,nil] the corresponding format, if present
+      #
+      #   @see format
+      #   @see formats=
+      #
+      #   @since 0.2.0
+      setting :formats, DEFAULT_FORMATS.dup
+
+      # Registers a MIME type to format mapping
+      #
+      # @param hash [Hash{Symbol=>String}] format symbols as keys and the MIME
+      #   type strings must as values
+      #
+      # @return [void]
+      #
+      # @since 0.2.0
+      #
+      # @see Hanami::Action::Mime
+      #
+      # @example configuration.format html: "text/html"
+      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
+      #
+      # @since 0.8.0
+      #
+      # @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 [String,nil] the corresponding MIME type, if present
+      #
+      # @since 0.2.0
+      # @api private
+      def mime_type_for(format)
+        formats.key(format)
+      end
+
+      # @!method default_request_format=(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.
+      #
+      #   @param format [Symbol]
+      #
+      #   @return [void]
+      #
+      #   @since 0.5.0
+      #
+      #   @see Hanami::Action::Mime
+      #
+      # @!method default_request_format
+      #
+      #   Returns the configured default request format
+      #
+      #   @return [Symbol] format
+      #
+      #   @see default_request_format=
+      #
+      #   @since 0.5.0
+      setting :default_request_format do |format|
+        Utils::Kernel.Symbol(format) unless format.nil?
+      end
+
+      # @!method default_response_format=(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.
+      #
+      #   @param format [Symbol]
+      #
+      #   @return [void]
+      #
+      #   @since 0.5.0
+      #
+      #   @see Hanami::Action::Mime
+      #
+      # @!method default_response_format
+      #
+      #   Returns the configured default response format
+      #
+      #   @return [Symbol] format
+      #
+      #   @see default_request_format=
+      #
+      #   @since 0.5.0
+      setting :default_response_format do |format|
+        Utils::Kernel.Symbol(format) unless format.nil?
+      end
+
+      # @!method default_charset=(charset)
+      #
+      #   Sets a charset (character set) as default fallback for all the requests
+      #   without a strict requirement for the charset.
+      #
+      #   By default, this value is nil.
+      #
+      #   @param charset [String]
+      #
+      #   @return [void]
+      #
+      #   @since 0.3.0
+      #
+      #   @see Hanami::Action::Mime
+      #
+      # @!method default_charset
+      #
+      #   Returns the configured default charset.
+      #
+      #   @return [String,nil] the charset, if present
+      #
+      #   @see default_charset=
+      #
+      #   @since 0.3.0
+      setting :default_charset
+
+      # @!method default_headers=(headers)
+      #
+      #   Sets default headers for all responses.
+      #
+      #   By default, this is an empty hash.
+      #
+      #   @param headers [Hash{String=>String}] the headers
+      #
+      #   @return [void]
+      #
+      #   @since 0.4.0
+      #
+      #   @see default_headers
+      #
+      #   @example
+      #     configuration.default_headers = {'X-Frame-Options' => 'DENY'}
+      #
+      # @!method default_headers
+      #
+      #   Returns the configured headers
+      #
+      #   @return [Hash{String=>String}] the headers
+      #
+      #   @since 0.4.0
+      #
+      #   @see default_headers=
+      setting :default_headers, {} do |headers|
+        headers.compact
+      end
+
+      # @!method cookies=(cookie_options)
+      #
+      #   Sets default cookie options for all responses.
+      #
+      #   By default this, is an empty hash.
+      #
+      #   @param cookie_options [Hash{Symbol=>String}] the cookie options
+      #
+      #   @return [void]
+      #
+      #   @since 0.4.0
+      #
+      #   @example
+      #     configuration.cookies = {
+      #       domain: 'hanamirb.org',
+      #       path: '/controller',
+      #       secure: true,
+      #       httponly: true
+      #     }
+      #
+      # @!method cookies
+      #
+      #   Returns the configured cookie options
+      #
+      #   @return [Hash{Symbol=>String}]
+      #
+      #   @since 0.4.0
+      #
+      #   @see cookies=
+      setting :cookies, {} do |cookie_options|
+        # Call `to_h` here to permit `ApplicationConfiguration::Cookies` object to be
+        # provided when application actions are configured
+        cookie_options.to_h.compact
+      end
+
+      # @!method root_directory=(dir)
+      #
+      #   Sets the the for the public directory, which is used for file downloads.
+      #   This must be an existent directory.
+      #
+      #   Defaults to the current working directory.
+      #
+      #   @param dir [String] the directory path
+      #
+      #   @return [void]
+      #
+      #   @since 1.0.0
+      #
+      #   @api private
+      #
+      # @!method root_directory
+      #
+      #   Returns the configured root directory
+      #
+      #   @return [String] the directory path
+      #
+      #   @see root_directory=
+      #
+      #   @since 1.0.0
+      #
+      #   @api private
+      setting :root_directory do |dir|
+        dir ||= Dir.pwd
+
+        Pathname(dir).realpath
+      end
+
+      # Default public directory
+      #
+      # This serves as the root directory for file downloads
+      #
+      # @since 1.0.0
+      #
+      # @api private
+      DEFAULT_PUBLIC_DIRECTORY = 'public'.freeze
+
+      # @!method public_directory=(directory)
+      #
+      #   Sets the path to public directory. This directory is used for file downloads.
+      #
+      #   This given directory will be appended onto the root directory.
+      #
+      #   By default, the public directory is "public".
+      #
+      #   @param directory [String] the public directory path
+      #
+      #   @return [void]
+      #
+      #   @see root_directory
+      #   @see public_directory
+      setting :public_directory, DEFAULT_PUBLIC_DIRECTORY
+
+      # Returns the configured public directory, appended onto the root directory.
+      #
+      # @return [String] the fill directory path
+      #
+      # @example
+      #   configuration.public_directory = "public"
+      #
+      #   configuration.public_directory
+      #   # => "/path/to/root/public"
+      #
+      # @see public_directory=
+      # @see root_directory=
+      def public_directory
+        # This must be a string, for Rack compatibility
+        root_directory.join(super).to_s
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end