sorbet-rails 0.5.1 → 0.5.2

data/spec/support/v4.2/sorbet/rbi/gems/concurrent-ruby.rbi

@@ -1,218 +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/concurrent-ruby/all/concurrent-ruby.rbi
-#
-# concurrent-ruby-1.1.5
-module Concurrent
-  extend Concurrent::Utility::EngineDetector
-  extend Concurrent::Utility::NativeExtensionLoader
-end
-module Concurrent::Utility
-end
-module Concurrent::Utility::EngineDetector
-  def on_cruby?; end
-  def on_jruby?; end
-  def on_jruby_9000?; end
-  def on_linux?; end
-  def on_osx?; end
-  def on_rbx?; end
-  def on_truffleruby?; end
-  def on_windows?; end
-  def ruby_engine; end
-  def ruby_version(version = nil, comparison, major, minor, patch); end
-end
-module Concurrent::Synchronization
-end
-class Concurrent::Synchronization::AbstractObject
-  def full_memory_barrier; end
-  def initialize; end
-  def self.attr_volatile(*names); end
-end
-module Concurrent::Utility::NativeExtensionLoader
-  def allow_c_extensions?; end
-  def c_extensions_loaded?; end
-  def java_extensions_loaded?; end
-  def load_error_path(error); end
-  def load_native_extensions; end
-  def set_c_extensions_loaded; end
-  def set_java_extensions_loaded; end
-  def try_load_c_extension(path); end
-end
-module Concurrent::Synchronization::MriAttrVolatile
-  def full_memory_barrier; end
-  def self.included(base); end
-end
-module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-  def attr_volatile(*names); end
-end
-class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject
-  def initialize; end
-  extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-  include Concurrent::Synchronization::MriAttrVolatile
-end
-module Concurrent::Synchronization::RbxAttrVolatile
-  def full_memory_barrier; end
-  def self.included(base); end
-end
-module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-  def attr_volatile(*names); end
-end
-class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject
-  def initialize; end
-  extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-  include Concurrent::Synchronization::RbxAttrVolatile
-end
-module Concurrent::Synchronization::TruffleRubyAttrVolatile
-  def full_memory_barrier; end
-  def self.included(base); end
-end
-module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-  def attr_volatile(*names); end
-end
-class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject
-  def initialize; end
-  extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-  include Concurrent::Synchronization::TruffleRubyAttrVolatile
-end
-class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject
-  def __initialize_atomic_fields__; end
-  def initialize; end
-  def self.atomic_attribute?(name); end
-  def self.atomic_attributes(inherited = nil); end
-  def self.attr_atomic(*names); end
-  def self.define_initialize_atomic_fields; end
-  def self.ensure_safe_initialization_when_final_fields_are_present; end
-  def self.safe_initialization!; end
-  def self.safe_initialization?; end
-end
-class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = nil); end
-  def ns_wait_until(timeout = nil, &condition); end
-  def synchronize; end
-end
-module Concurrent::Synchronization::ConditionSignalling
-  def ns_broadcast; end
-  def ns_signal; end
-end
-class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
-  def initialize(*defaults); end
-  def ns_wait(timeout = nil); end
-  def self.new(*args, &block); end
-  def synchronize; end
-  include Concurrent::Synchronization::ConditionSignalling
-end
-class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
-  def initialize(*defaults); end
-  def ns_wait(timeout = nil); end
-  def self.new(*args, &block); end
-  def synchronize; end
-  include Concurrent::Synchronization::ConditionSignalling
-end
-class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
-  def initialize(*defaults); end
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = nil); end
-  def self.new(*args, &block); end
-  def synchronize(&block); end
-end
-class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject
-  def new_condition; end
-end
-class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject
-  def broadcast; end
-  def initialize(lock); end
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = nil); end
-  def ns_wait_until(timeout = nil, &condition); end
-  def self.new(*args, &block); end
-  def self.private_new(*args, &block); end
-  def signal; end
-  def wait(timeout = nil); end
-  def wait_until(timeout = nil, &condition); end
-end
-class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject
-  def broadcast; end
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = nil); end
-  def ns_wait_until(timeout = nil, &condition); end
-  def signal; end
-  def synchronize; end
-  def wait(timeout = nil); end
-  def wait_until(timeout = nil, &condition); end
-end
-module Concurrent::Collection
-end
-class Concurrent::Collection::NonConcurrentMapBackend
-  def [](key); end
-  def []=(key, value); end
-  def _get(key); end
-  def _set(key, value); end
-  def clear; end
-  def compute(key); end
-  def compute_if_absent(key); end
-  def compute_if_present(key); end
-  def delete(key); end
-  def delete_pair(key, value); end
-  def dupped_backend; end
-  def each_pair; end
-  def get_and_set(key, value); end
-  def get_or_default(key, default_value); end
-  def initialize(options = nil); end
-  def initialize_copy(other); end
-  def key?(key); end
-  def merge_pair(key, value); end
-  def pair?(key, expected_value); end
-  def replace_if_exists(key, new_value); end
-  def replace_pair(key, old_value, new_value); end
-  def size; end
-  def store_computed_value(key, new_value); end
-end
-class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend
-  def []=(key, value); end
-  def clear; end
-  def compute(key); end
-  def compute_if_absent(key); end
-  def compute_if_present(key); end
-  def delete(key); end
-  def delete_pair(key, value); end
-  def get_and_set(key, value); end
-  def initialize(options = nil); end
-  def merge_pair(key, value); end
-  def replace_if_exists(key, new_value); end
-  def replace_pair(key, old_value, new_value); end
-end
-class Concurrent::Map < Concurrent::Collection::MriMapBackend
-  def [](key); end
-  def each; end
-  def each_key; end
-  def each_pair; end
-  def each_value; end
-  def empty?; end
-  def fetch(key, default_value = nil); end
-  def fetch_or_store(key, default_value = nil); end
-  def get(key); end
-  def initialize(options = nil, &block); end
-  def initialize_copy(other); end
-  def inspect; end
-  def key(value); end
-  def keys; end
-  def marshal_dump; end
-  def marshal_load(hash); end
-  def populate_from(hash); end
-  def put(key, value); end
-  def put_if_absent(key, value); end
-  def raise_fetch_no_key; end
-  def validate_options_hash!(options); end
-  def value?(value); end
-  def values; end
-end

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

@@ -1,92 +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/crass/all/crass.rbi
-#
-# crass-1.0.4
-module Crass
-  def self.parse(input, options = nil); end
-  def self.parse_properties(input, options = nil); end
-end
-class Crass::TokenScanner
-  def collect; end
-  def consume; end
-  def current; end
-  def initialize(tokens); end
-  def peek; end
-  def pos; end
-  def reconsume; end
-  def reset; end
-  def tokens; end
-end
-class Crass::Scanner
-  def consume; end
-  def consume_rest; end
-  def current; end
-  def eos?; end
-  def initialize(input); end
-  def mark; end
-  def marked; end
-  def marker; end
-  def marker=(arg0); end
-  def peek(length = nil); end
-  def pos; end
-  def pos=(arg0); end
-  def reconsume; end
-  def reset; end
-  def scan(pattern); end
-  def scan_until(pattern); end
-  def string; end
-end
-class Crass::Tokenizer
-  def consume; end
-  def consume_bad_url; end
-  def consume_comments; end
-  def consume_escaped; end
-  def consume_ident; end
-  def consume_name; end
-  def consume_number; end
-  def consume_numeric; end
-  def consume_string(ending = nil); end
-  def consume_unicode_range; end
-  def consume_url; end
-  def convert_string_to_number(str); end
-  def create_token(type, properties = nil); end
-  def initialize(input, options = nil); end
-  def preprocess(input); end
-  def self.tokenize(input, options = nil); end
-  def start_identifier?(text = nil); end
-  def start_number?(text = nil); end
-  def tokenize; end
-  def valid_escape?(text = nil); end
-end
-class Crass::Parser
-  def consume_at_rule(input = nil); end
-  def consume_component_value(input = nil); end
-  def consume_declaration(input = nil); end
-  def consume_declarations(input = nil, options = nil); end
-  def consume_function(input = nil); end
-  def consume_qualified_rule(input = nil); end
-  def consume_rules(flags = nil); end
-  def consume_simple_block(input = nil); end
-  def create_node(type, properties = nil); end
-  def create_selector(input); end
-  def create_style_rule(rule); end
-  def initialize(input, options = nil); end
-  def parse_component_value(input = nil); end
-  def parse_component_values(input = nil); end
-  def parse_declaration(input = nil); end
-  def parse_declarations(input = nil, options = nil); end
-  def parse_properties(input = nil); end
-  def parse_rule(input = nil); end
-  def parse_value(nodes); end
-  def self.parse_properties(input, options = nil); end
-  def self.parse_rules(input, options = nil); end
-  def self.parse_stylesheet(input, options = nil); end
-  def self.stringify(nodes, options = nil); end
-  def tokens; end
-end

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

@@ -1,265 +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/erubis/all/erubis.rbi
-#
-# erubis-2.7.0
-module Kernel
-  def not_implemented; end
-end
-module Erubis
-end
-module Erubis::Generator
-  def add_expr_debug(src, code); end
-  def add_expr_escaped(src, code); end
-  def add_expr_literal(src, code); end
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def add_stmt(src, code); end
-  def add_text(src, text); end
-  def escape_text(text); end
-  def escaped_expr(code); end
-  def escapefunc; end
-  def escapefunc=(arg0); end
-  def init_generator(properties = nil); end
-  def self.supported_properties; end
-end
-module Erubis::Converter
-  def convert(input); end
-  def convert_input(codebuf, input); end
-  def detect_spaces_at_bol(text, is_bol); end
-  def escape; end
-  def escape=(arg0); end
-  def init_converter(properties = nil); end
-  def postamble; end
-  def postamble=(arg0); end
-  def preamble; end
-  def preamble=(arg0); end
-  def self.supported_properties; end
-end
-module Erubis::Basic
-end
-module Erubis::Basic::Converter
-  def add_expr(src, code, indicator); end
-  def convert_input(src, input); end
-  def init_converter(properties = nil); end
-  def pattern; end
-  def pattern=(arg0); end
-  def pattern_regexp(pattern); end
-  def self.pattern_regexp(pattern); end
-  def self.supported_properties; end
-  def trim; end
-  def trim=(arg0); end
-  include Erubis::Converter
-end
-module Erubis::PI
-end
-module Erubis::PI::Converter
-  def add_pi_expr(codebuf, code, indicator); end
-  def add_pi_stmt(codebuf, code, pi_arg); end
-  def convert(input); end
-  def convert_input(codebuf, input); end
-  def init_converter(properties = nil); end
-  def pi; end
-  def pi=(arg0); end
-  def prefix; end
-  def prefix=(arg0); end
-  def self.desc; end
-  def self.supported_properties; end
-  include Erubis::Converter
-end
-class Erubis::ErubisError < StandardError
-end
-class Erubis::NotSupportedError < Erubis::ErubisError
-end
-class Erubis::Context
-  def [](key); end
-  def []=(key, value); end
-  def each; end
-  def initialize(hash = nil); end
-  def keys; end
-  def to_hash; end
-  def update(context_or_hash); end
-  include Enumerable
-end
-module Erubis::Evaluator
-  def evaluate(*args); end
-  def filename; end
-  def filename=(arg0); end
-  def init_evaluator(properties); end
-  def result(*args); end
-  def self.supported_properties; end
-  def src; end
-  def src=(arg0); end
-end
-module Erubis::RubyEvaluator
-  def def_method(object, method_name, filename = nil); end
-  def evaluate(_context = nil); end
-  def result(_binding_or_hash = nil); end
-  def self.supported_properties; end
-  include Erubis::Evaluator
-end
-class Erubis::Engine
-  def convert!(input); end
-  def initialize(input = nil, properties = nil); end
-  def process(input, context = nil, filename = nil); end
-  def process_proc(proc_obj, context = nil, filename = nil); end
-  def self.load_file(filename, properties = nil); end
-end
-class Erubis::Basic::Engine < Erubis::Engine
-  include Erubis::Basic::Converter
-  include Erubis::Evaluator
-  include Erubis::Generator
-end
-class Erubis::PI::Engine < Erubis::Engine
-  include Erubis::Evaluator
-  include Erubis::Generator
-  include Erubis::PI::Converter
-end
-module Erubis::XmlHelper
-  def escape_xml(value); end
-  def escape_xml2(value); end
-  def h(value); end
-  def html_escape(value); end
-  def self.escape_xml(value); end
-  def self.escape_xml2(value); end
-  def self.url_encode(str); end
-  def u(str); end
-  def url_encode(str); end
-end
-module Erubis::EscapeEnhancer
-  def add_expr(src, code, indicator); end
-  def self.desc; end
-end
-module Erubis::StdoutEnhancer
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def self.desc; end
-end
-module Erubis::PrintOutEnhancer
-  def add_expr_escaped(src, code); end
-  def add_expr_literal(src, code); end
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def add_text(src, text); end
-  def self.desc; end
-end
-module Erubis::PrintEnabledEnhancer
-  def add_preamble(src); end
-  def evaluate(context = nil); end
-  def print(*args); end
-  def self.desc; end
-end
-module Erubis::ArrayEnhancer
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def self.desc; end
-end
-module Erubis::ArrayBufferEnhancer
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def self.desc; end
-end
-module Erubis::StringBufferEnhancer
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def self.desc; end
-end
-module Erubis::StringIOEnhancer
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def self.desc; end
-end
-module Erubis::ErboutEnhancer
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def self.desc; end
-end
-module Erubis::NoTextEnhancer
-  def add_text(src, text); end
-  def self.desc; end
-end
-module Erubis::NoCodeEnhancer
-  def add_expr(src, code, indicator); end
-  def add_postamble(src); end
-  def add_preamble(src); end
-  def add_stmt(src, code); end
-  def add_text(src, text); end
-  def self.desc; end
-end
-module Erubis::SimplifyEnhancer
-  def convert(input); end
-  def self.desc; end
-end
-module Erubis::BiPatternEnhancer
-  def add_text(src, text); end
-  def bipattern=(pat); end
-  def initialize(input, properties = nil); end
-  def self.desc; end
-end
-module Erubis::PrefixedLineEnhancer
-  def add_text(src, text); end
-  def init_generator(properties = nil); end
-  def self.desc; end
-end
-module Erubis::PercentLineEnhancer
-  def add_text(src, text); end
-  def self.desc; end
-  include Erubis::PrefixedLineEnhancer
-end
-module Erubis::HeaderFooterEnhancer
-  def add_text(src, text); end
-  def convert(input); end
-  def footer; end
-  def footer=(arg0); end
-  def header; end
-  def header=(arg0); end
-  def self.desc; end
-end
-module Erubis::DeleteIndentEnhancer
-  def convert_input(src, input); end
-  def self.desc; end
-end
-module Erubis::InterpolationEnhancer
-  def _add_text_to_str(str, text); end
-  def add_expr_escaped(str, code); end
-  def add_expr_literal(str, code); end
-  def add_text(src, text); end
-  def convert_input(src, input); end
-  def self.desc; end
-end
-module Erubis::RubyGenerator
-  def add_expr_debug(src, code); end
-  def add_expr_escaped(src, code); end
-  def add_expr_literal(src, code); end
-  def add_stmt(src, code); end
-  def add_text(src, text); end
-  def escape_text(text); end
-  def escaped_expr(code); end
-  def init_generator(properties = nil); end
-  def self.supported_properties; end
-  include Erubis::Generator
-  include Erubis::StringBufferEnhancer
-end
-class Erubis::Eruby < Erubis::Basic::Engine
-  include Erubis::RubyEvaluator
-  include Erubis::RubyGenerator
-end
-class Erubis::FastEruby < Erubis::Eruby
-  include Erubis::InterpolationEnhancer
-end
-class Erubis::EscapedEruby < Erubis::Eruby
-  include Erubis::EscapeEnhancer
-end
-class Erubis::XmlEruby < Erubis::Eruby
-  include Erubis::EscapeEnhancer
-end
-class Erubis::PI::Eruby < Erubis::PI::Engine
-  def init_converter(properties = nil); end
-  include Erubis::RubyEvaluator
-  include Erubis::RubyGenerator
-end