hanami-controller 0.0.0 → 0.6.0

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

@@ -0,0 +1,99 @@
+module Hanami
+  module Action
+    module Cache
+
+      # Cache-Control directives which have values
+      #
+      # @since 0.3.0
+      # @api private
+      VALUE_DIRECTIVES      = %i(max_age s_maxage min_fresh max_stale).freeze
+
+      # Cache-Control directives which are implicitly true
+      #
+      # @since 0.3.0
+      # @api private
+      NON_VALUE_DIRECTIVES  = %i(public private no_cache no_store no_transform must_revalidate proxy_revalidate).freeze
+
+      # Class representing value directives
+      #
+      # ex: max-age=600
+      #
+      # @since 0.3.0
+      # @api private
+      class ValueDirective
+        attr_reader :name
+
+        def initialize(name, value)
+          @name, @value = name, value
+        end
+
+        def to_str
+          "#{@name.to_s.tr('_', '-')}=#{@value.to_i}"
+        end
+
+        def valid?
+          VALUE_DIRECTIVES.include? @name
+        end
+      end
+
+      # Class representing non value directives
+      #
+      # ex: no-cache
+      #
+      # @since 0.3.0
+      # @api private
+      class NonValueDirective
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def to_str
+          @name.to_s.tr('_', '-')
+        end
+
+        def valid?
+          NON_VALUE_DIRECTIVES.include? @name
+        end
+      end
+
+      # Collection of value and non value directives
+      #
+      # @since 0.3.0
+      # @api private
+      class Directives
+        include Enumerable
+
+        def initialize(*values)
+          @directives = []
+          values.each do |directive_key|
+            if directive_key.kind_of? Hash
+              directive_key.each { |name, value| self.<< ValueDirective.new(name, value) }
+            else
+              self.<< NonValueDirective.new(directive_key)
+            end
+          end
+        end
+
+        def each
+          @directives.each { |d| yield d }
+        end
+
+        def <<(directive)
+          @directives << directive if directive.valid?
+        end
+
+        def values
+          @directives.delete_if do |directive|
+            directive.name == :public && @directives.map(&:name).include?(:private)
+          end
+        end
+
+        def join(separator)
+          values.join(separator)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'hanami/action/cache/cache_control'
+
+module Hanami
+  module Action
+    module Cache
+
+      # Module with Expires logic
+      #
+      # @since 0.3.0
+      # @api private
+      module Expires
+
+        # The HTTP header for Expires
+        #
+        # @since 0.3.0
+        # @api private
+        HEADER = 'Expires'.freeze
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def expires(amount, *values)
+            @expires_directives ||= Directives.new(amount, *values)
+          end
+
+          def expires_directives
+            @expires_directives || Object.new.tap do |null_object|
+              def null_object.headers
+                Hash.new
+              end
+            end
+          end
+        end
+
+        # Finalize the response including default cache headers into the response
+        #
+        # @since 0.3.0
+        # @api private
+        #
+        # @see Hanami::Action#finish
+        def finish
+          super
+          headers.merge!(self.class.expires_directives.headers) unless headers.include? HEADER
+        end
+
+        # Class which stores Expires directives
+        #
+        # @since 0.3.0
+        #
+        # @api private
+        #
+        class Directives
+          def initialize(amount, *values)
+            @amount = amount
+            @cache_control = Hanami::Action::Cache::CacheControl::Directives.new(*(values << { max_age: amount }))
+          end
+
+          def headers
+            { HEADER => time.httpdate }.merge(@cache_control.headers)
+          end
+
+          private
+
+          def time
+            Time.now + @amount.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/callable.rb

@@ -0,0 +1,94 @@
+require 'hanami/action/params'
+
+module Hanami
+  module Action
+    module Callable
+      # Execute application logic.
+      # It implements the Rack protocol.
+      #
+      # The request params are passed as an argument to the `#call` method.
+      #
+      # If routed with Hanami::Router, it extracts the relevant bits from the
+      # Rack `env` (eg the requested `:id`).
+      #
+      # Otherwise everything it's passed as it is: the full Rack `env`
+      # in production, and the given `Hash` for unit tests. See the examples
+      # below.
+      #
+      # Application developers are forced to implement this method in their
+      # actions.
+      #
+      # @param env [Hash] the full Rack env or the params. This value may vary,
+      #   see the examples below.
+      #
+      # @return [Array] a serialized Rack response (eg. `[200, {}, ["Hi!"]]`)
+      #
+      # @since 0.1.0
+      #
+      # @example with Hanami::Router
+      #   require 'hanami/controller'
+      #
+      #    class Show
+      #      include Hanami::Action
+      #
+      #      def call(params)
+      #        # ...
+      #        puts params # => { id: 23 } extracted from Rack env
+      #      end
+      #    end
+      #
+      # @example Standalone
+      #   require 'hanami/controller'
+      #
+      #   class Show
+      #     include Hanami::Action
+      #
+      #     def call(params)
+      #       # ...
+      #       puts params
+      #         # => { :"rack.version"=>[1, 2],
+      #         #      :"rack.input"=>#<StringIO:0x007fa563463948>, ... }
+      #     end
+      #   end
+      #
+      # @example Unit Testing
+      #   require 'hanami/controller'
+      #
+      #   class Show
+      #     include Hanami::Action
+      #
+      #     def call(params)
+      #       # ...
+      #       puts params # => { id: 23, key: 'value' } passed as it is from testing
+      #     end
+      #   end
+      #
+      #   action   = Show.new
+      #   response = action.call({ id: 23, key: 'value' })
+      def call(env)
+        _rescue do
+          @_env    = env
+          @headers = ::Rack::Utils::HeaderHash.new(configuration.default_headers)
+          @params  = self.class.params_class.new(@_env)
+          super @params
+        end
+
+        finish
+      end
+
+      private
+
+      # Prepare the Rack response before the control is returned to the
+      # webserver.
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see Hanami::Action#finish
+      def finish
+        super
+        response
+      end
+    end
+  end
+end

data/lib/hanami/action/callbacks.rb

@@ -0,0 +1,210 @@
+require 'hanami/utils/class_attribute'
+require 'hanami/utils/callbacks'
+
+module Hanami
+  module Action
+    # Before and after callbacks
+    #
+    # @since 0.1.0
+    # @see Hanami::Action::ClassMethods#before
+    # @see Hanami::Action::ClassMethods#after
+    module Callbacks
+      # Override Ruby's hook for modules.
+      # It includes callbacks logic
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+      def self.included(base)
+        base.class_eval do
+          extend  ClassMethods
+          prepend InstanceMethods
+        end
+      end
+
+      # Callbacks API class methods
+      #
+      # @since 0.1.0
+      # @api private
+      module ClassMethods
+        # Override Ruby's hook for modules.
+        # It includes callbacks logic
+        #
+        # @param base [Class] the target action
+        #
+        # @since 0.1.0
+        # @api private
+        #
+        # @see http://www.ruby-doc.org/core/Module.html#method-i-extended
+        def self.extended(base)
+          base.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
+          end
+        end
+
+        # 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 blk [Proc] an anonymous function to be executed
+        #
+        # @return [void]
+        #
+        # @since 0.3.2
+        #
+        # @see Hanami::Action::Callbacks::ClassMethods#append_after
+        #
+        # @example Method names (symbols)
+        #   require 'hanami/controller'
+        #
+        #   class Show
+        #     include Hanami::Action
+        #
+        #     before :authenticate, :set_article
+        #
+        #     def call(params)
+        #     end
+        #
+        #     private
+        #     def authenticate
+        #       # ...
+        #     end
+        #
+        #     # `params` in the method signature is optional
+        #     def set_article(params)
+        #       @article = Article.find params[:id]
+        #     end
+        #   end
+        #
+        #   # The order of execution will be:
+        #   #
+        #   # 1. #authenticate
+        #   # 2. #set_article
+        #   # 3. #call
+        #
+        # @example Anonymous functions (Procs)
+        #   require 'hanami/controller'
+        #
+        #   class Show
+        #     include Hanami::Action
+        #
+        #     before { ... } # 1 do some authentication stuff
+        #     before {|params| @article = Article.find params[:id] } # 2
+        #
+        #     def call(params)
+        #     end
+        #   end
+        #
+        #   # The order of execution will be:
+        #   #
+        #   # 1. authentication
+        #   # 2. set the article
+        #   # 3. #call
+        def append_before(*callbacks, &blk)
+          before_callbacks.append(*callbacks, &blk)
+        end
+
+        # @since 0.1.0
+        alias_method :before, :append_before
+
+        # 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 blk [Proc] an anonymous function to be executed
+        #
+        # @return [void]
+        #
+        # @since 0.3.2
+        #
+        # @see Hanami::Action::Callbacks::ClassMethods#append_before
+        def append_after(*callbacks, &blk)
+          after_callbacks.append(*callbacks, &blk)
+        end
+
+        # @since 0.1.0
+        alias_method :after, :append_after
+
+        # 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 blk [Proc] an anonymous function to be executed
+        #
+        # @return [void]
+        #
+        # @since 0.3.2
+        #
+        # @see Hanami::Action::Callbacks::ClassMethods#prepend_after
+        def prepend_before(*callbacks, &blk)
+          before_callbacks.prepend(*callbacks, &blk)
+        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.
+        #
+        # @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
+        #
+        # @return [void]
+        #
+        # @since 0.3.2
+        #
+        # @see Hanami::Action::Callbacks::ClassMethods#prepend_before
+        def prepend_after(*callbacks, &blk)
+          after_callbacks.prepend(*callbacks, &blk)
+        end
+      end
+
+      # Callbacks API instance methods
+      #
+      # @since 0.1.0
+      # @api private
+      module InstanceMethods
+        # Implements the Rack/Hanami::Action protocol
+        #
+        # @since 0.1.0
+        # @api private
+        def call(params)
+          _run_before_callbacks(params)
+          super
+          _run_after_callbacks(params)
+        end
+
+        private
+        def _run_before_callbacks(params)
+          self.class.before_callbacks.run(self, params)
+        end
+
+        def _run_after_callbacks(params)
+          self.class.after_callbacks.run(self, params)
+        end
+      end
+    end
+  end
+end