RubyGems - sorbet-rails - Versions diffs - 0.5.0 → 0.5.1 - Mend

sorbet-rails 0.5.0 → 0.5.1

Files changed (523) hide show

data/spec/support/v5.2/app/models/wand.rb ADDED

@@ -0,0 +1,17 @@
+# typed: true
+class Wand < ApplicationRecord
+  include Mythical
+  enum core_type: {
+    phoenix_feather: 0,
+    dragon_heartstring: 1,
+    unicorn_tail_hair: 2,
+    basilisk_horn: 3,
+  }
+  belongs_to :wizard
+  def wood_type
+    'Type ' + super
+  end
+end

data/spec/support/v5.2/app/models/wizard.rb ADDED

@@ -0,0 +1,14 @@
+# typed: strict
+class Wizard < ApplicationRecord
+  validates :name, length: { minimum: 5 }, presence: true
+  enum house: {
+    Gryffindor: 0,
+    Hufflepuff: 1,
+    Ravenclaw: 2,
+    Slytherin: 3,
+  }
+  has_one :wand
+  has_many :spell_books
+end

data/spec/support/v5.2/app/views/layouts/application.html.erb ADDED

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>V52</title>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    <%= stylesheet_link_tag    'application', media: 'all' %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/support/v5.2/bin/setup CHANGED

@@ -17,6 +17,9 @@ chdir APP_ROOT do
   system! 'gem install bundler --conservative'
   system('bundle check') || system!('bundle install')
+  # Install JavaScript dependencies if using Yarn
+  # system('bin/yarn')
   # puts "\n== Copying sample files =="
   # unless File.exist?('config/database.yml')
   #   cp 'config/database.yml.sample', 'config/database.yml'

data/spec/support/v5.2/bin/update CHANGED

@@ -17,6 +17,9 @@ chdir APP_ROOT do
   system! 'gem install bundler --conservative'
   system('bundle check') || system!('bundle install')
+  # Install JavaScript dependencies if using Yarn
+  # system('bin/yarn')
   puts "\n== Updating database =="
   system! 'bin/rails db:migrate'

data/spec/support/v5.2/bin/yarn ADDED

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path('..', __dir__)
+Dir.chdir(APP_ROOT) do
+  begin
+    exec "yarnpkg", *ARGV
+  rescue Errno::ENOENT
+    $stderr.puts "Yarn executable was not detected in the system."
+    $stderr.puts "Download Yarn at https://yarnpkg.com/en/docs/install"
+    exit 1
+  end
+end

data/spec/support/v5.2/config/application.rb CHANGED

@@ -10,15 +10,15 @@ require "active_storage/engine"
 require "action_controller/railtie"
 require "action_mailer/railtie"
 require "action_view/railtie"
-require "action_cable/engine"
+# require "action_cable/engine"
 # require "sprockets/railtie"
-require "rails/test_unit/railtie"
+# require "rails/test_unit/railtie"
 # Require the gems listed in Gemfile, including any gems
 # you've limited to :test, :development, or :production.
 Bundler.require(*Rails.groups)
-module RailsApp
+module V52
   class Application < Rails::Application
     # Initialize configuration defaults for originally generated Rails version.
     config.load_defaults 5.2
@@ -28,9 +28,7 @@ module RailsApp
     # -- all .rb files in that directory are automatically loaded after loading
     # the framework and any gems in your application.
-    # Only loads a smaller set of middleware suitable for API only apps.
-    # Middleware like session, flash, cookies can be added back manually.
-    # Skip views, helpers and assets when generating a new resource.
-    config.api_only = true
+    # Don't generate system test files.
+    config.generators.system_tests = nil
   end
 end

data/spec/support/v5.2/config/environments/production.rb CHANGED

@@ -33,11 +33,6 @@ Rails.application.configure do
   # Store uploaded files on the local file system (see config/storage.yml for options)
   config.active_storage.service = :local
-  # Mount Action Cable outside main process or domain
-  # config.action_cable.mount_path = nil
-  # config.action_cable.url = 'wss://example.com/cable'
-  # config.action_cable.allowed_request_origins = [ 'http://example.com', /http:\/\/example.*/ ]
   # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
   # config.force_ssl = true
@@ -53,7 +48,7 @@ Rails.application.configure do
   # Use a real queuing backend for Active Job (and separate queues per environment)
   # config.active_job.queue_adapter     = :resque
-  # config.active_job.queue_name_prefix = "rails_app_#{Rails.env}"
+  # config.active_job.queue_name_prefix = "v5_2_#{Rails.env}"
   config.action_mailer.perform_caching = false

data/spec/support/v5.2/config/initializers/content_security_policy.rb ADDED

@@ -0,0 +1,26 @@
+# typed: strong
+# Be sure to restart your server when you modify this file.
+# Define an application-wide content security policy
+# For further information see the following documentation
+# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
+# Rails.application.config.content_security_policy do |policy|
+#   policy.default_src :self, :https
+#   policy.font_src    :self, :https, :data
+#   policy.img_src     :self, :https, :data
+#   policy.object_src  :none
+#   policy.script_src  :self, :https
+#   policy.style_src   :self, :https
+#   # Specify URI for violation reports
+#   # policy.report_uri "/csp-violation-report-endpoint"
+# end
+# If you are using UJS then enable automatic nonce generation
+# Rails.application.config.content_security_policy_nonce_generator = -> request { SecureRandom.base64(16) }
+# Report CSP violations to a specified URI
+# For further information see the following documentation:
+# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy-Report-Only
+# Rails.application.config.content_security_policy_report_only = true

data/spec/support/v5.2/config/initializers/cookies_serializer.rb ADDED

@@ -0,0 +1,6 @@
+# typed: strict
+# Be sure to restart your server when you modify this file.
+# Specify a serializer for the signed and encrypted cookie jars.
+# Valid options are :json, :marshal, and :hybrid.
+Rails.application.config.action_dispatch.cookies_serializer = :json

data/spec/support/v5.2/config/initializers/sorbet_rails.rb ADDED

@@ -0,0 +1,3 @@
+# typed: strict
+require(Rails.root.join('lib/mythical_rbi_plugin'))
+SorbetRails::ModelRbiFormatter.register_plugin(MythicalRbiPlugin)

data/spec/support/v5.2/config/routes.rb ADDED

@@ -0,0 +1,5 @@
+# typed: strict
+Rails.application.routes.draw do
+  get 'test/index' => 'test#index'
+  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
+end

data/spec/support/v5.2/db/migrate/20190620000001_create_wizards.rb ADDED

@@ -0,0 +1,13 @@
+# typed: true
+class CreateWizards < ActiveRecord::Migration[5.2]
+  def change
+    create_table :wizards do |t|
+      t.string :name
+      t.integer :house
+      t.string :parent_email
+      t.text :notes
+      t.timestamps
+    end
+  end
+end

data/spec/support/v5.2/db/migrate/20190620000002_create_wands.rb ADDED

@@ -0,0 +1,12 @@
+# typed: true
+class CreateWands < ActiveRecord::Migration[5.2]
+  def change
+    create_table :wands do |t|
+      t.references :wizard, unique: true, null: false
+      t.string :wood_type
+      t.integer :core_type
+      t.timestamps
+    end
+  end
+end

data/spec/support/v5.2/db/migrate/20190620000003_create_spell_books.rb ADDED

@@ -0,0 +1,9 @@
+# typed: true
+class CreateSpellBooks < ActiveRecord::Migration[5.2]
+  def change
+    create_table :spell_books do |t|
+      t.string :name
+      t.references :wizard
+    end
+  end
+end

data/spec/support/v5.2/db/migrate/20190620000004_add_more_column_types_to_wands.rb ADDED

@@ -0,0 +1,16 @@
+# typed: true
+class AddMoreColumnTypesToWands < ActiveRecord::Migration[5.2]
+  def change
+    add_column :wands, :flexibility,    :float,   null: false, default: 0.5
+    add_column :wands, :hardness,       :decimal, null: false, precision: 10, scale: 10, default: 5
+    add_column :wands, :reflectance,    :decimal, null: false, precision: 10, scale: 0, default: 0.5
+    add_column :wands, :broken,         :boolean, null: false, default: false
+    add_column :wands, :chosen_at_date, :date
+    add_column :wands, :chosen_at_time, :time
+    # JSON column type is only supported on 5.2 or higher
+    unless ['4.2', '5.0', '5.1'].include?(ENV['RAILS_VERSION'])
+      add_column :wands, :spell_history,  :json
+      add_column :wands, :maker_info,     :json,    null: false, default: '{}'
+    end
+  end
+end

data/spec/support/v5.2/db/schema.rb CHANGED

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
-ActiveRecord::Schema.define(version: 2019_06_22_000000) do
+ActiveRecord::Schema.define(version: 2019_06_20_000004) do
   create_table "spell_books", force: :cascade do |t|
     t.string "name"

data/spec/support/{v5.2-no-sorbet/test/models → v5.2/lib/assets}/.keep RENAMED

File without changes

data/spec/support/v5.2/lib/mythical_rbi_plugin.rb ADDED

@@ -0,0 +1,16 @@
+# typed: true
+class MythicalRbiPlugin < SorbetRails::ModelPlugins::Base
+  def generate(root)
+    return unless @model_class.include?(Mythical)
+    model_class_rbi = root.create_class(self.model_class_name)
+    # ActiveSupport::Concern class method will be inserted to the class
+    # directly. We need to also put the sig in the model class rbi directly
+    model_class_rbi.create_method(
+      'mythicals',
+      class_method: true,
+      return_type: "T::Array[#{@model_class.name}]",
+    )
+  end
+end

data/spec/support/v5.2/package.json ADDED

@@ -0,0 +1,5 @@
+{
+  "name": "v5_2",
+  "private": true,
+  "dependencies": {}
+}

data/spec/support/v5.2/sorbet/rbi/gems/actionmailer.rbi CHANGED

@@ -350,7 +350,7 @@ class ActionMailer::Base < AbstractController::Base
   extend ActiveSupport::Callbacks::ClassMethods
   extend ActiveSupport::DescendantsTracker
   extend ActiveSupport::Rescuable::ClassMethods
-  extend Anonymous_Module_19
+  extend Anonymous_Module_17
   include AbstractController::AssetPaths
   include AbstractController::Caching
   include AbstractController::Caching::Fragments
@@ -386,54 +386,6 @@ class ActionMailer::Base::LateAttachmentsProxy < SimpleDelegator
   def _raise_error; end
   def inline; end
 end
-module Anonymous_Module_19
+module Anonymous_Module_17
   def inherited(klass); end
 end
-module ActionMailer::TestHelper
-  def assert_emails(number); end
-  def assert_enqueued_email_with(mailer, method, args: nil, queue: nil, &block); end
-  def assert_enqueued_emails(number, &block); end
-  def assert_no_emails(&block); end
-  def assert_no_enqueued_emails(&block); end
-  include ActiveJob::TestHelper
-end
-class ActionMailer::NonInferrableMailerError < StandardError
-  def initialize(name); end
-end
-class ActionMailer::TestCase < ActiveSupport::TestCase
-  def _mailer_class; end
-  def _mailer_class=(val); end
-  def _mailer_class?; end
-  def self.__callbacks; end
-  def self._mailer_class; end
-  def self._mailer_class=(val); end
-  def self._mailer_class?; end
-  extend ActionMailer::TestCase::Behavior::ClassMethods
-  extend ActiveSupport::Testing::ConstantLookup::ClassMethods
-  include ActionMailer::TestCase::Behavior
-  include ActiveSupport::Testing::ConstantLookup
-end
-module ActionMailer::TestCase::ClearTestDeliveries
-  def clear_test_deliveries; end
-  extend ActiveSupport::Concern
-end
-module ActionMailer::TestCase::Behavior
-  def charset; end
-  def encode(subject); end
-  def initialize_test_deliveries; end
-  def read_fixture(action); end
-  def restore_delivery_method; end
-  def restore_test_deliveries; end
-  def set_delivery_method(method); end
-  def set_expected_mail; end
-  extend ActiveSupport::Concern
-  include ActionMailer::TestHelper
-  include ActiveSupport::Testing::ConstantLookup
-  include Rails::Dom::Testing::Assertions::DomAssertions
-  include Rails::Dom::Testing::Assertions::SelectorAssertions
-end
-module ActionMailer::TestCase::Behavior::ClassMethods
-  def determine_default_mailer(name); end
-  def mailer_class; end
-  def tests(mailer); end
-end

data/spec/support/v5.2/sorbet/rbi/gems/actionpack.rbi CHANGED

@@ -173,6 +173,7 @@ class ActionDispatch::Response::ContentTypeHeader < Struct
   def mime_type; end
   def mime_type=(_); end
   def self.[](*arg0); end
+  def self.inspect; end
   def self.members; end
   def self.new(*arg0); end
 end
@@ -479,6 +480,7 @@ class ActionDispatch::Journey::Format::Parameter < Struct
   def name; end
   def name=(_); end
   def self.[](*arg0); end
+  def self.inspect; end
   def self.members; end
   def self.new(*arg0); end
 end
@@ -1380,6 +1382,7 @@ class ActionDispatch::Routing::RouteSet::Config < Struct
   def relative_url_root; end
   def relative_url_root=(_); end
   def self.[](*arg0); end
+  def self.inspect; end
   def self.members; end
   def self.new(*arg0); end
 end
@@ -1589,6 +1592,85 @@ class ActionDispatch::Callbacks
   extend ActiveSupport::DescendantsTracker
   include ActiveSupport::Callbacks
 end
+module ActionController::ApiRendering
+  def render_to_body(options = nil); end
+  extend ActiveSupport::Concern
+end
+class ActionDispatch::Routing::RouteWrapper < SimpleDelegator
+  def action; end
+  def constraints; end
+  def controller; end
+  def endpoint; end
+  def engine?; end
+  def internal?; end
+  def name; end
+  def path; end
+  def rack_app; end
+  def reqs; end
+end
+class ActionDispatch::Routing::RoutesInspector
+  def collect_engine_routes(route); end
+  def collect_routes(routes); end
+  def filter_routes(filter); end
+  def format(formatter, filter = nil); end
+  def initialize(routes); end
+  def normalize_filter(filter); end
+end
+class ActionDispatch::Routing::ConsoleFormatter
+  def draw_header(routes); end
+  def draw_section(routes); end
+  def header(routes); end
+  def initialize; end
+  def no_routes(routes); end
+  def result; end
+  def section(routes); end
+  def section_title(title); end
+  def widths(routes); end
+end
+class ActionDispatch::Routing::HtmlTableFormatter
+  def header(routes); end
+  def initialize(view); end
+  def no_routes(*arg0); end
+  def result; end
+  def section(routes); end
+  def section_title(title); end
+end
+class ActionDispatch::DebugExceptions
+  def api_request?(content_type); end
+  def call(env); end
+  def create_template(request, wrapper); end
+  def initialize(app, routes_app = nil, response_format = nil); end
+  def log_array(logger, array); end
+  def log_error(request, wrapper); end
+  def logger(request); end
+  def render(status, body, format); end
+  def render_exception(request, exception); end
+  def render_for_api_request(content_type, wrapper); end
+  def render_for_browser_request(request, wrapper); end
+  def routes_inspector(exception); end
+  def stderr_logger; end
+end
+class ActionDispatch::DebugExceptions::DebugView < ActionView::Base
+  def debug_hash(object); end
+  def debug_headers(headers); end
+  def debug_params(params); end
+  def render(*arg0); end
+end
+class ActionDispatch::RemoteIp
+  def call(env); end
+  def check_ip; end
+  def initialize(app, ip_spoofing_check = nil, custom_proxies = nil); end
+  def proxies; end
+end
+class ActionDispatch::RemoteIp::IpSpoofAttackError < StandardError
+end
+class ActionDispatch::RemoteIp::GetIp
+  def calculate_ip; end
+  def filter_proxies(ips); end
+  def initialize(req, check_ip, proxies); end
+  def ips_from(header); end
+  def to_s; end
+end
 class ActionDispatch::MiddlewareStack
   def [](i); end
   def assert_index(index, where); end
@@ -1644,21 +1726,6 @@ class ActionDispatch::RequestId
   def internal_request_id; end
   def make_request_id(request_id); end
 end
-class ActionDispatch::RemoteIp
-  def call(env); end
-  def check_ip; end
-  def initialize(app, ip_spoofing_check = nil, custom_proxies = nil); end
-  def proxies; end
-end
-class ActionDispatch::RemoteIp::IpSpoofAttackError < StandardError
-end
-class ActionDispatch::RemoteIp::GetIp
-  def calculate_ip; end
-  def filter_proxies(ips); end
-  def initialize(req, check_ip, proxies); end
-  def ips_from(header); end
-  def to_s; end
-end
 class ActionDispatch::ShowExceptions
   def call(env); end
   def initialize(app, exceptions_app); end
@@ -1674,67 +1741,133 @@ class ActionDispatch::PublicExceptions
   def render_format(status, content_type, body); end
   def render_html(status); end
 end
-class ActionDispatch::Routing::RouteWrapper < SimpleDelegator
-  def action; end
-  def constraints; end
-  def controller; end
-  def endpoint; end
-  def engine?; end
-  def internal?; end
-  def name; end
-  def path; end
-  def rack_app; end
-  def reqs; end
+class ActionDispatch::Reloader < ActionDispatch::Executor
 end
-class ActionDispatch::Routing::RoutesInspector
-  def collect_engine_routes(route); end
-  def collect_routes(routes); end
-  def filter_routes(filter); end
-  def format(formatter, filter = nil); end
-  def initialize(routes); end
-  def normalize_filter(filter); end
+class ActionDispatch::Request::Session
+  def [](key); end
+  def []=(key, value); end
+  def clear; end
+  def delete(key); end
+  def destroy; end
+  def each(&block); end
+  def empty?; end
+  def exists?; end
+  def fetch(key, default = nil, &block); end
+  def has_key?(key); end
+  def id; end
+  def include?(key); end
+  def initialize(by, req); end
+  def inspect; end
+  def key?(key); end
+  def keys; end
+  def load!; end
+  def load_for_read!; end
+  def load_for_write!; end
+  def loaded?; end
+  def merge!(other); end
+  def options; end
+  def self.create(store, req, default_options); end
+  def self.find(req); end
+  def self.set(req, session); end
+  def stringify_keys(other); end
+  def to_h; end
+  def to_hash; end
+  def update(hash); end
+  def values; end
 end
-class ActionDispatch::Routing::ConsoleFormatter
-  def draw_header(routes); end
-  def draw_section(routes); end
-  def header(routes); end
+class ActionDispatch::Request::Session::Options
+  def [](key); end
+  def []=(k, v); end
+  def id(req); end
+  def initialize(by, default_options); end
+  def self.find(req); end
+  def self.set(req, options); end
+  def to_hash; end
+  def values_at(*args); end
+end
+class ActionDispatch::Session::SessionRestoreError < StandardError
   def initialize; end
-  def no_routes(routes); end
-  def result; end
-  def section(routes); end
-  def section_title(title); end
-  def widths(routes); end
 end
-class ActionDispatch::Routing::HtmlTableFormatter
-  def header(routes); end
-  def initialize(view); end
-  def no_routes(*arg0); end
-  def result; end
-  def section(routes); end
-  def section_title(title); end
+module ActionDispatch::Session::Compatibility
+  def generate_sid; end
+  def initialize(app, options = nil); end
+  def initialize_sid; end
+  def make_request(env); end
 end
-class ActionDispatch::DebugExceptions
-  def api_request?(content_type); end
-  def call(env); end
-  def create_template(request, wrapper); end
-  def initialize(app, routes_app = nil, response_format = nil); end
-  def log_array(logger, array); end
-  def log_error(request, wrapper); end
-  def logger(request); end
-  def render(status, body, format); end
-  def render_exception(request, exception); end
-  def render_for_api_request(content_type, wrapper); end
-  def render_for_browser_request(request, wrapper); end
-  def routes_inspector(exception); end
-  def stderr_logger; end
+module ActionDispatch::Session::StaleSessionCheck
+  def extract_session_id(env); end
+  def load_session(env); end
+  def stale_session_check!; end
+end
+module ActionDispatch::Session::SessionObject
+  def loaded_session?(session); end
+  def prepare_session(req); end
+end
+class ActionDispatch::Session::AbstractStore < Rack::Session::Abstract::Persisted
+  def set_cookie(request, session_id, cookie); end
+  include ActionDispatch::Session::Compatibility
+  include ActionDispatch::Session::SessionObject
+  include ActionDispatch::Session::StaleSessionCheck
+end
+class ActionDispatch::Session::CookieStore < ActionDispatch::Session::AbstractStore
+  def cookie_jar(request); end
+  def delete_session(req, session_id, options); end
+  def extract_session_id(req); end
+  def get_cookie(req); end
+  def initialize(app, options = nil); end
+  def load_session(req); end
+  def persistent_session_id!(data, sid = nil); end
+  def set_cookie(request, session_id, cookie); end
+  def unpacked_cookie_data(req); end
+  def write_session(req, sid, session_data, options); end
 end
-class ActionDispatch::DebugExceptions::DebugView < ActionView::Base
-  def debug_hash(object); end
-  def debug_headers(headers); end
-  def debug_params(params); end
-  def render(*arg0); end
+class ActionDispatch::Flash
+  def self.new(app); end
 end
-class ActionDispatch::Reloader < ActionDispatch::Executor
+module ActionDispatch::Flash::RequestMethods
+  def commit_flash; end
+  def flash; end
+  def flash=(flash); end
+  def flash_hash; end
+  def reset_session; end
+end
+class ActionDispatch::Flash::FlashNow
+  def [](k); end
+  def []=(k, v); end
+  def alert=(message); end
+  def flash; end
+  def flash=(arg0); end
+  def initialize(flash); end
+  def notice=(message); end
+end
+class ActionDispatch::Flash::FlashHash
+  def [](k); end
+  def []=(k, v); end
+  def alert; end
+  def alert=(message); end
+  def clear; end
+  def delete(key); end
+  def discard(k = nil); end
+  def each(&block); end
+  def empty?; end
+  def initialize(flashes = nil, discard = nil); end
+  def initialize_copy(other); end
+  def keep(k = nil); end
+  def key?(name); end
+  def keys; end
+  def merge!(h); end
+  def notice; end
+  def notice=(message); end
+  def now; end
+  def now_is_loaded?; end
+  def replace(h); end
+  def self.from_session_value(value); end
+  def stringify_array(array); end
+  def sweep; end
+  def to_hash; end
+  def to_session_value; end
+  def update(h); end
+  include Enumerable
 end
 class ActionDispatch::Routing::Redirect < ActionDispatch::Routing::Endpoint
   def block; end
@@ -1967,23 +2100,69 @@ class ActionDispatch::Routing::Mapper::Scope
 end
 class ActionController::LogSubscriber < ActiveSupport::LogSubscriber
 end
-class AbstractController::Error < StandardError
+module ActionController::ParamsWrapper
+  def _extract_parameters(parameters); end
+  def _wrap_parameters(parameters); end
+  def _wrapper_enabled?; end
+  def _wrapper_formats; end
+  def _wrapper_key; end
+  def process_action(*args); end
+  extend ActiveSupport::Concern
 end
-class AbstractController::ActionNotFound < StandardError
+class Anonymous_Struct_2 < Struct
+  def exclude; end
+  def exclude=(_); end
+  def format; end
+  def format=(_); end
+  def include; end
+  def include=(_); end
+  def klass; end
+  def klass=(_); end
+  def model; end
+  def model=(_); end
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
 end
-class AbstractController::Base
-  def _find_action_name(action_name); end
-  def _handle_action_missing(*args); end
-  def _valid_action_name?(action_name); end
-  def action_method?(name); end
-  def action_methods; end
-  def action_name; end
-  def action_name=(arg0); end
-  def available_action?(action_name); end
-  def controller_path; end
-  def formats; end
-  def formats=(arg0); end
-  def method_for_action(action_name); end
+class ActionController::ParamsWrapper::Options < Anonymous_Struct_2
+  def _default_wrap_model; end
+  def include; end
+  def initialize(name, format, include, exclude, klass, model); end
+  def lock; end
+  def locked?; end
+  def model; end
+  def name; end
+  def self.from_hash(hash); end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+  include Mutex_m
+end
+module ActionController::ParamsWrapper::ClassMethods
+  def _set_wrapper_options(options); end
+  def inherited(klass); end
+  def wrap_parameters(name_or_model_or_options, options = nil); end
+end
+class AbstractController::Error < StandardError
+end
+class AbstractController::ActionNotFound < StandardError
+end
+class AbstractController::Base
+  def _find_action_name(action_name); end
+  def _handle_action_missing(*args); end
+  def _valid_action_name?(action_name); end
+  def action_method?(name); end
+  def action_methods; end
+  def action_name; end
+  def action_name=(arg0); end
+  def available_action?(action_name); end
+  def controller_path; end
+  def formats; end
+  def formats=(arg0); end
+  def method_for_action(action_name); end
   def performed?; end
   def process(action, *args); end
   def process_action(method_name, *args); end
@@ -2052,7 +2231,6 @@ class ActionController::Metal < AbstractController::Base
   def status=(arg); end
   def to_a; end
   def url_for(string); end
-  include ActionController::Testing::Functional
 end
 class AbstractController::DoubleRenderError < AbstractController::Error
   def initialize(message = nil); end
@@ -2075,6 +2253,15 @@ module AbstractController::Rendering
   extend ActiveSupport::Concern
   include ActionView::ViewPaths
 end
+module AbstractController::Translation
+  def l(*args); end
+  def localize(*args); end
+  def t(key, options = nil); end
+  def translate(key, options = nil); end
+end
+module AbstractController::AssetPaths
+  extend ActiveSupport::Concern
+end
 module AbstractController::UrlFor
   def _routes; end
   extend ActiveSupport::Concern
@@ -2103,10 +2290,27 @@ module ActionController::Redirecting
   include AbstractController::Logger
   include ActionController::UrlFor
 end
-module ActionController::ApiRendering
+module ActionController::Rendering
+  def _normalize_args(action = nil, options = nil, &blk); end
+  def _normalize_options(options); end
+  def _normalize_text(options); end
+  def _process_options(options); end
+  def _process_variant(options); end
+  def _render_in_priorities(options); end
+  def _set_html_content_type; end
+  def _set_rendered_content_type(format); end
+  def process_action(*arg0); end
+  def render(*args); end
   def render_to_body(options = nil); end
+  def render_to_string(*arg0); end
   extend ActiveSupport::Concern
 end
+module ActionController::Rendering::ClassMethods
+  def inherited(klass); end
+  def render(*args, &block); end
+  def renderer; end
+  def setup_renderer!; end
+end
 class ActionController::MissingRenderer < LoadError
   def initialize(format); end
 end
@@ -2146,145 +2350,6 @@ end
 module ActionController::ConditionalGet::ClassMethods
   def etag(&etagger); end
 end
-module ActionController::BasicImplicitRender
-  def default_render(*args); end
-  def send_action(method, *args); end
-end
-module AbstractController::Callbacks
-  def process_action(*args); end
-  extend ActiveSupport::Concern
-  include ActiveSupport::Callbacks
-end
-module AbstractController::Callbacks::ClassMethods
-  def _insert_callbacks(callbacks, block = nil); end
-  def _normalize_callback_option(options, from, to); end
-  def _normalize_callback_options(options); end
-  def after_action(*names, &blk); end
-  def append_after_action(*names, &blk); end
-  def append_around_action(*names, &blk); end
-  def append_before_action(*names, &blk); end
-  def around_action(*names, &blk); end
-  def before_action(*names, &blk); end
-  def prepend_after_action(*names, &blk); end
-  def prepend_around_action(*names, &blk); end
-  def prepend_before_action(*names, &blk); end
-  def skip_after_action(*names); end
-  def skip_around_action(*names); end
-  def skip_before_action(*names); end
-end
-module ActionController::ForceSSL
-  def force_ssl_redirect(host_or_options = nil); end
-  extend ActiveSupport::Concern
-  include AbstractController::Callbacks
-end
-module ActionController::ForceSSL::ClassMethods
-  def force_ssl(options = nil); end
-end
-module ActionController::Rendering
-  def _normalize_args(action = nil, options = nil, &blk); end
-  def _normalize_options(options); end
-  def _normalize_text(options); end
-  def _process_options(options); end
-  def _process_variant(options); end
-  def _render_in_priorities(options); end
-  def _set_html_content_type; end
-  def _set_rendered_content_type(format); end
-  def process_action(*arg0); end
-  def render(*args); end
-  def render_to_body(options = nil); end
-  def render_to_string(*arg0); end
-  extend ActiveSupport::Concern
-end
-module ActionController::Rendering::ClassMethods
-  def inherited(klass); end
-  def render(*args, &block); end
-  def renderer; end
-  def setup_renderer!; end
-end
-module ActionController::DataStreaming
-  def send_data(data, options = nil); end
-  def send_file(path, options = nil); end
-  def send_file_headers!(options); end
-  extend ActiveSupport::Concern
-  include ActionController::Rendering
-end
-module ActionController::Rescue
-  def process_action(*args); end
-  def show_detailed_exceptions?; end
-  extend ActiveSupport::Concern
-  include ActiveSupport::Rescuable
-end
-module ActionController::Instrumentation
-  def append_info_to_payload(payload); end
-  def cleanup_view_runtime; end
-  def halted_callback_hook(filter); end
-  def process_action(*args); end
-  def redirect_to(*args); end
-  def render(*args); end
-  def send_data(data, options = nil); end
-  def send_file(path, options = nil); end
-  def view_runtime; end
-  def view_runtime=(arg0); end
-  extend ActiveSupport::Concern
-  include AbstractController::Logger
-end
-module ActionController::Instrumentation::ClassMethods
-  def log_process_action(payload); end
-end
-module ActionController::ParamsWrapper
-  def _extract_parameters(parameters); end
-  def _wrap_parameters(parameters); end
-  def _wrapper_enabled?; end
-  def _wrapper_formats; end
-  def _wrapper_key; end
-  def process_action(*args); end
-  extend ActiveSupport::Concern
-end
-class Anonymous_Struct_2 < Struct
-  def exclude; end
-  def exclude=(_); end
-  def format; end
-  def format=(_); end
-  def include; end
-  def include=(_); end
-  def klass; end
-  def klass=(_); end
-  def model; end
-  def model=(_); end
-  def name; end
-  def name=(_); end
-  def self.[](*arg0); end
-  def self.members; end
-  def self.new(*arg0); end
-end
-class ActionController::ParamsWrapper::Options < Anonymous_Struct_2
-  def _default_wrap_model; end
-  def include; end
-  def initialize(name, format, include, exclude, klass, model); end
-  def lock; end
-  def locked?; end
-  def model; end
-  def name; end
-  def self.from_hash(hash); end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
-  include Mutex_m
-end
-module ActionController::ParamsWrapper::ClassMethods
-  def _set_wrapper_options(options); end
-  def inherited(klass); end
-  def wrap_parameters(name_or_model_or_options, options = nil); end
-end
-module AbstractController::Translation
-  def l(*args); end
-  def localize(*args); end
-  def t(key, options = nil); end
-  def translate(key, options = nil); end
-end
-module AbstractController::AssetPaths
-  extend ActiveSupport::Concern
-end
 module ActionController::EtagWithTemplateDigest
   def determine_template_etag(options); end
   def lookup_and_digest_template(template); end
@@ -2333,6 +2398,7 @@ module AbstractController::Collector
   def url_encoded_form(*args, &block); end
   def vcf(*args, &block); end
   def vtt(*args, &block); end
+  def web_console_v2(*args, &block); end
   def webm(*args, &block); end
   def woff(*args, &block); end
   def woff2(*args, &block); end
@@ -2362,6 +2428,10 @@ class ActionController::MimeResponds::Collector::VariantCollector
   def variant; end
   def variant_key; end
 end
+module ActionController::BasicImplicitRender
+  def default_render(*args); end
+  def send_action(method, *args); end
+end
 module ActionController::ImplicitRender
   def default_render(*args); end
   def interactive_browser_request?; end
@@ -2395,6 +2465,28 @@ end
 module ActionController::FormBuilder::ClassMethods
   def default_form_builder(builder); end
 end
+module AbstractController::Callbacks
+  def process_action(*args); end
+  extend ActiveSupport::Concern
+  include ActiveSupport::Callbacks
+end
+module AbstractController::Callbacks::ClassMethods
+  def _insert_callbacks(callbacks, block = nil); end
+  def _normalize_callback_option(options, from, to); end
+  def _normalize_callback_options(options); end
+  def after_action(*names, &blk); end
+  def append_after_action(*names, &blk); end
+  def append_around_action(*names, &blk); end
+  def append_before_action(*names, &blk); end
+  def around_action(*names, &blk); end
+  def before_action(*names, &blk); end
+  def prepend_after_action(*names, &blk); end
+  def prepend_around_action(*names, &blk); end
+  def prepend_before_action(*names, &blk); end
+  def skip_after_action(*names); end
+  def skip_around_action(*names); end
+  def skip_before_action(*names); end
+end
 class ActionController::InvalidAuthenticityToken < ActionController::ActionControllerError
 end
 class ActionController::InvalidCrossOriginRequest < ActionController::ActionControllerError
@@ -2465,11 +2557,26 @@ module ActionController::ContentSecurityPolicy::ClassMethods
   def content_security_policy(enabled = nil, **options, &block); end
   def content_security_policy_report_only(report_only = nil, **options); end
 end
+module ActionController::ForceSSL
+  def force_ssl_redirect(host_or_options = nil); end
+  extend ActiveSupport::Concern
+  include AbstractController::Callbacks
+end
+module ActionController::ForceSSL::ClassMethods
+  def force_ssl(options = nil); end
+end
 module ActionController::Streaming
   def _process_options(options); end
   def _render_template(options); end
   extend ActiveSupport::Concern
 end
+module ActionController::DataStreaming
+  def send_data(data, options = nil); end
+  def send_file(path, options = nil); end
+  def send_file_headers!(options); end
+  extend ActiveSupport::Concern
+  include ActionController::Rendering
+end
 module ActionController::HttpAuthentication
 end
 module ActionController::HttpAuthentication::Basic
@@ -2529,16 +2636,39 @@ module ActionController::HttpAuthentication::Token::ControllerMethods
   def authenticate_with_http_token(&login_procedure); end
   def request_http_token_authentication(realm = nil, message = nil); end
 end
-module AbstractController::Caching
-  def cache(key, options = nil, &block); end
-  def view_cache_dependencies; end
-  extend ActiveSupport::Autoload
+module ActionController::Rescue
+  def process_action(*args); end
+  def show_detailed_exceptions?; end
   extend ActiveSupport::Concern
-  include AbstractController::Caching::ConfigMethods
-  include AbstractController::Caching::Fragments
+  include ActiveSupport::Rescuable
 end
-module AbstractController::Caching::Fragments
-  def combined_fragment_cache_key(key); end
+module ActionController::Instrumentation
+  def append_info_to_payload(payload); end
+  def cleanup_view_runtime; end
+  def halted_callback_hook(filter); end
+  def process_action(*args); end
+  def redirect_to(*args); end
+  def render(*args); end
+  def send_data(data, options = nil); end
+  def send_file(path, options = nil); end
+  def view_runtime; end
+  def view_runtime=(arg0); end
+  extend ActiveSupport::Concern
+  include AbstractController::Logger
+end
+module ActionController::Instrumentation::ClassMethods
+  def log_process_action(payload); end
+end
+module AbstractController::Caching
+  def cache(key, options = nil, &block); end
+  def view_cache_dependencies; end
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+  include AbstractController::Caching::ConfigMethods
+  include AbstractController::Caching::Fragments
+end
+module AbstractController::Caching::Fragments
+  def combined_fragment_cache_key(key); end
   def expire_fragment(key, options = nil); end
   def fragment_cache_key(key); end
   def fragment_exist?(key, options = nil); end
@@ -2570,6 +2700,146 @@ class ActionController::Renderer
   def self.for(controller, env = nil, defaults = nil); end
   def with_defaults(defaults); end
 end
+class ActionController::API < ActionController::Metal
+  def __callbacks; end
+  def __callbacks?; end
+  def _helper_methods; end
+  def _helper_methods=(val); end
+  def _helper_methods?; end
+  def _helpers; end
+  def _helpers=(val); end
+  def _helpers?; end
+  def _process_action_callbacks; end
+  def _renderers; end
+  def _renderers=(val); end
+  def _renderers?; end
+  def _run_process_action_callbacks(&block); end
+  def _view_paths; end
+  def _view_paths=(val); end
+  def _view_paths?; end
+  def _wrapper_options; end
+  def _wrapper_options=(val); end
+  def _wrapper_options?; end
+  def default_url_options; end
+  def default_url_options=(val); end
+  def default_url_options?; end
+  def etaggers; end
+  def etaggers=(val); end
+  def etaggers?; end
+  def helpers_path; end
+  def helpers_path=(val); end
+  def helpers_path?; end
+  def include_all_helpers; end
+  def include_all_helpers=(val); end
+  def include_all_helpers?; end
+  def logger; end
+  def logger=(value); end
+  def rescue_handlers; end
+  def rescue_handlers=(val); end
+  def rescue_handlers?; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._helper_methods; end
+  def self._helper_methods=(val); end
+  def self._helper_methods?; end
+  def self._helpers; end
+  def self._helpers=(val); end
+  def self._helpers?; end
+  def self._process_action_callbacks; end
+  def self._process_action_callbacks=(value); end
+  def self._renderers; end
+  def self._renderers=(val); end
+  def self._renderers?; end
+  def self._view_paths; end
+  def self._view_paths=(val); end
+  def self._view_paths?; end
+  def self._wrapper_options; end
+  def self._wrapper_options=(val); end
+  def self._wrapper_options?; end
+  def self.default_url_options; end
+  def self.default_url_options=(val); end
+  def self.default_url_options?; end
+  def self.etaggers; end
+  def self.etaggers=(val); end
+  def self.etaggers?; end
+  def self.helpers_path; end
+  def self.helpers_path=(val); end
+  def self.helpers_path?; end
+  def self.include_all_helpers; end
+  def self.include_all_helpers=(val); end
+  def self.include_all_helpers?; end
+  def self.logger; end
+  def self.logger=(value); end
+  def self.middleware_stack; end
+  def self.rescue_handlers; end
+  def self.rescue_handlers=(val); end
+  def self.rescue_handlers?; end
+  def self.without_modules(*modules); end
+  extend AbstractController::Callbacks::ClassMethods
+  extend AbstractController::Helpers::ClassMethods
+  extend AbstractController::UrlFor::ClassMethods
+  extend ActionController::ConditionalGet::ClassMethods
+  extend ActionController::ForceSSL::ClassMethods
+  extend ActionController::Helpers::ClassMethods
+  extend ActionController::Instrumentation::ClassMethods
+  extend ActionController::ParamsWrapper::ClassMethods
+  extend ActionController::Railties::Helpers
+  extend ActionController::Renderers::ClassMethods
+  extend ActionController::Rendering::ClassMethods
+  extend ActionView::Rendering::ClassMethods
+  extend ActionView::ViewPaths::ClassMethods
+  extend ActiveRecord::Railties::ControllerRuntime::ClassMethods
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  extend ActiveSupport::Rescuable::ClassMethods
+  extend Anonymous_Module_3
+  include AbstractController::Callbacks
+  include AbstractController::Callbacks
+  include AbstractController::Helpers
+  include AbstractController::Logger
+  include AbstractController::Logger
+  include AbstractController::Rendering
+  include AbstractController::UrlFor
+  include ActionController::ApiRendering
+  include ActionController::BasicImplicitRender
+  include ActionController::ConditionalGet
+  include ActionController::DataStreaming
+  include ActionController::ForceSSL
+  include ActionController::Helpers
+  include ActionController::ImplicitRender
+  include ActionController::Instrumentation
+  include ActionController::ParamsWrapper
+  include ActionController::Redirecting
+  include ActionController::Renderers
+  include ActionController::Renderers::All
+  include ActionController::Rendering
+  include ActionController::Rendering
+  include ActionController::Rescue
+  include ActionController::StrongParameters
+  include ActionController::UrlFor
+  include ActionController::UrlFor
+  include ActionDispatch::Routing::RouteSet::MountedHelpers
+  include ActionDispatch::Routing::UrlFor
+  include ActionDispatch::Routing::UrlFor
+  include ActionView::Rendering
+  include ActionView::ViewPaths
+  include ActionView::ViewPaths
+  include ActiveRecord::Railties::ControllerRuntime
+  include ActiveSupport::Benchmarkable
+  include ActiveSupport::Callbacks
+  include ActiveSupport::Rescuable
+  include ActiveSupport::Rescuable
+end
+module Anonymous_Module_3
+  def inherited(klass); end
+end
+module ActionView::RoutingUrlFor
+  def default_url_options=(obj); end
+  def self.default_url_options=(obj); end
+  include ActionDispatch::Routing::UrlFor
+  include ActionDispatch::Routing::UrlFor
+end
 class ActionController::Base < ActionController::Metal
   def __callbacks; end
   def __callbacks?; end
@@ -2773,7 +3043,7 @@ class ActionController::Base < ActionController::Metal
   extend ActiveSupport::Callbacks::ClassMethods
   extend ActiveSupport::DescendantsTracker
   extend ActiveSupport::Rescuable::ClassMethods
-  extend Anonymous_Module_3
+  extend Anonymous_Module_4
   include AbstractController::AssetPaths
   include AbstractController::Caching
   include AbstractController::Caching::Fragments
@@ -2834,412 +3104,6 @@ class ActionController::Base < ActionController::Metal
   include ActiveSupport::Rescuable
   include ActiveSupport::Rescuable
 end
-module Anonymous_Module_3
-  def inherited(klass); end
-end
-module ActionView::RoutingUrlFor
-  def default_url_options=(obj); end
-  def self.default_url_options=(obj); end
-  include ActionDispatch::Routing::UrlFor
-  include ActionDispatch::Routing::UrlFor
-end
-class ActionController::API < ActionController::Metal
-  def __callbacks; end
-  def __callbacks?; end
-  def _process_action_callbacks; end
-  def _renderers; end
-  def _renderers=(val); end
-  def _renderers?; end
-  def _run_process_action_callbacks(&block); end
-  def _view_paths; end
-  def _view_paths=(val); end
-  def _view_paths?; end
-  def _wrapper_options; end
-  def _wrapper_options=(val); end
-  def _wrapper_options?; end
-  def default_url_options; end
-  def default_url_options=(val); end
-  def default_url_options?; end
-  def etaggers; end
-  def etaggers=(val); end
-  def etaggers?; end
-  def logger; end
-  def logger=(value); end
-  def rescue_handlers; end
-  def rescue_handlers=(val); end
-  def rescue_handlers?; end
-  def self.__callbacks; end
-  def self.__callbacks=(val); end
-  def self.__callbacks?; end
-  def self._process_action_callbacks; end
-  def self._process_action_callbacks=(value); end
-  def self._renderers; end
-  def self._renderers=(val); end
-  def self._renderers?; end
-  def self._view_paths; end
-  def self._view_paths=(val); end
-  def self._view_paths?; end
-  def self._wrapper_options; end
-  def self._wrapper_options=(val); end
-  def self._wrapper_options?; end
-  def self.default_url_options; end
-  def self.default_url_options=(val); end
-  def self.default_url_options?; end
-  def self.etaggers; end
-  def self.etaggers=(val); end
-  def self.etaggers?; end
-  def self.logger; end
-  def self.logger=(value); end
-  def self.middleware_stack; end
-  def self.rescue_handlers; end
-  def self.rescue_handlers=(val); end
-  def self.rescue_handlers?; end
-  def self.without_modules(*modules); end
-  extend AbstractController::Callbacks::ClassMethods
-  extend AbstractController::UrlFor::ClassMethods
-  extend ActionController::ConditionalGet::ClassMethods
-  extend ActionController::ForceSSL::ClassMethods
-  extend ActionController::Instrumentation::ClassMethods
-  extend ActionController::ParamsWrapper::ClassMethods
-  extend ActionController::Railties::Helpers
-  extend ActionController::Renderers::ClassMethods
-  extend ActionController::Rendering::ClassMethods
-  extend ActionView::ViewPaths::ClassMethods
-  extend ActiveRecord::Railties::ControllerRuntime::ClassMethods
-  extend ActiveSupport::Callbacks::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  extend ActiveSupport::Rescuable::ClassMethods
-  extend Anonymous_Module_4
-  include AbstractController::Callbacks
-  include AbstractController::Callbacks
-  include AbstractController::Logger
-  include AbstractController::Logger
-  include AbstractController::Rendering
-  include AbstractController::UrlFor
-  include ActionController::ApiRendering
-  include ActionController::BasicImplicitRender
-  include ActionController::ConditionalGet
-  include ActionController::DataStreaming
-  include ActionController::ForceSSL
-  include ActionController::Instrumentation
-  include ActionController::ParamsWrapper
-  include ActionController::Redirecting
-  include ActionController::Renderers
-  include ActionController::Renderers::All
-  include ActionController::Rendering
-  include ActionController::Rendering
-  include ActionController::Rescue
-  include ActionController::StrongParameters
-  include ActionController::UrlFor
-  include ActionController::UrlFor
-  include ActionDispatch::Routing::RouteSet::MountedHelpers
-  include ActionDispatch::Routing::UrlFor
-  include ActionDispatch::Routing::UrlFor
-  include ActionView::ViewPaths
-  include ActiveRecord::Railties::ControllerRuntime
-  include ActiveSupport::Benchmarkable
-  include ActiveSupport::Callbacks
-  include ActiveSupport::Rescuable
-  include ActiveSupport::Rescuable
-end
 module Anonymous_Module_4
   def inherited(klass); end
 end
-module ActionController::TemplateAssertions
-  def assert_template(options = nil, message = nil); end
-end
-module ActionController::Testing
-  extend ActiveSupport::Concern
-end
-module ActionController::Testing::Functional
-  def recycle!; end
-end
-class ActionDispatch::TestRequest < ActionDispatch::Request
-  def accept=(mime_types); end
-  def action=(action_name); end
-  def host=(host); end
-  def if_modified_since=(last_modified); end
-  def if_none_match=(etag); end
-  def path=(path); end
-  def port=(number); end
-  def remote_addr=(addr); end
-  def request_method=(method); end
-  def request_uri=(uri); end
-  def self.create(env = nil); end
-  def self.default_env; end
-  def user_agent=(user_agent); end
-end
-class ActionDispatch::Flash
-  def self.new(app); end
-end
-module ActionDispatch::Flash::RequestMethods
-  def commit_flash; end
-  def flash; end
-  def flash=(flash); end
-  def flash_hash; end
-  def reset_session; end
-end
-class ActionDispatch::Flash::FlashNow
-  def [](k); end
-  def []=(k, v); end
-  def alert=(message); end
-  def flash; end
-  def flash=(arg0); end
-  def initialize(flash); end
-  def notice=(message); end
-end
-class ActionDispatch::Flash::FlashHash
-  def [](k); end
-  def []=(k, v); end
-  def alert; end
-  def alert=(message); end
-  def clear; end
-  def delete(key); end
-  def discard(k = nil); end
-  def each(&block); end
-  def empty?; end
-  def initialize(flashes = nil, discard = nil); end
-  def initialize_copy(other); end
-  def keep(k = nil); end
-  def key?(name); end
-  def keys; end
-  def merge!(h); end
-  def notice; end
-  def notice=(message); end
-  def now; end
-  def now_is_loaded?; end
-  def replace(h); end
-  def self.from_session_value(value); end
-  def stringify_array(array); end
-  def sweep; end
-  def to_hash; end
-  def to_session_value; end
-  def update(h); end
-  include Enumerable
-end
-module ActionDispatch::TestProcess
-  def assigns(key = nil); end
-  def cookies; end
-  def flash; end
-  def redirect_to_url; end
-  def session; end
-  include ActionDispatch::TestProcess::FixtureFile
-end
-module ActionDispatch::TestProcess::FixtureFile
-  def fixture_file_upload(path, mime_type = nil, binary = nil); end
-end
-module ActionDispatch::Assertions
-  def html_document; end
-  extend ActiveSupport::Concern
-  include ActionDispatch::Assertions::ResponseAssertions
-  include ActionDispatch::Assertions::RoutingAssertions
-  include Rails::Dom::Testing::Assertions
-end
-module ActionDispatch::Assertions::ResponseAssertions
-  def assert_redirected_to(options = nil, message = nil); end
-  def assert_response(type, message = nil); end
-  def code_with_name(code_or_name); end
-  def generate_response_message(expected, actual = nil); end
-  def location_if_redirected; end
-  def normalize_argument_to_redirection(fragment); end
-  def parameterize(value); end
-  def response_body_if_short; end
-end
-module ActionDispatch::Assertions::RoutingAssertions
-  def assert_generates(expected_path, options, defaults = nil, extras = nil, message = nil); end
-  def assert_recognizes(expected_options, path, extras = nil, msg = nil); end
-  def assert_routing(path, options, defaults = nil, extras = nil, message = nil); end
-  def fail_on(exception_class, message); end
-  def method_missing(selector, *args, &block); end
-  def recognized_request_for(path, extras = nil, msg); end
-  def with_routing; end
-end
-class ActionController::TestRequest < ActionDispatch::TestRequest
-  def assign_parameters(routes, controller_path, action, parameters, generated_path, query_string_keys); end
-  def content_type=(type); end
-  def controller_class; end
-  def initialize(env, session, controller_class); end
-  def params_parsers; end
-  def query_string=(string); end
-  def self.create(controller_class); end
-  def self.default_env; end
-  def self.new_session; end
-end
-class ActionController::LiveTestResponse < ActionController::Live::Response
-  def error?; end
-  def missing?; end
-  def success?; end
-end
-class ActionController::TestSession < Rack::Session::Abstract::SessionHash
-  def destroy; end
-  def exists?; end
-  def fetch(key, *args, &block); end
-  def initialize(session = nil); end
-  def keys; end
-  def load!; end
-  def values; end
-end
-class ActionController::TestCase < ActiveSupport::TestCase
-  def _controller_class; end
-  def _controller_class=(val); end
-  def _controller_class?; end
-  def self.__callbacks; end
-  def self._controller_class; end
-  def self._controller_class=(val); end
-  def self._controller_class?; end
-  extend ActionController::TestCase::Behavior::ClassMethods
-  extend ActiveSupport::Testing::ConstantLookup::ClassMethods
-  include ActionController::TemplateAssertions
-  include ActionController::TestCase::Behavior
-  include ActionDispatch::Assertions
-  include ActiveSupport::Testing::ConstantLookup
-  include Rails::Dom::Testing::Assertions
-  include Rails::Dom::Testing::Assertions
-end
-module ActionController::TestCase::Behavior
-  def build_response(klass); end
-  def check_required_ivars; end
-  def controller_class_name; end
-  def delete(action, **args); end
-  def document_root_element; end
-  def generated_path(generated_extras); end
-  def get(action, **args); end
-  def head(action, **args); end
-  def patch(action, **args); end
-  def post(action, **args); end
-  def process(action, method: nil, params: nil, session: nil, body: nil, flash: nil, format: nil, xhr: nil, as: nil); end
-  def put(action, **args); end
-  def query_parameter_names(generated_extras); end
-  def request; end
-  def response; end
-  def scrub_env!(env); end
-  def setup_controller_request_and_response; end
-  extend ActiveSupport::Concern
-  include ActionDispatch::TestProcess
-  include ActiveSupport::Testing::ConstantLookup
-  include Rails::Dom::Testing::Assertions
-end
-module ActionController::TestCase::Behavior::ClassMethods
-  def controller_class; end
-  def controller_class=(new_class); end
-  def determine_default_controller_class(name); end
-  def tests(controller_class); end
-end
-class ActionDispatch::RequestEncoder
-  def accept_header; end
-  def content_type; end
-  def encode_params(params); end
-  def initialize(mime_name, param_encoder, response_parser); end
-  def response_parser; end
-  def self.encoder(name); end
-  def self.parser(content_type); end
-  def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil); end
-end
-class ActionDispatch::RequestEncoder::IdentityEncoder
-  def accept_header; end
-  def content_type; end
-  def encode_params(params); end
-  def response_parser; end
-end
-module ActionDispatch::Integration
-end
-module ActionDispatch::Integration::RequestHelpers
-  def delete(path, **args); end
-  def follow_redirect!; end
-  def get(path, **args); end
-  def head(path, *args); end
-  def patch(path, **args); end
-  def post(path, **args); end
-  def put(path, **args); end
-end
-class ActionDispatch::Integration::Session
-  def _mock_session; end
-  def accept; end
-  def accept=(arg0); end
-  def body(*args, &block); end
-  def build_expanded_path(path); end
-  def build_full_uri(path, env); end
-  def controller; end
-  def cookies; end
-  def default_url_options; end
-  def default_url_options=(val); end
-  def default_url_options?; end
-  def headers(*args, &block); end
-  def host!(arg0); end
-  def host; end
-  def host=(arg0); end
-  def https!(flag = nil); end
-  def https?; end
-  def initialize(app); end
-  def path(*args, &block); end
-  def process(method, path, params: nil, headers: nil, env: nil, xhr: nil, as: nil); end
-  def redirect?(*args, &block); end
-  def remote_addr; end
-  def remote_addr=(arg0); end
-  def request; end
-  def request_count; end
-  def request_count=(arg0); end
-  def reset!; end
-  def response; end
-  def self.default_url_options; end
-  def self.default_url_options=(val); end
-  def self.default_url_options?; end
-  def status(*args, &block); end
-  def status_message(*args, &block); end
-  def url_options; end
-  include ActionDispatch::Routing::UrlFor
-  include ActionDispatch::TestProcess
-  include Minitest::Assertions
-  include Rails::Dom::Testing::Assertions
-end
-module ActionDispatch::Integration::Runner
-  def app; end
-  def assigns(*args); end
-  def before_setup; end
-  def cookies(*args); end
-  def copy_session_variables!; end
-  def create_session(app); end
-  def default_url_options; end
-  def default_url_options=(options); end
-  def delete(*args); end
-  def follow_redirect!(*args); end
-  def get(*args); end
-  def head(*args); end
-  def initialize(*args, &blk); end
-  def integration_session; end
-  def method_missing(method, *args, &block); end
-  def open_session; end
-  def patch(*args); end
-  def post(*args); end
-  def put(*args); end
-  def remove!; end
-  def reset!; end
-  def respond_to_missing?(method, _); end
-  include ActionDispatch::Assertions
-  include Rails::Dom::Testing::Assertions
-end
-class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  def self.__callbacks; end
-  extend ActionDispatch::IntegrationTest::Behavior::ClassMethods
-  include ActionDispatch::IntegrationTest::Behavior
-  include ActionDispatch::IntegrationTest::UrlOptions
-  include ActionDispatch::Routing::UrlFor
-  include ActionDispatch::TestProcess::FixtureFile
-  include ActionMailer::TestCase::ClearTestDeliveries
-end
-module ActionDispatch::IntegrationTest::UrlOptions
-  def url_options; end
-  extend ActiveSupport::Concern
-end
-module ActionDispatch::IntegrationTest::Behavior
-  def app; end
-  def document_root_element; end
-  extend ActiveSupport::Concern
-  include ActionController::TemplateAssertions
-  include ActionDispatch::Integration::Runner
-end
-module ActionDispatch::IntegrationTest::Behavior::ClassMethods
-  def app; end
-  def app=(app); end
-  def register_encoder(*args); end
-end