sorbet-rails 0.5.0 → 0.5.1

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0.rc1/activerecord.rbi

@@ -0,0 +1,10 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/~>6.0.0.rc1/activerecord.rbi
+#
+# typed: strong
+
+ActiveRecord::Migration::Compatibility::V6_0 = ActiveRecord::Migration::Current

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi

@@ -0,0 +1,23 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activesupport/>=6.0.0.rc1/activesupport.rbi
+#
+# typed: strong
+
+class Array
+  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
+  def excluding(*elements); end
+
+  sig do
+    params(
+      blk: T.nilable(T.proc.params(arg0: Elem).returns(T::Boolean))
+    ).returns(T.any(T::Array[Elem], T::Enumerable[Elem]))
+  end
+  def extract!(&blk); end
+
+  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
+  def including(*elements); end
+end

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi

@@ -5,10 +5,10 @@
 #
 #   https://github.com/sorbet/sorbet-typed/edit/master/lib/activesupport/all/activesupport.rbi
 #
-# typed: strong
+# typed: false
 
 module ActiveSupport
-  sig {params(kind: Symbol, blk: T.proc.bind(T.class_of(ActionController::Base)).void).void}
+  sig { params(kind: Symbol, blk: T.proc.bind(T.class_of(ActionController::Base)).void).void }
   def self.on_load(kind, &blk); end
 end
 
@@ -25,25 +25,25 @@ class Object
   sig { returns(TrueClass) }
   def duplicable?; end
 
-  sig {params(another_object: Object).returns(T::Boolean)}
+  sig { params(another_object: Object).returns(T::Boolean) }
   def in?(another_object); end
 
-  sig {returns(T::Hash[String, T.untyped])}
+  sig { returns(T::Hash[String, T.untyped]) }
   def instance_values; end
 
-  sig {returns(T::Array[String])}
+  sig { returns(T::Array[String]) }
   def instance_variable_names; end
 
   sig { returns(T.nilable(T.self_type)) }
   def presence; end
 
-  sig {returns(T::Boolean)}
+  sig { returns(T::Boolean) }
   def present?; end
 
-  sig {returns(String)}
+  sig { returns(String) }
   def to_param; end
 
-  sig {params(key: String).returns(String)}
+  sig { params(key: String).returns(String) }
   def to_query(key); end
 
   sig do
@@ -94,7 +94,7 @@ class NilClass
       b: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
     ).returns(NilClass)
   end
-  def try(method_name = nil, *args, &b) ; end
+  def try(method_name = nil, *args, &b); end
 
   sig do
     params(
@@ -103,5 +103,356 @@ class NilClass
       b: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
     ).returns(NilClass)
   end
-  def try!(method_name = nil, *args, &b) ; end
+  def try!(method_name = nil, *args, &b); end
+end
+
+class String
+  sig { returns(T::Boolean) }
+  def acts_like_string?; end
+
+  sig { params(position: T.any(Integer, String, Regexp, T::Range[Integer])).returns(T.nilable(String)) }
+  def at(position); end
+
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { params(first_letter: Symbol).returns(String) }
+  def camelize(first_letter = :upper); end
+
+  # camelcase is an alias of camelize
+  sig { params(first_letter: Symbol).returns(String) }
+  def camelcase(first_letter = :upper); end
+
+  sig { returns(String) }
+  def classify; end
+
+  sig { returns(String) }
+  def constantize; end
+
+  sig { returns(String) }
+  def dasherize; end
+
+  sig { returns(String) }
+  def deconstantize; end
+
+  sig { returns(String) }
+  def demodulize; end
+
+  # ends_with? is an alias of the core method 'end_with?'
+  sig { params(arg0: String).returns(T::Boolean) }
+  def ends_with?(*arg0); end
+
+  sig { params(string: String).returns(T::Boolean) }
+  def exclude?(string); end
+
+  sig { params(limit: Integer).returns(String) }
+  def first(limit = 1); end
+
+  sig { params(separate_class_name_and_id_with_underscore: T::Boolean).returns(String) }
+  def foreign_key(separate_class_name_and_id_with_underscore = true); end
+
+  sig { params(position: Integer).returns(String) }
+  def from(position); end
+
+  sig { returns(T.untyped) }
+  def html_safe; end
+
+  sig { params(capitalize: T::Boolean, keep_id_suffix: T::Boolean).returns(String) }
+  def humanize(capitalize: true, keep_id_suffix: false); end
+
+  sig { params(zone: String).returns(T.any(Time, ActiveSupport::TimeWithZone)) }
+  def in_time_zone(zone = ::Time.zone); end
+
+  sig { params(amount: Integer, indent_string: T.nilable(String), indent_empty_lines: T::Boolean).returns(T.nilable(String)) }
+  def indent!(amount, indent_string = nil, indent_empty_lines = false); end
+
+  sig { params(amount: Integer, indent_string: T.nilable(String), indent_empty_lines: T::Boolean).returns(T.nilable(String)) }
+  def indent(amount, indent_string = nil, indent_empty_lines = false); end
+
+  sig { returns(ActiveSupport::StringInquirer) }
+  def inquiry; end
+
+  sig { returns(T::Boolean) }
+  def is_utf8?; end
+
+  sig { params(limit: Integer).returns(String) }
+  def last(limit = 1); end
+
+  sig { returns(ActiveSupport::Multibyte::Chars) }
+  def mb_chars; end
+
+  sig { params(separator: String, preserve_case: T::Boolean).returns(String) }
+  def parameterize(separator: "-", preserve_case: false); end
+
+  sig { params(count: T.nilable(Integer), locale: Symbol).returns(String) }
+  def pluralize(count = nil, locale = :en); end
+
+  sig { params(patterns: T.untyped).returns(T.untyped) }
+  def remove!(*patterns); end
+
+  sig { params(patterns: T.untyped).returns(T.untyped) }
+  def remove(*patterns); end
+
+  sig { returns(T.nilable(String)) }
+  def safe_constantize; end
+
+  sig { params(locale: Symbol).returns(T.nilable(String)) }
+  def singularize(locale = :en); end
+
+  sig { returns(T.untyped) }
+  def squish!; end
+
+  sig { returns(String) }
+  def squish; end
+
+  # starts_with? is an alias of the core method 'start_with?''
+  sig { params(arg0: String).returns(T::Boolean) }
+  def starts_with?(*arg0); end
+
+  sig { returns(String) }
+  def strip_heredoc; end
+
+  sig { returns(String) }
+  def tableize; end
+
+  sig { params(keep_id_suffix: T::Boolean).returns(String) }
+  def titleize(keep_id_suffix: false); end
+
+  # titlecase is an alias of titleize
+  sig { params(keep_id_suffix: T::Boolean).returns(String) }
+  def titlecase(keep_id_suffix: false); end
+
+  sig { params(position: Integer).returns(String) }
+  def to(position); end
+
+  sig { returns(Date) }
+  def to_date; end
+
+  sig { returns(DateTime) }
+  def to_datetime; end
+
+  sig { params(form: Symbol).returns(Time) }
+  def to_time(form = :local); end
+
+  sig { params(truncate_at: Integer, separator: T.nilable(T.any(String, Regexp)), omission: String).returns(String) }
+  def truncate(truncate_at, separator: nil, omission: "..."); end
+
+  sig { params(words_count: Integer, separator: T.nilable(T.any(String, Regexp)), omission: String).returns(String) }
+  def truncate_words(words_count, separator: nil, omission: "..."); end
+
+  sig { returns(String) }
+  def underscore; end
+
+  sig { returns(String) }
+  def upcase_first; end
+end
+
+class Array
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def deep_dup; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def extract_options!; end
+
+  sig { returns(Elem) }
+  def fifth; end
+
+  sig { returns(Elem) }
+  def forty_two; end
+
+  sig { returns(Elem) }
+  def fourth; end
+
+  sig { params(position: Integer).returns(T::Array[T.untyped]) }
+  def from(position); end
+
+  sig { params(number: Integer, fill_with: T.untyped).returns(T.untyped) }
+  def in_groups(number, fill_with = nil); end
+
+  sig { params(number: Integer, fill_with: T.untyped).returns(T.untyped) }
+  def in_groups_of(number, fill_with = nil); end
+
+  sig { returns(T.untyped) }
+  def inquiry; end
+
+  sig { returns(Elem) }
+  def second; end
+
+  sig { returns(Elem) }
+  def second_to_last; end
+
+  sig do
+    params(
+      value: T.untyped,
+      blk: T.proc.params(arg0: Elem).void
+    ).returns(T::Array[Elem])
+  end
+  def split(value = nil, &blk); end
+
+  sig { returns(Elem) }
+  def third; end
+
+  sig { returns(Elem) }
+  def third_to_last; end
+
+  sig { params(position: Integer).returns(T::Array[T.untyped]) }
+  def to(position); end
+
+  # to_default_s is an alias of the core method 'to_s'
+  sig {returns(String)}
+  def to_defaul_s; end
+
+  sig { params(format: Symbol).returns(String) }
+  def to_formatted_s(format = :default); end
+
+  sig { returns(String) }
+  def to_param; end
+
+  sig { params(key: String).returns(String) }
+  def to_query(key); end
+
+  sig do
+    params(
+      words_connector: String,
+      two_words_connector: String,
+      last_word_connector: String,
+      locale: T.nilable(Symbol)
+    ).returns(String)
+  end
+  def to_sentence(words_connector: ", ", two_words_connector: " and ", last_word_connector: ", and ", locale: nil); end
+
+  sig { params(options: T.untyped).returns(T.untyped) }
+  def to_xml(options = nil); end
+
+  sig { params(elements: T.untyped).returns(T.untyped) }
+  def without(*elements); end
+end
+
+module ActiveSupport::NumberHelper
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      unit: String,
+      separator: String,
+      delimiter: String,
+      format: String,
+      negative_format: String
+    ).returns(String)
+  end
+  def number_to_currency(number, locale: :en, precision: 2, unit: "$", separator: ".", delimiter: ",", format: "%u%n", negative_format: "-%u%n"); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      delimiter: String,
+      separator: String,
+      delimiter_pattern: T.nilable(Regexp)
+    ).returns(String)
+  end
+  def number_to_delimited(number, locale: :en, delimiter: ",", separator: ".", delimiter_pattern: nil); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean,
+      units: T.any(T::Hash[T.untyped, T.untyped], String, Symbol),
+      format: String
+    ).returns(String)
+  end
+  def number_to_human(number, locale: :en, precision: 3, significant: true, separator: ".", delimiter: "", strip_insignificant_zeros: true, units: {}, format: "%n %u"); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean
+    ).returns(String)
+  end
+  def number_to_human_size(number, locale: :en, precision: 3, significant: true, separator: ".", delimiter: "", strip_insignificant_zeros: true); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean,
+      format: String
+    ).returns(String)
+  end
+  def number_to_percentage(number, locale: :en, precision: 3, significant: false, separator: ".", delimiter: "", strip_insignificant_zeros: false, format: "%n%"); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      area_code: T::Boolean,
+      delimiter: String,
+      extension: T.nilable(Integer),
+      country_code: T.nilable(Integer),
+      pattern: T.nilable(Regexp)
+    ).returns(String)
+  end
+  def number_to_phone(number, area_code: false, delimiter: "-", extension: nil, country_code: nil, pattern: nil); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean
+    ).returns(String)
+  end
+  def number_to_rounded(number, locale: :en, precision: 3, significant: false, separator: ".", delimiter: "", strip_insignificant_zeros: false); end
+end
+
+class Hash
+  sig { returns(T.self_type) }
+  def deep_stringify_keys; end
+
+  sig { returns(T.self_type) }
+  def deep_stringify_keys!; end
+
+  sig { returns(T.self_type) }
+  def deep_symbolize_keys; end
+
+  sig { returns(T.self_type) }
+  def deep_symbolize_keys!; end
+
+  sig { returns(T.self_type) }
+  def deep_transform_keys; end
+
+  sig { returns(T.self_type) }
+  def deep_transform_keys!; end
+
+  sig { returns(T.self_type) }
+  def stringify_keys; end
+
+  sig { returns(T.self_type) }
+  def stringify_keys!; end
+
+  sig { returns(T.self_type) }
+  def symbolize_keys; end
+
+  sig { returns(T.self_type) }
+  def symbolize_keys!; end
 end

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi

@@ -3518,7 +3518,7 @@ class Bundler::HTTPError < Bundler::BundlerError
 end
 
 class Bundler::Index
-  include ::Enumerable
+  include T::Enumerable
   EMPTY_SEARCH = ::T.let(nil, ::T.untyped)
   NULL = ::T.let(nil, ::T.untyped)
   RUBY = ::T.let(nil, ::T.untyped)
@@ -3775,6 +3775,10 @@ end
 
 class Bundler::LazySpecification::Identifier < Struct
   include ::Comparable
+  extend ::T::Generic
+
+  Elem = type_member(fixed: T.untyped)
+
   sig do
     params(
       other: ::T.untyped,
@@ -4081,7 +4085,7 @@ end
 
 class Bundler::Molinillo::DependencyGraph
   include ::TSort
-  include ::Enumerable
+  include T::Enumerable
   sig do
     params(
       other: ::T.untyped,
@@ -4439,6 +4443,9 @@ class Bundler::Molinillo::DependencyGraph::DetachVertexNamed < Bundler::Molinill
 end
 
 class Bundler::Molinillo::DependencyGraph::Edge < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig {returns(::T.untyped)}
   def destination(); end
 
@@ -4493,7 +4500,7 @@ class Bundler::Molinillo::DependencyGraph::Edge < Struct
 end
 
 class Bundler::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
+  extend T::Enumerable
   sig do
     params(
       graph: ::T.untyped,
@@ -4814,6 +4821,9 @@ class Bundler::Molinillo::DependencyGraph::Vertex
 end
 
 class Bundler::Molinillo::DependencyState < Bundler::Molinillo::ResolutionState
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig {returns(::T.untyped)}
   def pop_possibility_state(); end
 end
@@ -4855,9 +4865,14 @@ class Bundler::Molinillo::NoSuchDependencyError < Bundler::Molinillo::ResolverEr
 end
 
 class Bundler::Molinillo::PossibilityState < Bundler::Molinillo::ResolutionState
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
 end
 
 class Bundler::Molinillo::ResolutionState < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig {returns(::T.untyped)}
   def activated(); end
 
@@ -5050,6 +5065,9 @@ class Bundler::Molinillo::Resolver::Resolution
 end
 
 class Bundler::Molinillo::Resolver::Resolution::Conflict < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig {returns(::T.untyped)}
   def activated_by_name(); end
 
@@ -5162,6 +5180,9 @@ class Bundler::Molinillo::Resolver::Resolution::Conflict < Struct
 end
 
 class Bundler::Molinillo::Resolver::Resolution::PossibilitySet < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig {returns(::T.untyped)}
   def dependencies(); end
 
@@ -5212,6 +5233,9 @@ end
 
 class Bundler::Molinillo::Resolver::Resolution::UnwindDetails < Struct
   include ::Comparable
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig do
     params(
       other: ::T.untyped,
@@ -6971,6 +6995,9 @@ class Bundler::Settings
 end
 
 class Bundler::Settings::Path < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
   sig {returns(::T.untyped)}
   def append_ruby_scope(); end
 
@@ -8061,8 +8088,9 @@ end
 
 class Bundler::SpecSet
   include ::TSort
-  include ::Enumerable
+  include T::Enumerable
   extend ::Forwardable
+
   sig do
     params(
       args: ::T.untyped,