hanami-action 3.0.0.rc1

data/hanami-action.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# This file is synced from hanakai-rb/repo-sync. To update it, edit repo-sync.yml.
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hanami/action/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hanami-action"
+  spec.authors       = ["Hanakai team"]
+  spec.email         = ["info@hanakai.org"]
+  spec.license       = "MIT"
+  spec.version       = Hanami::Action::VERSION.dup
+
+  spec.summary       = "Complete, fast and testable actions for Rack and Hanami"
+  spec.description   = spec.summary
+  spec.homepage      = "https://hanamirb.org"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "hanami-action.gemspec", "lib/**/*"]
+  spec.bindir        = "exe"
+  spec.executables   = Dir["exe/*"].map { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md", "LICENSE"]
+
+  spec.metadata["changelog_uri"]     = "https://github.com/hanami/hanami-action/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/hanami/hanami-action"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/hanami/hanami-action/issues"
+  spec.metadata["funding_uri"]       = "https://github.com/sponsors/hanami"
+
+  spec.required_ruby_version = ">= 3.3"
+
+  spec.add_runtime_dependency "rack", ">= 2.2.16"
+  spec.add_runtime_dependency "hanami-utils", "~> 3.0.0.rc"
+  spec.add_runtime_dependency "dry-configurable", "~> 1.4"
+  spec.add_runtime_dependency "dry-core", "~> 1.0"
+  spec.add_runtime_dependency "zeitwerk", "~> 2.6"
+end
+

data/lib/hanami/action/body_parser/json.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hanami
+  class Action
+    module BodyParser
+      # Body parser for JSON request bodies.
+      #
+      # @api private
+      module JSON
+        def self.call(body, _env)
+          ::JSON.parse(body)
+        rescue ::JSON::ParserError => exception
+          raise BodyParsingError, exception.message
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/body_parser/multipart_form.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rack/multipart"
+
+module Hanami
+  class Action
+    module BodyParser
+      # Body parser for multipart form data (file uploads).
+      #
+      # @api private
+      module MultipartForm
+        def self.call(_body, env)
+          # Rack's `parse_multipart` reads the input from the env. We've already rewound this input
+          # in BodyParser, before this parser is called.
+          ::Rack::Multipart.parse_multipart(env)
+        rescue StandardError => exception
+          raise BodyParsingError, exception.message
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/body_parser.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "rack"
+require "hanami/utils/hash"
+
+module Hanami
+  class Action
+    # Parses request bodies based on the action's accepted formats.
+    #
+    # @api private
+    module BodyParser
+      FALLBACK_KEY = :_
+
+      class << self
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+
+        # Parses the request body if applicable
+        #
+        # @param env [Hash] Rack environment
+        # @param config [Hanami::Action::Config] action configuration
+        #
+        # @return [void]
+        def parse(env, config)
+          # If the router has already parsed the body, derive our own keys from it.
+          if env.key?(ROUTER_PARSED_BODY)
+            parsed = env[ROUTER_PARSED_BODY]
+            env[ACTION_PARSED_BODY] = parsed
+            env[ACTION_BODY_PARAMS] = symbolize_body(parsed)
+            return
+          end
+
+          return if env.key?(ACTION_PARSED_BODY)
+
+          input = env[::Rack::RACK_INPUT]
+          return unless input
+
+          media_type = Mime.extract_media_type(env[CONTENT_TYPE])
+          return unless media_type
+
+          if config.formats.empty?
+            # When no format is explicity configured, parse multipart/form-data bodies as a sensible
+            # default. These kinds of form submissions are a standard part of standard web behavior,
+            # and users expect them to work out of the box.
+            return unless media_type == "multipart/form-data"
+          else
+            return unless Mime.accepted_content_type?(media_type, config)
+          end
+
+          parser = config.formats.body_parser_for(media_type)
+          return unless parser
+
+          input = ensure_rewindable_input(env)
+          body = read_body(input)
+          return if body.nil? || body.empty?
+
+          # Pass both the body string and the Rack env to the parser. Most parsers should only need
+          # the body, but the env is there in case access to headers or calling Rack APIs is
+          # required.
+          parsed = parser.call(body, env)
+
+          env[ACTION_PARSED_BODY] = parsed
+          env[ACTION_BODY_PARAMS] = symbolize_body(parsed)
+        end
+
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
+
+        private
+
+        # Ensures the input in the Rack env is rewindable (for Rack 3 compatibility).
+        def ensure_rewindable_input(env)
+          input = env[::Rack::RACK_INPUT]
+          return input if input.respond_to?(:rewind)
+
+          env[::Rack::RACK_INPUT] = ::Rack::RewindableInput.new(input)
+        end
+
+        # Reads and rewinds the body.
+        def read_body(input)
+          input.rewind
+          body = input.read
+          input.rewind
+
+          body
+        end
+
+        # Symbolizes the parsed body, wrapping non-hash values in a fallback key.
+        def symbolize_body(parsed)
+          if parsed.is_a?(::Hash)
+            deep_symbolize(parsed)
+          else
+            {FALLBACK_KEY => deep_symbolize(parsed)}
+          end
+        end
+
+        # Recursively symbolizes hash keys within any structure (arrays or hashes).
+        def deep_symbolize(value)
+          case value
+          when ::Hash
+            Utils::Hash.deep_symbolize(value)
+          when ::Array
+            value.map { deep_symbolize(_1) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Action
+    module Cache
+      # Module with Cache-Control logic
+      #
+      # @since 0.3.0
+      # @api private
+      module CacheControl
+        # @since 0.3.0
+        # @api private
+        def self.included(base)
+          base.class_eval do
+            extend ClassMethods
+
+            @cache_control_directives = nil
+          end
+        end
+
+        # @since 0.3.0
+        # @api private
+        module ClassMethods
+          # @since 0.3.0
+          # @api private
+          def cache_control(*values)
+            @cache_control_directives ||= Directives.new(*values)
+          end
+
+          # @since 0.3.0
+          # @api private
+          def cache_control_directives
+            @cache_control_directives || Object.new.tap do |null_object|
+              def null_object.headers
+                {}
+              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(_, res, _)
+          unless res.headers.include?(Action::CACHE_CONTROL)
+            res.headers.merge!(self.class.cache_control_directives.headers)
+          end
+
+          super
+        end
+
+        # Class which stores CacheControl values
+        #
+        # @since 0.3.0
+        # @api private
+        class Directives
+          # @since 2.0.0
+          # @api private
+          SEPARATOR = ", "
+          private_constant :SEPARATOR
+
+          # @since 0.3.0
+          # @api private
+          def initialize(*values)
+            @directives = Hanami::Action::Cache::Directives.new(*values)
+          end
+
+          # @since 0.3.0
+          # @api private
+          def headers
+            if @directives.any?
+              {Action::CACHE_CONTROL => @directives.join(SEPARATOR)}
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "hanami/utils/blank"
+
+module Hanami
+  class Action
+    module Cache
+      # ETag value object
+      #
+      # @since 0.3.0
+      # @api private
+      class ETag
+        # @since 0.3.0
+        # @api private
+        def initialize(env, value)
+          @env, @value = env, value
+        end
+
+        # @since 0.3.0
+        # @api private
+        def fresh?
+          none_match && @value == none_match
+        end
+
+        # @since 0.3.0
+        # @api private
+        def header
+          {Action::ETAG => @value} if @value
+        end
+
+        private
+
+        # @since 0.3.0
+        # @api private
+        def none_match
+          @env[Action::IF_NONE_MATCH]
+        end
+      end
+
+      # LastModified value object
+      #
+      # @since 0.3.0
+      # @api private
+      class LastModified
+        # @since 0.3.0
+        # @api private
+        def initialize(env, value)
+          @env, @value = env, value
+        end
+
+        # @since 0.3.0
+        # @api private
+        def fresh?
+          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
+        # @api private
+        def header
+          {Action::LAST_MODIFIED => @value.httpdate} if @value.respond_to?(:httpdate)
+        end
+
+        private
+
+        # @since 0.3.0
+        # @api private
+        def modified_since
+          @env[Action::IF_MODIFIED_SINCE]
+        end
+      end
+
+      # Class responsible to determine if a given request is fresh
+      # based on IF_NONE_MATCH and IF_MODIFIED_SINCE headers
+      #
+      # @since 0.3.0
+      # @api private
+      class ConditionalGet
+        # @since 0.3.0
+        # @api private
+        def initialize(env, options)
+          @validations = [ETag.new(env, options[:etag]), LastModified.new(env, options[:last_modified])]
+        end
+
+        # @since 0.3.0
+        # @api private
+        def fresh?
+          yield if @validations.any?(&:fresh?)
+        end
+
+        # @since 0.3.0
+        # @api private
+        def headers
+          @validations.map(&:header).compact.reduce({}, :merge)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Hanami
+  class 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
+        # @since 0.3.0
+        # @api private
+        attr_reader :name
+
+        # @since 0.3.0
+        # @api private
+        def initialize(name, value)
+          @name, @value = name, value
+        end
+
+        # @since 0.3.0
+        # @api private
+        def to_str
+          "#{@name.to_s.tr('_', '-')}=#{@value.to_i}"
+        end
+
+        # @since 0.3.0
+        # @api private
+        def valid?
+          VALUE_DIRECTIVES.include? @name
+        end
+      end
+
+      # Class representing non value directives
+      #
+      # ex: no-cache
+      #
+      # @since 0.3.0
+      # @api private
+      class NonValueDirective
+        # @since 0.3.0
+        # @api private
+        attr_reader :name
+
+        # @since 0.3.0
+        # @api private
+        def initialize(name)
+          @name = name
+        end
+
+        # @since 0.3.0
+        # @api private
+        def to_str
+          @name.to_s.tr("_", "-")
+        end
+
+        # @since 0.3.0
+        # @api private
+        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
+
+        # @since 0.3.0
+        # @api private
+        def initialize(*values)
+          @directives = []
+          values.each do |directive_key|
+            if directive_key.is_a? Hash
+              directive_key.each { |name, value| self << ValueDirective.new(name, value) }
+            else
+              self << NonValueDirective.new(directive_key)
+            end
+          end
+        end
+
+        # @since 0.3.0
+        # @api private
+        def each(&block)
+          @directives.each(&block)
+        end
+
+        # @since 0.3.0
+        # @api private
+        def <<(directive)
+          @directives << directive if directive.valid?
+        end
+
+        # @since 0.3.0
+        # @api private
+        def values
+          @directives.delete_if do |directive|
+            directive.name == :public && @directives.map(&:name).include?(:private)
+          end
+        end
+
+        # @since 0.3.0
+        # @api private
+        def join(separator)
+          values.join(separator)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Action
+    module Cache
+      # Module with Expires logic
+      #
+      # @since 0.3.0
+      # @api private
+      module Expires
+        # @since 0.3.0
+        # @api private
+        def self.included(base)
+          base.class_eval do
+            extend ClassMethods
+
+            @expires_directives = nil
+          end
+        end
+
+        # @since 0.3.0
+        # @api private
+        module ClassMethods
+          # @since 0.3.0
+          # @api private
+          def expires(amount, *values)
+            @expires_directives ||= Directives.new(amount, *values)
+          end
+
+          # @since 0.3.0
+          # @api private
+          def expires_directives
+            @expires_directives || Object.new.tap do |null_object|
+              def null_object.headers
+                {}
+              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(_, res, _)
+          unless res.headers.include?(Action::EXPIRES)
+            res.headers.merge!(self.class.expires_directives.headers)
+          end
+
+          super
+        end
+
+        # Class which stores Expires directives
+        #
+        # @since 0.3.0
+        # @api private
+        class Directives
+          # @since 0.3.0
+          # @api private
+          def initialize(amount, *values)
+            @amount = amount
+            @cache_control = Hanami::Action::Cache::CacheControl::Directives.new(*(values << {max_age: amount}))
+          end
+
+          # @since 0.3.0
+          # @api private
+          def headers
+            {Action::EXPIRES => time.httpdate}.merge(@cache_control.headers)
+          end
+
+          private
+
+          # @since 0.3.0
+          # @api private
+          def time
+            Time.now + @amount.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/action/cache.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Action
+    # Cache type API
+    #
+    # @since 0.3.0
+    #
+    # @see Hanami::Action::Cache::ClassMethods#cache_control
+    # @see Hanami::Action::Cache::ClassMethods#expires
+    # @see Hanami::Action::Cache::ClassMethods#fresh
+    module Cache
+      # Override Ruby's hook for modules.
+      # It includes exposures logic
+      #
+      # @param base [Class] the target action
+      #
+      # @since 0.3.0
+      # @api private
+      #
+      # @see http://www.ruby-doc.org/core/Module.html#method-i-included
+      def self.included(base)
+        base.class_eval do
+          include CacheControl, Expires
+        end
+      end
+    end
+  end
+end