hanami-controller 0.0.0 → 0.6.0

data/lib/hanami/action/rack/callable.rb

@@ -0,0 +1,47 @@
+
+module Hanami
+  module Action
+    module Rack
+      module Callable
+        # Callable module for actions. With this module, actions with middlewares
+        # will be able to work with rack builder.
+        #
+        # @param env [Hash] the full Rack env or the params. This value may vary,
+        #   see the examples below.
+        #
+        # @since 0.4.0
+        #
+        # @see Hanami::Action::Rack::ClassMethods#rack_builder
+        # @see Hanami::Action::Rack::ClassMethods#use
+        #
+        # @example
+        #   require 'hanami/controller'
+        #
+        #    class MyMiddleware
+        #      def initialize(app)
+        #        @app = app
+        #      end
+        #
+        #      def call(env)
+        #        #...
+        #      end
+        #    end
+        #
+        #    class Show
+        #      include Hanami::Action
+        #      use MyMiddleware
+        #
+        #      def call(params)
+        #        # ...
+        #        puts params # => { id: 23 } extracted from Rack env
+        #      end
+        #    end
+        #
+        #    Show.respond_to?(:call) # => true
+        def call(env)
+          rack_builder.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/rack/file.rb

@@ -0,0 +1,33 @@
+require 'rack/file'
+
+module Hanami
+  module Action
+    module Rack
+      # File to be sent
+      #
+      # @since 0.4.3
+      # @api private
+      #
+      # @see Hanami::Action::Rack#send_file
+      class File
+        # @param path [String,Pathname] file path
+        #
+        # @since 0.4.3
+        # @api private
+        def initialize(path)
+          @file = ::Rack::File.new(nil)
+          @path = path
+        end
+
+        # @since 0.4.3
+        # @api private
+        def call(env)
+          @file.path = @path.to_s
+          @file.serving(env)
+        rescue Errno::ENOENT
+          [404, {}, nil]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/redirect.rb

@@ -0,0 +1,59 @@
+module Hanami
+  module Action
+    # HTTP redirect API
+    #
+    # @since 0.1.0
+    module Redirect
+      # The HTTP header for redirects
+      #
+      # @since 0.2.0
+      # @api private
+      LOCATION = 'Location'.freeze
+
+      private
+
+      # Redirect to the given URL and halt the request
+      #
+      # @param url [String] the destination URL
+      # @param status [Fixnum] the http code
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::Action::Throwable#halt
+      #
+      # @example With default status code (302)
+      #   require 'hanami/controller'
+      #
+      #   class Create
+      #     include Hanami::Action
+      #
+      #     def call(params)
+      #       # ...
+      #       redirect_to 'http://example.com/articles/23'
+      #     end
+      #   end
+      #
+      #   action = Create.new
+      #   action.call({}) # => [302, {'Location' => '/articles/23'}, '']
+      #
+      # @example With custom status code
+      #   require 'hanami/controller'
+      #
+      #   class Create
+      #     include Hanami::Action
+      #
+      #     def call(params)
+      #       # ...
+      #       redirect_to 'http://example.com/articles/23', status: 301
+      #     end
+      #   end
+      #
+      #   action = Create.new
+      #   action.call({}) # => [301, {'Location' => '/articles/23'}, '']
+      def redirect_to(url, status: 302)
+        headers[LOCATION] = ::String.new(url)
+        halt(status)
+      end
+    end
+  end
+end

data/lib/hanami/action/request.rb

@@ -0,0 +1,86 @@
+require 'rack/request'
+
+module Hanami
+  module Action
+    # An HTTP request based on top of Rack::Request.
+    # This guarantees backwards compatibility with with Rack.
+    #
+    # @since 0.3.1
+    #
+    # @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'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def session
+        raise NotImplementedError, 'Please include Action::Session and use Action#session'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def cookies
+        raise NotImplementedError, 'Please include Action::Cookies and use Action#cookies'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def params
+        raise NotImplementedError, 'Please use params passed to Action#call'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def update_param(*)
+        raise NotImplementedError, 'Please use params passed to Action#call'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def delete_param(*)
+        raise NotImplementedError, 'Please use params passed to Action#call'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def [](*)
+        raise NotImplementedError, 'Please use params passed to Action#call'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def []=(*)
+        raise NotImplementedError, 'Please use params passed to Action#call'
+      end
+
+      # @raise [NotImplementedError]
+      #
+      # @since 0.3.1
+      # @api private
+      def values_at(*)
+        raise NotImplementedError, 'Please use params passed to Action#call'
+      end
+    end
+  end
+end

data/lib/hanami/action/session.rb

@@ -0,0 +1,154 @@
+require 'hanami/action/flash'
+
+module Hanami
+  module 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
+        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
+
+      private
+
+      # Container useful to transport data with the HTTP session
+      #
+      # @return [Hanami::Action::Flash] a Flash instance
+      #
+      # @since 0.3.0
+      # @api private
+      #
+      # @see Hanami::Action::Flash
+      def flash
+        @flash ||= Flash.new(session, request_id)
+      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)
+        flash[ERRORS_KEY] = errors.to_a unless params.valid?
+        super
+      end
+
+      # Read errors from flash or delegate to the superclass
+      #
+      # @return [Hanami::Validations::Errors] A collection of validation errors
+      #
+      # @since 0.3.0
+      # @api private
+      #
+      # @see Hanami::Action::Validatable
+      # @see Hanami::Action::Session#flash
+      def errors
+        flash[ERRORS_KEY] || super
+      end
+
+      # Finalize the response
+      #
+      # @return [void]
+      #
+      # @since 0.3.0
+      # @api private
+      #
+      # @see Hanami::Action#finish
+      def finish
+        super
+        flash.clear
+      end
+    end
+  end
+end

data/lib/hanami/action/throwable.rb

@@ -0,0 +1,194 @@
+require 'hanami/utils/class_attribute'
+require 'hanami/http/status'
+
+module Hanami
+  module Action
+    # Throw API
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Action::Throwable::ClassMethods#handle_exception
+    # @see Hanami::Action::Throwable#halt
+    # @see Hanami::Action::Throwable#status
+    module Throwable
+      # @since 0.2.0
+      # @api private
+      RACK_ERRORS = 'rack.errors'.freeze
+
+      # This isn't part of Rack SPEC
+      #
+      # Exception notifiers use <tt>rack.exception</tt> instead of
+      # <tt>rack.errors</tt>, so we need to support it.
+      #
+      # @since 0.5.0
+      # @api private
+      #
+      # @see Hanami::Action::Throwable::RACK_ERRORS
+      # @see http://www.rubydoc.info/github/rack/rack/file/SPEC#The_Error_Stream
+      # @see https://github.com/hanami/controller/issues/133
+      RACK_EXCEPTION = 'rack.exception'.freeze
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Throw API class methods
+      #
+      # @since 0.1.0
+      # @api private
+      module ClassMethods
+        private
+
+        # Handle the given exception with an HTTP status code.
+        #
+        # When the exception is raise during #call execution, it will be
+        # translated into the associated HTTP status.
+        #
+        # This is a fine grained control, for a global configuration see
+        # Hanami::Action.handled_exceptions
+        #
+        # @param exception [Hash] the exception class must be the key and the
+        #   HTTP status the value of the hash
+        #
+        # @since 0.1.0
+        #
+        # @see Hanami::Action.handled_exceptions
+        #
+        # @example
+        #   require 'hanami/controller'
+        #
+        #   class Show
+        #     include Hanami::Action
+        #     handle_exception RecordNotFound => 404
+        #
+        #     def call(params)
+        #       # ...
+        #       raise RecordNotFound.new
+        #     end
+        #   end
+        #
+        #   Show.new.call({id: 1}) # => [404, {}, ['Not Found']]
+        def handle_exception(exception)
+          configuration.handle_exception(exception)
+        end
+      end
+
+      protected
+
+      # Halt the action execution with the given HTTP status code and message.
+      #
+      # When used, the execution of a callback or of an action is interrupted
+      # and the control returns to the framework, that decides how to handle
+      # the event.
+      #
+      # If a message is provided, it sets the response body with the message.
+      # Otherwise, it sets the response body with the default message associated
+      # to the code (eg 404 will set `"Not Found"`).
+      #
+      # @param code [Fixnum] a valid HTTP status code
+      # @param message [String] the response body
+      #
+      # @since 0.2.0
+      #
+      # @see Hanami::Controller#handled_exceptions
+      # @see Hanami::Action::Throwable#handle_exception
+      # @see Hanami::Http::Status:ALL
+      #
+      # @example Basic usage
+      #   require 'hanami/controller'
+      #
+      #   class Show
+      #     def call(params)
+      #       halt 404
+      #     end
+      #   end
+      #
+      #   # => [404, {}, ["Not Found"]]
+      #
+      # @example Custom message
+      #   require 'hanami/controller'
+      #
+      #   class Show
+      #     def call(params)
+      #       halt 404, "This is not the droid you're looking for."
+      #     end
+      #   end
+      #
+      #   # => [404, {}, ["This is not the droid you're looking for."]]
+      def halt(code, message = nil)
+        message ||= Http::Status.message_for(code)
+        status(code, message)
+
+        throw :halt
+      end
+
+      # Sets the given code and message for the response
+      #
+      # @param code [Fixnum] a valid HTTP status code
+      # @param message [String] the response body
+      #
+      # @since 0.1.0
+      # @see Hanami::Http::Status:ALL
+      def status(code, message)
+        self.status = code
+        self.body   = message
+      end
+
+      private
+      # @since 0.1.0
+      # @api private
+      def _rescue
+        catch :halt do
+          begin
+            yield
+          rescue => exception
+            _reference_in_rack_errors(exception)
+            _handle_exception(exception)
+          end
+        end
+      end
+
+      # @since 0.2.0
+      # @api private
+      def _reference_in_rack_errors(exception)
+        return if configuration.handled_exception?(exception)
+
+        @_env[RACK_EXCEPTION] = exception
+
+        if errors = @_env[RACK_ERRORS]
+          errors.write(_dump_exception(exception))
+          errors.flush
+        end
+      end
+
+      # @since 0.2.0
+      # @api private
+      def _dump_exception(exception)
+        [[exception.class, exception.message].compact.join(": "), *exception.backtrace].join("\n\t")
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _handle_exception(exception)
+        raise unless configuration.handle_exceptions
+
+        instance_exec(
+          exception,
+          &_exception_handler(exception)
+        )
+      end
+
+      # @since 0.3.0
+      # @api private
+      def _exception_handler(exception)
+        handler = configuration.exception_handler(exception)
+
+        if respond_to?(handler.to_s, true)
+          method(handler)
+        else
+          ->(ex) { halt handler }
+        end
+      end
+    end
+  end
+end