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.0/app/assets/config/manifest.js ADDED

	@@ -0,0 +1,2 @@
1	+ //= link_tree ../images
2	+ //= link_directory ../stylesheets .css

data/spec/support/v5.0/{test/fixtures → app/assets/images}/.keep RENAMED

File without changes

data/spec/support/v5.0/app/assets/stylesheets/application.css ADDED

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/support/v5.0/app/controllers/application_controller.rb ADDED

@@ -0,0 +1,4 @@
+# typed: strong
+class ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+end

data/spec/support/v5.0/{test/fixtures/files → app/controllers/concerns}/.keep RENAMED

File without changes

data/spec/support/v5.0/app/helpers/application_helper.rb ADDED

@@ -0,0 +1,3 @@
+# typed: strong
+module ApplicationHelper
+end

data/spec/support/v5.0/app/helpers/bar_helper.rb ADDED

@@ -0,0 +1,3 @@
+# typed: strong
+module BarHelper
+end

data/spec/support/v5.0/app/helpers/baz_helper.rb ADDED

@@ -0,0 +1,3 @@
+# typed: strong
+module BazHelper
+end

data/spec/support/v5.0/app/helpers/foo_helper.rb ADDED

@@ -0,0 +1,3 @@
+# typed: strong
+module FooHelper
+end

data/spec/support/v5.0/app/models/application_record.rb ADDED

@@ -0,0 +1,5 @@
+# typed: strict
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+  scope :recent, -> { where('created_at > ?', 1.month.ago) }
+end

data/spec/support/v5.0/{test/integration → app/models/concerns}/.keep RENAMED

File without changes

data/spec/support/v5.0/app/models/concerns/mythical.rb ADDED

@@ -0,0 +1,11 @@
+# typed: false
+require 'active_support/concern'
+module Mythical
+  extend ActiveSupport::Concern
+  class_methods do
+    def mythicals
+      all.to_a # yeah!
+    end
+  end
+end

data/spec/support/v5.0/app/models/potion.rb ADDED

@@ -0,0 +1,5 @@
+# typed: strong
+# an abstract class that has no table
+class Potion < ApplicationRecord
+  self.abstract_class = true
+end

data/spec/support/v5.0/app/models/spell_book.rb ADDED

@@ -0,0 +1,5 @@
+# typed: strong
+class SpellBook < ApplicationRecord
+  validates :name, length: { minimum: 5 }, presence: true
+  belongs_to :wizard
+end

data/spec/support/v5.0/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.0/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.0/app/views/layouts/application.html.erb ADDED

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

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

@@ -9,9 +9,9 @@ require "active_record/railtie"
 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.
@@ -22,10 +22,5 @@ module V50
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration should go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded.
-    # 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
   end
 end

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

@@ -27,10 +27,6 @@ Rails.application.configure do
   # config.action_dispatch.x_sendfile_header = 'X-Sendfile' # for Apache
   # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
-  # 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

data/spec/support/v5.0/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.0/config/initializers/new_framework_defaults.rb CHANGED

@@ -5,6 +5,14 @@
 #
 # Read the Guide for Upgrading Ruby on Rails for more info on each option.
+Rails.application.config.action_controller.raise_on_unfiltered_parameters = true
+# Enable per-form CSRF tokens. Previous versions had false.
+Rails.application.config.action_controller.per_form_csrf_tokens = true
+# Enable origin-checking CSRF mitigation. Previous versions had false.
+Rails.application.config.action_controller.forgery_protection_origin_check = true
 # Make Ruby 2.4 preserve the timezone of the receiver when calling `to_time`.
 # Previous versions had false.
 ActiveSupport.to_time_preserves_timezone = true

data/spec/support/v5.0/config/initializers/session_store.rb ADDED

@@ -0,0 +1,4 @@
+# typed: strict
+# Be sure to restart your server when you modify this file.
+Rails.application.config.session_store :cookie_store, key: '_v5_0_session'

data/spec/support/v5.0/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.0/config/routes.rb CHANGED

@@ -1,5 +1,5 @@
+# typed: strict
 Rails.application.routes.draw do
-  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
   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/{rails_shared/db/migrate/20190620001234_create_wizards.rb → v5.0/db/migrate/20190620000001_create_wizards.rb} RENAMED

@@ -1,4 +1,5 @@
-class CreateWizards < ActiveRecord::Migration["#{ENV['RAILS_VERSION']}" || "5.2"]
+# typed: true
+class CreateWizards < ActiveRecord::Migration[5.0]
   def change
     create_table :wizards do |t|
       t.string :name

data/spec/support/{rails_shared/db/migrate/20190620003037_create_wands.rb → v5.0/db/migrate/20190620000002_create_wands.rb} RENAMED

@@ -1,4 +1,5 @@
-class CreateWands < ActiveRecord::Migration["#{ENV['RAILS_VERSION']}" || "5.2"]
+# typed: true
+class CreateWands < ActiveRecord::Migration[5.0]
   def change
     create_table :wands do |t|
       t.references :wizard, unique: true, null: false

data/spec/support/{rails_shared/db/migrate/20190620003739_create_spell_books.rb → v5.0/db/migrate/20190620000003_create_spell_books.rb} RENAMED

@@ -1,4 +1,5 @@
-class CreateSpellBooks < ActiveRecord::Migration["#{ENV['RAILS_VERSION']}" || "5.2"]
+# typed: true
+class CreateSpellBooks < ActiveRecord::Migration[5.0]
   def change
     create_table :spell_books do |t|
       t.string :name

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

@@ -0,0 +1,16 @@
+# typed: true
+class AddMoreColumnTypesToWands < ActiveRecord::Migration[5.0]
+  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.0/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: 20190622000000) do
+ActiveRecord::Schema.define(version: 20190620000004) do
   create_table "spell_books", force: :cascade do |t|
     t.string  "name"

data/spec/support/v5.0/{test/mailers → lib/assets}/.keep RENAMED

File without changes

data/spec/support/v5.0/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.0/sorbet/rbi/gems/actionmailer.rbi CHANGED

@@ -291,7 +291,7 @@ class ActionMailer::Base < AbstractController::Base
   extend ActiveSupport::Callbacks::ClassMethods
   extend ActiveSupport::DescendantsTracker
   extend ActiveSupport::Rescuable::ClassMethods
-  extend Anonymous_Module_30
+  extend Anonymous_Module_22
   include AbstractController::AssetPaths
   include AbstractController::Caching
   include AbstractController::Caching::Fragments
@@ -326,54 +326,6 @@ class ActionMailer::Base::LateAttachmentsProxy < SimpleDelegator
   def _raise_error; end
   def inline; end
 end
-module Anonymous_Module_30
+module Anonymous_Module_22
   def inherited(klass); end
 end
-module ActionMailer::TestHelper
-  def assert_emails(number); 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=(arg0); end
-  def _mailer_class?; end
-  def self._mailer_class; end
-  def self._mailer_class=(val); end
-  def self._mailer_class?; end
-  def self._setup_callbacks; end
-  def self._teardown_callbacks; 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.0/sorbet/rbi/gems/actionpack.rbi CHANGED

@@ -145,7 +145,7 @@ class ActionDispatch::Response
   include MonitorMixin
   include Rack::Response::Helpers
 end
-class ActionDispatch::Response::Header < Anonymous_Delegator_5
+class ActionDispatch::Response::Header < Anonymous_Delegator_4
   def []=(k, v); end
   def initialize(response, header); end
   def merge(other); end
@@ -357,6 +357,86 @@ module ActionController::Railties::Helpers
 end
 class ActionController::Railtie < Rails::Railtie
 end
+module Mime
+  def self.[](type); end
+  def self.const_defined?(sym, inherit = nil); end
+  def self.const_missing(sym); end
+  def self.fetch(type); end
+end
+class Mime::Mimes
+  def <<(type); end
+  def delete_if; end
+  def each; end
+  def initialize; end
+  def symbols; end
+  include Enumerable
+end
+class Mime::Type
+  def ==(mime_type); end
+  def ===(list); end
+  def =~(mime_type); end
+  def all?; end
+  def eql?(other); end
+  def hash; end
+  def html?; end
+  def initialize(string, symbol = nil, synonyms = nil); end
+  def method_missing(method, *args); end
+  def ref; end
+  def respond_to_missing?(method, include_private = nil); end
+  def self.lookup(string); end
+  def self.lookup_by_extension(extension); end
+  def self.parse(accept_header); end
+  def self.parse_data_with_trailing_star(type); end
+  def self.parse_trailing_star(accept_header); end
+  def self.register(string, symbol, mime_type_synonyms = nil, extension_synonyms = nil, skip_lookup = nil); end
+  def self.register_alias(string, symbol, extension_synonyms = nil); end
+  def self.register_callback(&block); end
+  def self.unregister(symbol); end
+  def string; end
+  def symbol; end
+  def synonyms; end
+  def to_a; end
+  def to_ary; end
+  def to_s; end
+  def to_str; end
+  def to_sym; end
+end
+class Mime::Type::AcceptItem
+  def <=>(item); end
+  def index; end
+  def index=(arg0); end
+  def initialize(index, name, q = nil); end
+  def name; end
+  def name=(arg0); end
+  def q; end
+  def q=(arg0); end
+  def to_s; end
+end
+class Mime::Type::AcceptList
+  def self.find_item_by_name(array, name); end
+  def self.sort!(list); end
+end
+class Mime::AllType < Mime::Type
+  def all?; end
+  def html?; end
+  def initialize; end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  extend Singleton::SingletonClassMethods
+  include Singleton
+end
+class Mime::NullType
+  def method_missing(method, *args); end
+  def nil?; end
+  def ref; end
+  def respond_to_missing?(method, include_private = nil); end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  extend Singleton::SingletonClassMethods
+  include Singleton
+end
 module ActionDispatch::Routing
   extend ActiveSupport::Autoload
 end
@@ -473,7 +553,7 @@ class ActionDispatch::Journey::Format
   def self.required_path(symbol); end
   def self.required_segment(symbol); end
 end
-class Anonymous_Struct_6 < Struct
+class Anonymous_Struct_5 < Struct
   def escaper; end
   def escaper=(_); end
   def name; end
@@ -483,7 +563,7 @@ class Anonymous_Struct_6 < Struct
   def self.members; end
   def self.new(*arg0); end
 end
-class ActionDispatch::Journey::Format::Parameter < Anonymous_Struct_6
+class ActionDispatch::Journey::Format::Parameter < Anonymous_Struct_5
   def escape(value); end
 end
 module ActionDispatch::Journey::Visitors
@@ -901,86 +981,6 @@ module ActionDispatch::Http::MimeNegotiation
   def variant=(variant); end
   extend ActiveSupport::Concern
 end
-module Mime
-  def self.[](type); end
-  def self.const_defined?(sym, inherit = nil); end
-  def self.const_missing(sym); end
-  def self.fetch(type); end
-end
-class Mime::Mimes
-  def <<(type); end
-  def delete_if; end
-  def each; end
-  def initialize; end
-  def symbols; end
-  include Enumerable
-end
-class Mime::Type
-  def ==(mime_type); end
-  def ===(list); end
-  def =~(mime_type); end
-  def all?; end
-  def eql?(other); end
-  def hash; end
-  def html?; end
-  def initialize(string, symbol = nil, synonyms = nil); end
-  def method_missing(method, *args); end
-  def ref; end
-  def respond_to_missing?(method, include_private = nil); end
-  def self.lookup(string); end
-  def self.lookup_by_extension(extension); end
-  def self.parse(accept_header); end
-  def self.parse_data_with_trailing_star(type); end
-  def self.parse_trailing_star(accept_header); end
-  def self.register(string, symbol, mime_type_synonyms = nil, extension_synonyms = nil, skip_lookup = nil); end
-  def self.register_alias(string, symbol, extension_synonyms = nil); end
-  def self.register_callback(&block); end
-  def self.unregister(symbol); end
-  def string; end
-  def symbol; end
-  def synonyms; end
-  def to_a; end
-  def to_ary; end
-  def to_s; end
-  def to_str; end
-  def to_sym; end
-end
-class Mime::Type::AcceptItem
-  def <=>(item); end
-  def index; end
-  def index=(arg0); end
-  def initialize(index, name, q = nil); end
-  def name; end
-  def name=(arg0); end
-  def q; end
-  def q=(arg0); end
-  def to_s; end
-end
-class Mime::Type::AcceptList
-  def self.find_item_by_name(array, name); end
-  def self.sort!(list); end
-end
-class Mime::AllType < Mime::Type
-  def all?; end
-  def html?; end
-  def initialize; end
-  def self.allocate; end
-  def self.instance; end
-  def self.new(*arg0); end
-  extend Singleton::SingletonClassMethods
-  include Singleton
-end
-class Mime::NullType
-  def method_missing(method, *args); end
-  def nil?; end
-  def ref; end
-  def respond_to_missing?(method, include_private = nil); end
-  def self.allocate; end
-  def self.instance; end
-  def self.new(*arg0); end
-  extend Singleton::SingletonClassMethods
-  include Singleton
-end
 module ActionDispatch::Http::Parameters
   def parameters; end
   def params; end
@@ -1528,6 +1528,10 @@ 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::MiddlewareStack
   def [](i); end
   def assert_index(index, where); end
@@ -1669,6 +1673,132 @@ class ActionDispatch::RemoteIp::GetIp
   def ips_from(header); end
   def to_s; end
 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_hash; end
+  def update(hash); end
+  def values; end
+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(const_error = nil); end
+  def original_exception; end
+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
+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::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
 class ActionDispatch::Routing::Redirect < ActionDispatch::Routing::Endpoint
   def block; end
   def call(env); end
@@ -1893,16 +2023,62 @@ class ActionDispatch::Routing::Mapper::Scope
 end
 class ActionController::LogSubscriber < ActiveSupport::LogSubscriber
 end
-class AbstractController::Error < StandardError
-end
-class AbstractController::ActionNotFound < 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::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
+class Anonymous_Struct_6 < 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 ActionController::ParamsWrapper::Options < Anonymous_Struct_6
+  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
@@ -1979,7 +2155,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
@@ -2001,6 +2176,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
@@ -2031,10 +2215,26 @@ 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 _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
@@ -2074,159 +2274,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 after_filter(*names, &blk); end
-  def append_after_action(*names, &blk); end
-  def append_after_filter(*names, &blk); end
-  def append_around_action(*names, &blk); end
-  def append_around_filter(*names, &blk); end
-  def append_before_action(*names, &blk); end
-  def append_before_filter(*names, &blk); end
-  def around_action(*names, &blk); end
-  def around_filter(*names, &blk); end
-  def before_action(*names, &blk); end
-  def before_filter(*names, &blk); end
-  def prepend_after_action(*names, &blk); end
-  def prepend_after_filter(*names, &blk); end
-  def prepend_around_action(*names, &blk); end
-  def prepend_around_filter(*names, &blk); end
-  def prepend_before_action(*names, &blk); end
-  def prepend_before_filter(*names, &blk); end
-  def skip_action_callback(*names); end
-  def skip_after_action(*names); end
-  def skip_after_filter(*names, &blk); end
-  def skip_around_action(*names); end
-  def skip_around_filter(*names, &blk); end
-  def skip_before_action(*names); end
-  def skip_before_filter(*names, &blk); end
-  def skip_filter(*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 _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_7 < 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 ActionController::ParamsWrapper::Options < Anonymous_Struct_7
-  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
@@ -2290,6 +2337,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
@@ -2314,31 +2365,67 @@ end
 module ActionController::FormBuilder::ClassMethods
   def default_form_builder(builder); end
 end
-class ActionController::InvalidAuthenticityToken < ActionController::ActionControllerError
-end
-class ActionController::InvalidCrossOriginRequest < ActionController::ActionControllerError
+module AbstractController::Callbacks
+  def process_action(*args); end
+  extend ActiveSupport::Concern
+  include ActiveSupport::Callbacks
 end
-module ActionController::RequestForgeryProtection
-  def any_authenticity_token_valid?; end
-  def compare_with_real_token(token, session); end
-  def form_authenticity_param; end
-  def form_authenticity_token(form_options: nil); end
-  def handle_unverified_request; end
-  def mark_for_same_origin_verification!; end
-  def marked_for_same_origin_verification?; end
-  def masked_authenticity_token(session, form_options: nil); end
-  def non_xhr_javascript_response?; end
-  def normalize_action_path(action_path); end
-  def per_form_csrf_token(session, action_path, method); end
-  def protect_against_forgery?; end
-  def real_csrf_token(session); end
-  def request_authenticity_tokens; end
-  def unmask_token(masked_token); end
-  def valid_authenticity_token?(session, encoded_masked_token); end
-  def valid_per_form_csrf_token?(token, session); end
-  def valid_request_origin?; end
-  def verified_request?; end
-  def verify_authenticity_token; 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 after_filter(*names, &blk); end
+  def append_after_action(*names, &blk); end
+  def append_after_filter(*names, &blk); end
+  def append_around_action(*names, &blk); end
+  def append_around_filter(*names, &blk); end
+  def append_before_action(*names, &blk); end
+  def append_before_filter(*names, &blk); end
+  def around_action(*names, &blk); end
+  def around_filter(*names, &blk); end
+  def before_action(*names, &blk); end
+  def before_filter(*names, &blk); end
+  def prepend_after_action(*names, &blk); end
+  def prepend_after_filter(*names, &blk); end
+  def prepend_around_action(*names, &blk); end
+  def prepend_around_filter(*names, &blk); end
+  def prepend_before_action(*names, &blk); end
+  def prepend_before_filter(*names, &blk); end
+  def skip_action_callback(*names); end
+  def skip_after_action(*names); end
+  def skip_after_filter(*names, &blk); end
+  def skip_around_action(*names); end
+  def skip_around_filter(*names, &blk); end
+  def skip_before_action(*names); end
+  def skip_before_filter(*names, &blk); end
+  def skip_filter(*names); end
+end
+class ActionController::InvalidAuthenticityToken < ActionController::ActionControllerError
+end
+class ActionController::InvalidCrossOriginRequest < ActionController::ActionControllerError
+end
+module ActionController::RequestForgeryProtection
+  def any_authenticity_token_valid?; end
+  def compare_with_real_token(token, session); end
+  def form_authenticity_param; end
+  def form_authenticity_token(form_options: nil); end
+  def handle_unverified_request; end
+  def mark_for_same_origin_verification!; end
+  def marked_for_same_origin_verification?; end
+  def masked_authenticity_token(session, form_options: nil); end
+  def non_xhr_javascript_response?; end
+  def normalize_action_path(action_path); end
+  def per_form_csrf_token(session, action_path, method); end
+  def protect_against_forgery?; end
+  def real_csrf_token(session); end
+  def request_authenticity_tokens; end
+  def unmask_token(masked_token); end
+  def valid_authenticity_token?(session, encoded_masked_token); end
+  def valid_per_form_csrf_token?(token, session); end
+  def valid_request_origin?; end
+  def verified_request?; end
+  def verify_authenticity_token; end
   def verify_same_origin_request; end
   def xor_byte_strings(s1, s2); end
   extend ActiveSupport::Concern
@@ -2371,11 +2458,26 @@ class ActionController::RequestForgeryProtection::ProtectionMethods::Exception
   def handle_unverified_request; end
   def initialize(controller); 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
@@ -2435,6 +2537,29 @@ 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 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 AbstractController::Caching
   def cache(key, options = nil, &block); end
   def view_cache_dependencies; end
@@ -2475,6 +2600,143 @@ class ActionController::Renderer
   def self.for(controller, env = nil, defaults = nil); end
   def with_defaults(defaults); end
 end
+class ActionController::API < ActionController::Metal
+  def _helper_methods; end
+  def _helper_methods=(arg0); end
+  def _helper_methods?; end
+  def _helpers; end
+  def _helpers=(arg0); end
+  def _helpers?; end
+  def _process_action_callbacks; end
+  def _process_action_callbacks?; end
+  def _renderers; end
+  def _renderers=(arg0); end
+  def _renderers?; end
+  def _run_process_action_callbacks(&block); end
+  def _view_paths; end
+  def _view_paths=(arg0); end
+  def _view_paths?; end
+  def _wrapper_options; end
+  def _wrapper_options=(arg0); end
+  def _wrapper_options?; end
+  def default_url_options; end
+  def default_url_options=(arg0); end
+  def default_url_options?; end
+  def etaggers; end
+  def etaggers=(arg0); end
+  def etaggers?; end
+  def helpers_path; end
+  def helpers_path=(arg0); end
+  def helpers_path?; end
+  def include_all_helpers; end
+  def include_all_helpers=(arg0); end
+  def include_all_helpers?; end
+  def logger; end
+  def logger=(value); end
+  def rescue_handlers; end
+  def rescue_handlers=(arg0); end
+  def rescue_handlers?; 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=(val); end
+  def self._process_action_callbacks?; 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_7
+  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 ActionView::RoutingUrlFor
+  def default_url_options=(obj); end
+  def self.default_url_options=(obj); end
+  include ActionDispatch::Routing::UrlFor
+  include ActionDispatch::Routing::UrlFor
+end
+module Anonymous_Module_7
+  def inherited(klass); end
+end
 class ActionController::Base < ActionController::Metal
   def _helper_methods; end
   def _helper_methods=(arg0); end
@@ -2720,431 +2982,6 @@ class ActionController::Base < ActionController::Metal
   include ActiveSupport::Rescuable
   include ActiveSupport::Rescuable
 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
 module Anonymous_Module_8
   def inherited(klass); end
 end
-class ActionController::API < ActionController::Metal
-  def _process_action_callbacks; end
-  def _process_action_callbacks?; end
-  def _renderers; end
-  def _renderers=(arg0); end
-  def _renderers?; end
-  def _run_process_action_callbacks(&block); end
-  def _view_paths; end
-  def _view_paths=(arg0); end
-  def _view_paths?; end
-  def _wrapper_options; end
-  def _wrapper_options=(arg0); end
-  def _wrapper_options?; end
-  def default_url_options; end
-  def default_url_options=(arg0); end
-  def default_url_options?; end
-  def etaggers; end
-  def etaggers=(arg0); end
-  def etaggers?; end
-  def logger; end
-  def logger=(value); end
-  def rescue_handlers; end
-  def rescue_handlers=(arg0); end
-  def rescue_handlers?; end
-  def self._process_action_callbacks; end
-  def self._process_action_callbacks=(val); end
-  def self._process_action_callbacks?; 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_9
-  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_9
-  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
-module ActionController::Testing::ClassMethods
-  def before_filters; 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
-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 initialize(env, session); end
-  def params_parsers; end
-  def query_string=(string); end
-  def self.create; 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=(arg0); end
-  def _controller_class?; end
-  def self._controller_class; end
-  def self._controller_class=(val); end
-  def self._controller_class?; end
-  def self._setup_callbacks; 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 html_format?(parameters); end
-  def kwarg_request?(args); end
-  def non_kwarg_request_warning; end
-  def patch(action, *args); end
-  def post(action, *args); end
-  def process(action, *args); end
-  def process_with_kwargs(http_method, action, *args); 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
-  def xhr(*args); end
-  def xml_http_request(*args); 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 delete_via_redirect(path, *args); end
-  def follow_redirect!; end
-  def get(path, *args); end
-  def get_via_redirect(path, *args); end
-  def head(path, *args); end
-  def patch(path, *args); end
-  def patch_via_redirect(path, *args); end
-  def post(path, *args); end
-  def post_via_redirect(path, *args); end
-  def put(path, *args); end
-  def put_via_redirect(path, *args); end
-  def request_via_redirect(http_method, path, *args); end
-  def xhr(request_method, path, parameters = nil, headers_or_env = nil); end
-  def xml_http_request(request_method, path, parameters = nil, headers_or_env = nil); end
-end
-class ActionDispatch::Integration::Session
-  def _mock_session; end
-  def accept; end
-  def accept=(arg0); end
-  def body(*args, &block); end
-  def build_full_uri(path, env); end
-  def controller; end
-  def cookies; end
-  def default_url_options; end
-  def default_url_options=(arg0); 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 kwarg_request?(args); end
-  def non_kwarg_request_warning; end
-  def path(*args, &block); end
-  def process(method, path, params: nil, headers: nil, env: nil, xhr: nil, as: nil); end
-  def process_with_kwargs(http_method, path, *args); 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 get_via_redirect(*args); end
-  def head(*args); end
-  def initialize(*args, &blk); end
-  def integration_session; end
-  def method_missing(sym, *args, &block); end
-  def open_session; end
-  def patch(*args); end
-  def post(*args); end
-  def post_via_redirect(*args); end
-  def put(*args); end
-  def remove!; end
-  def reset!; end
-  def respond_to?(method, include_private = nil); end
-  def xhr(*args); end
-  def xml_http_request(*args); end
-  include ActionDispatch::Assertions
-  include Rails::Dom::Testing::Assertions
-end
-class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  def self._setup_callbacks; end
-  def self._teardown_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