hanami-controller 1.3.3 → 2.0.0.alpha4

data/lib/hanami/action/request.rb

@@ -1,7 +1,8 @@
 require 'rack/request'
+require 'securerandom'
 
 module Hanami
-  module Action
+  class Action
     # An HTTP request based on top of Rack::Request.
     # This guarantees backwards compatibility with with Rack.
     #
@@ -9,36 +10,45 @@ module Hanami
     #
     # @see http://www.rubydoc.info/gems/rack/Rack/Request
     class Request < ::Rack::Request
-      # @raise [NotImplementedError]
-      #
-      # @since 0.3.1
-      # @api private
-      def content_type
-        raise NotImplementedError, 'Please use Action#content_type'
+      HTTP_ACCEPT = "HTTP_ACCEPT".freeze
+      REQUEST_ID  = "hanami.request_id".freeze
+      DEFAULT_ACCEPT = "*/*".freeze
+      DEFAULT_ID_LENGTH = 16
+
+      attr_reader :params
+
+      def initialize(env, params)
+        super(env)
+        @params = params
       end
 
-      # @raise [NotImplementedError]
-      #
-      # @since 0.3.1
-      # @api private
-      def session
-        raise NotImplementedError, 'Please include Action::Session and use Action#session'
+      def id
+        # FIXME make this number configurable and document the probabilities of clashes
+        @id ||= @env[REQUEST_ID] = SecureRandom.hex(DEFAULT_ID_LENGTH)
       end
 
-      # @raise [NotImplementedError]
-      #
-      # @since 0.3.1
+      def accept?(mime_type)
+        !!::Rack::Utils.q_values(accept).find do |mime, _|
+          ::Rack::Mime.match?(mime_type, mime)
+        end
+      end
+
+      def accept_header?
+        accept != DEFAULT_ACCEPT
+      end
+
+      # @since 0.1.0
       # @api private
-      def cookies
-        raise NotImplementedError, 'Please include Action::Cookies and use Action#cookies'
+      def accept
+        @accept ||= @env[HTTP_ACCEPT] || DEFAULT_ACCEPT
       end
 
       # @raise [NotImplementedError]
       #
       # @since 0.3.1
       # @api private
-      def params
-        raise NotImplementedError, 'Please use params passed to Action#call'
+      def content_type
+        raise NotImplementedError, 'Please use Action#content_type'
       end
 
       # @raise [NotImplementedError]

data/lib/hanami/action/response.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'rack/response'
+require 'hanami/utils/kernel'
+require 'hanami/action/flash'
+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'
+
+module Hanami
+  class Action
+    class Response < ::Rack::Response
+      DEFAULT_VIEW_OPTIONS = -> * { {} }.freeze
+
+      REQUEST_METHOD = "REQUEST_METHOD"
+      HTTP_ACCEPT = "HTTP_ACCEPT"
+      SESSION_KEY = "rack.session"
+      REQUEST_ID  = "hanami.request_id"
+      LOCATION    = "Location"
+
+      X_CASCADE = "X-Cascade"
+      CONTENT_LENGTH = "Content-Length"
+      NOT_FOUND = 404
+
+      RACK_STATUS  = 0
+      RACK_HEADERS = 1
+      RACK_BODY    = 2
+
+      HEAD = "HEAD"
+
+      FLASH_SESSION_KEY = "_flash"
+
+      EMPTY_BODY = [].freeze
+
+      FILE_SYSTEM_ROOT = Pathname.new("/").freeze
+
+      attr_reader :request, :action, :exposures, :format, :env, :view_options
+      attr_accessor :charset
+
+      def self.build(status, env)
+        new(action: "", configuration: nil, content_type: Mime.best_q_match(env[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))
+        end
+      end
+
+      def initialize(request:, action:, configuration:, content_type: nil, env: {}, headers: {}, view_options: nil)
+        super([], 200, headers.dup)
+        set_header("Content-Type", content_type)
+
+        @request = request
+        @action = action
+        @configuration = configuration
+        @charset = ::Rack::MediaType.params(content_type).fetch('charset', nil)
+        @exposures = {}
+        @env = env
+        @view_options = view_options || DEFAULT_VIEW_OPTIONS
+
+        @sending_file = false
+      end
+
+      def body=(str)
+        @length = 0
+        @body   = EMPTY_BODY.dup
+
+        # FIXME: there could be a bug that prevents Content-Length to be sent for files
+        if str.is_a?(::Rack::File::Iterator)
+          @body = str
+        else
+          write(str) unless str.nil? || str == EMPTY_BODY
+        end
+      end
+
+      def render(view, **options)
+        self.body = view.(**view_options.(request, self), **exposures.merge(options)).to_str
+      end
+
+      def format=(args)
+        @format, content_type = *args
+        content_type = Action::Mime.content_type_with_charset(content_type, charset)
+        set_header("Content-Type", content_type)
+      end
+
+      def [](key)
+        @exposures.fetch(key)
+      end
+
+      def []=(key, value)
+        @exposures[key] = value
+      end
+
+      def session
+        env[SESSION_KEY] ||= {}
+      end
+
+      def cookies
+        @cookies ||= CookieJar.new(env.dup, headers, @configuration.cookies)
+      end
+
+      def flash
+        @flash ||= Flash.new(session[FLASH_SESSION_KEY])
+      end
+
+      def redirect_to(url, status: 302)
+        return unless renderable?
+
+        redirect(::String.new(url), status)
+        Halt.call(status)
+      end
+
+      def send_file(path)
+        _send_file(
+          Rack::File.new(path, @configuration.public_directory).call(env)
+        )
+      end
+
+      def unsafe_send_file(path)
+        directory = if Pathname.new(path).relative?
+                      @configuration.root_directory
+                    else
+                      FILE_SYSTEM_ROOT
+                    end
+
+        _send_file(
+          Rack::File.new(path, directory).call(env)
+        )
+      end
+
+      def cache_control(*values)
+        directives = Cache::CacheControl::Directives.new(*values)
+        headers.merge!(directives.headers)
+      end
+
+      def expires(amount, *values)
+        directives = Cache::Expires::Directives.new(amount, *values)
+        headers.merge!(directives.headers)
+      end
+
+      def fresh(options)
+        conditional_get = Cache::ConditionalGet.new(env, options)
+
+        headers.merge!(conditional_get.headers)
+
+        conditional_get.fresh? do
+          Halt.call(304)
+        end
+      end
+
+      # @api private
+      def request_id
+        env.fetch(REQUEST_ID) do
+          # FIXME: raise a meaningful error, by inviting devs to include Hanami::Action::Session
+          raise "Can't find request ID"
+        end
+      end
+
+      def set_format(value)
+        @format = value
+      end
+
+      def renderable?
+        return !head? && body.empty? if body.respond_to?(:empty?)
+
+        !@sending_file && !head?
+      end
+
+      alias to_ary to_a
+
+      def head?
+        env[REQUEST_METHOD] == HEAD
+      end
+
+      # @api private
+      def _send_file(send_file_response)
+        headers.merge!(send_file_response[RACK_HEADERS])
+
+        if send_file_response[RACK_STATUS] == NOT_FOUND
+          headers.delete(X_CASCADE)
+          headers.delete(CONTENT_LENGTH)
+          Halt.call(NOT_FOUND)
+        else
+          self.status = send_file_response[RACK_STATUS]
+          self.body = send_file_response[RACK_BODY]
+          @sending_file = true
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/session.rb

@@ -1,143 +1,21 @@
 require 'hanami/action/flash'
 
 module Hanami
-  module Action
+  class Action
     # Session API
     #
     # This module isn't included by default.
     #
     # @since 0.1.0
     module Session
-      # The key that returns raw session from the Rack env
-      #
-      # @since 0.1.0
-      # @api private
-      SESSION_KEY = 'rack.session'.freeze
-
-      # The key that is used by flash to transport errors
-      #
-      # @since 0.3.0
-      # @api private
-      ERRORS_KEY  = :__errors
-
-      # Add session to default exposures
-      #
-      # @since 0.4.4
-      # @api private
-      def self.included(action)
-        action.class_eval do
-          _expose :session, :flash
+      def self.included(base)
+        base.class_eval do
+          before { |req, _| req.id }
         end
       end
 
-      # Gets the session from the request and expose it as an Hash.
-      #
-      # @return [Hash] the HTTP session from the request
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require 'hanami/controller'
-      #   require 'hanami/action/session'
-      #
-      #   class Show
-      #     include Hanami::Action
-      #     include Hanami::Action::Session
-      #
-      #     def call(params)
-      #       # ...
-      #
-      #       # get a value
-      #       session[:user_id] # => '23'
-      #
-      #       # set a value
-      #       session[:foo] = 'bar'
-      #
-      #       # remove a value
-      #       session[:bax] = nil
-      #     end
-      #   end
-      def session
-        @_env[SESSION_KEY] ||= {}
-      end
-
-      # Read errors from flash or delegate to the superclass
-      #
-      # @return [Hanami::Validations::Errors] A collection of validation errors
-      #
-      # @since 0.3.0
-      #
-      # @see Hanami::Action::Validatable
-      # @see Hanami::Action::Session#flash
-      def errors
-        flash[ERRORS_KEY] || params.respond_to?(:errors) && params.errors
-      end
-
       private
 
-      # Container useful to transport data with the HTTP session
-      #
-      # @return [Hanami::Action::Flash] a Flash instance
-      #
-      # @since 0.3.0
-      #
-      # @see Hanami::Action::Flash
-      def flash
-        @flash ||= Flash.new(session)
-      end
-
-      # In case of validations errors, preserve those informations after a
-      # redirect.
-      #
-      # @return [void]
-      #
-      # @since 0.3.0
-      # @api private
-      #
-      # @see Hanami::Action::Redirect#redirect_to
-      #
-      # @example
-      #   require 'hanami/controller'
-      #
-      #   module Comments
-      #     class Index
-      #       include Hanami::Action
-      #       include Hanami::Action::Session
-      #
-      #       expose :comments
-      #
-      #       def call(params)
-      #         @comments = CommentRepository.all
-      #       end
-      #     end
-      #
-      #     class Create
-      #       include Hanami::Action
-      #       include Hanami::Action::Session
-      #
-      #       params do
-      #         param :text, type: String, presence: true
-      #       end
-      #
-      #       def call(params)
-      #         comment = Comment.new(params)
-      #         CommentRepository.create(comment) if params.valid?
-      #
-      #         redirect_to '/comments'
-      #       end
-      #     end
-      #   end
-      #
-      #   # The validation errors caused by Comments::Create are available
-      #   # **after the redirect** in the context of Comments::Index.
-      def redirect_to(*args)
-        if params.respond_to?(:valid?)
-          flash[ERRORS_KEY] = errors.to_a unless params.valid?
-        end
-        flash.keep!
-        super
-      end
-
       # Finalize the response
       #
       # @return [void]
@@ -146,9 +24,14 @@ module Hanami
       # @api private
       #
       # @see Hanami::Action#finish
-      def finish
+      def finish(req, res, *)
+        if (next_flash = res.flash.next).any?
+          res.session['_flash'] = next_flash
+        else
+          res.session.delete('_flash')
+        end
+
         super
-        flash.clear
       end
     end
   end