sorbet-rails 0.5.1 → 0.5.2

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

@@ -1,214 +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/parlour/all/parlour.rbi
-#
-# parlour-0.6.1
-module Parlour
-end
-module Kernel
-end
-class Parlour::Plugin
-  def generate(*args, &blk); end
-  def initialize(*args, &blk); end
-  def self.inherited(*args, &blk); end
-  def self.registered_plugins(*args, &blk); end
-  def self.run_plugins(*args, &blk); end
-  extend T::Helpers
-  extend T::InterfaceWrapper::Helpers
-  extend T::Private::Abstract::Hooks
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator
-  def current_plugin(*args, &blk); end
-  def current_plugin=(arg0); end
-  def initialize(*args, &blk); end
-  def options(*args, &blk); end
-  def rbi(*args, &blk); end
-  def root(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Parameter
-  def ==(*args, &blk); end
-  def default(*args, &blk); end
-  def initialize(*args, &blk); end
-  def kind(*args, &blk); end
-  def name(*args, &blk); end
-  def name_without_kind(*args, &blk); end
-  def to_def_param(*args, &blk); end
-  def to_sig_param(*args, &blk); end
-  def type(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::RbiObject
-  def add_comment(*args, &blk); end
-  def add_comments(*args, &blk); end
-  def comments(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_comments(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def generated_by(*args, &blk); end
-  def generator(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def name(*args, &blk); end
-  extend T::Helpers
-  extend T::InterfaceWrapper::Helpers
-  extend T::Private::Abstract::Hooks
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Method < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def abstract(*args, &blk); end
-  def class_method(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_definition(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def implementation(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def overridable(*args, &blk); end
-  def override(*args, &blk); end
-  def parameters(*args, &blk); end
-  def qualifiers(*args, &blk); end
-  def return_type(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Attribute < Parlour::RbiGenerator::Method
-  def generate_definition(*args, &blk); end
-  def initialize(*args, &blk); end
-  def kind(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-end
-class Parlour::RbiGenerator::Arbitrary < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def code(*args, &blk); end
-  def code=(arg0); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-end
-class Parlour::RbiGenerator::Options
-  def break_params(*args, &blk); end
-  def indented(*args, &blk); end
-  def initialize(*args, &blk); end
-  def tab_size(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::Include < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-end
-class Parlour::RbiGenerator::Extend < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-end
-class Parlour::RbiGenerator::Constant < Parlour::RbiGenerator::RbiObject
-  def ==(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def value(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-end
-class Parlour::RbiGenerator::Namespace < Parlour::RbiGenerator::RbiObject
-  def add_comment_to_next_child(*args, &blk); end
-  def children(*args, &blk); end
-  def constants(*args, &blk); end
-  def create_arbitrary(code:, &block); end
-  def create_attr(name, kind:, type:, &block); end
-  def create_attr_accessor(name, type:, &block); end
-  def create_attr_reader(name, type:, &block); end
-  def create_attr_writer(name, type:, &block); end
-  def create_attribute(name, kind:, type:, &block); end
-  def create_class(*args, &blk); end
-  def create_constant(*args, &blk); end
-  def create_extend(*args, &blk); end
-  def create_extends(*args, &blk); end
-  def create_include(*args, &blk); end
-  def create_includes(*args, &blk); end
-  def create_method(*args, &blk); end
-  def create_module(*args, &blk); end
-  def describe(*args, &blk); end
-  def extends(*args, &blk); end
-  def generate_body(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def includes(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def move_next_comments(*args, &blk); end
-  def path(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::ModuleNamespace < Parlour::RbiGenerator::Namespace
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def interface(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::RbiGenerator::ClassNamespace < Parlour::RbiGenerator::Namespace
-  def abstract(*args, &blk); end
-  def describe(*args, &blk); end
-  def generate_rbi(*args, &blk); end
-  def initialize(*args, &blk); end
-  def merge_into_self(*args, &blk); end
-  def mergeable?(*args, &blk); end
-  def superclass(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end
-class Parlour::ConflictResolver
-  def all_eql?(*args, &blk); end
-  def resolve_conflicts(*args, &blk); end
-  def single_type_of_array(*args, &blk); end
-  extend T::Private::Methods::MethodHooks
-  extend T::Private::Methods::SingletonMethodHooks
-  extend T::Sig
-end

data/spec/support/v4.2/sorbet/rbi/gems/rack-test.rbi

@@ -1,145 +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/rack-test/all/rack-test.rbi
-#
-# rack-test-0.6.3
-module Rack
-end
-class Rack::MockSession
-  def after_request(&block); end
-  def clear_cookies; end
-  def cookie_jar; end
-  def cookie_jar=(arg0); end
-  def default_host; end
-  def initialize(app, default_host = nil); end
-  def last_request; end
-  def last_response; end
-  def request(uri, env); end
-  def set_cookie(cookie, uri = nil); end
-end
-module Rack::Test
-  def self.encoding_aware_strings?; end
-end
-class Rack::Test::Cookie
-  def <=>(other); end
-  def default_uri; end
-  def domain; end
-  def empty?; end
-  def expired?; end
-  def expires; end
-  def initialize(raw, uri = nil, default_host = nil); end
-  def matches?(uri); end
-  def name; end
-  def path; end
-  def raw; end
-  def replaces?(other); end
-  def secure?; end
-  def valid?(uri); end
-  def value; end
-  include Rack::Utils
-end
-class Rack::Test::CookieJar
-  def <<(new_cookie); end
-  def [](name); end
-  def []=(name, value); end
-  def delete(name); end
-  def for(uri); end
-  def hash_for(uri = nil); end
-  def initialize(cookies = nil, default_host = nil); end
-  def merge(raw_cookies, uri = nil); end
-  def to_hash; end
-end
-class Rack::Test::MockDigestRequest
-  def initialize(params); end
-  def method; end
-  def method_missing(sym); end
-  def response(password); end
-end
-module Rack::Test::Utils
-  def build_file_part(parameter_name, uploaded_file); end
-  def build_multipart(params, first = nil); end
-  def build_nested_query(value, prefix = nil); end
-  def build_parts(parameters); end
-  def build_primitive_part(parameter_name, value); end
-  def get_parts(parameters); end
-  def self.build_multipart(params, first = nil); end
-  def self.build_nested_query(value, prefix = nil); end
-  include Rack::Utils
-end
-module Rack::Test::Methods
-  def _current_session_names; end
-  def authorize(*args, &block); end
-  def basic_authorize(*args, &block); end
-  def build_rack_mock_session; end
-  def build_rack_test_session(name); end
-  def clear_cookies(*args, &block); end
-  def current_session; end
-  def delete(*args, &block); end
-  def digest_authorize(*args, &block); end
-  def env(*args, &block); end
-  def follow_redirect!(*args, &block); end
-  def get(*args, &block); end
-  def head(*args, &block); end
-  def header(*args, &block); end
-  def last_request(*args, &block); end
-  def last_response(*args, &block); end
-  def options(*args, &block); end
-  def patch(*args, &block); end
-  def post(*args, &block); end
-  def put(*args, &block); end
-  def rack_mock_session(name = nil); end
-  def rack_test_session(name = nil); end
-  def request(*args, &block); end
-  def set_cookie(*args, &block); end
-  def with_session(name); end
-  extend Forwardable
-end
-class Rack::Test::UploadedFile
-  def content_type; end
-  def content_type=(arg0); end
-  def initialize(path, content_type = nil, binary = nil); end
-  def local_path; end
-  def method_missing(method_name, *args, &block); end
-  def original_filename; end
-  def path; end
-  def respond_to?(method_name, include_private = nil); end
-  def tempfile; end
-end
-class Rack::Test::Error < StandardError
-end
-class Rack::Test::Session
-  def authorize(username, password); end
-  def basic_authorize(username, password); end
-  def clear_cookies(*args, &block); end
-  def default_env; end
-  def delete(uri, params = nil, env = nil, &block); end
-  def digest_auth_configured?; end
-  def digest_auth_header; end
-  def digest_authorize(username, password); end
-  def env(name, value); end
-  def env_for(path, env); end
-  def follow_redirect!; end
-  def get(uri, params = nil, env = nil, &block); end
-  def head(uri, params = nil, env = nil, &block); end
-  def header(name, value); end
-  def headers_for_env; end
-  def initialize(mock_session); end
-  def last_request(*args, &block); end
-  def last_response(*args, &block); end
-  def options(uri, params = nil, env = nil, &block); end
-  def params_to_string(params); end
-  def patch(uri, params = nil, env = nil, &block); end
-  def post(uri, params = nil, env = nil, &block); end
-  def process_request(uri, env); end
-  def put(uri, params = nil, env = nil, &block); end
-  def request(uri, env = nil, &block); end
-  def retry_with_digest_auth?(env); end
-  def set_cookie(*args, &block); end
-  extend Forwardable
-  include Rack::Test::Utils
-end

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

@@ -1,490 +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/rack/all/rack.rbi
-#
-# rack-1.6.11
-module Rack
-  def self.release; end
-  def self.version; end
-end
-module Rack::Multipart
-  def self.build_multipart(params, first = nil); end
-  def self.parse_multipart(env); end
-end
-module Rack::Utils
-  def best_q_match(q_value_header, available_mimes); end
-  def build_nested_query(value, prefix = nil); end
-  def build_query(params); end
-  def byte_ranges(env, size); end
-  def bytesize(string); end
-  def clean_path_info(path_info); end
-  def delete_cookie_header!(header, key, value = nil); end
-  def escape(s); end
-  def escape_html(string); end
-  def escape_path(s); end
-  def normalize_params(params, name, v = nil, depth = nil); end
-  def params_hash_type?(obj); end
-  def parse_nested_query(qs, d = nil); end
-  def parse_query(qs, d = nil, &unescaper); end
-  def q_values(q_value_header); end
-  def rfc2109(time); end
-  def rfc2822(time); end
-  def secure_compare(a, b); end
-  def select_best_encoding(available_encodings, accept_encoding); end
-  def self.best_q_match(q_value_header, available_mimes); end
-  def self.build_nested_query(value, prefix = nil); end
-  def self.build_query(params); end
-  def self.byte_ranges(env, size); end
-  def self.bytesize(string); end
-  def self.clean_path_info(path_info); end
-  def self.delete_cookie_header!(header, key, value = nil); end
-  def self.escape(s); end
-  def self.escape_html(string); end
-  def self.escape_path(s); end
-  def self.key_space_limit; end
-  def self.key_space_limit=(arg0); end
-  def self.multipart_part_limit; end
-  def self.multipart_part_limit=(arg0); end
-  def self.normalize_params(params, name, v = nil, depth = nil); end
-  def self.param_depth_limit; end
-  def self.param_depth_limit=(arg0); end
-  def self.params_hash_type?(obj); end
-  def self.parse_nested_query(qs, d = nil); end
-  def self.parse_query(qs, d = nil, &unescaper); end
-  def self.q_values(q_value_header); end
-  def self.rfc2109(time); end
-  def self.rfc2822(time); end
-  def self.secure_compare(a, b); end
-  def self.select_best_encoding(available_encodings, accept_encoding); end
-  def self.set_cookie_header!(header, key, value); end
-  def self.status_code(status); end
-  def self.unescape(s, encoding = nil); end
-  def set_cookie_header!(header, key, value); end
-  def status_code(status); end
-  def unescape(s, encoding = nil); end
-end
-class Rack::Utils::ParameterTypeError < TypeError
-end
-class Rack::Utils::InvalidParameterError < ArgumentError
-end
-class Rack::Utils::Context
-  def app; end
-  def call(env); end
-  def context(env, app = nil); end
-  def for; end
-  def initialize(app_f, app_r); end
-  def recontext(app); end
-end
-class Rack::Utils::HeaderHash < Hash
-  def [](k); end
-  def []=(k, v); end
-  def delete(k); end
-  def each; end
-  def has_key?(k); end
-  def include?(k); end
-  def initialize(hash = nil); end
-  def key?(k); end
-  def member?(k); end
-  def merge!(other); end
-  def merge(other); end
-  def replace(other); end
-  def self.new(hash = nil); end
-  def to_hash; end
-end
-class Rack::Utils::KeySpaceConstrainedParams
-  def [](key); end
-  def []=(key, value); end
-  def initialize(limit = nil); end
-  def key?(key); end
-  def to_params_hash; end
-end
-module Rack::Auth
-end
-module Rack::Auth::Digest
-end
-module Rack::Session
-end
-class Rack::Request
-  def GET; end
-  def POST; end
-  def [](key); end
-  def []=(key, value); end
-  def accept_encoding; end
-  def accept_language; end
-  def base_url; end
-  def body; end
-  def content_charset; end
-  def content_length; end
-  def content_type; end
-  def cookies; end
-  def delete?; end
-  def delete_param(k); end
-  def env; end
-  def form_data?; end
-  def forwarded_scheme; end
-  def fullpath; end
-  def get?; end
-  def head?; end
-  def host; end
-  def host_with_port; end
-  def initialize(env); end
-  def ip; end
-  def link?; end
-  def logger; end
-  def media_type; end
-  def media_type_params; end
-  def options?; end
-  def params; end
-  def parse_http_accept_header(header); end
-  def parse_multipart(env); end
-  def parse_query(qs); end
-  def parseable_data?; end
-  def patch?; end
-  def path; end
-  def path_info; end
-  def path_info=(s); end
-  def port; end
-  def post?; end
-  def put?; end
-  def query_string; end
-  def referer; end
-  def referrer; end
-  def reject_trusted_ip_addresses(ip_addresses); end
-  def request_method; end
-  def scheme; end
-  def script_name; end
-  def script_name=(s); end
-  def session; end
-  def session_options; end
-  def split_ip_addresses(ip_addresses); end
-  def ssl?; end
-  def strip_doublequotes(s); end
-  def trace?; end
-  def trusted_proxy?(ip); end
-  def unlink?; end
-  def update_param(k, v); end
-  def url; end
-  def user_agent; end
-  def values_at(*keys); end
-  def xhr?; end
-end
-class Rack::BodyProxy
-  def close; end
-  def closed?; end
-  def each(*args, &block); end
-  def initialize(body, &block); end
-  def method_missing(*args, &block); end
-  def respond_to?(*args); end
-end
-class Rack::Response
-  def [](key); end
-  def []=(key, value); end
-  def body; end
-  def body=(arg0); end
-  def close; end
-  def delete_cookie(key, value = nil); end
-  def each(&callback); end
-  def empty?; end
-  def finish(&block); end
-  def header; end
-  def headers; end
-  def initialize(body = nil, status = nil, header = nil); end
-  def length; end
-  def length=(arg0); end
-  def redirect(target, status = nil); end
-  def set_cookie(key, value); end
-  def status; end
-  def status=(arg0); end
-  def to_a(&block); end
-  def to_ary(&block); end
-  def write(str); end
-  include Rack::Response::Helpers
-end
-module Rack::Response::Helpers
-  def accepted?; end
-  def bad_request?; end
-  def client_error?; end
-  def content_length; end
-  def content_type; end
-  def created?; end
-  def forbidden?; end
-  def headers; end
-  def i_m_a_teapot?; end
-  def include?(header); end
-  def informational?; end
-  def invalid?; end
-  def location; end
-  def method_not_allowed?; end
-  def not_found?; end
-  def ok?; end
-  def original_headers; end
-  def redirect?; end
-  def redirection?; end
-  def server_error?; end
-  def successful?; end
-  def unauthorized?; end
-  def unprocessable?; end
-end
-module Rack::Mime
-  def match?(value, matcher); end
-  def mime_type(ext, fallback = nil); end
-  def self.match?(value, matcher); end
-  def self.mime_type(ext, fallback = nil); end
-end
-class Rack::File
-  def _call(env); end
-  def cache_control; end
-  def cache_control=(arg0); end
-  def call(env); end
-  def each; end
-  def fail(status, body, headers = nil); end
-  def filesize; end
-  def initialize(root, headers = nil, default_mime = nil); end
-  def mime_type; end
-  def path; end
-  def path=(arg0); end
-  def response_body; end
-  def root; end
-  def root=(arg0); end
-  def serving(env); end
-  def to_path; end
-end
-class Rack::Sendfile
-  def call(env); end
-  def initialize(app, variation = nil, mappings = nil); end
-  def map_accel_path(env, path); end
-  def variation(env); end
-end
-class Rack::Lock
-  def call(env); end
-  def initialize(app, mutex = nil); end
-end
-class Rack::Runtime
-  def call(env); end
-  def clock_time; end
-  def initialize(app, name = nil); end
-end
-class Rack::MethodOverride
-  def allowed_methods; end
-  def call(env); end
-  def initialize(app); end
-  def method_override(env); end
-  def method_override_param(req); end
-end
-module Rack::Session::Abstract
-end
-class Rack::Session::Abstract::SessionHash
-  def [](key); end
-  def []=(key, value); end
-  def clear; end
-  def delete(key); end
-  def destroy; end
-  def each(&block); end
-  def empty?; end
-  def exists?; end
-  def fetch(key); end
-  def has_key?(key); end
-  def id; end
-  def id=(arg0); end
-  def include?(key); end
-  def initialize(store, 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!(hash); end
-  def options; end
-  def replace(hash); end
-  def self.find(env); end
-  def self.set(env, session); end
-  def self.set_options(env, options); end
-  def store(key, value); end
-  def stringify_keys(other); end
-  def to_hash; end
-  def update(hash); end
-  def values; end
-  include Enumerable
-end
-class Rack::Session::Abstract::ID
-  def call(env); end
-  def commit_session(env, status, headers, body); end
-  def commit_session?(env, session, options); end
-  def context(env, app = nil); end
-  def current_session_id(env); end
-  def default_options; end
-  def destroy_session(env, sid, options); end
-  def extract_session_id(env); end
-  def force_options?(options); end
-  def forced_session_update?(session, options); end
-  def generate_sid(secure = nil); end
-  def get_session(env, sid); end
-  def initialize(app, options = nil); end
-  def initialize_sid; end
-  def key; end
-  def load_session(env); end
-  def loaded_session?(session); end
-  def prepare_session(env); end
-  def security_matches?(env, options); end
-  def session_class; end
-  def session_exists?(env); end
-  def set_cookie(env, headers, cookie); end
-  def set_session(env, sid, session, options); end
-end
-class Rack::Session::Cookie < Rack::Session::Abstract::ID
-  def coder; end
-  def destroy_session(env, session_id, options); end
-  def digest_match?(data, digest); end
-  def extract_session_id(env); end
-  def generate_hmac(data, secret); end
-  def get_session(env, sid); end
-  def initialize(app, options = nil); end
-  def persistent_session_id!(data, sid = nil); end
-  def set_session(env, session_id, session, options); end
-  def unpacked_cookie_data(env); 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::Head
-  def call(env); end
-  def initialize(app); 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::Chunked
-  def call(env); end
-  def chunkable_version?(ver); end
-  def initialize(app); end
-  include Rack::Utils
-end
-class Rack::Chunked::Body
-  def close; end
-  def each; end
-  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, &block); 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.env_with_encoding(env, opts, uri); 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