omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/railtie.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch"
+require "action_dispatch/log_subscriber"
+require "active_support/messages/rotation_configuration"
+
+module ActionDispatch
+  class Railtie < Rails::Railtie # :nodoc:
+    config.action_dispatch = ActiveSupport::OrderedOptions.new
+    config.action_dispatch.x_sendfile_header = nil
+    config.action_dispatch.ip_spoofing_check = true
+    config.action_dispatch.show_exceptions = :all
+    config.action_dispatch.tld_length = 1
+    config.action_dispatch.ignore_accept_header = false
+    config.action_dispatch.rescue_templates = {}
+    config.action_dispatch.rescue_responses = {}
+    config.action_dispatch.default_charset = nil
+    config.action_dispatch.rack_cache = false
+    config.action_dispatch.http_auth_salt = "http authentication"
+    config.action_dispatch.signed_cookie_salt = "signed cookie"
+    config.action_dispatch.encrypted_cookie_salt = "encrypted cookie"
+    config.action_dispatch.encrypted_signed_cookie_salt = "signed encrypted cookie"
+    config.action_dispatch.authenticated_encrypted_cookie_salt = "authenticated encrypted cookie"
+    config.action_dispatch.use_authenticated_cookie_encryption = false
+    config.action_dispatch.use_cookies_with_metadata = false
+    config.action_dispatch.perform_deep_munge = true
+    config.action_dispatch.request_id_header = ActionDispatch::Constants::X_REQUEST_ID
+    config.action_dispatch.log_rescued_responses = true
+    config.action_dispatch.debug_exception_log_level = :fatal
+    config.action_dispatch.strict_freshness = false
+
+    config.action_dispatch.default_headers = {
+      "X-Frame-Options" => "SAMEORIGIN",
+      "X-XSS-Protection" => "1; mode=block",
+      "X-Content-Type-Options" => "nosniff",
+      "X-Download-Options" => "noopen",
+      "X-Permitted-Cross-Domain-Policies" => "none",
+      "Referrer-Policy" => "strict-origin-when-cross-origin"
+    }
+
+    config.action_dispatch.cookies_rotations = ActiveSupport::Messages::RotationConfiguration.new
+
+    config.eager_load_namespaces << ActionDispatch
+
+    initializer "action_dispatch.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_dispatch] = ActionDispatch.deprecator
+    end
+
+    initializer "action_dispatch.configure" do |app|
+      ActionDispatch::Http::URL.secure_protocol = app.config.force_ssl
+      ActionDispatch::Http::URL.tld_length = app.config.action_dispatch.tld_length
+
+      ActiveSupport.on_load(:action_dispatch_request) do
+        self.ignore_accept_header = app.config.action_dispatch.ignore_accept_header
+        ActionDispatch::Request::Utils.perform_deep_munge = app.config.action_dispatch.perform_deep_munge
+      end
+
+      ActiveSupport.on_load(:action_dispatch_response) do
+        self.default_charset = app.config.action_dispatch.default_charset || app.config.encoding
+        self.default_headers = app.config.action_dispatch.default_headers
+      end
+
+      ActionDispatch::ExceptionWrapper.rescue_responses.merge!(config.action_dispatch.rescue_responses)
+      ActionDispatch::ExceptionWrapper.rescue_templates.merge!(config.action_dispatch.rescue_templates)
+
+      config.action_dispatch.always_write_cookie = Rails.env.development? if config.action_dispatch.always_write_cookie.nil?
+      ActionDispatch::Cookies::CookieJar.always_write_cookie = config.action_dispatch.always_write_cookie
+
+      ActionDispatch::Routing::Mapper.route_source_locations = Rails.env.development?
+
+      ActionDispatch::Http::Cache::Request.strict_freshness = app.config.action_dispatch.strict_freshness
+      ActionDispatch.test_app = app
+    end
+  end
+end

data/lib/action_dispatch/request/session.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rack/session/abstract/id"
+
+module ActionDispatch
+  class Request
+    # Session is responsible for lazily loading the session from store.
+    class Session # :nodoc:
+      DisabledSessionError    = Class.new(StandardError)
+      ENV_SESSION_KEY         = Rack::RACK_SESSION # :nodoc:
+      ENV_SESSION_OPTIONS_KEY = Rack::RACK_SESSION_OPTIONS # :nodoc:
+
+      # Singleton object used to determine if an optional param wasn't specified.
+      Unspecified = Object.new
+
+      # Creates a session hash, merging the properties of the previous session if any.
+      def self.create(store, req, default_options)
+        session_was = find req
+        session     = Request::Session.new(store, req)
+        session.merge! session_was if session_was
+
+        set(req, session)
+        Options.set(req, Request::Session::Options.new(store, default_options))
+        session
+      end
+
+      def self.disabled(req)
+        new(nil, req, enabled: false).tap do
+          Session::Options.set(req, Session::Options.new(nil, { id: nil }))
+        end
+      end
+
+      def self.find(req)
+        req.get_header ENV_SESSION_KEY
+      end
+
+      def self.set(req, session)
+        req.set_header ENV_SESSION_KEY, session
+      end
+
+      def self.delete(req)
+        req.delete_header ENV_SESSION_KEY
+      end
+
+      class Options # :nodoc:
+        def self.set(req, options)
+          req.set_header ENV_SESSION_OPTIONS_KEY, options
+        end
+
+        def self.find(req)
+          req.get_header ENV_SESSION_OPTIONS_KEY
+        end
+
+        def initialize(by, default_options)
+          @by       = by
+          @delegate = default_options.dup
+        end
+
+        def [](key)
+          @delegate[key]
+        end
+
+        def id(req)
+          @delegate.fetch(:id) {
+            @by.send(:extract_session_id, req)
+          }
+        end
+
+        def []=(k, v);        @delegate[k] = v; end
+        def to_hash;          @delegate.dup; end
+        def values_at(*args); @delegate.values_at(*args); end
+      end
+
+      def initialize(by, req, enabled: true)
+        @by       = by
+        @req      = req
+        @delegate = {}
+        @loaded   = false
+        @exists   = nil # We haven't checked yet.
+        @enabled  = enabled
+        @id_was = nil
+        @id_was_initialized = false
+      end
+
+      def id
+        options.id(@req)
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def options
+        Options.find @req
+      end
+
+      def destroy
+        clear
+
+        if enabled?
+          options = self.options || {}
+          @by.send(:delete_session, @req, options.id(@req), options)
+
+          # Load the new sid to be written with the response.
+          @loaded = false
+          load_for_write!
+        end
+      end
+
+      # Returns value of the key stored in the session or `nil` if the given key is
+      # not found in the session.
+      def [](key)
+        load_for_read!
+        key = key.to_s
+
+        if key == "session_id"
+          id&.public_id
+        else
+          @delegate[key]
+        end
+      end
+
+      # Returns the nested value specified by the sequence of keys, returning `nil` if
+      # any intermediate step is `nil`.
+      def dig(*keys)
+        load_for_read!
+        keys = keys.map.with_index { |key, i| i.zero? ? key.to_s : key }
+        @delegate.dig(*keys)
+      end
+
+      # Returns true if the session has the given key or false.
+      def has_key?(key)
+        load_for_read!
+        @delegate.key?(key.to_s)
+      end
+      alias :key? :has_key?
+      alias :include? :has_key?
+
+      # Returns keys of the session as Array.
+      def keys
+        load_for_read!
+        @delegate.keys
+      end
+
+      # Returns values of the session as Array.
+      def values
+        load_for_read!
+        @delegate.values
+      end
+
+      # Writes given value to given key of the session.
+      def []=(key, value)
+        load_for_write!
+        @delegate[key.to_s] = value
+      end
+
+      # Clears the session.
+      def clear
+        load_for_delete!
+        @delegate.clear
+      end
+
+      # Returns the session as Hash.
+      def to_hash
+        load_for_read!
+        @delegate.dup.delete_if { |_, v| v.nil? }
+      end
+      alias :to_h :to_hash
+
+      # Updates the session with given Hash.
+      #
+      #     session.to_hash
+      #     # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2"}
+      #
+      #     session.update({ "foo" => "bar" })
+      #     # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2", "foo" => "bar"}
+      #
+      #     session.to_hash
+      #     # => {"session_id"=>"e29b9ea315edf98aad94cc78c34cc9b2", "foo" => "bar"}
+      def update(hash)
+        unless hash.respond_to?(:to_hash)
+          raise TypeError, "no implicit conversion of #{hash.class.name} into Hash"
+        end
+
+        load_for_write!
+        @delegate.update hash.to_hash.stringify_keys
+      end
+      alias :merge! :update
+
+      # Deletes given key from the session.
+      def delete(key)
+        load_for_delete!
+        @delegate.delete key.to_s
+      end
+
+      # Returns value of the given key from the session, or raises `KeyError` if can't
+      # find the given key and no default value is set. Returns default value if
+      # specified.
+      #
+      #     session.fetch(:foo)
+      #     # => KeyError: key not found: "foo"
+      #
+      #     session.fetch(:foo, :bar)
+      #     # => :bar
+      #
+      #     session.fetch(:foo) do
+      #       :bar
+      #     end
+      #     # => :bar
+      def fetch(key, default = Unspecified, &block)
+        load_for_read!
+        if default == Unspecified
+          @delegate.fetch(key.to_s, &block)
+        else
+          @delegate.fetch(key.to_s, default, &block)
+        end
+      end
+
+      def inspect
+        if loaded?
+          super
+        else
+          "#<#{self.class}:0x#{(object_id << 1).to_s(16)} not yet loaded>"
+        end
+      end
+
+      def exists?
+        return false unless enabled?
+        return @exists unless @exists.nil?
+        @exists = @by.send(:session_exists?, @req)
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def empty?
+        load_for_read!
+        @delegate.empty?
+      end
+
+      def each(&block)
+        to_hash.each(&block)
+      end
+
+      def id_was
+        load_for_read!
+        @id_was
+      end
+
+      private
+        def load_for_read!
+          load! if !loaded? && exists?
+        end
+
+        def load_for_write!
+          if enabled?
+            load! unless loaded?
+          else
+            raise DisabledSessionError, "Your application has sessions disabled. To write to the session you must first configure a session store"
+          end
+        end
+
+        def load_for_delete!
+          load! if enabled? && !loaded?
+        end
+
+        def load!
+          if enabled?
+            @id_was_initialized = true unless exists?
+            id, session = @by.load_session @req
+            options[:id] = id
+            @delegate.replace(session.stringify_keys)
+            @id_was = id unless @id_was_initialized
+          end
+          @id_was_initialized = true
+          @loaded = true
+        end
+    end
+  end
+end

data/lib/action_dispatch/request/utils.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActionDispatch
+  class Request
+    class Utils # :nodoc:
+      mattr_accessor :perform_deep_munge, default: true
+
+      def self.each_param_value(params, &block)
+        case params
+        when Array
+          params.each { |element| each_param_value(element, &block) }
+        when Hash
+          params.each_value { |value| each_param_value(value, &block) }
+        when String
+          block.call params
+        end
+      end
+
+      def self.normalize_encode_params(params)
+        if perform_deep_munge
+          NoNilParamEncoder.normalize_encode_params params
+        else
+          ParamEncoder.normalize_encode_params params
+        end
+      end
+
+      def self.check_param_encoding(params)
+        case params
+        when Array
+          params.each { |element| check_param_encoding(element) }
+        when Hash
+          params.each_value { |value| check_param_encoding(value) }
+        when String
+          unless params.valid_encoding?
+            # Raise Rack::Utils::InvalidParameterError for consistency with Rack.
+            # ActionDispatch::Request#GET will re-raise as a BadRequest error.
+            raise Rack::Utils::InvalidParameterError, "Invalid encoding for parameter: #{params.scrub}"
+          end
+        end
+      end
+
+      def self.set_binary_encoding(request, params, controller, action)
+        CustomParamEncoder.encode(request, params, controller, action)
+      end
+
+      class ParamEncoder # :nodoc:
+        # Convert nested Hash to HashWithIndifferentAccess.
+        def self.normalize_encode_params(params)
+          case params
+          when Array
+            handle_array params
+          when Hash
+            if params.has_key?(:tempfile)
+              ActionDispatch::Http::UploadedFile.new(params)
+            else
+              hwia = ActiveSupport::HashWithIndifferentAccess.new
+              params.each_pair do |key, val|
+                hwia[key] = normalize_encode_params(val)
+              end
+              hwia
+            end
+          else
+            params
+          end
+        end
+
+        def self.handle_array(params)
+          params.map! { |el| normalize_encode_params(el) }
+        end
+      end
+
+      # Remove nils from the params hash.
+      class NoNilParamEncoder < ParamEncoder # :nodoc:
+        def self.handle_array(params)
+          list = super
+          list.compact!
+          list
+        end
+      end
+
+      class CustomParamEncoder # :nodoc:
+        def self.encode(request, params, controller, action)
+          return params unless controller && controller.valid_encoding? && encoding_template = action_encoding_template(request, controller, action)
+          params.except(:controller, :action).each do |key, value|
+            ActionDispatch::Request::Utils.each_param_value(value) do |param|
+              # If `param` is frozen, it comes from the router defaults
+              next if param.frozen?
+
+              if encoding_template[key.to_s]
+                param.force_encoding(encoding_template[key.to_s])
+              end
+            end
+          end
+          params
+        end
+
+        def self.action_encoding_template(request, controller, action) # :nodoc:
+          request.controller_class_for(controller).action_encoding_template(action)
+        rescue MissingController
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/action_dispatch/routing/endpoint.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Routing
+    class Endpoint # :nodoc:
+      def dispatcher?;   false; end
+      def redirect?;     false; end
+      def matches?(req);  true; end
+      def app;            self; end
+      def rack_app;        app; end
+
+      def engine?
+        rack_app.is_a?(Class) && rack_app < Rails::Engine
+      end
+    end
+  end
+end