sorbet-rails 0.5.1 → 0.5.2

data/spec/support/v4.2/sorbet/config

@@ -1,2 +0,0 @@
---dir
-.

data/spec/support/v4.2/sorbet/rbi/gems/actionmailer.rbi

@@ -1,267 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/actionmailer/all/actionmailer.rbi
-#
-# actionmailer-4.2.11
-module ActionMailer
-  def self.gem_version; end
-  def self.version; end
-  extend ActiveSupport::Autoload
-end
-module ActionMailer::VERSION
-end
-class ActionMailer::Railtie < Rails::Railtie
-end
-class ActionMailer::Collector
-  def all(*args, &block); end
-  def any(*args, &block); end
-  def custom(mime, options = nil); end
-  def initialize(context, &block); end
-  def responses; end
-  include AbstractController::Collector
-end
-class ActionMailer::LogSubscriber < ActiveSupport::LogSubscriber
-end
-module ActionMailer::DeliveryMethods
-  def wrap_delivery_behavior!(*args); end
-  extend ActiveSupport::Concern
-end
-module ActionMailer::DeliveryMethods::ClassMethods
-  def add_delivery_method(symbol, klass, default_options = nil); end
-  def deliveries(*args, &block); end
-  def deliveries=(arg); end
-  def wrap_delivery_behavior(mail, method = nil, options = nil); end
-end
-module ActionMailer::Previews
-  extend ActiveSupport::Concern
-end
-module ActionMailer::Previews::ClassMethods
-  def register_preview_interceptor(interceptor); end
-  def register_preview_interceptors(*interceptors); end
-end
-class ActionMailer::Preview
-  def self.all; end
-  def self.call(email); end
-  def self.email_exists?(email); end
-  def self.emails; end
-  def self.exists?(preview); end
-  def self.find(preview); end
-  def self.inform_preview_interceptors(message); end
-  def self.load_previews; end
-  def self.preview_name; end
-  def self.preview_path; end
-  def self.show_previews; end
-  extend ActiveSupport::DescendantsTracker
-end
-module ActionMailer::MailHelper
-  def attachments; end
-  def block_format(text); end
-  def format_paragraph(text, len = nil, indent = nil); end
-  def mailer; end
-  def message; end
-end
-class ActionMailer::Base < AbstractController::Base
-  def _helper_methods; end
-  def _helper_methods=(arg0); end
-  def _helper_methods?; end
-  def _helpers; end
-  def _helpers=(arg0); end
-  def _helpers?; end
-  def _layout; end
-  def _process_action_callbacks; end
-  def _process_action_callbacks?; end
-  def _protected_ivars; end
-  def _run_process_action_callbacks(&block); end
-  def _view_paths; end
-  def _view_paths=(arg0); end
-  def _view_paths?; end
-  def asset_host; end
-  def asset_host=(value); end
-  def assets_dir; end
-  def assets_dir=(value); end
-  def attachments; end
-  def collect_responses(headers); end
-  def create_parts_from_responses(m, responses); end
-  def default_asset_host_protocol; end
-  def default_asset_host_protocol=(value); end
-  def default_i18n_subject(interpolations = nil); end
-  def default_params; end
-  def default_params=(arg0); end
-  def default_params?; end
-  def default_url_options; end
-  def default_url_options=(arg0); end
-  def default_url_options?; end
-  def delivery_method; end
-  def delivery_method=(arg0); end
-  def delivery_method?; end
-  def delivery_methods; end
-  def delivery_methods=(arg0); end
-  def delivery_methods?; end
-  def each_template(paths, name, &block); end
-  def file_settings; end
-  def file_settings=(arg0); end
-  def file_settings?; end
-  def headers(args = nil); end
-  def initialize(method_name = nil, *args); end
-  def insert_part(container, response, charset); end
-  def javascripts_dir; end
-  def javascripts_dir=(value); end
-  def logger; end
-  def logger=(value); end
-  def mail(headers = nil, &block); end
-  def mailer_name; end
-  def message; end
-  def message=(arg0); end
-  def perform_deliveries; end
-  def perform_deliveries=(obj); end
-  def preview_interceptors; end
-  def preview_path; end
-  def process(method_name, *args); end
-  def raise_delivery_errors; end
-  def raise_delivery_errors=(obj); end
-  def relative_url_root; end
-  def relative_url_root=(value); 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._layout; end
-  def self._layout=(val); end
-  def self._layout?; end
-  def self._layout_conditions; end
-  def self._layout_conditions=(val); end
-  def self._layout_conditions?; end
-  def self._process_action_callbacks; end
-  def self._process_action_callbacks=(val); end
-  def self._process_action_callbacks?; end
-  def self._view_paths; end
-  def self._view_paths=(val); end
-  def self._view_paths?; end
-  def self.asset_host; end
-  def self.asset_host=(value); end
-  def self.assets_dir; end
-  def self.assets_dir=(value); end
-  def self.controller_path; end
-  def self.default(value = nil); end
-  def self.default_asset_host_protocol; end
-  def self.default_asset_host_protocol=(value); end
-  def self.default_options=(value = nil); end
-  def self.default_params; end
-  def self.default_params=(val); end
-  def self.default_params?; end
-  def self.default_url_options; end
-  def self.default_url_options=(val); end
-  def self.default_url_options?; end
-  def self.deliver_mail(mail); end
-  def self.delivery_method; end
-  def self.delivery_method=(val); end
-  def self.delivery_method?; end
-  def self.delivery_methods; end
-  def self.delivery_methods=(val); end
-  def self.delivery_methods?; end
-  def self.file_settings; end
-  def self.file_settings=(val); end
-  def self.file_settings?; end
-  def self.javascripts_dir; end
-  def self.javascripts_dir=(value); end
-  def self.logger; end
-  def self.logger=(value); end
-  def self.mailer_name; end
-  def self.mailer_name=(arg0); end
-  def self.method_missing(method_name, *args); end
-  def self.new(*arg0); end
-  def self.perform_deliveries; end
-  def self.perform_deliveries=(obj); end
-  def self.preview_interceptors; end
-  def self.preview_interceptors=(obj); end
-  def self.preview_path; end
-  def self.preview_path=(obj); end
-  def self.raise_delivery_errors; end
-  def self.raise_delivery_errors=(obj); end
-  def self.receive(raw_mail); end
-  def self.register_interceptor(interceptor); end
-  def self.register_interceptors(*interceptors); end
-  def self.register_observer(observer); end
-  def self.register_observers(*observers); end
-  def self.relative_url_root; end
-  def self.relative_url_root=(value); end
-  def self.respond_to?(method, include_private = nil); end
-  def self.sendmail_settings; end
-  def self.sendmail_settings=(val); end
-  def self.sendmail_settings?; end
-  def self.set_payload_for_mail(payload, mail); end
-  def self.show_previews; end
-  def self.show_previews=(obj); end
-  def self.smtp_settings; end
-  def self.smtp_settings=(val); end
-  def self.smtp_settings?; end
-  def self.stylesheets_dir; end
-  def self.stylesheets_dir=(value); end
-  def self.supports_path?; end
-  def self.test_settings; end
-  def self.test_settings=(val); end
-  def self.test_settings?; end
-  def sendmail_settings; end
-  def sendmail_settings=(arg0); end
-  def sendmail_settings?; end
-  def set_content_type(m, user_content_type, class_default); end
-  def show_previews; end
-  def smtp_settings; end
-  def smtp_settings=(arg0); end
-  def smtp_settings?; end
-  def stylesheets_dir; end
-  def stylesheets_dir=(value); end
-  def test_settings; end
-  def test_settings=(arg0); end
-  def test_settings?; end
-  extend AbstractController::Callbacks::ClassMethods
-  extend AbstractController::Helpers::ClassMethods
-  extend AbstractController::UrlFor::ClassMethods
-  extend ActionMailer::DeliveryMethods::ClassMethods
-  extend ActionMailer::Previews::ClassMethods
-  extend ActionView::Layouts::ClassMethods
-  extend ActionView::Rendering::ClassMethods
-  extend ActionView::ViewPaths::ClassMethods
-  extend ActiveSupport::Callbacks::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  extend Anonymous_Module_20
-  include AbstractController::AssetPaths
-  include AbstractController::Callbacks
-  include AbstractController::Helpers
-  include AbstractController::Logger
-  include AbstractController::Rendering
-  include AbstractController::Translation
-  include AbstractController::UrlFor
-  include ActionDispatch::Routing::RouteSet::MountedHelpers
-  include ActionDispatch::Routing::UrlFor
-  include ActionDispatch::Routing::UrlFor
-  include ActionMailer::DeliveryMethods
-  include ActionMailer::Previews
-  include ActionView::Layouts
-  include ActionView::Rendering
-  include ActionView::ViewPaths
-  include ActionView::ViewPaths
-  include ActiveSupport::Benchmarkable
-  include ActiveSupport::Callbacks
-end
-class ActionMailer::Base::NullMail
-  def body; end
-  def header; end
-  def method_missing(*args); end
-  def respond_to?(string, include_all = nil); end
-end
-class ActionMailer::Base::LateAttachmentsProxy < SimpleDelegator
-  def []=(_name, _content); end
-  def _raise_error; end
-  def inline; end
-end
-module Anonymous_Module_20
-  def inherited(klass); end
-end

data/spec/support/v4.2/sorbet/rbi/gems/actionpack.rbi

@@ -1,2883 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/actionpack/all/actionpack.rbi
-#
-# actionpack-4.2.11
-module ActionPack
-  def self.gem_version; end
-  def self.version; end
-end
-module ActionPack::VERSION
-end
-module Rack
-end
-module ActionDispatch
-  def self.test_app; end
-  def self.test_app=(obj); end
-  def test_app; end
-  def test_app=(obj); end
-  extend ActiveSupport::Autoload
-end
-class ActionDispatch::IllegalStateError < StandardError
-end
-module ActionDispatch::Http
-  extend ActiveSupport::Autoload
-end
-module ActionDispatch::Session
-end
-class ActionDispatch::Railtie < Rails::Railtie
-end
-module AbstractController
-  extend ActiveSupport::Autoload
-end
-module ActionDispatch::Http::FilterRedirect
-  def filtered_location; end
-  def location_filter; end
-  def location_filter_match?(filters); end
-end
-module ActionDispatch::Http::Cache
-end
-module ActionDispatch::Http::Cache::Request
-  def etag_matches?(etag); end
-  def fresh?(response); end
-  def if_modified_since; end
-  def if_none_match; end
-  def if_none_match_etags; end
-  def not_modified?(modified_at); end
-end
-module ActionDispatch::Http::Cache::Response
-  def cache_control; end
-  def cache_control_headers; end
-  def cache_control_segments; end
-  def date; end
-  def date=(utc_time); end
-  def date?; end
-  def etag; end
-  def etag=(etag); end
-  def etag?; end
-  def handle_conditional_get!; end
-  def last_modified; end
-  def last_modified=(utc_time); end
-  def last_modified?; end
-  def prepare_cache_control!; end
-  def set_conditional_cache_control!; end
-end
-class ActionDispatch::Response
-  def [](*args, &block); end
-  def []=(*args, &block); end
-  def abort; end
-  def append_charset?; end
-  def assign_default_content_type_and_charset!(headers); end
-  def await_commit; end
-  def await_sent; end
-  def before_committed; end
-  def before_sending; end
-  def body; end
-  def body=(body); end
-  def body_parts; end
-  def build_buffer(response, body); end
-  def charset; end
-  def charset=(arg0); end
-  def close; end
-  def code; end
-  def commit!; end
-  def committed?; end
-  def content_type; end
-  def content_type=(content_type); end
-  def cookies; end
-  def default_charset; end
-  def default_charset=(obj); end
-  def default_headers; end
-  def default_headers=(obj); end
-  def delete_cookie(key, value = nil); end
-  def each(*args, &block); end
-  def header; end
-  def header=(arg0); end
-  def headers; end
-  def headers=(arg0); end
-  def initialize(status = nil, header = nil, body = nil, options = nil); end
-  def location; end
-  def location=(url); end
-  def merge_default_headers(original, default); end
-  def message; end
-  def munge_body_object(body); end
-  def prepare!; end
-  def rack_response(status, header); end
-  def redirect_url; end
-  def request; end
-  def request=(arg0); end
-  def response_code; end
-  def self.default_charset; end
-  def self.default_charset=(obj); end
-  def self.default_headers; end
-  def self.default_headers=(obj); end
-  def sending!; end
-  def sending?; end
-  def sending_file=(arg0); end
-  def sent!; end
-  def sent?; end
-  def set_cookie(key, value); end
-  def status; end
-  def status=(status); end
-  def status_message; end
-  def stream; end
-  def to_a; end
-  def to_ary; end
-  include ActionDispatch::Http::Cache::Response
-  include ActionDispatch::Http::FilterRedirect
-  include MonitorMixin
-  include Rack::Response::Helpers
-end
-class ActionDispatch::Response::Buffer
-  def abort; end
-  def close; end
-  def closed?; end
-  def each(&block); end
-  def initialize(response, buf); end
-  def write(string); end
-end
-class ActionDispatch::Response::RackBody
-  def body; end
-  def close; end
-  def each(*args, &block); end
-  def initialize(response); end
-  def respond_to?(method, include_private = nil); end
-  def to_ary; end
-  def to_path; end
-end
-module ActionController
-  def self.add_renderer(key, &block); end
-  def self.eager_load!; end
-  def self.remove_renderer(key); end
-  extend ActiveSupport::Autoload
-end
-module ActionController::Live
-  def log_error(exception); end
-  def process(name); end
-  def response_body=(body); end
-  def set_response!(request); end
-end
-class ActionController::Live::SSE
-  def close; end
-  def initialize(stream, options = nil); end
-  def perform_write(json, options); end
-  def write(object, options = nil); end
-end
-class ActionController::Live::ClientDisconnected < RuntimeError
-end
-class ActionController::Live::Buffer < ActionDispatch::Response::Buffer
-  def abort; end
-  def await_close; end
-  def call_on_error; end
-  def close; end
-  def connected?; end
-  def each; end
-  def ignore_disconnect; end
-  def ignore_disconnect=(arg0); end
-  def initialize(response); end
-  def on_error(&block); end
-  def write(string); end
-  include MonitorMixin
-end
-class ActionController::Live::Response < ActionDispatch::Response
-  def before_committed; end
-  def before_sending; end
-  def build_buffer(response, body); end
-  def handle_conditional_get!; end
-  def merge_default_headers(original, default); end
-end
-class ActionController::Live::Response::Header < Anonymous_Delegator_4
-  def []=(k, v); end
-  def initialize(response, header); end
-  def merge(other); end
-  def to_hash; end
-end
-class ActionDispatch::Http::UploadedFile
-  def close(unlink_now = nil); end
-  def content_type; end
-  def content_type=(arg0); end
-  def eof?; end
-  def headers; end
-  def headers=(arg0); end
-  def initialize(hash); end
-  def open; end
-  def original_filename; end
-  def original_filename=(arg0); end
-  def path; end
-  def read(length = nil, buffer = nil); end
-  def rewind; end
-  def size; end
-  def tempfile; end
-  def tempfile=(arg0); end
-  def to_io; end
-end
-class ActionController::ParameterMissing < KeyError
-  def initialize(param); end
-  def param; end
-end
-class ActionController::UnpermittedParameters < IndexError
-  def initialize(params); end
-  def params; end
-end
-class ActionController::Parameters < ActiveSupport::HashWithIndifferentAccess
-  def [](key); end
-  def always_permitted_parameters; end
-  def always_permitted_parameters=(obj); end
-  def array_of_permitted_scalars?(value); end
-  def array_of_permitted_scalars_filter(params, key); end
-  def convert_hashes_to_parameters(key, value, assign_if_converted = nil); end
-  def convert_value_to_parameters(value); end
-  def converted_arrays; end
-  def delete(key, &block); end
-  def dup; end
-  def each(&block); end
-  def each_element(object); end
-  def each_pair(&block); end
-  def extract!(*keys); end
-  def fetch(key, *args); end
-  def fields_for_style?(object); end
-  def hash_filter(params, filter); end
-  def initialize(attributes = nil); end
-  def new_instance_with_inherited_permitted_status(hash); end
-  def permit!; end
-  def permit(*filters); end
-  def permitted=(new_permitted); end
-  def permitted?; end
-  def permitted_scalar?(value); end
-  def permitted_scalar_filter(params, key); end
-  def require(key); end
-  def required(key); end
-  def select!(&block); end
-  def self.action_on_unpermitted_parameters; end
-  def self.action_on_unpermitted_parameters=(obj); end
-  def self.always_permitted_parameters; end
-  def self.always_permitted_parameters=(obj); end
-  def self.const_missing(const_name); end
-  def self.permit_all_parameters; end
-  def self.permit_all_parameters=(obj); end
-  def slice(*keys); end
-  def to_h; end
-  def to_unsafe_h; end
-  def to_unsafe_hash; end
-  def transform_keys; end
-  def transform_values; end
-  def unpermitted_keys(params); end
-  def unpermitted_parameters!(params); end
-end
-module ActionController::StrongParameters
-  def params; end
-  def params=(value); end
-  extend ActiveSupport::Concern
-  include ActiveSupport::Rescuable
-end
-module AbstractController::Railties
-end
-module AbstractController::Railties::RoutesHelpers
-  def self.with(routes, include_path_helpers = nil); end
-end
-module ActionController::Railties
-end
-module ActionController::Railties::Helpers
-  def inherited(klass); end
-end
-class ActionController::Railtie < Rails::Railtie
-end
-module Mime
-  def self.[](type); end
-  def self.fetch(type); end
-end
-class Mime::Mimes < Array
-  def <<(*arg0); end
-  def []=(*arg0); end
-  def clear(*arg0); end
-  def collect!(*arg0); end
-  def compact!(*arg0); end
-  def concat(*arg0); end
-  def delete(*arg0); end
-  def delete_at(*arg0); end
-  def delete_if(*arg0); end
-  def flatten!(*arg0); end
-  def insert(*arg0); end
-  def map!(*arg0); end
-  def pop(*arg0); end
-  def push(*arg0); end
-  def reject!(*arg0); end
-  def replace(*arg0); end
-  def reverse!(*arg0); end
-  def shift(*arg0); end
-  def slice!(*arg0); end
-  def sort!(*arg0); end
-  def symbols; end
-  def uniq!(*arg0); end
-  def unshift(*arg0); end
-end
-class Mime::Type
-  def ==(mime_type); end
-  def ===(list); end
-  def =~(mime_type); end
-  def eql?(other); end
-  def hash; end
-  def html?; end
-  def html_types; 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.html_types; 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(input); 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 ==(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 < Array
-  def app_xml; end
-  def app_xml_idx; end
-  def assort!; end
-  def exchange_xml_items; end
-  def text_xml; end
-  def text_xml_idx; end
-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
-module ActionDispatch::Journey
-end
-class ActionDispatch::Journey::Router
-  def ast; end
-  def custom_routes; end
-  def filter_routes(path); end
-  def find_routes(req); end
-  def initialize(routes); end
-  def match_head_routes(routes, req); end
-  def match_routes(routes, req); end
-  def partitioned_routes; end
-  def recognize(rails_req); end
-  def routes; end
-  def routes=(arg0); end
-  def serve(req); end
-  def simulator; end
-  def visualizer; end
-end
-class ActionDispatch::Journey::Router::Utils
-  def self.escape_fragment(fragment); end
-  def self.escape_path(path); end
-  def self.escape_segment(segment); end
-  def self.normalize_path(path); end
-  def self.unescape_uri(uri); end
-end
-class ActionDispatch::Journey::Router::Utils::UriEncoder
-  def escape(component, pattern); end
-  def escape_fragment(fragment); end
-  def escape_path(path); end
-  def escape_segment(segment); end
-  def percent_encode(unsafe); end
-  def unescape_uri(uri); end
-end
-class ActionDispatch::Journey::Router::Strexp
-  def anchor; end
-  def ast; end
-  def initialize(ast, path, requirements, separators, anchor = nil); end
-  def path; end
-  def requirements; end
-  def self.build(path, requirements, separators, anchor = nil); end
-  def self.compile(*arg0); end
-  def separators; end
-end
-class ActionDispatch::Journey::Routes
-  def add_route(app, path, conditions, defaults, name = nil); end
-  def ast; end
-  def clear; end
-  def clear_cache!; end
-  def each(&block); end
-  def empty?; end
-  def initialize; end
-  def last; end
-  def length; end
-  def named_routes; end
-  def partitioned_routes; end
-  def routes; end
-  def simulator; end
-  def size; end
-  include Enumerable
-end
-class ActionController::ActionControllerError < StandardError
-end
-class ActionController::BadRequest < ActionController::ActionControllerError
-  def initialize(type = nil, e = nil); end
-  def original_exception; end
-end
-class ActionController::RenderError < ActionController::ActionControllerError
-end
-class ActionController::RoutingError < ActionController::ActionControllerError
-  def failures; end
-  def initialize(message, failures = nil); end
-end
-class ActionController::UrlGenerationError < ActionController::ActionControllerError
-end
-class ActionController::MethodNotAllowed < ActionController::ActionControllerError
-  def initialize(*allowed_methods); end
-end
-class ActionController::NotImplemented < ActionController::MethodNotAllowed
-end
-class ActionController::UnknownController < ActionController::ActionControllerError
-end
-class ActionController::MissingFile < ActionController::ActionControllerError
-end
-class ActionController::SessionOverflowError < ActionController::ActionControllerError
-  def initialize(message = nil); end
-end
-class ActionController::UnknownHttpMethod < ActionController::ActionControllerError
-end
-class ActionController::UnknownFormat < ActionController::ActionControllerError
-end
-class ActionDispatch::Journey::Formatter
-  def build_cache; end
-  def cache; end
-  def clear; end
-  def extract_parameterized_parts(route, options, recall, parameterize = nil); end
-  def generate(name, options, path_parameters, parameterize = nil); end
-  def initialize(routes); end
-  def match_route(name, options); end
-  def missing_keys(route, parts); end
-  def named_routes; end
-  def non_recursive(cache, options); end
-  def possibles(cache, options, depth = nil); end
-  def routes; end
-end
-class ActionDispatch::Journey::Scanner
-  def eos?; end
-  def initialize; end
-  def next_token; end
-  def pos; end
-  def pre_match; end
-  def scan; end
-  def scan_setup(str); end
-end
-class ActionDispatch::Journey::Format
-  def evaluate(hash); end
-  def initialize(parts); end
-  def self.required_path(symbol); end
-  def self.required_segment(symbol); end
-end
-class Anonymous_Struct_5 < Struct
-  def escaper; end
-  def escaper=(_); 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 ActionDispatch::Journey::Format::Parameter < Anonymous_Struct_5
-  def escape(value); end
-end
-module ActionDispatch::Journey::Visitors
-end
-class ActionDispatch::Journey::Visitors::Visitor
-  def accept(node); end
-  def binary(node); end
-  def nary(node); end
-  def terminal(node); end
-  def unary(node); end
-  def visit(node); end
-  def visit_CAT(n); end
-  def visit_DOT(n); end
-  def visit_GROUP(n); end
-  def visit_LITERAL(n); end
-  def visit_OR(n); end
-  def visit_SLASH(n); end
-  def visit_STAR(n); end
-  def visit_SYMBOL(n); end
-end
-class ActionDispatch::Journey::Visitors::FormatBuilder < ActionDispatch::Journey::Visitors::Visitor
-  def accept(node); end
-  def binary(node); end
-  def terminal(node); end
-  def visit_GROUP(n); end
-  def visit_STAR(n); end
-  def visit_SYMBOL(n); end
-end
-class ActionDispatch::Journey::Visitors::Each < ActionDispatch::Journey::Visitors::Visitor
-  def block; end
-  def initialize(block); end
-  def visit(node); end
-end
-class ActionDispatch::Journey::Visitors::String < ActionDispatch::Journey::Visitors::Visitor
-  def binary(node); end
-  def nary(node); end
-  def terminal(node); end
-  def visit_GROUP(node); end
-end
-class ActionDispatch::Journey::Visitors::Dot < ActionDispatch::Journey::Visitors::Visitor
-  def accept(node); end
-  def binary(node); end
-  def initialize; end
-  def nary(node); end
-  def terminal(node); end
-  def unary(node); end
-  def visit_CAT(node); end
-  def visit_GROUP(node); end
-  def visit_OR(node); end
-  def visit_STAR(node); end
-end
-module ActionDispatch::Journey::Nodes
-end
-class ActionDispatch::Journey::Nodes::Node
-  def each(&block); end
-  def initialize(left); end
-  def left; end
-  def left=(arg0); end
-  def literal?; end
-  def memo; end
-  def memo=(arg0); end
-  def name; end
-  def symbol?; end
-  def to_dot; end
-  def to_s; end
-  def to_sym; end
-  def type; end
-  include Enumerable
-end
-class ActionDispatch::Journey::Nodes::Terminal < ActionDispatch::Journey::Nodes::Node
-  def symbol; end
-end
-class ActionDispatch::Journey::Nodes::Literal < ActionDispatch::Journey::Nodes::Terminal
-  def literal?; end
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Dummy < ActionDispatch::Journey::Nodes::Literal
-  def initialize(x = nil); end
-  def literal?; end
-end
-class ActionDispatch::Journey::Nodes::Symbol < ActionDispatch::Journey::Nodes::Terminal
-  def default_regexp?; end
-  def initialize(left); end
-  def regexp; end
-  def regexp=(arg0); end
-  def symbol; end
-  def symbol?; end
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Slash < ActionDispatch::Journey::Nodes::Terminal
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Dot < ActionDispatch::Journey::Nodes::Terminal
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Unary < ActionDispatch::Journey::Nodes::Node
-  def children; end
-end
-class ActionDispatch::Journey::Nodes::Group < ActionDispatch::Journey::Nodes::Unary
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Star < ActionDispatch::Journey::Nodes::Unary
-  def name; end
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Binary < ActionDispatch::Journey::Nodes::Node
-  def children; end
-  def initialize(left, right); end
-  def right; end
-  def right=(arg0); end
-end
-class ActionDispatch::Journey::Nodes::Cat < ActionDispatch::Journey::Nodes::Binary
-  def type; end
-end
-class ActionDispatch::Journey::Nodes::Or < ActionDispatch::Journey::Nodes::Node
-  def children; end
-  def initialize(children); end
-  def type; end
-end
-class ActionDispatch::Journey::Parser < Racc::Parser
-  def _reduce_1(val, _values); end
-  def _reduce_10(val, _values); end
-  def _reduce_15(val, _values); end
-  def _reduce_16(val, _values); end
-  def _reduce_17(val, _values); end
-  def _reduce_18(val, _values); end
-  def _reduce_2(val, _values); end
-  def _reduce_7(val, _values); end
-  def _reduce_8(val, _values); end
-  def _reduce_9(val, _values); end
-  def _reduce_none(val, _values); end
-  def initialize; end
-  def next_token; end
-  def parse(string); end
-  include ActionDispatch::Journey::Nodes
-end
-class ActionDispatch::Journey::Route
-  def app; end
-  def ast; end
-  def conditions; end
-  def constraints; end
-  def defaults; end
-  def dispatcher?; end
-  def format(path_options); end
-  def glob?; end
-  def initialize(name, app, path, constraints, defaults = nil); end
-  def ip; end
-  def matches?(request); end
-  def name; end
-  def optional_parts; end
-  def parts; end
-  def path; end
-  def precedence; end
-  def precedence=(arg0); end
-  def required_default?(key); end
-  def required_defaults; end
-  def required_keys; end
-  def required_parts; end
-  def requirements; end
-  def score(constraints); end
-  def segment_keys; end
-  def segments; end
-  def verb; end
-end
-module ActionDispatch::Journey::Path
-end
-class ActionDispatch::Journey::Path::Pattern
-  def =~(other); end
-  def anchored; end
-  def ast; end
-  def build_formatter; end
-  def initialize(strexp); end
-  def match(other); end
-  def names; end
-  def offsets; end
-  def optional_names; end
-  def regexp_visitor; end
-  def required_names; end
-  def requirements; end
-  def self.from_string(string); end
-  def source; end
-  def spec; end
-  def to_regexp; end
-end
-class ActionDispatch::Journey::Path::Pattern::RegexpOffsets < ActionDispatch::Journey::Visitors::Visitor
-  def initialize(matchers); end
-  def offsets; end
-  def visit(node); end
-  def visit_SYMBOL(node); end
-end
-class ActionDispatch::Journey::Path::Pattern::AnchoredRegexp < ActionDispatch::Journey::Visitors::Visitor
-  def accept(node); end
-  def initialize(separator, matchers); end
-  def visit_CAT(node); end
-  def visit_DOT(node); end
-  def visit_GROUP(node); end
-  def visit_LITERAL(node); end
-  def visit_SLASH(node); end
-  def visit_STAR(node); end
-  def visit_SYMBOL(node); end
-end
-class ActionDispatch::Journey::Path::Pattern::UnanchoredRegexp < ActionDispatch::Journey::Path::Pattern::AnchoredRegexp
-  def accept(node); end
-end
-class ActionDispatch::Journey::Path::Pattern::MatchData
-  def [](x); end
-  def captures; end
-  def initialize(names, offsets, match); end
-  def length; end
-  def names; end
-  def post_match; end
-  def to_s; end
-end
-class ActionDispatch::Journey::Router::RoutingError < StandardError
-end
-module ActionDispatch::Journey::NFA
-end
-module ActionDispatch::Journey::NFA::Dot
-  def to_dot; end
-end
-module ActionDispatch::Journey::GTG
-end
-class ActionDispatch::Journey::GTG::TransitionTable
-  def []=(from, to, sym); end
-  def accepting?(state); end
-  def accepting_states; end
-  def add_accepting(state); end
-  def add_memo(idx, memo); end
-  def as_json(options = nil); end
-  def eclosure(t); end
-  def initialize; end
-  def memo(idx); end
-  def memos; end
-  def move(t, a); end
-  def states; end
-  def states_hash_for(sym); end
-  def to_svg; end
-  def transitions; end
-  def visualizer(paths, title = nil); end
-  include ActionDispatch::Journey::NFA::Dot
-end
-class ActionDispatch::Journey::GTG::Builder
-  def ast; end
-  def build_followpos; end
-  def endpoints; end
-  def firstpos(node); end
-  def followpos(node); end
-  def followpos_table; end
-  def initialize(root); end
-  def lastpos(node); end
-  def nullable?(node); end
-  def root; end
-  def symbol(edge); end
-  def transition_table; end
-end
-class ActionDispatch::Journey::GTG::MatchData
-  def initialize(memos); end
-  def memos; end
-end
-class ActionDispatch::Journey::GTG::Simulator
-  def =~(string); end
-  def initialize(transition_table); end
-  def match(string); end
-  def memos(string); end
-  def simulate(string); end
-  def tt; end
-end
-class ActionDispatch::Journey::NFA::TransitionTable
-  def []=(i, f, s); end
-  def accepting; end
-  def accepting=(arg0); end
-  def accepting?(state); end
-  def accepting_states; end
-  def add_memo(idx, memo); end
-  def alphabet; end
-  def eclosure(t); end
-  def following_states(t, a); end
-  def generalized_table; end
-  def initialize; end
-  def inverted; end
-  def memo(idx); end
-  def memos; end
-  def merge(left, right); end
-  def move(t, a); end
-  def states; end
-  def transitions; end
-  include ActionDispatch::Journey::NFA::Dot
-end
-class ActionDispatch::Journey::NFA::Visitor < ActionDispatch::Journey::Visitors::Visitor
-  def initialize(tt); end
-  def terminal(node); end
-  def visit_CAT(node); end
-  def visit_GROUP(node); end
-  def visit_OR(node); end
-end
-class ActionDispatch::Journey::NFA::Builder
-  def initialize(ast); end
-  def transition_table; end
-end
-class ActionDispatch::Journey::NFA::MatchData
-  def initialize(memos); end
-  def memos; end
-end
-class ActionDispatch::Journey::NFA::Simulator
-  def =~(string); end
-  def initialize(transition_table); end
-  def match(string); end
-  def simulate(string); end
-  def tt; end
-end
-class ActionDispatch::Http::Headers
-  def [](key); end
-  def []=(key, value); end
-  def each(&block); end
-  def env; end
-  def env_name(key); end
-  def fetch(key, *args, &block); end
-  def include?(key); end
-  def initialize(env = nil); end
-  def key?(key); end
-  def merge!(headers_or_env); end
-  def merge(headers_or_env); end
-  include Enumerable
-end
-module ActionDispatch::Http::MimeNegotiation
-  def accepts; end
-  def content_mime_type; end
-  def content_type; end
-  def format(view_path = nil); end
-  def format=(extension); end
-  def formats; end
-  def formats=(extensions); end
-  def negotiate_mime(order); end
-  def use_accept_header; end
-  def valid_accept_header; end
-  def variant; end
-  def variant=(variant); end
-  extend ActiveSupport::Concern
-end
-module ActionDispatch::Http::Parameters
-  def normalize_encode_params(params); end
-  def parameters; end
-  def params; end
-  def path_parameters; end
-  def path_parameters=(parameters); end
-  def symbolized_path_parameters; end
-end
-class ActionDispatch::Http::ParameterFilter
-  def compiled_filter; end
-  def filter(params); end
-  def initialize(filters = nil); end
-end
-class ActionDispatch::Http::ParameterFilter::CompiledFilter
-  def blocks; end
-  def call(original_params); end
-  def initialize(regexps, blocks); end
-  def regexps; end
-  def self.compile(filters); end
-end
-module ActionDispatch::Http::FilterParameters
-  def env_filter; end
-  def filtered_env; end
-  def filtered_parameters; end
-  def filtered_path; end
-  def filtered_query_string; end
-  def initialize(env); end
-  def parameter_filter; end
-  def parameter_filter_for(filters); end
-end
-module ActionDispatch::Http::URL
-  def domain(tld_length = nil); end
-  def host; end
-  def host_with_port; end
-  def initialize(env); end
-  def optional_port; end
-  def port; end
-  def port_string; end
-  def protocol; end
-  def raw_host_with_port; end
-  def self.add_anchor(path, anchor); end
-  def self.add_params(path, params); end
-  def self.add_trailing_slash(path); end
-  def self.build_host_url(host, port, protocol, options, path); end
-  def self.extract_domain(host, tld_length); end
-  def self.extract_domain_from(host, tld_length); end
-  def self.extract_subdomain(host, tld_length); end
-  def self.extract_subdomains(host, tld_length); end
-  def self.extract_subdomains_from(host, tld_length); end
-  def self.full_url_for(options); end
-  def self.named_host?(host); end
-  def self.normalize_host(_host, options); end
-  def self.normalize_port(port, protocol); end
-  def self.normalize_protocol(protocol); end
-  def self.path_for(options); end
-  def self.tld_length; end
-  def self.tld_length=(obj); end
-  def self.url_for(options); end
-  def server_port; end
-  def standard_port; end
-  def standard_port?; end
-  def subdomain(tld_length = nil); end
-  def subdomains(tld_length = nil); end
-  def tld_length; end
-  def tld_length=(obj); end
-  def url; end
-end
-class ActionDispatch::Request < Rack::Request
-  def GET; end
-  def POST; end
-  def accept; end
-  def accept_charset; end
-  def accept_encoding; end
-  def accept_language; end
-  def auth_type; end
-  def authorization; end
-  def body; end
-  def body_stream; end
-  def cache_control; end
-  def check_method(name); end
-  def check_path_parameters!; end
-  def content_length; end
-  def cookie_jar; end
-  def deep_munge(hash); end
-  def delete?; end
-  def flash; end
-  def form_data?; end
-  def from; end
-  def fullpath; end
-  def gateway_interface; end
-  def get?; end
-  def head?; end
-  def headers; end
-  def ignore_accept_header; end
-  def ignore_accept_header=(obj); end
-  def initialize(env); end
-  def ip; end
-  def key?(key); end
-  def local?; end
-  def media_type; end
-  def method; end
-  def method_symbol; end
-  def negotiate; end
-  def original_fullpath; end
-  def original_url; end
-  def parse_query(qs); end
-  def patch?; end
-  def path_translated; end
-  def post?; end
-  def pragma; end
-  def put?; end
-  def query_parameters; end
-  def raw_post; end
-  def remote_addr; end
-  def remote_host; end
-  def remote_ident; end
-  def remote_ip; end
-  def remote_user; end
-  def request_method; end
-  def request_method=(request_method); end
-  def request_method_symbol; end
-  def request_parameters; end
-  def reset_session; end
-  def self.ignore_accept_header; end
-  def self.ignore_accept_header=(obj); end
-  def server_name; end
-  def server_protocol; end
-  def server_software; end
-  def session=(session); end
-  def session_options=(options); end
-  def uuid; end
-  def xhr?; end
-  def xml_http_request?; end
-  include ActionDispatch::Http::Cache::Request
-  include ActionDispatch::Http::FilterParameters
-  include ActionDispatch::Http::MimeNegotiation
-  include ActionDispatch::Http::Parameters
-  include ActionDispatch::Http::URL
-end
-class ActionDispatch::Routing::Endpoint
-  def app; end
-  def dispatcher?; end
-  def matches?(req); end
-  def redirect?; end
-end
-module ActionController::ModelNaming
-  def convert_to_model(object); end
-  def model_name_from_record_or_class(record_or_class); end
-end
-module ActionDispatch::Routing::PolymorphicRoutes
-  def edit_polymorphic_path(record_or_hash, options = nil); end
-  def edit_polymorphic_url(record_or_hash, options = nil); end
-  def new_polymorphic_path(record_or_hash, options = nil); end
-  def new_polymorphic_url(record_or_hash, options = nil); end
-  def polymorphic_path(record_or_hash_or_array, options = nil); end
-  def polymorphic_path_for_action(action, record_or_hash, options); end
-  def polymorphic_url(record_or_hash_or_array, options = nil); end
-  def polymorphic_url_for_action(action, record_or_hash, options); end
-  include ActionController::ModelNaming
-end
-class ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder
-  def get_method_for_class(klass); end
-  def get_method_for_string(str); end
-  def handle_class(klass); end
-  def handle_class_call(target, klass); end
-  def handle_list(list); end
-  def handle_model(record); end
-  def handle_model_call(target, model); end
-  def handle_string(record); end
-  def handle_string_call(target, str); end
-  def initialize(key_strategy, prefix, suffix); end
-  def prefix; end
-  def self.build(action, type); end
-  def self.get(action, type); end
-  def self.path; end
-  def self.plural(prefix, suffix); end
-  def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options); end
-  def self.singular(prefix, suffix); end
-  def self.url; end
-  def suffix; end
-end
-module ActionDispatch::Routing::UrlFor
-  def _generate_paths_by_default; end
-  def _routes_context; end
-  def _with_routes(routes); end
-  def initialize(*arg0); end
-  def optimize_routes_generation?; end
-  def url_for(options = nil); end
-  def url_options; end
-  extend ActiveSupport::Concern
-  include ActionDispatch::Routing::PolymorphicRoutes
-end
-class ActionDispatch::Routing::RouteSet
-  def add_route(app, conditions = nil, requirements = nil, defaults = nil, name = nil, anchor = nil); end
-  def append(&block); end
-  def build_conditions(current_conditions, path_values); end
-  def build_path(path, ast, requirements, anchor); end
-  def call(env); end
-  def clear!; end
-  def default_scope; end
-  def default_scope=(arg0); end
-  def default_url_options; end
-  def default_url_options=(arg0); end
-  def define_mounted_helper(name); end
-  def disable_clear_and_finalize; end
-  def disable_clear_and_finalize=(arg0); end
-  def dispatcher(defaults); end
-  def draw(&block); end
-  def empty?; end
-  def eval_block(block); end
-  def extra_keys(options, recall = nil); end
-  def finalize!; end
-  def find_relative_url_root(options); end
-  def find_script_name(options); end
-  def formatter; end
-  def formatter=(arg0); end
-  def generate(route_key, options, recall = nil); end
-  def generate_extras(options, recall = nil); end
-  def initialize(request_class = nil); end
-  def inspect; end
-  def mounted_helpers; end
-  def named_routes; end
-  def named_routes=(arg0); end
-  def optimize_routes_generation?; end
-  def path_for(options, route_name = nil); end
-  def prepend(&block); end
-  def recognize_path(path, environment = nil); end
-  def relative_url_root; end
-  def relative_url_root=(obj); end
-  def request_class; end
-  def request_class=(arg0); end
-  def resources_path_names; end
-  def resources_path_names=(arg0); end
-  def router; end
-  def router=(arg0); end
-  def routes; end
-  def self.default_resources_path_names; end
-  def self.relative_url_root; end
-  def self.relative_url_root=(obj); end
-  def set; end
-  def set=(arg0); end
-  def url_for(options, route_name = nil, url_strategy = nil); end
-  def url_helpers(supports_path = nil); end
-end
-class ActionDispatch::Routing::RouteSet::Dispatcher < ActionDispatch::Routing::Endpoint
-  def controller(params, default_controller = nil); end
-  def controller_reference(controller_param); end
-  def dispatch(controller, action, env); end
-  def dispatcher?; end
-  def initialize(defaults); end
-  def merge_default_action!(params); end
-  def normalize_controller!(params); end
-  def prepare_params!(params); end
-  def serve(req); end
-end
-class ActionDispatch::Routing::RouteSet::NamedRouteCollection
-  def [](name); end
-  def []=(name, route); end
-  def add(name, route); end
-  def clear!; end
-  def clear; end
-  def define_url_helper(mod, route, name, opts, route_key, url_strategy); end
-  def each; end
-  def get(name); end
-  def helper_names; end
-  def helpers; end
-  def initialize; end
-  def key?(name); end
-  def length; end
-  def names; end
-  def path_helpers_module(warn = nil); end
-  def route_defined?(name); end
-  def routes; end
-  def url_helpers_module; end
-  include Enumerable
-end
-class ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper
-  def call(t, args, inner_options); end
-  def deprecate_string_options(options); end
-  def handle_positional_args(controller_options, inner_options, args, result, path_params); end
-  def initialize(route, options, route_name, url_strategy); end
-  def route_name; end
-  def self.create(route, options, route_name, url_strategy); end
-  def self.optimize_helper?(route); end
-  def url_strategy; end
-end
-class ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper::OptimizedUrlHelper < ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper
-  def arg_size; end
-  def call(t, args, inner_options); end
-  def initialize(route, options, route_name, url_strategy); end
-  def missing_keys(args); end
-  def optimize_routes_generation?(t); end
-  def optimized_helper(args); end
-  def parameterize_args(args); end
-  def raise_generation_error(args, missing_keys); end
-end
-module ActionDispatch::Routing::RouteSet::MountedHelpers
-  extend ActiveSupport::Concern
-  include ActionDispatch::Routing::UrlFor
-end
-class ActionDispatch::Routing::RouteSet::Generator
-  def controller; end
-  def current_controller; end
-  def different_controller?; end
-  def generate; end
-  def initialize(named_route, options, recall, set); end
-  def named_route; end
-  def named_route_exists?; end
-  def normalize_action!; end
-  def normalize_controller!; end
-  def normalize_controller_action_id!; end
-  def normalize_options!; end
-  def normalize_recall!; end
-  def options; end
-  def recall; end
-  def segment_keys; end
-  def set; end
-  def use_recall_for(key); end
-  def use_relative_controller!; end
-end
-class ActionDispatch::Request::Utils
-  def perform_deep_munge; end
-  def perform_deep_munge=(obj); end
-  def self.deep_munge(hash, keys = nil); end
-  def self.perform_deep_munge; end
-  def self.perform_deep_munge=(obj); end
-end
-class ActionDispatch::ExceptionWrapper
-  def application_trace; end
-  def backtrace; end
-  def backtrace_cleaner; end
-  def clean_backtrace(*args); end
-  def env; end
-  def exception; end
-  def expand_backtrace; end
-  def file; end
-  def framework_trace; end
-  def full_trace; end
-  def initialize(env, exception); end
-  def line_number; end
-  def original_exception(exception); end
-  def registered_original_exception?(exception); end
-  def rescue_responses; end
-  def rescue_responses=(obj); end
-  def rescue_template; end
-  def rescue_templates; end
-  def rescue_templates=(obj); end
-  def self.rescue_responses; end
-  def self.rescue_responses=(obj); end
-  def self.rescue_templates; end
-  def self.rescue_templates=(obj); end
-  def self.status_code_for_exception(class_name); end
-  def source_extracts; end
-  def source_fragment(path, line); end
-  def status_code; end
-  def traces; end
-end
-class ActionDispatch::Cookies
-  def call(env); end
-  def initialize(app); end
-end
-class ActionDispatch::Cookies::CookieOverflow < StandardError
-end
-module ActionDispatch::Cookies::ChainedCookieJars
-  def encrypted; end
-  def permanent; end
-  def signed; end
-  def signed_or_encrypted; end
-end
-module ActionDispatch::Cookies::VerifyAndUpgradeLegacySignedMessage
-  def initialize(*args); end
-  def verify_and_upgrade_legacy_signed_message(name, signed_message); end
-end
-class ActionDispatch::Cookies::CookieJar
-  def [](name); end
-  def []=(name, options); end
-  def always_write_cookie; end
-  def always_write_cookie=(obj); end
-  def clear(options = nil); end
-  def commit!; end
-  def committed?; end
-  def delete(name, options = nil); end
-  def deleted?(name, options = nil); end
-  def each(&block); end
-  def fetch(name, *args, &block); end
-  def handle_options(options); end
-  def has_key?(name); end
-  def initialize(key_generator, host = nil, secure = nil, options = nil); end
-  def key?(name); end
-  def recycle!; end
-  def self.always_write_cookie; end
-  def self.always_write_cookie=(obj); end
-  def self.build(request); end
-  def self.options_for_env(env); end
-  def update(other_hash); end
-  def write(headers); end
-  def write_cookie?(cookie); end
-  include Enumerable
-end
-class ActionDispatch::Cookies::PermanentCookieJar
-  def [](name); end
-  def []=(name, options); end
-  def initialize(parent_jar, key_generator, options = nil); end
-  include ActionDispatch::Cookies::ChainedCookieJars
-end
-class ActionDispatch::Cookies::JsonSerializer
-  def self.dump(value); end
-  def self.load(value); end
-end
-module ActionDispatch::Cookies::SerializedCookieJars
-  def deserialize(name, value); end
-  def digest; end
-  def needs_migration?(value); end
-  def serialize(name, value); end
-  def serializer; end
-end
-class ActionDispatch::Cookies::SignedCookieJar
-  def [](name); end
-  def []=(name, options); end
-  def initialize(parent_jar, key_generator, options = nil); end
-  def verify(signed_message); end
-  include ActionDispatch::Cookies::ChainedCookieJars
-  include ActionDispatch::Cookies::SerializedCookieJars
-end
-class ActionDispatch::Cookies::UpgradeLegacySignedCookieJar < ActionDispatch::Cookies::SignedCookieJar
-  def [](name); end
-  include ActionDispatch::Cookies::VerifyAndUpgradeLegacySignedMessage
-end
-class ActionDispatch::Cookies::EncryptedCookieJar
-  def [](name); end
-  def []=(name, options); end
-  def decrypt_and_verify(encrypted_message); end
-  def initialize(parent_jar, key_generator, options = nil); end
-  include ActionDispatch::Cookies::ChainedCookieJars
-  include ActionDispatch::Cookies::SerializedCookieJars
-end
-class ActionDispatch::Cookies::UpgradeLegacyEncryptedCookieJar < ActionDispatch::Cookies::EncryptedCookieJar
-  def [](name); end
-  include ActionDispatch::Cookies::VerifyAndUpgradeLegacySignedMessage
-end
-module AbstractController::Helpers
-  extend ActiveSupport::Concern
-end
-class AbstractController::Helpers::MissingHelperError < LoadError
-  def initialize(error, path); end
-end
-module AbstractController::Helpers::ClassMethods
-  def add_template_helper(mod); end
-  def clear_helpers; end
-  def default_helper_module!; end
-  def helper(*args, &block); end
-  def helper_method(*meths); end
-  def inherited(klass); end
-  def modules_for_helpers(args); end
-end
-module ActionController::Helpers
-  def self.helpers_path; end
-  def self.helpers_path=(arg0); end
-  extend ActiveSupport::Concern
-  include AbstractController::Helpers
-end
-module ActionController::Helpers::ClassMethods
-  def all_application_helpers; end
-  def all_helpers_from_path(path); end
-  def helper_attr(*attrs); end
-  def helpers; end
-  def modules_for_helpers(args); end
-end
-class ActionDispatch::MiddlewareStack
-  def [](i); end
-  def assert_index(index, where); end
-  def build(app = nil, &block); end
-  def delete(target); end
-  def each; end
-  def initialize(*args); end
-  def initialize_copy(other); end
-  def insert(index, *args, &block); end
-  def insert_after(index, *args, &block); end
-  def insert_before(index, *args, &block); end
-  def last; end
-  def middlewares; end
-  def middlewares=(arg0); end
-  def size; end
-  def swap(target, *args, &block); end
-  def unshift(*args, &block); end
-  def use(*args, &block); end
-  include Enumerable
-end
-class ActionDispatch::MiddlewareStack::Middleware
-  def ==(middleware); end
-  def args; end
-  def block; end
-  def build(app); end
-  def classcache; end
-  def initialize(klass_or_name, *args, &block); end
-  def inspect; end
-  def klass; end
-  def name; end
-  def normalize(object); end
-end
-class ActionDispatch::FileHandler
-  def call(env); end
-  def content_type(path); end
-  def ext; end
-  def gzip_encoding_accepted?(env); end
-  def gzip_file_path(path); end
-  def initialize(root, cache_control); end
-  def match?(path); end
-  def valid_path?(path); end
-end
-class ActionDispatch::Static
-  def call(env); end
-  def initialize(app, path, cache_control = nil); end
-end
-class ActionDispatch::RequestId
-  def call(env); end
-  def external_request_id(env); end
-  def initialize(app); end
-  def internal_request_id; end
-end
-class ActionDispatch::ShowExceptions
-  def call(env); end
-  def initialize(app, exceptions_app); end
-  def pass_response(status); end
-  def render_exception(env, exception); end
-end
-class ActionDispatch::PublicExceptions
-  def call(env); end
-  def initialize(public_path); end
-  def public_path; end
-  def public_path=(arg0); end
-  def render(status, content_type, body); end
-  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 json_regexp; end
-  def name; end
-  def path; end
-  def rack_app; end
-  def regexp; end
-  def reqs; end
-  def verb; 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
-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; 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; end
-  def result; end
-  def section(routes); end
-  def section_title(title); end
-end
-class ActionDispatch::DebugExceptions
-  def call(env); end
-  def initialize(app, routes_app = nil); end
-  def log_error(env, wrapper); end
-  def logger(env); end
-  def render(status, body, format); end
-  def render_exception(env, exception); end
-  def routes_inspector(exception); end
-  def stderr_logger; end
-end
-class ActionDispatch::RemoteIp
-  def call(env); end
-  def check_ip; end
-  def initialize(app, check_ip_spoofing = 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(env, middleware); end
-  def ips_from(header); end
-  def to_s; end
-end
-class ActionDispatch::Reloader
-  def _cleanup_callbacks; end
-  def _cleanup_callbacks?; end
-  def _prepare_callbacks; end
-  def _prepare_callbacks?; end
-  def _run_cleanup_callbacks(&block); end
-  def _run_prepare_callbacks(&block); end
-  def call(env); end
-  def cleanup!; end
-  def initialize(app, condition = nil); end
-  def prepare!; end
-  def self._cleanup_callbacks; end
-  def self._cleanup_callbacks=(val); end
-  def self._cleanup_callbacks?; end
-  def self._prepare_callbacks; end
-  def self._prepare_callbacks=(val); end
-  def self._prepare_callbacks?; end
-  def self.cleanup!; end
-  def self.prepare!; end
-  def self.to_cleanup(*args, &block); end
-  def self.to_prepare(*args, &block); end
-  def validated?; end
-  extend ActiveSupport::Callbacks::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  include ActiveSupport::Callbacks
-  include ActiveSupport::Deprecation::Reporting
-end
-class ActionDispatch::Callbacks
-  def _call_callbacks; end
-  def _call_callbacks?; end
-  def _run_call_callbacks(&block); end
-  def call(env); end
-  def initialize(app); end
-  def self._call_callbacks; end
-  def self._call_callbacks=(val); end
-  def self._call_callbacks?; end
-  def self.after(*args, &block); end
-  def self.before(*args, &block); end
-  def self.to_cleanup(*args, &block); end
-  def self.to_prepare(*args, &block); end
-  extend ActiveSupport::Callbacks::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  include ActiveSupport::Callbacks
-end
-class ActionDispatch::Request::Session
-  def [](key); end
-  def []=(key, value); end
-  def clear; end
-  def delete(key); end
-  def destroy; 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, env); 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, env, default_options); end
-  def self.find(env); end
-  def self.set(env, 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 initialize(by, env, default_options); end
-  def self.find(env); end
-  def self.set(env, options); end
-  def to_hash; end
-  def values_at(*args); end
-end
-class ActionDispatch::Session::SessionRestoreError < StandardError
-  def initialize(const_error); end
-  def original_exception; end
-end
-module ActionDispatch::Session::Compatibility
-  def generate_sid; end
-  def initialize(app, options = nil); end
-  def initialize_sid; 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(env); end
-end
-class ActionDispatch::Session::AbstractStore < Rack::Session::Abstract::ID
-  def set_cookie(env, session_id, cookie); end
-  include ActionDispatch::Session::Compatibility
-  include ActionDispatch::Session::SessionObject
-  include ActionDispatch::Session::StaleSessionCheck
-end
-class ActionDispatch::Session::CookieStore < Rack::Session::Abstract::ID
-  def cookie_jar(env); end
-  def destroy_session(env, session_id, options); end
-  def extract_session_id(env); end
-  def get_cookie(env); end
-  def initialize(app, options = nil); end
-  def load_session(env); end
-  def persistent_session_id!(data, sid = nil); end
-  def set_cookie(env, session_id, cookie); end
-  def set_session(env, sid, session_data, options); end
-  def unpacked_cookie_data(env); end
-  include ActionDispatch::Session::Compatibility
-  include ActionDispatch::Session::SessionObject
-  include ActionDispatch::Session::StaleSessionCheck
-end
-class ActionDispatch::Flash
-  def call(env); end
-  def initialize(app); 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::ParamsParser
-  def call(env); end
-  def initialize(app, parsers = nil); end
-  def logger(env); end
-  def parse_formatted_parameters(env); end
-end
-class ActionDispatch::ParamsParser::ParseError < StandardError
-  def initialize(message, original_exception); end
-  def original_exception; end
-end
-module AbstractController::Collector
-  def atom(*args, &block); end
-  def bmp(*args, &block); end
-  def css(*args, &block); end
-  def csv(*args, &block); end
-  def gif(*args, &block); end
-  def html(*args, &block); end
-  def ics(*args, &block); end
-  def jpeg(*args, &block); end
-  def js(*args, &block); end
-  def json(*args, &block); end
-  def method_missing(symbol, &block); end
-  def mpeg(*args, &block); end
-  def multipart_form(*args, &block); end
-  def pdf(*args, &block); end
-  def png(*args, &block); end
-  def rss(*args, &block); end
-  def self.generate_method_for_mime(mime); end
-  def text(*args, &block); end
-  def tiff(*args, &block); end
-  def url_encoded_form(*args, &block); end
-  def vcf(*args, &block); end
-  def xml(*args, &block); end
-  def yaml(*args, &block); end
-  def zip(*args, &block); 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 process(action, *args); end
-  def process_action(method_name, *args); end
-  def response_body; end
-  def response_body=(arg0); end
-  def self.abstract!; end
-  def self.abstract; end
-  def self.abstract?; end
-  def self.action_methods; end
-  def self.clear_action_methods!; end
-  def self.controller_path; end
-  def self.hidden_actions; end
-  def self.inherited(klass); end
-  def self.internal_methods; end
-  def self.method_added(name); end
-  def self.supports_path?; end
-  def send_action(*arg0); end
-  extend ActiveSupport::Configurable::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  include ActiveSupport::Configurable
-end
-class AbstractController::DoubleRenderError < AbstractController::Error
-  def initialize(message = nil); end
-end
-module AbstractController::Rendering
-  def _normalize_args(action = nil, options = nil); end
-  def _normalize_options(options); end
-  def _normalize_render(*args, &block); end
-  def _process_format(format, options = nil); end
-  def _process_options(options); end
-  def _protected_ivars; end
-  def render(*args, &block); end
-  def render_to_body(options = nil); end
-  def render_to_string(*args, &block); end
-  def rendered_format; end
-  def view_assigns; end
-  extend ActiveSupport::Concern
-  include ActionView::ViewPaths
-end
-module AbstractController::Logger
-  extend ActiveSupport::Concern
-end
-module AbstractController::Translation
-  def l(*args); end
-  def localize(*args); end
-  def t(*args); end
-  def translate(*args); end
-end
-module AbstractController::AssetPaths
-  extend ActiveSupport::Concern
-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); end
-  def skip_around_action(*names); end
-  def skip_around_filter(*names); end
-  def skip_before_action(*names); end
-  def skip_before_filter(*names); end
-  def skip_filter(*names); end
-end
-module AbstractController::UrlFor
-  def _routes; end
-  extend ActiveSupport::Concern
-  include ActionDispatch::Routing::UrlFor
-end
-module AbstractController::UrlFor::ClassMethods
-  def _routes; end
-  def action_methods; end
-end
-class ActionDispatch::Routing::Redirect < ActionDispatch::Routing::Endpoint
-  def block; end
-  def call(env); end
-  def escape(params); end
-  def escape_fragment(params); end
-  def escape_path(params); end
-  def initialize(status, block); end
-  def inspect; end
-  def path(params, request); end
-  def redirect?; end
-  def relative_path?(path); end
-  def serve(req); end
-  def status; end
-end
-class ActionDispatch::Routing::PathRedirect < ActionDispatch::Routing::Redirect
-  def inspect; end
-  def interpolation_required?(string, params); end
-  def path(params, request); end
-end
-class ActionDispatch::Routing::OptionRedirect < ActionDispatch::Routing::Redirect
-  def inspect; end
-  def options; end
-  def path(params, request); end
-end
-module ActionDispatch::Routing::Redirection
-  def redirect(*args, &block); end
-end
-class ActionDispatch::Routing::Mapper
-  def initialize(set); end
-  def self.normalize_name(name); end
-  def self.normalize_path(path); end
-  include ActionDispatch::Routing::Mapper::Base
-  include ActionDispatch::Routing::Mapper::Concerns
-  include ActionDispatch::Routing::Mapper::HttpHelpers
-  include ActionDispatch::Routing::Mapper::Resources
-  include ActionDispatch::Routing::Mapper::Scoping
-  include ActionDispatch::Routing::Redirection
-end
-class ActionDispatch::Routing::Mapper::Constraints < ActionDispatch::Routing::Endpoint
-  def app; end
-  def constraint_args(constraint, request); end
-  def constraints; end
-  def dispatcher?; end
-  def initialize(app, constraints, dispatcher_p); end
-  def matches?(req); end
-  def serve(req); end
-end
-class ActionDispatch::Routing::Mapper::Mapping
-  def add_controller_module(controller, modyoule); end
-  def add_request_method(via, conditions); end
-  def anchor; end
-  def app(blocks); end
-  def as; end
-  def blocks(options_constraints, scope_blocks); end
-  def check_controller_and_action(path_params, controller, action); end
-  def check_part(name, part, path_params, hash); end
-  def conditions; end
-  def constraints(options, path_params); end
-  def default_action; end
-  def default_controller; end
-  def defaults; end
-  def dispatcher(defaults); end
-  def initialize(scope, set, path, defaults, as, options); end
-  def normalize_defaults!(options); end
-  def normalize_format!(formatted); end
-  def normalize_options!(options, formatted, path_params, path_ast, modyoule); end
-  def normalize_path!(path, format); end
-  def optional_format?(path, format); end
-  def path_ast(path); end
-  def path_params(ast); end
-  def requirements; end
-  def self.build(scope, set, path, as, options); end
-  def split_constraints(path_params, constraints); end
-  def split_to(to); end
-  def to; end
-  def to_route; end
-  def translate_controller(controller); end
-  def verify_callable_constraint(callable_constraint); end
-  def verify_regexp_requirement(requirement); end
-end
-module ActionDispatch::Routing::Mapper::Base
-  def app_name(app, rails_app); end
-  def default_url_options(options); end
-  def default_url_options=(options); end
-  def define_generate_prefix(app, name); end
-  def has_named_route?(name); end
-  def match(path, options = nil); end
-  def mount(app, options = nil); end
-  def rails_app?(app); end
-  def root(options = nil); end
-  def with_default_scope(scope, &block); end
-end
-module ActionDispatch::Routing::Mapper::HttpHelpers
-  def delete(*args, &block); end
-  def get(*args, &block); end
-  def map_method(method, args, &block); end
-  def patch(*args, &block); end
-  def post(*args, &block); end
-  def put(*args, &block); end
-end
-module ActionDispatch::Routing::Mapper::Scoping
-  def constraints(constraints = nil); end
-  def controller(controller, options = nil); end
-  def defaults(defaults = nil); end
-  def merge_action_scope(parent, child); end
-  def merge_as_scope(parent, child); end
-  def merge_blocks_scope(parent, child); end
-  def merge_constraints_scope(parent, child); end
-  def merge_controller_scope(parent, child); end
-  def merge_defaults_scope(parent, child); end
-  def merge_module_scope(parent, child); end
-  def merge_options_scope(parent, child); end
-  def merge_path_names_scope(parent, child); end
-  def merge_path_scope(parent, child); end
-  def merge_shallow_path_scope(parent, child); end
-  def merge_shallow_prefix_scope(parent, child); end
-  def merge_shallow_scope(parent, child); end
-  def namespace(path, options = nil); end
-  def override_keys(child); end
-  def scope(*args); end
-end
-module ActionDispatch::Routing::Mapper::Resources
-  def action_options?(options); end
-  def action_path(name, path = nil); end
-  def add_route(action, options); end
-  def apply_common_behavior_for(method, resources, options, &block); end
-  def canonical_action?(action); end
-  def collection; end
-  def decomposed_match(path, options); end
-  def match(path, *rest); end
-  def member; end
-  def name_for_action(as, action); end
-  def namespace(path, options = nil); end
-  def nested; end
-  def nested_options; end
-  def nested_scope?; end
-  def nesting_depth; end
-  def new; end
-  def param_constraint; end
-  def param_constraint?; end
-  def parent_resource; end
-  def path_for_action(action, path); end
-  def prefix_name_for_action(as, action); end
-  def resource(*resources, &block); end
-  def resource_method_scope?; end
-  def resource_scope(kind, resource); end
-  def resource_scope?; end
-  def resources(*resources, &block); end
-  def resources_path_names(options); end
-  def root(path, options = nil); end
-  def scope_action_options; end
-  def scope_action_options?; end
-  def set_member_mappings_for_resource; end
-  def shallow; end
-  def shallow?; end
-  def shallow_nesting_depth; end
-  def shallow_scope(path, options = nil); end
-  def using_match_shorthand?(path, options); end
-  def with_exclusive_scope; end
-  def with_scope_level(kind); end
-end
-class ActionDispatch::Routing::Mapper::Resources::Resource
-  def actions; end
-  def collection_name; end
-  def collection_scope; end
-  def controller; end
-  def default_actions; end
-  def initialize(entities, options = nil); end
-  def member_name; end
-  def member_scope; end
-  def name; end
-  def nested_param; end
-  def nested_scope; end
-  def new_scope(new_path); end
-  def options; end
-  def param; end
-  def path; end
-  def plural; end
-  def resource_scope; end
-  def shallow=(value); end
-  def shallow?; end
-  def shallow_scope; end
-  def singular; end
-end
-class ActionDispatch::Routing::Mapper::Resources::SingletonResource < ActionDispatch::Routing::Mapper::Resources::Resource
-  def collection_name; end
-  def default_actions; end
-  def initialize(entities, options); end
-  def member_name; end
-  def member_scope; end
-  def nested_scope; end
-  def plural; end
-  def singular; end
-end
-module ActionDispatch::Routing::Mapper::Concerns
-  def concern(name, callable = nil, &block); end
-  def concerns(*args); end
-end
-class ActionDispatch::Routing::Mapper::Scope
-  def [](key); end
-  def []=(k, v); end
-  def action_name(name_prefix, prefix, collection_name, member_name); end
-  def fetch(key, &block); end
-  def initialize(hash, parent = nil, scope_level = nil); end
-  def nested?; end
-  def new(hash); end
-  def new_level(level); end
-  def options; end
-  def parent; end
-  def resource_method_scope?; end
-  def resource_scope?; end
-  def resources?; end
-  def scope_level; end
-end
-class ActionController::LogSubscriber < ActiveSupport::LogSubscriber
-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_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 ActionController::MiddlewareStack < ActionDispatch::MiddlewareStack
-  def build(action, app = nil); end
-end
-class ActionController::MiddlewareStack::Middleware < ActionDispatch::MiddlewareStack::Middleware
-  def initialize(klass, *args, &block); end
-  def valid?(action); end
-end
-class ActionController::Metal < AbstractController::Base
-  def content_type; end
-  def content_type=(type); end
-  def controller_name; end
-  def dispatch(name, request); end
-  def env; end
-  def env=(arg0); end
-  def headers; end
-  def headers=(arg0); end
-  def initialize; end
-  def location; end
-  def location=(url); end
-  def middleware_stack; end
-  def middleware_stack=(arg0); end
-  def middleware_stack?; end
-  def params; end
-  def params=(val); end
-  def performed?; end
-  def request; end
-  def request=(arg0); end
-  def response; end
-  def response=(arg0); end
-  def response_body=(body); end
-  def response_code; end
-  def self.action(name, klass = nil); end
-  def self.call(env); end
-  def self.controller_name; end
-  def self.inherited(base); end
-  def self.middleware; end
-  def self.middleware_stack; end
-  def self.middleware_stack=(val); end
-  def self.middleware_stack?; end
-  def self.use(*args, &block); end
-  def session(*args, &block); end
-  def status; end
-  def status=(status); end
-  def to_a; end
-  def url_for(string); end
-end
-module ActionController::HideActions
-  def method_for_action(action_name); end
-  extend ActiveSupport::Concern
-end
-module ActionController::HideActions::ClassMethods
-  def action_methods; end
-  def hide_action(*args); end
-  def visible_action?(action_name); end
-end
-module ActionController::UrlFor
-  def url_options; end
-  extend ActiveSupport::Concern
-  include AbstractController::UrlFor
-end
-module ActionController::RackDelegation
-  def content_type(*args, &block); end
-  def content_type=(arg); end
-  def dispatch(action, request); end
-  def headers(*args, &block); end
-  def location(*args, &block); end
-  def location=(arg); end
-  def reset_session; end
-  def response_body=(body); end
-  def response_code(*args, &block); end
-  def set_response!(request); end
-  def status(*args, &block); end
-  def status=(arg); end
-  extend ActiveSupport::Concern
-end
-class ActionController::RedirectBackError < AbstractController::Error
-  def initialize(message = nil); end
-end
-module ActionController::Redirecting
-  def _compute_redirect_to_location(request, options); end
-  def _extract_redirect_to_status(options, response_status); end
-  def redirect_to(options = nil, response_status = nil); end
-  def self._compute_redirect_to_location(request, options); end
-  extend ActiveSupport::Concern
-  include AbstractController::Logger
-  include ActionController::RackDelegation
-  include ActionController::UrlFor
-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_format(format, options = nil); end
-  def _process_options(options); end
-  def _render_in_priorities(options); 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
-class ActionController::MissingRenderer < LoadError
-  def initialize(format); end
-end
-module ActionController::Renderers
-  def _render_to_body_with_renderer(options); end
-  def _render_with_renderer_js(js, options); end
-  def _render_with_renderer_json(json, options); end
-  def _render_with_renderer_xml(xml, options); end
-  def render_to_body(options); end
-  def self._render_with_renderer_method_name(key); end
-  def self.add(key, &block); end
-  def self.remove(key); end
-  extend ActiveSupport::Concern
-end
-module ActionController::Renderers::ClassMethods
-  def use_renderer(*args); end
-  def use_renderers(*args); end
-end
-module ActionController::Renderers::All
-  extend ActiveSupport::Concern
-  include ActionController::Renderers
-end
-module ActionController::Head
-  def head(status, options = nil); end
-  def include_content?(status); end
-end
-module ActionController::ConditionalGet
-  def combine_etags(options); end
-  def expires_in(seconds, options = nil); end
-  def expires_now; end
-  def fresh_when(record_or_options, additional_options = nil); end
-  def stale?(record_or_options, additional_options = nil); end
-  extend ActiveSupport::Concern
-  include ActionController::Head
-  include ActionController::RackDelegation
-end
-module ActionController::ConditionalGet::ClassMethods
-  def etag(&etagger); end
-end
-module ActionController::EtagWithTemplateDigest
-  def determine_template_etag(options); end
-  def lookup_and_digest_template(template); end
-  def pick_template_for_etag(options); end
-  extend ActiveSupport::Concern
-  include ActionController::ConditionalGet
-end
-module ActionController::Caching
-  def cache(key, options = nil, &block); end
-  def view_cache_dependencies; end
-  extend ActiveSupport::Autoload
-  extend ActiveSupport::Concern
-  include AbstractController::Callbacks
-  include ActionController::Caching::ConfigMethods
-  include ActionController::Caching::Fragments
-  include ActionController::RackDelegation
-end
-module ActionController::Caching::Fragments
-  def expire_fragment(key, options = nil); end
-  def fragment_cache_key(key); end
-  def fragment_exist?(key, options = nil); end
-  def instrument_fragment_cache(name, key); end
-  def read_fragment(key, options = nil); end
-  def write_fragment(key, content, options = nil); end
-end
-module ActionController::Caching::ConfigMethods
-  def cache_configured?; end
-  def cache_store; end
-  def cache_store=(store); end
-end
-module ActionController::Caching::ClassMethods
-  def view_cache_dependency(&dependency); end
-end
-module ActionController::MimeResponds
-  def respond_to(*mimes); end
-  def respond_with(*arg0); end
-  extend ActiveSupport::Concern
-end
-module ActionController::MimeResponds::ClassMethods
-  def respond_to(*arg0); end
-end
-class ActionController::MimeResponds::Collector
-  def all(*args, &block); end
-  def any(*args, &block); end
-  def custom(mime_type, &block); end
-  def format; end
-  def format=(arg0); end
-  def initialize(mimes, variant = nil); end
-  def negotiate_format(request); end
-  def response; end
-  include AbstractController::Collector
-end
-class ActionController::MimeResponds::Collector::VariantCollector
-  def all(*args, &block); end
-  def any(*args, &block); end
-  def initialize(variant = nil); end
-  def method_missing(name, *args, &block); end
-  def variant; end
-end
-module ActionController::ImplicitRender
-  def default_render(*args); end
-  def method_for_action(action_name); end
-  def send_action(method, *args); end
-end
-module ActionController::Cookies
-  def cookies; end
-  extend ActiveSupport::Concern
-  include ActionController::RackDelegation
-end
-module ActionController::Flash
-  def redirect_to(options = nil, response_status_and_flash = nil); end
-  extend ActiveSupport::Concern
-end
-module ActionController::Flash::ClassMethods
-  def add_flash_types(*types); end
-end
-class ActionController::InvalidAuthenticityToken < ActionController::ActionControllerError
-end
-class ActionController::InvalidCrossOriginRequest < ActionController::ActionControllerError
-end
-module ActionController::RequestForgeryProtection
-  def compare_with_real_token(token, session); end
-  def form_authenticity_param; end
-  def form_authenticity_token; 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); end
-  def non_xhr_javascript_response?; end
-  def protect_against_forgery?; end
-  def real_csrf_token(session); end
-  def valid_authenticity_token?(session, encoded_masked_token); 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
-  include AbstractController::Callbacks
-  include AbstractController::Helpers
-end
-module ActionController::RequestForgeryProtection::ClassMethods
-  def protect_from_forgery(options = nil); end
-  def protection_method_class(name); end
-end
-module ActionController::RequestForgeryProtection::ProtectionMethods
-end
-class ActionController::RequestForgeryProtection::ProtectionMethods::NullSession
-  def handle_unverified_request; end
-  def initialize(controller); end
-end
-class ActionController::RequestForgeryProtection::ProtectionMethods::NullSession::NullSessionHash < Rack::Session::Abstract::SessionHash
-  def destroy; end
-  def exists?; end
-  def initialize(env); end
-end
-class ActionController::RequestForgeryProtection::ProtectionMethods::NullSession::NullCookieJar < ActionDispatch::Cookies::CookieJar
-  def self.build(request); end
-  def write(*arg0); end
-end
-class ActionController::RequestForgeryProtection::ProtectionMethods::ResetSession
-  def handle_unverified_request; end
-  def initialize(controller); end
-end
-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
-class ActionController::DataStreaming::FileBody
-  def each; end
-  def initialize(path); end
-  def to_path; end
-end
-module ActionController::HttpAuthentication
-end
-module ActionController::HttpAuthentication::Basic
-  def auth_param(request); end
-  def auth_scheme(request); end
-  def authenticate(request, &login_procedure); end
-  def authentication_request(controller, realm); end
-  def decode_credentials(request); end
-  def encode_credentials(user_name, password); end
-  def has_basic_credentials?(request); end
-  def user_name_and_password(request); end
-  extend ActionController::HttpAuthentication::Basic
-end
-module ActionController::HttpAuthentication::Basic::ControllerMethods
-  def authenticate_or_request_with_http_basic(realm = nil, &login_procedure); end
-  def authenticate_with_http_basic(&login_procedure); end
-  def request_http_basic_authentication(realm = nil); end
-  extend ActiveSupport::Concern
-end
-module ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods
-  def http_basic_authenticate_with(options = nil); end
-end
-module ActionController::HttpAuthentication::Digest
-  def authenticate(request, realm, &password_procedure); end
-  def authentication_header(controller, realm); end
-  def authentication_request(controller, realm, message = nil); end
-  def decode_credentials(header); end
-  def decode_credentials_header(request); end
-  def encode_credentials(http_method, credentials, password, password_is_ha1); end
-  def expected_response(http_method, uri, credentials, password, password_is_ha1 = nil); end
-  def ha1(credentials, password); end
-  def nonce(secret_key, time = nil); end
-  def opaque(secret_key); end
-  def secret_token(request); end
-  def validate_digest_response(request, realm, &password_procedure); end
-  def validate_nonce(secret_key, request, value, seconds_to_timeout = nil); end
-  extend ActionController::HttpAuthentication::Digest
-end
-module ActionController::HttpAuthentication::Digest::ControllerMethods
-  def authenticate_or_request_with_http_digest(realm = nil, &password_procedure); end
-  def authenticate_with_http_digest(realm = nil, &password_procedure); end
-  def request_http_digest_authentication(realm = nil, message = nil); end
-end
-module ActionController::HttpAuthentication::Token
-  def authenticate(controller, &login_procedure); end
-  def authentication_request(controller, realm); end
-  def encode_credentials(token, options = nil); end
-  def params_array_from(raw_params); end
-  def raw_params(auth); end
-  def rewrite_param_values(array_params); end
-  def token_and_options(request); end
-  def token_params_from(auth); end
-  extend ActionController::HttpAuthentication::Token
-end
-module ActionController::HttpAuthentication::Token::ControllerMethods
-  def authenticate_or_request_with_http_token(realm = nil, &login_procedure); end
-  def authenticate_with_http_token(&login_procedure); end
-  def request_http_token_authentication(realm = nil); end
-end
-module ActionController::Rescue
-  def process_action(*args); end
-  def rescue_with_handler(exception); 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
-  include ActionController::RackDelegation
-end
-module ActionController::Instrumentation::ClassMethods
-  def log_process_action(payload); end
-end
-class ActionController::Base < 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 _layout; end
-  def _process_action_callbacks; end
-  def _process_action_callbacks?; end
-  def _protected_ivars; end
-  def _renderers; end
-  def _renderers=(arg0); end
-  def _renderers?; end
-  def _run_process_action_callbacks(&block); end
-  def _view_cache_dependencies; end
-  def _view_cache_dependencies=(arg0); end
-  def _view_cache_dependencies?; 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 alert; end
-  def allow_forgery_protection; end
-  def allow_forgery_protection=(value); end
-  def asset_host; end
-  def asset_host=(value); end
-  def assets_dir; end
-  def assets_dir=(value); end
-  def default_asset_host_protocol; end
-  def default_asset_host_protocol=(value); end
-  def default_static_extension; end
-  def default_static_extension=(value); end
-  def default_url_options; end
-  def default_url_options=(arg0); end
-  def default_url_options?; end
-  def etag_with_template_digest; end
-  def etag_with_template_digest=(arg0); end
-  def etag_with_template_digest?; end
-  def etaggers; end
-  def etaggers=(arg0); end
-  def etaggers?; end
-  def flash(*args, &block); end
-  def forgery_protection_strategy; end
-  def forgery_protection_strategy=(value); end
-  def helpers_path; end
-  def helpers_path=(arg0); end
-  def helpers_path?; end
-  def hidden_actions; end
-  def hidden_actions=(arg0); end
-  def hidden_actions?; end
-  def include_all_helpers; end
-  def include_all_helpers=(arg0); end
-  def include_all_helpers?; end
-  def javascripts_dir; end
-  def javascripts_dir=(value); end
-  def log_warning_on_csrf_failure; end
-  def log_warning_on_csrf_failure=(value); end
-  def logger; end
-  def logger=(value); end
-  def notice; end
-  def perform_caching; end
-  def perform_caching=(value); end
-  def relative_url_root; end
-  def relative_url_root=(value); end
-  def request_forgery_protection_token; end
-  def request_forgery_protection_token=(value); end
-  def rescue_handlers; end
-  def rescue_handlers=(arg0); end
-  def rescue_handlers?; end
-  def self._flash_types; end
-  def self._flash_types=(val); end
-  def self._flash_types?; 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._layout; end
-  def self._layout=(val); end
-  def self._layout?; end
-  def self._layout_conditions; end
-  def self._layout_conditions=(val); end
-  def self._layout_conditions?; 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_cache_dependencies; end
-  def self._view_cache_dependencies=(val); end
-  def self._view_cache_dependencies?; 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.allow_forgery_protection; end
-  def self.allow_forgery_protection=(value); end
-  def self.asset_host; end
-  def self.asset_host=(value); end
-  def self.assets_dir; end
-  def self.assets_dir=(value); end
-  def self.default_asset_host_protocol; end
-  def self.default_asset_host_protocol=(value); end
-  def self.default_static_extension; end
-  def self.default_static_extension=(value); end
-  def self.default_url_options; end
-  def self.default_url_options=(val); end
-  def self.default_url_options?; end
-  def self.etag_with_template_digest; end
-  def self.etag_with_template_digest=(val); end
-  def self.etag_with_template_digest?; end
-  def self.etaggers; end
-  def self.etaggers=(val); end
-  def self.etaggers?; end
-  def self.forgery_protection_strategy; end
-  def self.forgery_protection_strategy=(value); end
-  def self.helpers_path; end
-  def self.helpers_path=(val); end
-  def self.helpers_path?; end
-  def self.hidden_actions; end
-  def self.hidden_actions=(val); end
-  def self.hidden_actions?; end
-  def self.include_all_helpers; end
-  def self.include_all_helpers=(val); end
-  def self.include_all_helpers?; end
-  def self.javascripts_dir; end
-  def self.javascripts_dir=(value); end
-  def self.log_warning_on_csrf_failure; end
-  def self.log_warning_on_csrf_failure=(value); end
-  def self.logger; end
-  def self.logger=(value); end
-  def self.middleware_stack; end
-  def self.perform_caching; end
-  def self.perform_caching=(value); end
-  def self.protected_instance_variables; end
-  def self.relative_url_root; end
-  def self.relative_url_root=(value); end
-  def self.request_forgery_protection_token; end
-  def self.request_forgery_protection_token=(value); end
-  def self.rescue_handlers; end
-  def self.rescue_handlers=(val); end
-  def self.rescue_handlers?; end
-  def self.stylesheets_dir; end
-  def self.stylesheets_dir=(value); end
-  def self.without_modules(*modules); end
-  def stylesheets_dir; end
-  def stylesheets_dir=(value); end
-  extend AbstractController::Callbacks::ClassMethods
-  extend AbstractController::Helpers::ClassMethods
-  extend AbstractController::UrlFor::ClassMethods
-  extend ActionController::Caching::ClassMethods
-  extend ActionController::Caching::ConfigMethods
-  extend ActionController::ConditionalGet::ClassMethods
-  extend ActionController::Flash::ClassMethods
-  extend ActionController::ForceSSL::ClassMethods
-  extend ActionController::Helpers::ClassMethods
-  extend ActionController::HideActions::ClassMethods
-  extend ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods
-  extend ActionController::Instrumentation::ClassMethods
-  extend ActionController::MimeResponds::ClassMethods
-  extend ActionController::ParamsWrapper::ClassMethods
-  extend ActionController::Railties::Helpers
-  extend ActionController::Renderers::ClassMethods
-  extend ActionController::RequestForgeryProtection::ClassMethods
-  extend ActionView::Layouts::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::AssetPaths
-  include AbstractController::Callbacks
-  include AbstractController::Callbacks
-  include AbstractController::Callbacks
-  include AbstractController::Callbacks
-  include AbstractController::Helpers
-  include AbstractController::Helpers
-  include AbstractController::Logger
-  include AbstractController::Logger
-  include AbstractController::Rendering
-  include AbstractController::Translation
-  include AbstractController::UrlFor
-  include ActionController::Caching
-  include ActionController::ConditionalGet
-  include ActionController::ConditionalGet
-  include ActionController::Cookies
-  include ActionController::DataStreaming
-  include ActionController::EtagWithTemplateDigest
-  include ActionController::Flash
-  include ActionController::ForceSSL
-  include ActionController::Helpers
-  include ActionController::HideActions
-  include ActionController::HttpAuthentication::Basic::ControllerMethods
-  include ActionController::HttpAuthentication::Digest::ControllerMethods
-  include ActionController::HttpAuthentication::Token::ControllerMethods
-  include ActionController::ImplicitRender
-  include ActionController::Instrumentation
-  include ActionController::MimeResponds
-  include ActionController::ParamsWrapper
-  include ActionController::RackDelegation
-  include ActionController::RackDelegation
-  include ActionController::RackDelegation
-  include ActionController::RackDelegation
-  include ActionController::RackDelegation
-  include ActionController::RackDelegation
-  include ActionController::Redirecting
-  include ActionController::Renderers
-  include ActionController::Renderers::All
-  include ActionController::Rendering
-  include ActionController::Rendering
-  include ActionController::RequestForgeryProtection
-  include ActionController::Rescue
-  include ActionController::Streaming
-  include ActionController::StrongParameters
-  include ActionController::UrlFor
-  include ActionController::UrlFor
-  include ActionDispatch::Routing::RouteSet::MountedHelpers
-  include ActionDispatch::Routing::UrlFor
-  include ActionDispatch::Routing::UrlFor
-  include ActionView::Layouts
-  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
-end
-module Anonymous_Module_7
-  def inherited(klass); end
-end
-class ActionDispatch::TestRequest < ActionDispatch::Request
-  def accept=(mime_types); end
-  def action=(action_name); end
-  def cookies; end
-  def default_env; end
-  def host=(host); end
-  def if_modified_since=(last_modified); end
-  def if_none_match=(etag); end
-  def initialize(env = nil); end
-  def path=(path); end
-  def port=(number); end
-  def rack_cookies; end
-  def remote_addr=(addr); end
-  def request_method=(method); end
-  def request_uri=(uri); end
-  def self.new(env = nil); end
-  def user_agent=(user_agent); end
-end
-class ActionDispatch::TestResponse < ActionDispatch::Response
-  def error?; end
-  def missing?; end
-  def redirect?; end
-  def self.from_response(response); end
-  def success?; end
-end
-module ActionDispatch::TestProcess
-  def assigns(key = nil); end
-  def cookies; end
-  def fixture_file_upload(path, mime_type = nil, binary = nil); end
-  def flash; end
-  def redirect_to_url; end
-  def session; 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 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
-module ActionController::TemplateAssertions
-  def assert_template(options = nil, message = nil); end
-  def process(*args); end
-  def reset_template_assertion; end
-  def setup_subscriptions; end
-  def teardown_subscriptions; end
-  extend ActiveSupport::Concern
-end
-class ActionController::TestRequest < ActionDispatch::TestRequest
-  def assign_parameters(routes, controller_path, action, parameters = nil); end
-  def default_env; end
-  def initialize(env = nil); end
-  def recycle!; end
-end
-class ActionController::TestResponse < ActionDispatch::TestResponse
-  def recycle!; end
-end
-class ActionController::LiveTestResponse < ActionController::Live::Response
-  def body; end
-  def error?; end
-  def missing?; end
-  def recycle!; end
-  def redirect?; 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
-  def self._teardown_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_request; end
-  def build_request_uri(action, parameters); end
-  def build_response(klass); end
-  def check_required_ivars; end
-  def delete(action, *args); end
-  def document_root_element; end
-  def get(action, *args); end
-  def head(action, *args); end
-  def html_format?(parameters); end
-  def paramify_values(hash_or_array_or_value); end
-  def patch(action, *args); end
-  def post(action, *args); end
-  def process(action, http_method = nil, *args); end
-  def put(action, *args); end
-  def request; end
-  def response; end
-  def setup_controller_request_and_response; end
-  def xhr(request_method, action, parameters = nil, session = nil, flash = nil); end
-  def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil); 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
-module ActionDispatch::Integration
-end
-module ActionDispatch::Integration::RequestHelpers
-  def delete(path, parameters = nil, headers_or_env = nil); end
-  def delete_via_redirect(path, parameters = nil, headers_or_env = nil); end
-  def follow_redirect!; end
-  def get(path, parameters = nil, headers_or_env = nil); end
-  def get_via_redirect(path, parameters = nil, headers_or_env = nil); end
-  def head(path, parameters = nil, headers_or_env = nil); end
-  def patch(path, parameters = nil, headers_or_env = nil); end
-  def patch_via_redirect(path, parameters = nil, headers_or_env = nil); end
-  def post(path, parameters = nil, headers_or_env = nil); end
-  def post_via_redirect(path, parameters = nil, headers_or_env = nil); end
-  def put(path, parameters = nil, headers_or_env = nil); end
-  def put_via_redirect(path, parameters = nil, headers_or_env = nil); end
-  def request_via_redirect(http_method, path, parameters = nil, headers_or_env = nil); 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 path(*args, &block); end
-  def process(method, path, parameters = nil, headers_or_env = 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 cookies(*args); end
-  def copy_session_variables!; end
-  def default_url_options; end
-  def default_url_options=(options); end
-  def delete(*args); end
-  def get(*args); end
-  def get_via_redirect(*args); end
-  def head(*args); 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 app; end
-  def document_root_element; end
-  def self._setup_callbacks; end
-  def self._teardown_callbacks; end
-  def self.app; end
-  def self.app=(app); end
-  def url_options; end
-  include ActionController::TemplateAssertions
-  include ActionDispatch::Integration::Runner
-  include ActionDispatch::Routing::UrlFor
-end