hanami-controller 0.0.0 → 0.6.0

data/lib/hanami/action/configurable.rb

@@ -0,0 +1,49 @@
+require 'hanami/utils/class_attribute'
+
+module Hanami
+  module Action
+    # Configuration API
+    #
+    # @since 0.2.0
+    #
+    # @see Hanami::Controller::Configuration
+    module Configurable
+      # Override Ruby's hook for modules.
+      # It includes configuration logic
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.2.0
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core-2.1.2/Module.html#method-i-included
+      #
+      # @example
+      #   require 'hanami/controller'
+      #
+      #   class Show
+      #     include Hanami::Action
+      #   end
+      #
+      #   Show.configuration
+      def self.included(base)
+        config = Hanami::Controller::Configuration.for(base)
+
+        base.class_eval do
+          include Utils::ClassAttribute
+
+          class_attribute :configuration
+          self.configuration = config
+        end
+
+        config.copy!(base)
+      end
+
+      private
+
+      def configuration
+        self.class.configuration
+      end
+    end
+  end
+end

data/lib/hanami/action/cookie_jar.rb

@@ -0,0 +1,181 @@
+require 'hanami/utils/hash'
+
+module Hanami
+  module Action
+    # A set of HTTP Cookies
+    #
+    # It acts as an Hash
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Action::Cookies#cookies
+    class CookieJar
+      # The key that returns raw cookies from the Rack env
+      #
+      # @since 0.1.0
+      # @api private
+      HTTP_HEADER       = 'HTTP_COOKIE'.freeze
+
+      # The key used by Rack to set the session cookie
+      #
+      # We let CookieJar to NOT take care of this cookie, but it leaves the
+      # responsibility to the Rack middleware that handle sessions.
+      #
+      # This prevents <tt>Set-Cookie</tt> to be sent twice.
+      #
+      # @since 0.5.1
+      # @api private
+      #
+      # @see https://github.com/hanami/controller/issues/138
+      RACK_SESSION_KEY   = :'rack.session'
+
+      # The key used by Rack to set the cookies as an Hash in the env
+      #
+      # @since 0.1.0
+      # @api private
+      COOKIE_HASH_KEY   = 'rack.request.cookie_hash'.freeze
+
+      # The key used by Rack to set the cookies as a String in the env
+      #
+      # @since 0.1.0
+      # @api private
+      COOKIE_STRING_KEY = 'rack.request.cookie_string'.freeze
+
+      # @since 0.4.5
+      # @api private
+      COOKIE_SEPARATOR = ';,'.freeze
+
+      # Initialize the CookieJar
+      #
+      # @param env [Hash] a raw Rack env
+      # @param headers [Hash] the response headers
+      #
+      # @return [CookieJar]
+      #
+      # @since 0.1.0
+      def initialize(env, headers, default_options)
+        @_headers        = headers
+        @cookies         = Utils::Hash.new(extract(env)).symbolize!
+        @default_options = default_options
+      end
+
+      # Finalize itself, by setting the proper headers to add and remove
+      # cookies, before the response is returned to the webserver.
+      #
+      # @return [void]
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::Action::Cookies#finish
+      def finish
+        @cookies.delete(RACK_SESSION_KEY)
+        @cookies.each { |k,v| v.nil? ? delete_cookie(k) : set_cookie(k, _merge_default_values(v)) }
+      end
+
+      # Returns the object associated with the given key
+      #
+      # @param key [Symbol] the key
+      #
+      # @return [Object,nil] return the associated object, if found
+      #
+      # @since 0.2.0
+      def [](key)
+        @cookies[key]
+      end
+
+      # Associate the given value with the given key and store them
+      #
+      # @param key [Symbol] the key
+      # @param value [#to_s,Hash] value that can be serialized as a string or
+      #   expressed as a Hash
+      # @option value [String] :domain - The domain
+      # @option value [String] :path - The path
+      # @option value [Integer] :max_age - Duration expressed in seconds
+      # @option value [Time] :expires - Expiration time
+      # @option value [TrueClass,FalseClass] :secure - Restrict cookie to secure
+      #   connections
+      # @option value [TrueClass,FalseClass] :httponly - Restrict JavaScript
+      #   access
+      #
+      # @return [void]
+      #
+      # @since 0.2.0
+      #
+      # @see http://en.wikipedia.org/wiki/HTTP_cookie
+      def []=(key, value)
+        @cookies[key] = value
+      end
+
+      private
+
+      # Merge default cookies options with values provided by user
+      #
+      # Cookies values provided by user are respected
+      #
+      # @since 0.4.0
+      # @api private
+      def _merge_default_values(value)
+        cookies_options = if value.is_a? Hash
+          value.merge! _add_expires_option(value)
+        else
+          { value: value }
+        end
+        @default_options.merge cookies_options
+      end
+
+      # Add expires option to cookies if :max_age presents
+      #
+      # @since 0.4.3
+      # @api private
+      def _add_expires_option(value)
+        if value.has_key?(:max_age) && !value.has_key?(:expires)
+          { expires: (Time.now + value[:max_age]) }
+        else
+          {}
+        end
+      end
+
+      # Extract the cookies from the raw Rack env.
+      #
+      # This implementation is borrowed from Rack::Request#cookies.
+      #
+      # @since 0.1.0
+      # @api private
+      def extract(env)
+        hash   = env[COOKIE_HASH_KEY] ||= {}
+        string = env[HTTP_HEADER]
+
+        return hash if string == env[COOKIE_STRING_KEY]
+        # TODO Next Rack 1.7.x ?? version will have ::Rack::Utils.parse_cookies
+        # We can then replace the following lines.
+        hash.clear
+
+        # According to RFC 2109:
+        #   If multiple cookies satisfy the criteria above, they are ordered in
+        #   the Cookie header such that those with more specific Path attributes
+        #   precede those with less specific.  Ordering with respect to other
+        #   attributes (e.g., Domain) is unspecified.
+        cookies = ::Rack::Utils.parse_query(string, COOKIE_SEPARATOR) { |s| ::Rack::Utils.unescape(s) rescue s }
+        cookies.each { |k,v| hash[k] = Array === v ? v.first : v }
+        env[COOKIE_STRING_KEY] = string
+        hash
+      end
+
+      # Set a cookie in the headers
+      #
+      # @since 0.1.0
+      # @api private
+      def set_cookie(key, value)
+        ::Rack::Utils.set_cookie_header!(@_headers, key, value)
+      end
+
+      # Remove a cookie from the headers
+      #
+      # @since 0.1.0
+      # @api private
+      def delete_cookie(key)
+        ::Rack::Utils.delete_cookie_header!(@_headers, key, {})
+      end
+    end
+  end
+end

data/lib/hanami/action/cookies.rb

@@ -0,0 +1,85 @@
+require 'hanami/action/cookie_jar'
+
+module Hanami
+  module Action
+    # Cookies API
+    #
+    # This module isn't included by default.
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Action::Cookies#cookies
+    module Cookies
+      protected
+
+      # Gets the cookies from the request and expose them as an Hash
+      #
+      # It automatically sets options from global configuration, but it allows to
+      # override values case by case.
+      #
+      # For a list of options please have a look at <tt>Hanami::Controller::Configuration</tt>,
+      # and <tt>Hanami::Action::CookieJar</tt>.
+      #
+      # @return [Hanami::Action::CookieJar] cookies
+      #
+      # @since 0.1.0
+      # @api public
+      #
+      # @see Hanami::Controller::Configuration#cookies
+      # @see Hanami::Action::CookieJar#[]=
+      #
+      # @example Basic Usage
+      #   require 'hanami/controller'
+      #   require 'hanami/action/cookies'
+      #
+      #   class Show
+      #     include Hanami::Action
+      #     include Hanami::Action::Cookies
+      #
+      #     def call(params)
+      #       # ...
+      #
+      #       # get a value
+      #       cookies[:user_id] # => '23'
+      #
+      #       # set a value
+      #       cookies[:foo] = 'bar'
+      #
+      #       # remove a value
+      #       cookies[:bax] = nil
+      #     end
+      #   end
+      #
+      # @example Cookies Options
+      #   require 'hanami/controller'
+      #   require 'hanami/action/cookies'
+      #
+      #   class Show
+      #     include Hanami::Action
+      #     include Hanami::Action::Cookies
+      #
+      #     def call(params)
+      #       # ...
+      #       # set a value
+      #       cookies[:foo] = { value: 'bar', max_age: 300, path: '/dashboard' }
+      #     end
+      #   end
+      def cookies
+        @cookies ||= CookieJar.new(@_env.dup, headers, configuration.cookies)
+      end
+
+      private
+
+      # Finalize the response by flushing cookies into the response
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see Hanami::Action#finish
+      def finish
+        super
+        cookies.finish
+      end
+    end
+  end
+end

data/lib/hanami/action/exposable.rb

@@ -0,0 +1,115 @@
+module Hanami
+  module Action
+    # Exposures API
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::Action::Exposable::ClassMethods#expose
+    module Exposable
+      # Override Ruby's hook for modules.
+      # It includes exposures logic
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core-2.1.2/Module.html#method-i-included
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Exposures API class methods
+      #
+      # @since 0.1.0
+      # @api private
+      module ClassMethods
+        # Expose the given attributes on the outside of the object with
+        # a getter and a special method called #exposures.
+        #
+        # @param names [Array<Symbol>] the name(s) of the attribute(s) to be
+        #   exposed
+        #
+        # @return [void]
+        #
+        # @since 0.1.0
+        #
+        # @example
+        #   require 'hanami/controller'
+        #
+        #   class Show
+        #     include Hanami::Action
+        #
+        #     expose :article, :tags
+        #
+        #     def call(params)
+        #       @article = Article.find params[:id]
+        #       @tags    = Tag.for(article)
+        #     end
+        #   end
+        #
+        #   action = Show.new
+        #   action.call({id: 23})
+        #
+        #   action.article # => #<Article ...>
+        #   action.tags    # => [#<Tag ...>, #<Tag ...>]
+        #
+        #   action.exposures # => { :article => #<Article ...>, :tags => [ ... ] }
+        def expose(*names)
+          class_eval do
+            names.each do |name|
+              attr_reader(name) unless attr_reader?(name)
+            end
+
+            exposures.push(*names)
+          end
+        end
+
+        # Set of exposures attribute names
+        #
+        # @return [Array] the exposures attribute names
+        #
+        # @since 0.1.0
+        # @api private
+        def exposures
+          @exposures ||= []
+        end
+
+        private
+        # Check if the attr_reader is already defined
+        #
+        # @since 0.3.0
+        # @api private
+        def attr_reader?(name)
+          (instance_methods | private_instance_methods).include?(name)
+        end
+      end
+
+      # Set of exposures
+      #
+      # @return [Hash] the exposures
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::Action::Exposable::ClassMethods.expose
+      def exposures
+        @exposures ||= {}.tap do |result|
+          self.class.exposures.each do |name|
+            result[name] = send(name)
+          end
+        end
+      end
+
+      # Finalize the response
+      #
+      # @since 0.3.0
+      # @api private
+      #
+      # @see Hanami::Action#finish
+      def finish
+        super
+        exposures
+      end
+    end
+  end
+end

data/lib/hanami/action/flash.rb

@@ -0,0 +1,182 @@
+module Hanami
+  module Action
+    # Container useful to transport data with the HTTP session
+    # It has a life span of one HTTP request or redirect.
+    #
+    # @since 0.3.0
+    # @api private
+    class Flash
+      # Session key where the data is stored
+      #
+      # @since 0.3.0
+      # @api private
+      SESSION_KEY = :__flash
+
+      # Session key where the last request_id is stored
+      #
+      # @since 0.4.0
+      # @api private
+      LAST_REQUEST_KEY = :__last_request_id
+
+      # Initialize a new Flash instance
+      #
+      # @param session [Rack::Session::Abstract::SessionHash] the session
+      # @param request_id [String] the HTTP Request ID
+      #
+      # @return [Hanami::Action::Flash] the flash
+      #
+      # @see http://www.rubydoc.info/gems/rack/Rack/Session/Abstract/SessionHash
+      # @see Hanami::Action::Rack#session_id
+      def initialize(session, request_id)
+        @session         = session
+        @request_id      = request_id
+        @last_request_id = session[LAST_REQUEST_KEY]
+
+        session[SESSION_KEY]             ||= {}
+        session[SESSION_KEY][request_id] ||= {}
+      end
+
+      # Set the given value for the given key
+      #
+      # @param key [#to_s] the key
+      # @param value [Object] the value
+      #
+      # @since 0.3.0
+      # @api private
+      def []=(key, value)
+        data[key] = value
+      end
+
+      # Get the value associated to the given key, if any
+      #
+      # @return [Object,NilClass] the value
+      #
+      # @since 0.3.0
+      # @api private
+      def [](key)
+        last_request_flash.merge(data).fetch(key) do
+          _values.find {|data| !data[key].nil? }
+        end
+      end
+
+      # Removes entirely the flash from the session if it has stale contents
+      # or if empty.
+      #
+      # @return [void]
+      #
+      # @since 0.3.0
+      # @api private
+      def clear
+        # FIXME we're just before a release and I can't find a proper way to reproduce
+        # this bug that I've found via a browser.
+        #
+        # It may happen that `#flash` is nil, and those two methods will fail
+        unless flash.nil?
+          expire_stale!
+          set_last_request_id!
+          remove!
+        end
+      end
+
+      # Check if there are contents stored in the flash from the current or the
+      # previous request.
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.3.0
+      # @api private
+      def empty?
+        _values.all?(&:empty?)
+      end
+
+      private
+
+      # The flash registry that holds the data for **all** the recent requests
+      #
+      # @return [Hash] the flash
+      #
+      # @since 0.3.0
+      # @api private
+      def flash
+        @session[SESSION_KEY] || {}
+      end
+
+      # The flash registry that holds the data **only for** the current request
+      #
+      # @return [Hash] the flash for the current request
+      #
+      # @since 0.3.0
+      # @api private
+      def data
+        flash[@request_id] || {}
+      end
+
+      # Expire the stale data from the previous request.
+      #
+      # @return [void]
+      #
+      # @since 0.3.0
+      # @api private
+      def expire_stale!
+        flash.each do |request_id, _|
+          flash.delete(request_id) if delete?(request_id)
+        end
+      end
+
+      # Remove the flash entirely from the session if empty.
+      #
+      # @return [void]
+      #
+      # @since 0.3.0
+      # @api private
+      #
+      # @see Hanami::Action::Flash#empty?
+      def remove!
+        @session.delete(SESSION_KEY) if empty?
+      end
+
+      # Values from all the stored requests
+      #
+      # @return [Array]
+      #
+      # @since 0.3.0
+      # @api private
+      def _values
+        flash.values
+      end
+
+      # Determine if delete data from flash for the given Request ID
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.4.0
+      # @api private
+      #
+      # @see Hanami::Action::Flash#expire_stale!
+      def delete?(request_id)
+        ![@request_id, @session[LAST_REQUEST_KEY]].include?(request_id)
+      end
+
+      # Get the last request session flash
+      #
+      # @return [Hash] the flash of last request
+      #
+      # @since 0.4.0
+      # @api private
+      def last_request_flash
+        flash[@last_request_id] || {}
+      end
+
+      # Store the last request_id to create the next flash with its values
+      # is current flash is not empty.
+      #
+      # @return [void]
+      # @since 0.4.0
+      # @api private
+      def set_last_request_id!
+        @session[LAST_REQUEST_KEY] = @request_id if !empty?
+      end
+
+    end
+  end
+end