has_helpers 5.0.2

data/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi

@@ -0,0 +1,475 @@
+# 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/activerecord.rbi
+#
+# typed: strong
+
+class ActiveRecord::Migration::Compatibility::V5_1 < ActiveRecord::Migration::Compatibility::V5_2; end
+
+# 5.2 has a different definition for create_table because 6.0 adds a new option.
+# This is the only difference between 5.2 and 6.0.
+class ActiveRecord::Migration::Compatibility::V5_2 < ActiveRecord::Migration::Current
+  # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb#L151-L290
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      comment: T.untyped,
+      id: T.any(T::Boolean, Symbol),
+      primary_key: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped,
+      temporary: T::Boolean,
+      force: T.any(T::Boolean, Symbol),
+      as: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def create_table(
+    table_name,
+    comment: nil,
+    id: :primary_key,
+    primary_key: :_,
+    options: nil,
+    temporary: false,
+    force: false,
+    as: nil,
+    &blk
+  ); end
+end
+
+ActiveRecord::Migration::Compatibility::V6_0 = ActiveRecord::Migration::Current
+
+# Method definitions are documented here:
+# https://api.rubyonrails.org/v6.0/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
+class ActiveRecord::Migration::Current < ActiveRecord::Migration
+  # Tables
+
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb#L152-L292
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      comment: T.untyped,
+      id: T.any(T::Boolean, Symbol),
+      primary_key: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped,
+      temporary: T::Boolean,
+      force: T.any(T::Boolean, Symbol),
+      if_not_exists: T::Boolean,
+      as: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def create_table(
+    table_name,
+    comment: nil,
+    id: :primary_key,
+    primary_key: :_,
+    options: nil,
+    temporary: false,
+    force: false,
+    if_not_exists: false,
+    as: nil,
+    &blk
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      bulk: T::Boolean,
+      blk: T.proc.params(t: ActiveRecord::ConnectionAdapters::Table).void
+    ).void
+  end
+  def change_table(
+    table_name,
+    bulk: false,
+    &blk
+  ); end
+
+  sig { params(table_name: T.any(String, Symbol), new_name: T.any(String, Symbol)).void }
+  def rename_table(table_name, new_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      force: T.any(T::Boolean, Symbol),
+      if_exists: T::Boolean,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def drop_table(
+    table_name,
+    force: false,
+    if_exists: false,
+    &blk
+  ); end
+
+  # Join Tables
+
+  sig do
+    params(
+      table_1: T.any(String, Symbol),
+      table_2: T.any(String, Symbol),
+      column_options: T.untyped,
+      table_name: T.any(String, Symbol),
+      temporary: T.untyped,
+      force: T::Boolean,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def create_join_table(
+    table_1,
+    table_2,
+    column_options: {},
+    table_name: nil,
+    temporary: nil,
+    force: false,
+    &blk
+  ); end
+
+  sig do
+    params(
+      table_1: T.any(String, Symbol),
+      table_2: T.any(String, Symbol),
+      options: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def drop_join_table(
+    table_1,
+    table_2,
+    options = {},
+    &blk
+  ); end
+
+  # Columns
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      limit: T.untyped,
+      default: T.untyped,
+      null: T::Boolean,
+      precision: Integer,
+      scale: Integer,
+      comment: String
+    ).void
+  end
+  def add_column(
+    table_name,
+    column_name,
+    type,
+    limit: nil,
+    default: nil,
+    null: nil,
+    precision: nil,
+    scale: nil,
+    comment: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      limit: T.untyped,
+      default: T.untyped,
+      null: T::Boolean,
+      precision: Integer,
+      scale: Integer,
+      comment: String
+    ).void
+  end
+  def change_column(
+    table_name,
+    column_name,
+    type,
+    limit: nil,
+    default: nil,
+    null: nil,
+    precision: nil,
+    scale: nil,
+    comment: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      null: T::Boolean,
+      default: T.untyped
+    ).void
+  end
+  def change_column_null(table_name, column_name, null, default = nil); end
+
+  sig { params(table_name: T.any(String, Symbol), column_name: T.any(String, Symbol), default_or_changes: T.untyped).void }
+  def change_column_default(table_name, column_name, default_or_changes); end
+
+  sig { params(table_name: T.any(String, Symbol), column_name: T.any(String, Symbol), new_column_name: T.any(String, Symbol)).void }
+  def rename_column(table_name, column_name, new_column_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.nilable(T.any(String, Symbol)),
+      options: T.untyped
+    ).void
+  end
+  def remove_column(
+    table_name,
+    column_name,
+    type = nil,
+    options = {}
+  ); end
+
+  sig { params(table_name: T.any(String, Symbol), column_names: T.any(String, Symbol)).void }
+  def remove_columns(table_name, *column_names); end
+
+  # Foreign Keys
+
+  sig do
+    params(
+      from_table: T.any(String, Symbol),
+      to_table: T.any(String, Symbol),
+      column: T.any(String, Symbol),
+      primary_key: T.any(String, Symbol),
+      name: T.any(String, Symbol),
+      on_delete: Symbol,
+      on_update: Symbol,
+      validate: T::Boolean
+    ).void
+  end
+  def add_foreign_key(
+    from_table,
+    to_table,
+    column: nil,
+    primary_key: nil,
+    name: nil,
+    on_delete: nil,
+    on_update: nil,
+    validate: true
+  ); end
+
+  sig do
+    params(
+      from_table: T.any(String, Symbol),
+      to_table: T.nilable(T.any(String, Symbol)),
+      column: T.any(String, Symbol),
+      primary_key: T.any(String, Symbol),
+      name: T.any(String, Symbol),
+      on_delete: Symbol,
+      on_update: Symbol,
+      validate: T::Boolean
+    ).void
+  end
+  def remove_foreign_key(
+    from_table,
+    to_table = nil,
+    column: nil,
+    primary_key: nil,
+    name: nil,
+    on_delete: nil,
+    on_update: nil,
+    validate: true
+  ); end
+
+  sig do
+    params(
+      from_table: T.any(String, Symbol),
+      to_table: T.any(String, Symbol),
+      name: T.any(String, Symbol),
+      column: T.any(String, Symbol),
+      options: T.untyped
+    ).returns(T::Boolean)
+  end
+  def foreign_key_exists?(from_table, to_table = nil, name: nil, column: nil, **options); end
+
+  sig { params(table_name: T.any(String, Symbol)).returns(T::Array[T.untyped]) }
+  def foreign_keys(table_name); end
+
+  # Indices
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      using: T.untyped,
+      unique: T::Boolean,
+      where: T.untyped,
+      order: T.untyped,
+      name: T.any(String, Symbol),
+      length: T.untyped,
+      opclass: T.untyped,
+      type: T.untyped,
+      internal: T.untyped,
+      algorithm: T.untyped
+    ).void
+  end
+  def add_index(
+    table_name,
+    column_name,
+    using: nil,
+    unique: false,
+    where: nil,
+    order: nil,
+    name: nil,
+    length: nil,
+    opclass: nil,
+    type: nil,
+    internal: nil,
+    algorithm: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      using: T.untyped,
+      unique: T::Boolean,
+      where: T.untyped,
+      order: T.untyped,
+      name: T.any(String, Symbol),
+      length: T.untyped,
+      opclass: T.untyped,
+      type: T.untyped,
+      internal: T.untyped,
+      algorithm: T.untyped
+    ).void
+  end
+  def remove_index(
+    table_name,
+    column,
+    using: nil,
+    unique: false,
+    where: nil,
+    order: nil,
+    name: nil,
+    length: nil,
+    opclass: nil,
+    type: nil,
+    internal: nil,
+    algorithm: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      old_name: T.any(String, Symbol),
+      new_name: T.any(String, Symbol)
+    ).void
+  end
+  def rename_index(
+    table_name,
+    old_name,
+    new_name
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      options: T.untyped
+    ).returns(T::Boolean)
+  end
+  def index_exists?(table_name, column_name, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol), index_name: T.any(String, Symbol)).returns(T::Boolean) }
+  def index_name_exists?(table_name, index_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.nilable(Symbol),
+      options: T.untyped
+    ).returns(T::Boolean)
+  end
+  def column_exists?(table_name, column_name, type = nil, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol)).returns(T::Array[T.untyped]) }
+  def indexes(table_name); end
+
+  # References
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      ref_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      index: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      foreign_key: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      polymorphic: T::Boolean,
+      null: T.untyped
+    ).void
+  end
+  def add_reference(
+    table_name,
+    ref_name,
+    type: :bigint,
+    index: true,
+    foreign_key: false,
+    polymorphic: false,
+    null: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      ref_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      index: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      foreign_key: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      polymorphic: T::Boolean,
+      null: T.untyped
+    ).void
+  end
+  def remove_reference(
+    table_name,
+    ref_name,
+    type: :bigint,
+    index: true,
+    foreign_key: false,
+    polymorphic: false,
+    null: nil
+  ); end
+
+  # Timestamps
+
+  sig { params(table_name: T.any(String, Symbol), options: T.untyped).void }
+  def add_timestamps(table_name, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol), options: T.untyped).void }
+  def remove_timestamps(table_name, options = {}); end
+
+  # Extensions
+
+  sig { params(name: T.any(String, Symbol)).void }
+  def enable_extension(name); end
+
+  sig { params(name: T.any(String, Symbol)).void }
+  def disable_extension(name); end
+
+  # Miscellaneous
+
+  sig { params(message: String, subitem: T.untyped).void }
+  def say(message, subitem = false); end
+
+  sig { params(message: String, blk: T.untyped).returns(T.untyped) }
+  def say_with_time(message, &blk); end
+
+  sig { params(blk: T.untyped).void }
+  def suppress_messages(&blk); end
+
+  sig { params(blk: T.proc.params(arg0: T.untyped).void).void }
+  def reversible(&blk); end
+
+  sig { params(migration_classes: T.untyped, blk: T.nilable(T.proc.params(arg0: T.untyped).void)).void }
+  def revert(*migration_classes, &blk); end
+
+  sig { params(sql: String, name: T.nilable(String)).returns(T.untyped) }
+  def execute(sql, name = nil); end
+end

data/sorbet/rbi/sorbet-typed/lib/activestorage/>=6.0.0/activestorage.rbi

@@ -0,0 +1,19 @@
+# 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/activestorage/>=6.0.0/activestorage.rbi
+#
+# typed: strong
+
+class ActiveStorage::Attached::One
+  sig { returns(T::Boolean) }
+  def blank?; end
+end
+
+class ActiveStorage::Attached::Many
+  # Returns all attached blobs.
+  sig { returns(T::Array[T.untyped]) }
+  def blobs; end
+end

data/sorbet/rbi/sorbet-typed/lib/activestorage/all/activestorage.rbi

@@ -0,0 +1,173 @@
+# 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/activestorage/all/activestorage.rbi
+#
+# typed: strong
+
+module ActiveStorage
+  sig { returns(Gem::Version) }
+  def self.gem_version; end
+
+  sig { returns(Gem::Version) }
+  def self.version; end
+end
+
+class ActiveStorage::Attached::One
+  # These aren't technically included, but Attached::One delegates any missing
+  # methods to Attachment, which in turn delegates to Blob. This is essentially
+  # a hack to make it easier to maintain the ActiveStorage signatures. We can't
+  #include Blob directly because it's a class, so `include`ing it doesn't work.
+  include ActiveStorage::Blob::Analyzable
+  include ActiveStorage::Blob::Identifiable
+  include ActiveStorage::Blob::Representable
+
+  # Attaches an `attachable` to the record.
+  #
+  # If the record is persisted and unchanged, the attachment is saved to
+  # the database immediately. Otherwise, it'll be saved to the DB when the
+  # record is next saved.
+  #
+  # ```ruby
+  # person.avatar.attach(params[:avatar]) # ActionDispatch::Http::UploadedFile object
+  # person.avatar.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
+  # person.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpg")
+  # person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
+  # ```
+  sig { params(attachable: T.untyped).void }
+  def attach(attachable); end
+
+  # Returns `true` if an attachment has been made.
+  #
+  # ```ruby
+  # class User < ApplicationRecord
+  #   has_one_attached :avatar
+  # end
+  #
+  # ::HasHelpers::User.new.avatar.attached? # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def attached?; end
+
+  # Returns the associated attachment record.
+  #
+  # You don't have to call this method to access the attachment's methods as
+  # they are all available at the model level.
+  sig { returns(T.nilable(ActiveStorage::Attachment)) }
+  def attachment; end
+
+  # Deletes the attachment without purging it, leaving its blob in place.
+  sig { void }
+  def detach; end
+
+  # Directly purges the attachment (i.e. destroys the blob and
+  # attachment and deletes the file on the service).
+  sig { void }
+  def purge; end
+
+  # Purges the attachment through the queuing system.
+  sig { void }
+  def purge_later; end
+end
+
+class ActiveStorage::Attached::Many
+  # These aren't technically included, but Attached::Many delegates any missing
+  # methods to Attachment, which in turn delegates to Blob. This is essentially
+  # a hack to make it easier to maintain the ActiveStorage signatures. We can't
+  # include Blob directly because it's a class, so `include`ing it doesn't work.
+  include ActiveStorage::Blob::Analyzable
+  include ActiveStorage::Blob::Identifiable
+  include ActiveStorage::Blob::Representable
+
+  # Attaches one or more `attachables` to the record.
+  #
+  # If the record is persisted and unchanged, the attachments are saved to
+  # the database immediately. Otherwise, they'll be saved to the DB when the
+  # record is next saved.
+  #
+  # ```ruby
+  # document.images.attach(params[:images]) # Array of ActionDispatch::Http::UploadedFile objects
+  # document.images.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
+  # document.images.attach(io: File.open("/path/to/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpg")
+  # document.images.attach([ first_blob, second_blob ])
+  # ```
+  sig { params(attachables: T.untyped).void }
+  def attach(*attachables); end
+
+  # Returns `true` if any attachments have been made.
+  #
+  # ```ruby
+  # class Gallery < ApplicationRecord
+  #   has_many_attached :photos
+  # end
+  #
+  # Gallery.new.photos.attached? # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def attached?; end
+
+  # Returns all the associated attachment records.
+  #
+  # All methods called on this proxy object that aren't listed here will automatically be delegated to `attachments`.
+  sig { returns(T.nilable(T::Array[ActiveStorage::Attachment])) }
+  def attachments; end
+
+  # Deletes associated attachments without purging them, leaving their respective blobs in place.
+  sig { void }
+  def detach; end
+
+  # Directly purges each associated attachment (i.e. destroys the blobs and
+  # attachments and deletes the files on the service).
+  sig { void }
+  def purge; end
+
+  # Purges each associated attachment through the queuing system.
+  sig { void }
+  def purge_later; end
+end
+
+module ActiveStorage::Blob::Representable
+  # Returns an ActiveStorage::Variant instance with the set of `transformations` provided. This is only relevant for image
+  # files, and it allows any image to be transformed for size, colors, and the like. Example:
+  #
+  # ```ruby
+  # avatar.variant(resize_to_limit: [100, 100]).processed.service_url
+  # ```
+  #
+  # This will create and process a variant of the avatar blob that's constrained to a height and width of 100px.
+  # Then it'll upload said variant to the service according to a derivative key of the blob and the transformations.
+  #
+  # Frequently, though, you don't actually want to transform the variant right away. But rather simply refer to a
+  # specific variant that can be created by a controller on-demand. Like so:
+  #
+  # ```ruby
+  # <%= image_tag Current.user.avatar.variant(resize_to_limit: [100, 100]) %>
+  # ```
+  #
+  # This will create a URL for that specific blob with that specific variant, which the ActiveStorage::RepresentationsController
+  # can then produce on-demand.
+  #
+  # Raises ActiveStorage::InvariableError if ImageMagick cannot transform the blob. To determine whether a blob is
+  # variable, call ActiveStorage::Blob#variable?.
+  sig { params(transformations: T.untyped).returns(ActiveStorage::Variant) }
+  def variant(transformations); end
+end
+
+class ActiveStorage::Attachment < ActiveRecord::Base
+  # These aren't technically included, but Attachment delegates any missing
+  # methods to Blob, which means it effectively inherits methods from Blob.
+  # This is essentially a hack to make it easier to maintain the
+  # ActiveStorage signatures. We can't include Blob directly because
+  # it's a class, so `include`ing it doesn't work.
+  include ActiveStorage::Blob::Analyzable
+  include ActiveStorage::Blob::Identifiable
+  include ActiveStorage::Blob::Representable
+end
+
+class ActiveStorage::Blob < ActiveRecord::Base
+  include ActiveStorage::Blob::Analyzable
+  include ActiveStorage::Blob::Identifiable
+  include ActiveStorage::Blob::Representable
+end

data/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