omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/testing/request_encoder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "nokogiri"
+
+module ActionDispatch
+  class RequestEncoder # :nodoc:
+    class IdentityEncoder
+      def content_type; end
+      def accept_header; end
+      def encode_params(params); params; end
+      def response_parser; -> body { body }; end
+    end
+
+    @encoders = { identity: IdentityEncoder.new }
+
+    attr_reader :response_parser
+
+    def initialize(mime_name, param_encoder, response_parser)
+      @mime = Mime[mime_name]
+
+      unless @mime
+        raise ArgumentError, "Can't register a request encoder for " \
+          "unregistered MIME Type: #{mime_name}. See `Mime::Type.register`."
+      end
+
+      @response_parser = response_parser || -> body { body }
+      @param_encoder   = param_encoder   || :"to_#{@mime.symbol}".to_proc
+    end
+
+    def content_type
+      @mime.to_s
+    end
+
+    def accept_header
+      @mime.to_s
+    end
+
+    def encode_params(params)
+      @param_encoder.call(params) if params
+    end
+
+    def self.parser(content_type)
+      type = Mime::Type.lookup(content_type).ref if content_type
+      encoder(type).response_parser
+    end
+
+    def self.encoder(name)
+      @encoders[name] || @encoders[:identity]
+    end
+
+    def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil)
+      @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
+    end
+
+    register_encoder :html, response_parser: -> body { Rails::Dom::Testing.html_document.parse(body) }
+    register_encoder :json, response_parser: -> body { JSON.parse(body, object_class: ActiveSupport::HashWithIndifferentAccess) }
+  end
+end

data/lib/action_dispatch/testing/test_helpers/page_dump_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module TestHelpers
+    module PageDumpHelper
+      class InvalidResponse < StandardError; end
+
+      # Saves the content of response body to a file and tries to open it in your browser.
+      # Launchy must be present in your Gemfile for the page to open automatically.
+      def save_and_open_page(path = html_dump_default_path)
+        save_page(path).tap { |s_path| open_file(s_path) }
+      end
+
+      private
+        def save_page(path = html_dump_default_path)
+          raise InvalidResponse.new("Response is a redirection!") if response.redirection?
+          path = Pathname.new(path)
+          path.dirname.mkpath
+          File.write(path, response.body)
+          path
+        end
+
+        def open_file(path)
+          require "launchy"
+          Launchy.open(path)
+        rescue LoadError
+          warn "File saved to #{path}.\nPlease install the launchy gem to open the file automatically."
+        end
+
+        def html_dump_default_path
+          Rails.root.join("tmp/html_dump", "#{method_name}_#{DateTime.current.to_i}.html").to_s
+        end
+    end
+  end
+end

data/lib/action_dispatch/testing/test_process.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/middleware/cookies"
+require "action_dispatch/middleware/flash"
+
+module ActionDispatch
+  module TestProcess
+    module FixtureFile
+      # Shortcut for
+      # `Rack::Test::UploadedFile.new(File.join(ActionDispatch::IntegrationTest.file_f
+      # ixture_path, path), type)`:
+      #
+      #     post :change_avatar, params: { avatar: file_fixture_upload('david.png', 'image/png') }
+      #
+      # Default fixture files location is `test/fixtures/files`.
+      #
+      # To upload binary files on Windows, pass `:binary` as the last parameter. This
+      # will not affect other platforms:
+      #
+      #     post :change_avatar, params: { avatar: file_fixture_upload('david.png', 'image/png', :binary) }
+      def file_fixture_upload(path, mime_type = nil, binary = false)
+        if self.class.file_fixture_path && !File.exist?(path)
+          path = file_fixture(path)
+        end
+
+        Rack::Test::UploadedFile.new(path, mime_type, binary)
+      end
+      alias_method :fixture_file_upload, :file_fixture_upload
+    end
+
+    include FixtureFile
+
+    def assigns(key = nil)
+      raise NoMethodError,
+        'assigns has been extracted to a gem. To continue using it,
+        add `gem "rails-controller-testing"` to your Gemfile.'
+    end
+
+    def session
+      @request.session
+    end
+
+    def flash
+      @request.flash
+    end
+
+    def cookies
+      @cookie_jar ||= Cookies::CookieJar.build(@request, @request.cookies)
+    end
+
+    def redirect_to_url
+      @response.redirect_url
+    end
+  end
+end

data/lib/action_dispatch/testing/test_request.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/hash/indifferent_access"
+require "rack/utils"
+
+module ActionDispatch
+  class TestRequest < Request
+    DEFAULT_ENV = Rack::MockRequest.env_for("/",
+      "HTTP_HOST"                => "test.host".b,
+      "REMOTE_ADDR"              => "0.0.0.0".b,
+      "HTTP_USER_AGENT"          => "Rails Testing".b,
+    )
+
+    # Create a new test request with default `env` values.
+    def self.create(env = {})
+      env = Rails.application.env_config.merge(env) if defined?(Rails.application) && Rails.application
+      env["rack.request.cookie_hash"] ||= {}.with_indifferent_access
+      new(default_env.merge(env))
+    end
+
+    def self.default_env
+      DEFAULT_ENV
+    end
+    private_class_method :default_env
+
+    def request_method=(method)
+      super(method.to_s.upcase)
+    end
+
+    def host=(host)
+      set_header("HTTP_HOST", host)
+    end
+
+    def port=(number)
+      set_header("SERVER_PORT", number)
+    end
+
+    def request_uri=(uri)
+      set_header("REQUEST_URI", uri)
+    end
+
+    def path=(path)
+      set_header("PATH_INFO", path)
+    end
+
+    def action=(action_name)
+      path_parameters[:action] = action_name.to_s
+    end
+
+    def if_modified_since=(last_modified)
+      set_header("HTTP_IF_MODIFIED_SINCE", last_modified)
+    end
+
+    def if_none_match=(etag)
+      set_header("HTTP_IF_NONE_MATCH", etag)
+    end
+
+    def remote_addr=(addr)
+      set_header("REMOTE_ADDR", addr)
+    end
+
+    def user_agent=(user_agent)
+      set_header("HTTP_USER_AGENT", user_agent)
+    end
+
+    def accept=(mime_types)
+      delete_header("action_dispatch.request.accepts")
+      set_header("HTTP_ACCEPT", Array(mime_types).collect(&:to_s).join(","))
+    end
+  end
+end

data/lib/action_dispatch/testing/test_response.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/testing/request_encoder"
+
+module ActionDispatch
+  # Integration test methods such as Integration::RequestHelpers#get and
+  # Integration::RequestHelpers#post return objects of class TestResponse, which
+  # represent the HTTP response results of the requested controller actions.
+  #
+  # See Response for more information on controller response objects.
+  class TestResponse < Response
+    def self.from_response(response)
+      new response.status, response.headers, response.body
+    end
+
+    # Returns a parsed body depending on the response MIME type. When a parser
+    # corresponding to the MIME type is not found, it returns the raw body.
+    #
+    # #### Examples
+    #     get "/posts"
+    #     response.content_type         # => "text/html; charset=utf-8"
+    #     response.parsed_body.class    # => Nokogiri::HTML5::Document
+    #     response.parsed_body.to_html  # => "<!DOCTYPE html>\n<html>\n..."
+    #
+    #     assert_pattern { response.parsed_body.at("main") => { content: "Hello, world" } }
+    #
+    #     response.parsed_body.at("main") => {name:, content:}
+    #     assert_equal "main", name
+    #     assert_equal "Some main content", content
+    #
+    #     get "/posts.json"
+    #     response.content_type         # => "application/json; charset=utf-8"
+    #     response.parsed_body.class    # => Array
+    #     response.parsed_body          # => [{"id"=>42, "title"=>"Title"},...
+    #
+    #     assert_pattern { response.parsed_body => [{ id: 42 }] }
+    #
+    #     get "/posts/42.json"
+    #     response.content_type         # => "application/json; charset=utf-8"
+    #     response.parsed_body.class    # => ActiveSupport::HashWithIndifferentAccess
+    #     response.parsed_body          # => {"id"=>42, "title"=>"Title"}
+    #
+    #     assert_pattern { response.parsed_body => [{ title: /title/i }] }
+    #
+    #     response.parsed_body => {id:, title:}
+    #     assert_equal 42, id
+    #     assert_equal "Title", title
+    def parsed_body
+      @parsed_body ||= response_parser.call(body)
+    end
+
+    def response_parser
+      @response_parser ||= RequestEncoder.parser(media_type)
+    end
+  end
+end

data/lib/action_dispatch.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#++
+
+# :markup: markdown
+
+require "active_support"
+require "active_support/rails"
+require "active_support/core_ext/module/attribute_accessors"
+
+require "action_pack"
+require "rack"
+require "action_dispatch/deprecator"
+
+module Rack # :nodoc:
+  autoload :Test, "rack/test"
+end
+
+# # Action Dispatch
+#
+# Action Dispatch is a module of Action Pack.
+#
+# Action Dispatch parses information about the web request, handles routing as
+# defined by the user, and does advanced processing related to HTTP such as
+# MIME-type negotiation, decoding parameters in POST, PATCH, or PUT bodies,
+# handling HTTP caching logic, cookies and sessions.
+module ActionDispatch
+  extend ActiveSupport::Autoload
+
+  class MissingController < NameError
+  end
+
+  eager_autoload do
+    autoload_under "http" do
+      autoload :ContentSecurityPolicy
+      autoload :PermissionsPolicy
+      autoload :Request
+      autoload :Response
+    end
+  end
+
+  autoload_under "middleware" do
+    autoload :AssumeSSL
+    autoload :HostAuthorization
+    autoload :RequestId
+    autoload :Callbacks
+    autoload :Cookies
+    autoload :ActionableExceptions
+    autoload :DebugExceptions
+    autoload :DebugLocks
+    autoload :DebugView
+    autoload :ExceptionWrapper
+    autoload :Executor
+    autoload :Flash
+    autoload :PublicExceptions
+    autoload :Reloader
+    autoload :RemoteIp
+    autoload :ServerTiming
+    autoload :ShowExceptions
+    autoload :SSL
+    autoload :Static
+  end
+
+  autoload :Constants
+  autoload :Journey
+  autoload :MiddlewareStack, "action_dispatch/middleware/stack"
+  autoload :Routing
+
+  module Http
+    extend ActiveSupport::Autoload
+
+    autoload :Cache
+    autoload :Headers
+    autoload :MimeNegotiation
+    autoload :Parameters
+    autoload :UploadedFile, "action_dispatch/http/upload"
+    autoload :URL
+  end
+
+  module Session
+    autoload :AbstractStore,       "action_dispatch/middleware/session/abstract_store"
+    autoload :AbstractSecureStore, "action_dispatch/middleware/session/abstract_store"
+    autoload :CookieStore,         "action_dispatch/middleware/session/cookie_store"
+    autoload :MemCacheStore,       "action_dispatch/middleware/session/mem_cache_store"
+    autoload :CacheStore,          "action_dispatch/middleware/session/cache_store"
+
+    def self.resolve_store(session_store) # :nodoc:
+      self.const_get(session_store.to_s.camelize)
+    rescue NameError
+      raise <<~ERROR
+        Unable to resolve session store #{session_store.inspect}.
+
+        #{session_store.inspect} resolves to ActionDispatch::Session::#{session_store.to_s.camelize},
+        but that class is undefined.
+
+        Is #{session_store.inspect} spelled correctly, and are any necessary gems installed?
+      ERROR
+    end
+  end
+
+  mattr_accessor :test_app
+
+  autoload_under "testing" do
+    autoload :Assertions
+    autoload :Integration
+    autoload :IntegrationTest, "action_dispatch/testing/integration"
+    autoload :TestProcess
+    autoload :TestRequest
+    autoload :TestResponse
+    autoload :AssertionResponse
+  end
+
+  autoload :SystemTestCase, "action_dispatch/system_test_case"
+
+  def eager_load!
+    super
+    Routing.eager_load!
+  end
+end
+
+autoload :Mime, "action_dispatch/http/mime_type"
+
+ActiveSupport.on_load(:action_view) do
+  ActionView::Base.default_formats ||= Mime::SET.symbols
+  ActionView::Template.mime_types_implementation = Mime
+  ActionView::LookupContext::DetailsKey.clear
+end

data/lib/action_pack/gem_version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionPack
+  # Returns the currently loaded version of Action Pack as a `Gem::Version`.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha1"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_pack/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require_relative "gem_version"
+
+module ActionPack
+  # Returns the currently loaded version of Action Pack as a `Gem::Version`.
+  def self.version
+    gem_version
+  end
+end

data/lib/action_pack.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#++
+
+# :markup: markdown
+
+require "action_pack/version"