phlex-stimulus 0.1.0

data/sorbet/rbi/annotations/actionview.rbi

@@ -0,0 +1,75 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module ActionView
+  TemplateError = T.type_alias { Template::Error }
+
+  class MissingTemplate < ActionView::ActionViewError
+    sig { returns(String) }
+    def path; end
+  end
+end
+
+class ActionView::Helpers::FormBuilder
+  sig { returns(T.untyped) }
+  def object; end
+end
+
+module ActionView::Helpers::NumberHelper
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_currency(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_human(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_human_size(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_percentage(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_phone(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_with_delimiter(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_with_precision(number, options = T.unsafe(nil)); end
+end
+
+module ActionView::Helpers::SanitizeHelper
+  mixes_in_class_methods ActionView::Helpers::SanitizeHelper::ClassMethods
+end
+
+module ActionView::Helpers::UrlHelper
+  extend ActiveSupport::Concern
+  include ActionView::Helpers::TagHelper
+  mixes_in_class_methods ActionView::Helpers::UrlHelper::ClassMethods
+
+  sig { params(name: T.nilable(String), options: T.untyped, html_options: T.untyped, block: T.untyped).returns(ActiveSupport::SafeBuffer) }
+  def link_to(name = nil, options = nil, html_options = nil, &block); end
+
+  sig { params(condition: T.untyped, name: String, options: T.untyped, html_options: T.untyped, block: T.untyped).returns(T.untyped) }
+  def link_to_if(condition, name, options = {}, html_options = {}, &block); end
+end
+
+module ActionView::Layouts
+  mixes_in_class_methods ActionView::Layouts::ClassMethods
+end
+
+module ActionView::Rendering
+  mixes_in_class_methods ActionView::Rendering::ClassMethods
+end
+
+module ActionView::ViewPaths
+  mixes_in_class_methods ActionView::ViewPaths::ClassMethods
+end
+
+module ActionView::ViewPaths::ClassMethods
+  sig { params(value: T.any(String, T::Array[String])).void }
+  def append_view_path(value); end
+end

data/sorbet/rbi/annotations/activejob.rbi

@@ -0,0 +1,50 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveJob::Base
+  sig { params(blk: T.proc.bind(T.attached_class).params(job: T.attached_class, exception: Exception).void).void }
+  def self.after_discard(&blk); end
+
+  sig { params(filters: T.untyped, blk: T.nilable(T.proc.bind(T.attached_class).params(job: T.attached_class).void)).void }
+  def self.after_enqueue(*filters, &blk); end
+
+  sig { params(filters: T.untyped, blk: T.nilable(T.proc.bind(T.attached_class).params(job: T.attached_class).void)).void }
+  def self.after_perform(*filters, &blk); end
+
+  sig { params(filters: T.untyped, blk: T.nilable(T.proc.bind(T.attached_class).params(job: T.attached_class, block: T.untyped).void)).void }
+  def self.around_enqueue(*filters, &blk); end
+
+  sig { params(filters: T.untyped, blk: T.nilable(T.proc.bind(T.attached_class).params(job: T.attached_class, block: T.untyped).void)).void }
+  def self.around_perform(*filters, &blk); end
+
+  sig { params(filters: T.untyped, blk: T.nilable(T.proc.bind(T.attached_class).params(job: T.attached_class).void)).void }
+  def self.before_enqueue(*filters, &blk); end
+
+  sig { params(filters: T.untyped, blk: T.nilable(T.proc.bind(T.attached_class).params(job: T.attached_class).void)).void }
+  def self.before_perform(*filters, &blk); end
+
+  sig { type_parameters(:ExceptionType).params(exceptions: T::Class[T.type_parameter(:ExceptionType)], block: T.nilable(T.proc.params(job: T.attached_class, error: T.type_parameter(:ExceptionType)).void)).void }
+  sig { params(exceptions: T.any(Module, String), block: T.nilable(T.proc.params(job: T.attached_class, error: T.untyped).void)).void }
+  def self.discard_on(*exceptions, &block); end
+
+  sig { params(klasses: T.any(Module, String), with: T.nilable(Symbol), block: T.nilable(T.proc.params(exception: T.untyped).void)).void }
+  def self.rescue_from(*klasses, with: nil, &block); end
+
+  sig { params(exceptions: T.any(Module, String), wait: T.any(ActiveSupport::Duration, Integer, Symbol, T.proc.params(executions: Integer).returns(Integer)), attempts: T.any(Integer, Symbol), queue: T.nilable(T.any(String, Symbol)), priority: T.untyped, jitter: Numeric, block: T.nilable(T.proc.params(job: T.attached_class, error: T.untyped).void)).void }
+  def self.retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: ActiveJob::Exceptions::JITTER_DEFAULT, &block); end
+
+  sig { params(part_name: T.nilable(T.any(String, Symbol)), block: T.nilable(T.proc.bind(T.attached_class).returns(T.untyped))).void }
+  def self.queue_as(part_name = nil, &block); end
+
+  sig { params(priority: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).returns(T.untyped))).void }
+  def self.queue_with_priority(priority = nil, &block); end
+end
+
+# @version >= 8.1.0.beta1
+module ActiveJob::Continuable
+  sig { params(step_name: Symbol, start: T.untyped, isolated: T::Boolean, block: T.nilable(T.proc.params(step: ActiveJob::Continuation::Step).void)).void }
+  def step(step_name, start: nil, isolated: false, &block); end
+end

data/sorbet/rbi/annotations/activemodel.rbi

@@ -0,0 +1,119 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module ActiveModel::Attributes
+  sig { returns(T::Array[String]) }
+  def attribute_names; end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def attributes; end
+end
+
+module ActiveModel::Attributes::ClassMethods
+  sig { returns(T::Array[String]) }
+  def attribute_names; end
+end
+
+module ActiveModel::Dirty
+  sig { returns(T::Array[String]) }
+  def changed; end
+
+  sig { returns(T::Boolean) }
+  def changed?; end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def changed_attributes; end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def changes; end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def previous_changes; end
+end
+
+class ActiveModel::Errors
+  Elem = type_member { { fixed: ActiveModel::Error } }
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def [](attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(ActiveModel::Error) }
+  def add(attribute, type = :invalid, **options); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Boolean) }
+  def added?(attribute, type = :invalid, options = {}); end
+
+  sig { params(options: T.untyped).returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json(options = nil); end
+
+  sig { returns(T::Array[Symbol]) }
+  def attribute_names; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T.nilable(T::Array[String])) }
+  def delete(attribute, type = nil, **options); end
+
+  sig { returns(T::Hash[Symbol, T::Array[T::Hash[Symbol, T.untyped]]]) }
+  def details; end
+
+  sig { returns(T::Array[Elem]) }
+  def errors; end
+
+  sig { params(attribute: T.any(Symbol, String), message: String).returns(String) }
+  def full_message(attribute, message); end
+
+  sig { returns(T::Array[String]) }
+  def full_messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def full_messages_for(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(String) }
+  def generate_message(attribute, type = :invalid, options = {}); end
+
+  sig { returns(T::Hash[Symbol, T::Array[ActiveModel::Error]]) }
+  def group_by_attribute; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def has_key?(attribute); end
+
+  sig { params(error: ActiveModel::Error, override_options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def import(error, override_options = {}); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def include?(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def key?(attribute); end
+
+  sig { params(other: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def merge!(other); end
+
+  sig { returns(T::Hash[Symbol, T::Array[String]]) }
+  def messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def messages_for(attribute); end
+
+  sig { returns(T::Array[Elem]) }
+  def objects; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped).returns(T::Boolean) }
+  def of_kind?(attribute, type = :invalid); end
+
+  sig { returns(T::Array[String]) }
+  def to_a; end
+
+  sig { params(full_messages: T.untyped).returns(T::Hash[Symbol, T::Array[String]]) }
+  def to_hash(full_messages = false); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def where(attribute, type = nil, **options); end
+end
+
+module ActiveModel::Validations
+  sig { returns(ActiveModel::Errors) }
+  def errors; end
+end

data/sorbet/rbi/annotations/activerecord.rbi

@@ -0,0 +1,172 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module ActiveRecord::AttributeMethods::ClassMethods
+  sig { returns(T::Array[String]) }
+  def attribute_names; end
+end
+
+module ActiveRecord::AttributeMethods::Dirty
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def attributes_in_database; end
+
+  sig { returns(T::Array[String]) }
+  def changed_attribute_names_to_save; end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def changes_to_save; end
+
+  sig { returns(T::Boolean) }
+  def has_changes_to_save?; end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def saved_changes; end
+
+  sig { returns(T::Boolean) }
+  def saved_changes?; end
+end
+
+class ActiveRecord::Schema
+  sig { params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void }
+  def self.define(info = nil, &blk); end
+end
+
+class ActiveRecord::Migration
+  # @shim: Methods on migration are delegated to `SchemaStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::SchemaStatements
+
+  # @shim: Methods on migration are delegated to `DatabaseStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::DatabaseStatements
+end
+
+# @version >= 7.2.0
+module ActiveRecord::Assertions::QueryAssertions
+  sig { type_parameters(:R).params(count: T.nilable(Integer), include_schema: T::Boolean, block: T.proc.returns(T.type_parameter(:R))).returns(T.type_parameter(:R)) }
+  def assert_queries_count(count = nil, include_schema: false, &block); end
+
+  sig { type_parameters(:R).params(include_schema: T::Boolean, block: T.proc.returns(T.type_parameter(:R))).returns(T.type_parameter(:R)) }
+  def assert_no_queries(include_schema: false, &block); end
+
+  sig { type_parameters(:R).params(match: T.any(String, Regexp), count: T.nilable(Integer), include_schema: T::Boolean, block: T.proc.returns(T.type_parameter(:R))).returns(T.type_parameter(:R)) }
+  def assert_queries_match(match, count: nil, include_schema: false, &block); end
+
+  sig { type_parameters(:R).params(match: T.any(String, Regexp), include_schema: T::Boolean, block: T.proc.returns(T.type_parameter(:R))).returns(T.type_parameter(:R)) }
+  def assert_no_queries_match(match, include_schema: false, &block); end
+end
+
+# @version >= 7.2.0
+class ActiveSupport::TestCase
+  # @shim: Rails includes query assertions into ActiveSupport::TestCase from rails/test_help when ActiveRecord is loaded.
+  include ActiveRecord::Assertions::QueryAssertions
+end
+
+class ActiveRecord::Base
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  sig { returns(TrueClass) }
+  def present?; end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_initialize(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_find(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_touch(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_commit(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_rollback(*args, **options, &block); end
+end
+
+class ActiveRecord::Relation
+  Elem = type_member(:out) { { fixed: T.untyped } }
+
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { abstract.params(blk: T.proc.params(arg0: Elem).returns(BasicObject)).returns(T.untyped) }
+  sig { abstract.returns(T::Enumerator[Elem]) }
+  def each(&blk); end
+end
+
+module ActiveRecord::Core
+  sig { params(comparison_object: T.anything).returns(T::Boolean) }
+  def ==(comparison_object); end
+end
+
+module ActiveRecord::Persistence
+  sig { type_parameters(:Klass).params(klass: T::Class[T.type_parameter(:Klass)]).returns(T.type_parameter(:Klass)) }
+  def becomes(klass); end
+
+  sig { type_parameters(:Klass).params(klass: T::Class[T.type_parameter(:Klass)]).returns(T.type_parameter(:Klass)) }
+  def becomes!(klass); end
+
+  sig { returns(T::Boolean) }
+  def destroyed?; end
+
+  sig { returns(T::Boolean) }
+  def new_record?; end
+
+  sig { returns(T::Boolean) }
+  def persisted?; end
+
+  sig { returns(T::Boolean) }
+  def previously_new_record?; end
+
+  sig { returns(T::Boolean) }
+  def previously_persisted?; end
+end