sorbet-rails 0.5.0 → 0.5.1

data/spec/support/v5.2/sorbet/rbi/gems/rack.rbi

@@ -349,21 +349,12 @@ class Rack::Sendfile
   def map_accel_path(env, path); end
   def variation(env); end
 end
-class Rack::ConditionalGet
+class Rack::MethodOverride
+  def allowed_methods; end
   def call(env); end
-  def etag_matches?(none_match, headers); end
-  def fresh?(env, headers); end
   def initialize(app); end
-  def modified_since?(modified_since, headers); end
-  def to_rfc2822(since); end
-end
-class Rack::ETag
-  def call(env); end
-  def digest_body(body); end
-  def etag_body?(body); end
-  def etag_status?(status); end
-  def initialize(app, no_cache_control = nil, cache_control = nil); end
-  def skip_caching?(headers); end
+  def method_override(env); end
+  def method_override_param(req); end
 end
 module Rack::Session::Abstract
 end
@@ -435,6 +426,59 @@ class Rack::Session::Abstract::ID < Rack::Session::Abstract::Persisted
   def self.inherited(klass); end
   def write_session(req, sid, session, options); end
 end
+class Rack::Session::Cookie < Rack::Session::Abstract::Persisted
+  def coder; end
+  def delete_session(req, session_id, options); end
+  def digest_match?(data, digest); end
+  def extract_session_id(request); end
+  def find_session(req, sid); end
+  def generate_hmac(data, secret); end
+  def initialize(app, options = nil); end
+  def persistent_session_id!(data, sid = nil); end
+  def secure?(options); end
+  def unpacked_cookie_data(request); end
+  def write_session(req, session_id, session, options); end
+end
+class Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(str); end
+end
+class Rack::Session::Cookie::Base64::Marshal < Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(str); end
+end
+class Rack::Session::Cookie::Base64::JSON < Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(obj); end
+end
+class Rack::Session::Cookie::Base64::ZipJSON < Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(obj); end
+end
+class Rack::Session::Cookie::Identity
+  def decode(str); end
+  def encode(str); end
+end
+class Rack::ConditionalGet
+  def call(env); end
+  def etag_matches?(none_match, headers); end
+  def fresh?(env, headers); end
+  def initialize(app); end
+  def modified_since?(modified_since, headers); end
+  def to_rfc2822(since); end
+end
+class Rack::ETag
+  def call(env); end
+  def digest_body(body); end
+  def etag_body?(body); end
+  def etag_status?(status); end
+  def initialize(app, no_cache_control = nil, cache_control = nil); end
+  def skip_caching?(headers); end
+end
+class Rack::TempfileReaper
+  def call(env); end
+  def initialize(app); end
+end
 class Rack::Chunked
   def call(env); end
   def chunkable_version?(ver); end
@@ -447,88 +491,3 @@ class Rack::Chunked::Body
   def initialize(body); end
   include Rack::Utils
 end
-class Rack::Lint
-  def _call(env); end
-  def call(env = nil); end
-  def check_content_length(status, headers); end
-  def check_content_type(status, headers); end
-  def check_env(env); end
-  def check_error(error); end
-  def check_headers(header); end
-  def check_hijack(env); end
-  def check_hijack_response(headers, env); end
-  def check_input(input); end
-  def check_status(status); end
-  def close; end
-  def each; end
-  def initialize(app); end
-  def verify_content_length(bytes); end
-  include Rack::Lint::Assertion
-end
-class Rack::Lint::LintError < RuntimeError
-end
-module Rack::Lint::Assertion
-  def assert(message); end
-end
-class Rack::Lint::InputWrapper
-  def close(*args); end
-  def each(*args); end
-  def gets(*args); end
-  def initialize(input); end
-  def read(*args); end
-  def rewind(*args); end
-  include Rack::Lint::Assertion
-end
-class Rack::Lint::ErrorWrapper
-  def close(*args); end
-  def flush; end
-  def initialize(error); end
-  def puts(str); end
-  def write(str); end
-  include Rack::Lint::Assertion
-end
-class Rack::Lint::HijackWrapper
-  def close(*args, &block); end
-  def close_read(*args, &block); end
-  def close_write(*args, &block); end
-  def closed?(*args, &block); end
-  def flush(*args, &block); end
-  def initialize(io); end
-  def read(*args, &block); end
-  def read_nonblock(*args, &block); end
-  def write(*args, &block); end
-  def write_nonblock(*args, &block); end
-  extend Forwardable
-  include Rack::Lint::Assertion
-end
-class Rack::MockRequest
-  def delete(uri, opts = nil); end
-  def get(uri, opts = nil); end
-  def head(uri, opts = nil); end
-  def initialize(app); end
-  def options(uri, opts = nil); end
-  def patch(uri, opts = nil); end
-  def post(uri, opts = nil); end
-  def put(uri, opts = nil); end
-  def request(method = nil, uri = nil, opts = nil); end
-  def self.env_for(uri = nil, opts = nil); end
-  def self.parse_uri_rfc2396(uri); end
-end
-class Rack::MockRequest::FatalWarning < RuntimeError
-end
-class Rack::MockRequest::FatalWarner
-  def flush; end
-  def puts(warning); end
-  def string; end
-  def write(warning); end
-end
-class Rack::MockResponse < Rack::Response
-  def =~(other); end
-  def body; end
-  def empty?; end
-  def errors; end
-  def errors=(arg0); end
-  def initialize(status, headers, body, errors = nil); end
-  def match(other); end
-  def original_headers; end
-end

data/spec/support/v5.2/sorbet/rbi/gems/rails-html-sanitizer.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rails-html-sanitizer/all/rails-html-sanitizer.rbi
 #
-# rails-html-sanitizer-1.0.4
+# rails-html-sanitizer-1.2.0
 module Rails
 end
 module Rails::Html
@@ -18,6 +18,7 @@ class Rails::Html::Sanitizer
   def sanitize(html, options = nil); end
   def self.full_sanitizer; end
   def self.link_sanitizer; end
+  def self.safe_list_sanitizer; end
   def self.white_list_sanitizer; end
 end
 class Rails::Html::PermitScrubber < Loofah::Scrubber
@@ -52,7 +53,7 @@ class Rails::Html::LinkSanitizer < Rails::Html::Sanitizer
   def initialize; end
   def sanitize(html, options = nil); end
 end
-class Rails::Html::WhiteListSanitizer < Rails::Html::Sanitizer
+class Rails::Html::SafeListSanitizer < Rails::Html::Sanitizer
   def allowed_attributes(options); end
   def allowed_tags(options); end
   def initialize; end

data/spec/support/v5.2/sorbet/rbi/gems/railties.rbi

@@ -344,36 +344,6 @@ class Rails::Engine::Configuration < Rails::Railtie::Configuration
   def root; end
   def root=(value); end
 end
-module Rails::TestUnit
-end
-class Rails::TestUnit::Runner
-  def filters; end
-  def self.attach_before_load_options(opts); end
-  def self.compose_filter(runnable, filter); end
-  def self.extract_filters(argv); end
-  def self.filters; end
-  def self.load_tests(argv); end
-  def self.parse_options(argv); end
-  def self.rake_run(argv = nil); end
-  def self.run(argv = nil); end
-end
-class Rails::TestUnit::CompositeFilter
-  def ===(method); end
-  def derive_line_filters(patterns); end
-  def derive_named_filter(filter); end
-  def initialize(runnable, filter, patterns); end
-  def named_filter; end
-end
-class Rails::TestUnit::Filter
-  def ===(method); end
-  def definition_for(method); end
-  def initialize(runnable, file, line); end
-end
-module Rails::LineFiltering
-  def run(reporter, options = nil); end
-end
-class Rails::TestUnitRailtie < Rails::Railtie
-end
 class SourceAnnotationExtractor
   def display(results, options = nil); end
   def extract_annotations_from(file, pattern); end
@@ -389,6 +359,7 @@ class SourceAnnotationExtractor::Annotation < Struct
   def self.[](*arg0); end
   def self.directories; end
   def self.extensions; end
+  def self.inspect; end
   def self.members; end
   def self.new(*arg0); end
   def self.register_directories(*dirs); end
@@ -535,188 +506,3 @@ class Rails::Application::DefaultMiddlewareStack
 end
 class Rails::Rack::Logger < ActiveSupport::LogSubscriber
 end
-module Rails::Command
-  def self.command_type; end
-  def self.environment; end
-  def self.file_lookup_paths; end
-  def self.find_by_namespace(namespace, command_name = nil); end
-  def self.hidden_commands; end
-  def self.invoke(full_namespace, args = nil, **config); end
-  def self.lookup_paths; end
-  def self.print_commands; end
-  def self.root; end
-  def self.sorted_groups; end
-  extend ActiveSupport::Autoload
-  extend Rails::Command::Behavior::ClassMethods
-  include Rails::Command::Behavior
-end
-module Rails::Command::Behavior
-  extend ActiveSupport::Concern
-end
-module Rails::Command::Behavior::ClassMethods
-  def levenshtein_distance(str1, str2); end
-  def lookup!; end
-  def lookup(namespaces); end
-  def namespaces_to_paths(namespaces); end
-  def no_color!; end
-  def print_list(base, namespaces); end
-  def subclasses; end
-end
-module Rails::Generators
-  def namespace; end
-  def namespace=(obj); end
-  def self.aliases; end
-  def self.api_only!; end
-  def self.command_type; end
-  def self.configure!(config); end
-  def self.fallbacks; end
-  def self.file_lookup_paths; end
-  def self.find_by_namespace(name, base = nil, context = nil); end
-  def self.help(command = nil); end
-  def self.hidden_namespaces; end
-  def self.hide_namespace(*namespaces); end
-  def self.hide_namespaces(*namespaces); end
-  def self.invoke(namespace, args = nil, config = nil); end
-  def self.invoke_fallbacks_for(name, base); end
-  def self.lookup_paths; end
-  def self.namespace; end
-  def self.namespace=(obj); end
-  def self.no_color!; end
-  def self.options; end
-  def self.print_generators; end
-  def self.print_list(base, namespaces); end
-  def self.public_namespaces; end
-  def self.sorted_groups; end
-  def self.templates_path; end
-  extend Rails::Command::Behavior::ClassMethods
-  include Rails::Command::Behavior
-end
-module Rails::Generators::Testing
-end
-module Rails::Generators::Testing::Behaviour
-  def create_generated_attribute(attribute_type, name = nil, index = nil); end
-  def destination_root_is_set?; end
-  def ensure_current_path; end
-  def generator(args = nil, options = nil, config = nil); end
-  def migration_file_name(relative); end
-  def prepare_destination; end
-  def run_generator(args = nil, config = nil); end
-  extend ActiveSupport::Concern
-  include ActiveSupport::Testing::Stream
-end
-module Rails::Generators::Testing::Behaviour::ClassMethods
-  def arguments(array); end
-  def destination(path); end
-  def tests(klass); end
-end
-module Rails::Generators::Testing::SetupAndTeardown
-  def setup; end
-  def teardown; end
-end
-module Rails::Generators::Testing::Assertions
-  def assert_class_method(method, content, &block); end
-  def assert_directory(relative, *contents); end
-  def assert_field_default_value(attribute_type, value); end
-  def assert_field_type(attribute_type, field_type); end
-  def assert_file(relative, *contents); end
-  def assert_instance_method(method, content); end
-  def assert_method(method, content); end
-  def assert_migration(relative, *contents, &block); end
-  def assert_no_directory(relative); end
-  def assert_no_file(relative); end
-  def assert_no_migration(relative); end
-end
-class Rails::Generators::TestCase < ActiveSupport::TestCase
-  def current_path; end
-  def current_path=(val); end
-  def current_path?; end
-  def default_arguments; end
-  def default_arguments=(val); end
-  def default_arguments?; end
-  def destination_root; end
-  def destination_root=(val); end
-  def destination_root?; end
-  def generator_class; end
-  def generator_class=(val); end
-  def generator_class?; end
-  def self.current_path; end
-  def self.current_path=(val); end
-  def self.current_path?; end
-  def self.default_arguments; end
-  def self.default_arguments=(val); end
-  def self.default_arguments?; end
-  def self.destination_root; end
-  def self.destination_root=(val); end
-  def self.destination_root?; end
-  def self.generator_class; end
-  def self.generator_class=(val); end
-  def self.generator_class?; end
-  extend Rails::Generators::Testing::Behaviour::ClassMethods
-  include FileUtils
-  include Rails::Generators::Testing::Assertions
-  include Rails::Generators::Testing::Behaviour
-  include Rails::Generators::Testing::SetupAndTeardown
-end
-class ActiveRecord::ExplainRegistry
-  def self.collect?(*args, &block); end
-end
-class ActiveRecord::Scoping::ScopeRegistry
-  def self.value_for(*args, &block); end
-end
-class ActiveRecord::SchemaMigration < ActiveRecord::Base
-  def self.default_scope_override; end
-end
-module ActiveSupport
-end
-class ActiveSupport::TestCase < Minitest::Test
-  def config; end
-  def config=(val); end
-  def config?; end
-  def fixture_class_names; end
-  def fixture_class_names=(val); end
-  def fixture_class_names?; end
-  def fixture_path; end
-  def fixture_path?; end
-  def fixture_table_names; end
-  def fixture_table_names=(val); end
-  def fixture_table_names?; end
-  def pre_loaded_fixtures; end
-  def pre_loaded_fixtures=(val); end
-  def pre_loaded_fixtures?; end
-  def self.config; end
-  def self.config=(val); end
-  def self.config?; end
-  def self.fixture_class_names; end
-  def self.fixture_class_names=(val); end
-  def self.fixture_class_names?; end
-  def self.fixture_path; end
-  def self.fixture_path=(val); end
-  def self.fixture_path?; end
-  def self.fixture_table_names; end
-  def self.fixture_table_names=(val); end
-  def self.fixture_table_names?; end
-  def self.pre_loaded_fixtures; end
-  def self.pre_loaded_fixtures=(val); end
-  def self.pre_loaded_fixtures?; end
-  def self.use_instantiated_fixtures; end
-  def self.use_instantiated_fixtures=(val); end
-  def self.use_instantiated_fixtures?; end
-  def self.use_transactional_tests; end
-  def self.use_transactional_tests=(val); end
-  def self.use_transactional_tests?; end
-  def use_instantiated_fixtures; end
-  def use_instantiated_fixtures=(val); end
-  def use_instantiated_fixtures?; end
-  def use_transactional_tests; end
-  def use_transactional_tests=(val); end
-  def use_transactional_tests?; end
-  extend ActiveRecord::TestFixtures::ClassMethods
-  include ActiveRecord::TestFixtures
-end
-class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  def before_setup; end
-  def self.fixture_path; end
-end
-class ActionController::TestCase < ActiveSupport::TestCase
-  def before_setup; end
-end

data/spec/support/v5.2/sorbet/rbi/gems/web-console.rbi

@@ -0,0 +1,73 @@
+# 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/web-console/all/web-console.rbi
+#
+# web-console-3.7.0
+module WebConsole
+  def self.logger; end
+  extend ActiveSupport::Autoload
+end
+class WebConsole::Railtie < Rails::Railtie
+end
+module Kernel
+  def console(binding = nil); end
+  def self.console(binding = nil); end
+end
+module ActionDispatch
+end
+class ActionDispatch::DebugExceptions
+  def render_exception_with_web_console(request, exception); end
+  def render_exception_without_web_console(request, exception); end
+end
+class WebConsole::Middleware
+  def acceptable_content_type?(headers); end
+  def binding_change_re; end
+  def call(env); end
+  def call_app(env); end
+  def change_stack_trace(id, request); end
+  def create_regular_or_whiny_request(env); end
+  def id_for_repl_session_stack_frame_change(request); end
+  def id_for_repl_session_update(request); end
+  def initialize(app); end
+  def json_response(opts = nil); end
+  def json_response_with_session(id, request, opts = nil); end
+  def mount_point; end
+  def mount_point=(obj); end
+  def repl_sessions_re; end
+  def respond_with_unacceptable_request; end
+  def respond_with_unavailable_session(id); end
+  def self.mount_point; end
+  def self.mount_point=(obj); end
+  def self.whiny_requests; end
+  def self.whiny_requests=(obj); end
+  def update_re; end
+  def update_repl_session(id, request); end
+  def whiny_requests; end
+  def whiny_requests=(obj); end
+end
+class WebConsole::Whitelist
+  def coerce_network_to_ipaddr(network); end
+  def human_readable_ipaddr(ipaddr); end
+  def include?(network); end
+  def initialize(networks = nil); end
+  def normalize_networks(networks); end
+  def to_s; end
+end
+class WebConsole::Request < ActionDispatch::Request
+  def acceptable?; end
+  def from_whitelisted_ip?; end
+  def self.whitelisted_ips; end
+  def self.whitelisted_ips=(obj); end
+  def strict_remote_ip; end
+  def whitelisted_ips; end
+  def whitelisted_ips=(obj); end
+end
+class WebConsole::Request::GetSecureIp < ActionDispatch::RemoteIp::GetIp
+  def filter_proxies(ips); end
+  def initialize(req, proxies); end
+end