wt_activerecord_index_spy 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80c60b9f84a74e7e6a712ab694cde7d9df2d7bd7b5f02c19e0203c0c3f6a337d
-  data.tar.gz: c0997eb1f14fbf0a5a136cf977dd2778f02ef09f1951aa28fbdd933e6d47854e
+  metadata.gz: 13718502249b3f34cd531659645af8ef885271bfe20889b16c9a8987b1089a95
+  data.tar.gz: fa2414fb8ea022fb18c57dd7d4d449e93aec34339693a48336eb6113feadc7eb
 SHA512:
-  metadata.gz: 95643efc73118307c0c090e5ce3c1887c2039e74b6049cebb0132ec0b57266783485f972bf7ba3f6f904240814eb2df978f7f484a5ee69b473d4e375886f8177
-  data.tar.gz: be4478bfce890caeae51f703bed4e13772c60443b9bdb06172a6ed8f52fe5ab228d71c9e03f795a02eb7e49da4bb097fd1eed2e0869ab740e207253e259bc07f
+  metadata.gz: ebb5cf1c343b9c831dccf6eb611cf40937168d92b0fef5a0fc5cfc1f0dcb7ba9c4b7cf324857db588c0639ac468b2aa788877f0eee42873c3eb3de16b3a0d00c
+  data.tar.gz: 7d2b25ae8c834756741498560b2db3af0f1a3fd96af06b8eb72d34bb51fbecdfee7b4e14578edad84eb1ac9acf8e33c9e91a9decd11a29ea65c24bdfe5357b3b

data/.github/workflows/main.yml

@@ -33,6 +33,9 @@ jobs:
       run: |
         gem install bundler
         bundle install
+    - name: Typecheck
+      run: |
+        bundle exec srb tc
     - name: Create databases
       run: |
         sudo systemctl start mysql.service

data/.rubocop.yml

@@ -1,3 +1,6 @@
+require:
+  - rubocop-sorbet
+
 AllCops:
   TargetRubyVersion: 2.5
   SuggestExtensions: false

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.5.0
+* Add Sorbet with a few type definitions
+
 ## 0.4.1
 * Fix issue with missing identifier from ActiveRecord (#21)
 

data/Rakefile

@@ -11,20 +11,6 @@ RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]
 
-Rake::Task["release:rubygem_push"].clear
-desc "Pick up the .gem file from pkg/ and push it to Gemfury"
-task "release:rubygem_push" do
-  # IMPORTANT: You need to have the `fury` gem installed, and you need to be logged in.
-  # Please DO READ about "impersonation", which is how you push to your company account instead
-  # of your personal account!
-  # https://gemfury.com/help/collaboration#impersonation
-  paths = Dir.glob("#{__dir__}/pkg/*.gem")
-  raise "Must have found only 1 .gem path, but found #{paths.inspect}" if paths.length != 1
-
-  escaped_gem_path = Shellwords.escape(paths.shift)
-  `fury push #{escaped_gem_path} --as=wetransfer`
-end
-
 namespace :db do
   require_relative "./spec/support/test_database"
   require "active_record"

data/lib/wt_activerecord_index_spy/aggregator.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "erb"
@@ -8,36 +9,59 @@ module WtActiverecordIndexSpy
   # Since it's not possible to be sure for every query, it separates the result
   # in certains and uncertains.
   class Aggregator
+    extend T::Sig
+
+    Results = T.type_alias { T::Hash[String, Item] }
+
+    sig {returns(Results)}
     attr_reader :results
 
-    Item = Struct.new(:identifier, :query, :origin, :certainity_level, keyword_init: true)
+    class Item < T::Struct
+      prop :identifier, String
+      prop :query, String
+      prop :origin, String
+      prop :certainity_level, Symbol
+    end
 
+    sig {void}
     def initialize
-      @results = {}
+      @results = T.let({}, Results)
     end
 
+    sig {void}
     def reset
       @results = {}
+      nil
     end
 
-    # item: an instance of Aggregator::Item
+    sig {params(item: Item).returns(Item)}
     def add(item)
       @results[item.query] = item
     end
 
+    sig {returns(T::Array[Item])}
     def certain_results
       @results.map do |_query, item|
         item if item.certainity_level == :certain
       end.compact
     end
 
+    sig {returns(T::Array[Item])}
     def uncertain_results
       @results.map do |_query, item|
         item if item.certainity_level == :uncertain
       end.compact
     end
 
-    def export_html_results(file, stdout: $stdout)
+    sig do
+      params(
+        file: T.nilable(T.any(File, Tempfile)),
+        stdout: IO
+      )
+      .void
+      .checked(:compiled)
+    end
+    def export_html_results(file=nil, stdout: $stdout)
       file ||= default_html_output_file
       content = ERB.new(File.read(File.join(File.dirname(__FILE__), "./results.html.erb")), 0, "-")
                    .result_with_hash(certain_results: certain_results, uncertain_results: uncertain_results)
@@ -49,6 +73,7 @@ module WtActiverecordIndexSpy
 
     private
 
+    sig {returns(File)}
     def default_html_output_file
       File.new(
         File.join(Dir.tmpdir, "wt_activerecord_index_spy-results.html"),

data/lib/wt_activerecord_index_spy/notification_listener.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module WtActiverecordIndexSpy
@@ -8,7 +9,7 @@ module WtActiverecordIndexSpy
   # It gets each query that uses a WHERE statement and runs a EXPLAIN query to
   # see if it uses an index.
   class NotificationListener
-    IGNORED_SQL = [
+    IGNORED_SQL = T.let([
       /^PRAGMA (?!(table_info))/,
       /^SELECT currval/,
       /^SELECT CAST/,
@@ -23,7 +24,7 @@ module WtActiverecordIndexSpy
       /^TRUNCATE TABLE/,
       /^EXPLAIN/,
       /FROM INFORMATION_SCHEMA/,
-    ].freeze
+    ].freeze, T::Array[Regexp])
 
     attr_reader :queries_missing_index
 

data/lib/wt_activerecord_index_spy/query_analyser/mysql.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module WtActiverecordIndexSpy

data/lib/wt_activerecord_index_spy/query_analyser/postgres.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module WtActiverecordIndexSpy

data/lib/wt_activerecord_index_spy/query_analyser.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module WtActiverecordIndexSpy

data/lib/wt_activerecord_index_spy/test_helpers.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 require "rspec/matchers"

data/lib/wt_activerecord_index_spy/test_models.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 # This class should not be required by the library because

data/lib/wt_activerecord_index_spy/version.rb

@@ -1,5 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
 module WtActiverecordIndexSpy
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/wt_activerecord_index_spy.rb

@@ -1,5 +1,7 @@
+# typed: false
 # frozen_string_literal: true
 
+require 'sorbet-runtime'
 require_relative "wt_activerecord_index_spy/version"
 require_relative "wt_activerecord_index_spy/aggregator"
 require_relative "wt_activerecord_index_spy/query_analyser"

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=/vendor/bundle

data/sorbet/rbi/gems/activemodel.rbi

@@ -0,0 +1,839 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: ignore
+#
+# 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/activemodel/all/activemodel.rbi
+#
+# activemodel-6.1.3.2
+
+module ActiveModel
+  def self.eager_load!; end
+  def self.gem_version; end
+  def self.version; end
+  extend ActiveSupport::Autoload
+end
+module ActiveModel::VERSION
+end
+module ActiveModel::Serializers
+  extend ActiveSupport::Autoload
+end
+class ActiveModel::Attribute
+  def ==(other); end
+  def _original_value_for_database; end
+  def assigned?; end
+  def came_from_user?; end
+  def changed?; end
+  def changed_from_assignment?; end
+  def changed_in_place?; end
+  def encode_with(coder); end
+  def eql?(other); end
+  def forgetting_assignment; end
+  def has_been_read?; end
+  def hash; end
+  def init_with(coder); end
+  def initialize(name, value_before_type_cast, type, original_attribute = nil, value = nil); end
+  def initialize_dup(other); end
+  def initialized?; end
+  def name; end
+  def original_attribute; end
+  def original_value; end
+  def original_value_for_database; end
+  def self.from_database(name, value_before_type_cast, type, value = nil); end
+  def self.from_user(name, value_before_type_cast, type, original_attribute = nil); end
+  def self.null(name); end
+  def self.uninitialized(name, type); end
+  def self.with_cast_value(name, value_before_type_cast, type); end
+  def type; end
+  def type_cast(*arg0); end
+  def value; end
+  def value_before_type_cast; end
+  def value_for_database; end
+  def with_cast_value(value); end
+  def with_type(type); end
+  def with_value_from_database(value); end
+  def with_value_from_user(value); end
+end
+class ActiveModel::Attribute::FromDatabase < ActiveModel::Attribute
+  def _original_value_for_database; end
+  def type_cast(value); end
+end
+class ActiveModel::Attribute::FromUser < ActiveModel::Attribute
+  def came_from_user?; end
+  def type_cast(value); end
+end
+class ActiveModel::Attribute::WithCastValue < ActiveModel::Attribute
+  def changed_in_place?; end
+  def type_cast(value); end
+end
+class ActiveModel::Attribute::Null < ActiveModel::Attribute
+  def initialize(name); end
+  def type_cast(*arg0); end
+  def with_cast_value(value); end
+  def with_type(type); end
+  def with_value_from_database(value); end
+  def with_value_from_user(value); end
+end
+class ActiveModel::Attribute::Uninitialized < ActiveModel::Attribute
+  def forgetting_assignment; end
+  def initialize(name, type); end
+  def initialized?; end
+  def original_value; end
+  def value; end
+  def value_for_database; end
+  def with_type(type); end
+end
+class ActiveModel::AttributeSet
+  def ==(other); end
+  def [](name); end
+  def []=(name, value); end
+  def accessed; end
+  def attributes; end
+  def deep_dup; end
+  def default_attribute(name); end
+  def each_value(**, &&); end
+  def except(**, &&); end
+  def fetch(**, &&); end
+  def fetch_value(name, &block); end
+  def freeze; end
+  def initialize(attributes); end
+  def initialize_clone(_); end
+  def initialize_dup(_); end
+  def key?(name); end
+  def keys; end
+  def map(&block); end
+  def reset(key); end
+  def to_h; end
+  def to_hash; end
+  def values_before_type_cast; end
+  def write_cast_value(name, value); end
+  def write_from_database(name, value); end
+  def write_from_user(name, value); end
+end
+class ActiveModel::AttributeSet::Builder
+  def build_from_database(values = nil, additional_types = nil); end
+  def default_attributes; end
+  def initialize(types, default_attributes = nil); end
+  def types; end
+end
+class ActiveModel::LazyAttributeSet < ActiveModel::AttributeSet
+  def additional_types; end
+  def attributes; end
+  def default_attribute(name, value_present = nil, value = nil); end
+  def default_attributes; end
+  def fetch_value(name, &block); end
+  def initialize(values, types, additional_types, default_attributes, attributes = nil); end
+  def key?(name); end
+  def keys; end
+  def types; end
+  def values; end
+end
+class ActiveModel::LazyAttributeHash
+  def ==(other); end
+  def [](key); end
+  def []=(key, value); end
+  def additional_types; end
+  def assign_default_value(name); end
+  def deep_dup; end
+  def default_attributes; end
+  def delegate_hash; end
+  def each_key(&block); end
+  def each_value(**, &&); end
+  def except(**, &&); end
+  def fetch(**, &&); end
+  def initialize(types, values, additional_types, default_attributes, delegate_hash = nil); end
+  def initialize_dup(_); end
+  def key?(key); end
+  def marshal_dump; end
+  def marshal_load(values); end
+  def materialize; end
+  def transform_values(**, &&); end
+  def types; end
+  def values; end
+end
+class ActiveModel::AttributeSet::YAMLEncoder
+  def decode(coder); end
+  def default_types; end
+  def encode(attribute_set, coder); end
+  def initialize(default_types); end
+end
+class ActiveModel::Error
+  def ==(other); end
+  def attribute; end
+  def attributes_for_hash; end
+  def base; end
+  def detail; end
+  def details; end
+  def eql?(other); end
+  def full_message; end
+  def hash; end
+  def i18n_customize_full_message; end
+  def i18n_customize_full_message=(arg0); end
+  def i18n_customize_full_message?; end
+  def initialize(base, attribute, type = nil, **options); end
+  def initialize_dup(other); end
+  def inspect; end
+  def match?(attribute, type = nil, **options); end
+  def message; end
+  def options; end
+  def raw_type; end
+  def self.full_message(attribute, message, base); end
+  def self.generate_message(attribute, type, base, options); end
+  def self.i18n_customize_full_message; end
+  def self.i18n_customize_full_message=(value); end
+  def self.i18n_customize_full_message?; end
+  def strict_match?(attribute, type, **options); end
+  def type; end
+end
+class ActiveModel::NestedError < ActiveModel::Error
+  def initialize(base, inner_error, override_options = nil); end
+  def inner_error; end
+  def message(*args, &block); end
+  extend Forwardable
+end
+class ActiveModel::Errors
+  def [](attribute); end
+  def add(attribute, type = nil, **options); end
+  def add_from_legacy_details_hash(details); end
+  def added?(attribute, type = nil, options = nil); end
+  def any?(*args, &block); end
+  def as_json(options = nil); end
+  def attribute_names; end
+  def blank?(*args, &block); end
+  def clear(*args, &block); end
+  def copy!(other); end
+  def count(*args, &block); end
+  def delete(attribute, type = nil, **options); end
+  def deprecation_removal_warning(method_name, alternative_message = nil); end
+  def deprecation_rename_warning(old_method_name, new_method_name); end
+  def details; end
+  def each(&block); end
+  def empty?(*args, &block); end
+  def errors; end
+  def full_message(attribute, message); end
+  def full_messages; end
+  def full_messages_for(attribute); end
+  def generate_message(attribute, type = nil, options = nil); end
+  def group_by_attribute; end
+  def has_key?(attribute); end
+  def import(error, override_options = nil); end
+  def include?(attribute); end
+  def init_with(coder); end
+  def initialize(base); end
+  def initialize_dup(other); end
+  def key?(attribute); end
+  def keys; end
+  def marshal_load(array); end
+  def merge!(other); end
+  def messages; end
+  def messages_for(attribute); end
+  def normalize_arguments(attribute, type, **options); end
+  def objects; end
+  def of_kind?(attribute, type = nil); end
+  def size(*args, &block); end
+  def slice!(*keys); end
+  def to_a; end
+  def to_h; end
+  def to_hash(full_messages = nil); end
+  def to_xml(options = nil); end
+  def uniq!(*args, &block); end
+  def values; end
+  def where(attribute, type = nil, **options); end
+  extend Forwardable
+  include Enumerable
+end
+class ActiveModel::DeprecationHandlingMessageHash < SimpleDelegator
+  def []=(attribute, value); end
+  def delete(attribute); end
+  def initialize(errors); end
+  def prepare_content; end
+end
+class ActiveModel::DeprecationHandlingMessageArray < SimpleDelegator
+  def <<(message); end
+  def clear; end
+  def initialize(content, errors, attribute); end
+end
+class ActiveModel::DeprecationHandlingDetailsHash < SimpleDelegator
+  def initialize(details); end
+end
+class ActiveModel::StrictValidationFailed < StandardError
+end
+class ActiveModel::RangeError < RangeError
+end
+class ActiveModel::UnknownAttributeError < NoMethodError
+  def attribute; end
+  def initialize(record, attribute); end
+  def record; end
+end
+class ActiveModel::MissingAttributeError < NoMethodError
+end
+module ActiveModel::AttributeMethods
+  def _read_attribute(attr); end
+  def attribute_method?(attr_name); end
+  def attribute_missing(match, *args, &block); end
+  def matched_attribute_method(method_name); end
+  def method_missing(method, *args, &block); end
+  def missing_attribute(attr_name, stack); end
+  def respond_to?(method, include_private_methods = nil); end
+  def respond_to_without_attributes?(*arg0); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::AttributeMethods::ClassMethods
+  def alias_attribute(new_name, old_name); end
+  def attribute_alias(name); end
+  def attribute_alias?(new_name); end
+  def attribute_method_affix(*affixes); end
+  def attribute_method_matchers_cache; end
+  def attribute_method_matchers_matching(method_name); end
+  def attribute_method_prefix(*prefixes); end
+  def attribute_method_suffix(*suffixes); end
+  def define_attribute_method(attr_name, _owner: nil); end
+  def define_attribute_methods(*attr_names); end
+  def define_proxy_call(include_private, code_generator, name, target, *extra); end
+  def generated_attribute_methods; end
+  def instance_method_already_implemented?(method_name); end
+  def undefine_attribute_methods; end
+end
+class ActiveModel::AttributeMethods::ClassMethods::CodeGenerator
+  def <<(source_line); end
+  def execute; end
+  def initialize(owner, path, line); end
+  def rename_method(old_name, new_name); end
+  def self.batch(owner, path, line); end
+end
+class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
+  def initialize(options = nil); end
+  def match(method_name); end
+  def method_name(attr_name); end
+  def prefix; end
+  def suffix; end
+  def target; end
+end
+class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher::AttributeMethodMatch < Struct
+  def attr_name; end
+  def attr_name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def target; end
+  def target=(_); end
+end
+module ActiveModel::AttributeMethods::AttrNames
+  def self.define_attribute_accessor_method(owner, attr_name, writer: nil); end
+end
+class ActiveModel::Attribute::UserProvidedDefault < ActiveModel::Attribute::FromUser
+  def initialize(name, value, type, database_default); end
+  def marshal_dump; end
+  def marshal_load(values); end
+  def user_provided_value; end
+  def value_before_type_cast; end
+  def with_type(type); end
+end
+class ActiveModel::Name
+  def !~(**, &&); end
+  def <=>(**, &&); end
+  def ==(arg); end
+  def ===(arg); end
+  def =~(**, &&); end
+  def _singularize(string); end
+  def as_json(**, &&); end
+  def cache_key; end
+  def collection; end
+  def collection=(arg0); end
+  def element; end
+  def element=(arg0); end
+  def eql?(**, &&); end
+  def human(options = nil); end
+  def i18n_key; end
+  def i18n_key=(arg0); end
+  def initialize(klass, namespace = nil, name = nil); end
+  def match?(**, &&); end
+  def name; end
+  def name=(arg0); end
+  def param_key; end
+  def param_key=(arg0); end
+  def plural; end
+  def plural=(arg0); end
+  def route_key; end
+  def route_key=(arg0); end
+  def singular; end
+  def singular=(arg0); end
+  def singular_route_key; end
+  def singular_route_key=(arg0); end
+  def to_s(**, &&); end
+  def to_str(**, &&); end
+  include Comparable
+end
+module ActiveModel::Naming
+  def model_name; end
+  def self.extended(base); end
+  def self.model_name_from_record_or_class(record_or_class); end
+  def self.param_key(record_or_class); end
+  def self.plural(record_or_class); end
+  def self.route_key(record_or_class); end
+  def self.singular(record_or_class); end
+  def self.singular_route_key(record_or_class); end
+  def self.uncountable?(record_or_class); end
+end
+module ActiveModel::Translation
+  def human_attribute_name(attribute, options = nil); end
+  def i18n_scope; end
+  def lookup_ancestors; end
+  include ActiveModel::Naming
+end
+module ActiveModel::Type
+  def self.default_value; end
+  def self.lookup(*args, **kwargs); end
+  def self.register(type_name, klass = nil, **options, &block); end
+  def self.registry; end
+  def self.registry=(arg0); end
+end
+module ActiveModel::Type::Helpers
+end
+class ActiveModel::Type::Helpers::AcceptsMultiparameterTime < Module
+  def initialize(defaults: nil); end
+end
+module ActiveModel::Type::Helpers::AcceptsMultiparameterTime::InstanceMethods
+  def assert_valid_value(value); end
+  def cast(value); end
+  def serialize(value); end
+  def value_constructed_by_mass_assignment?(value); end
+end
+module ActiveModel::Type::Helpers::Numeric
+  def cast(value); end
+  def changed?(old_value, _new_value, new_value_before_type_cast); end
+  def non_numeric_string?(value); end
+  def number_to_non_number?(old_value, new_value_before_type_cast); end
+  def serialize(value); end
+end
+module ActiveModel::Type::Helpers::Mutable
+  def cast(value); end
+  def changed_in_place?(raw_old_value, new_value); end
+end
+module ActiveModel::Type::Helpers::TimeValue
+  def apply_seconds_precision(value); end
+  def fast_string_to_time(string); end
+  def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil); end
+  def serialize(value); end
+  def type_cast_for_schema(value); end
+  def user_input_in_time_zone(value); end
+end
+module ActiveModel::Type::Helpers::Timezone
+  def default_timezone; end
+  def is_utc?; end
+end
+class ActiveModel::Type::Value
+  def ==(other); end
+  def assert_valid_value(_); end
+  def binary?; end
+  def cast(value); end
+  def cast_value(value); end
+  def changed?(old_value, new_value, _new_value_before_type_cast); end
+  def changed_in_place?(raw_old_value, new_value); end
+  def deserialize(value); end
+  def eql?(other); end
+  def force_equality?(_value); end
+  def hash; end
+  def initialize(precision: nil, limit: nil, scale: nil); end
+  def limit; end
+  def map(value); end
+  def precision; end
+  def scale; end
+  def serializable?(value); end
+  def serialize(value); end
+  def type; end
+  def type_cast_for_schema(value); end
+  def value_constructed_by_mass_assignment?(_value); end
+end
+class ActiveModel::Type::Integer < ActiveModel::Type::Value
+  def _limit; end
+  def cast_value(value); end
+  def deserialize(value); end
+  def ensure_in_range(value); end
+  def in_range?(value); end
+  def initialize(**arg0); end
+  def max_value; end
+  def min_value; end
+  def range; end
+  def serializable?(value); end
+  def serialize(value); end
+  def type; end
+  include ActiveModel::Type::Helpers::Numeric
+end
+class ActiveModel::Type::BigInteger < ActiveModel::Type::Integer
+  def max_value; end
+end
+class ActiveModel::Type::Binary < ActiveModel::Type::Value
+  def binary?; end
+  def cast(value); end
+  def changed_in_place?(raw_old_value, value); end
+  def serialize(value); end
+  def type; end
+end
+class ActiveModel::Type::Binary::Data
+  def ==(other); end
+  def hex; end
+  def initialize(value); end
+  def to_s; end
+  def to_str; end
+end
+class ActiveModel::Type::Boolean < ActiveModel::Type::Value
+  def cast_value(value); end
+  def serialize(value); end
+  def type; end
+end
+class ActiveModel::Type::Date < ActiveModel::Type::Value
+  def cast_value(value); end
+  def fallback_string_to_date(string); end
+  def fast_string_to_date(string); end
+  def new_date(year, mon, mday); end
+  def type; end
+  def type_cast_for_schema(value); end
+  def value_from_multiparameter_assignment(*arg0); end
+  include ActiveModel::Type::Helpers::Timezone
+  include Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_2
+end
+module Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_2
+  def value_from_multiparameter_assignment(values_hash); end
+  include ActiveModel::Type::Helpers::AcceptsMultiparameterTime::InstanceMethods
+end
+class ActiveModel::Type::DateTime < ActiveModel::Type::Value
+  def cast_value(value); end
+  def fallback_string_to_time(string); end
+  def microseconds(time); end
+  def type; end
+  def value_from_multiparameter_assignment(values_hash); end
+  include ActiveModel::Type::Helpers::TimeValue
+  include ActiveModel::Type::Helpers::Timezone
+  include Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_3
+end
+module Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_3
+  def value_from_multiparameter_assignment(values_hash); end
+  include ActiveModel::Type::Helpers::AcceptsMultiparameterTime::InstanceMethods
+end
+class ActiveModel::Type::Decimal < ActiveModel::Type::Value
+  def apply_scale(value); end
+  def cast_value(value); end
+  def convert_float_to_big_decimal(value); end
+  def float_precision; end
+  def type; end
+  def type_cast_for_schema(value); end
+  include ActiveModel::Type::Helpers::Numeric
+end
+class ActiveModel::Type::Float < ActiveModel::Type::Value
+  def cast_value(value); end
+  def type; end
+  def type_cast_for_schema(value); end
+  include ActiveModel::Type::Helpers::Numeric
+end
+class ActiveModel::Type::ImmutableString < ActiveModel::Type::Value
+  def cast_value(value); end
+  def initialize(**args); end
+  def serialize(value); end
+  def type; end
+end
+class ActiveModel::Type::String < ActiveModel::Type::ImmutableString
+  def cast_value(value); end
+  def changed_in_place?(raw_old_value, new_value); end
+  def to_immutable_string; end
+end
+class ActiveModel::Type::Time < ActiveModel::Type::Value
+  def cast_value(value); end
+  def type; end
+  def user_input_in_time_zone(value); end
+  include ActiveModel::Type::Helpers::TimeValue
+  include ActiveModel::Type::Helpers::Timezone
+  include Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_4
+end
+module Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_4
+  def value_from_multiparameter_assignment(values_hash); end
+  include ActiveModel::Type::Helpers::AcceptsMultiparameterTime::InstanceMethods
+end
+class ActiveModel::Type::Registry
+  def find_registration(symbol, *args, **kwargs); end
+  def initialize; end
+  def initialize_dup(other); end
+  def lookup(symbol, *args, **kwargs); end
+  def register(type_name, klass = nil, **options, &block); end
+  def registration_klass; end
+  def registrations; end
+end
+class ActiveModel::Type::Registration
+  def block; end
+  def call(_registry, *args, **kwargs); end
+  def initialize(name, block, **arg2); end
+  def matches?(type_name, *args, **kwargs); end
+  def name; end
+end
+class ActiveModel::ForbiddenAttributesError < StandardError
+end
+module ActiveModel::ForbiddenAttributesProtection
+  def sanitize_for_mass_assignment(attributes); end
+  def sanitize_forbidden_attributes(attributes); end
+end
+module ActiveModel::AttributeAssignment
+  def _assign_attribute(k, v); end
+  def _assign_attributes(attributes); end
+  def assign_attributes(new_attributes); end
+  def attributes=(new_attributes); end
+  include ActiveModel::ForbiddenAttributesProtection
+end
+module ActiveModel::Conversion
+  def to_key; end
+  def to_model; end
+  def to_param; end
+  def to_partial_path; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Conversion::ClassMethods
+  def _to_partial_path; end
+end
+module ActiveModel::Validations
+  def errors; end
+  def initialize_dup(other); end
+  def invalid?(context = nil); end
+  def raise_validation_error; end
+  def read_attribute_for_validation(*arg0); end
+  def run_validations!; end
+  def valid?(context = nil); end
+  def validate!(context = nil); end
+  def validate(context = nil); end
+  def validates_with(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::ClassMethods
+  def _parse_validates_options(options); end
+  def _validates_default_keys; end
+  def attribute_method?(attribute); end
+  def clear_validators!; end
+  def inherited(base); end
+  def validate(*args, &block); end
+  def validates!(*attributes); end
+  def validates(*attributes); end
+  def validates_each(*attr_names, &block); end
+  def validates_with(*args, &block); end
+  def validators; end
+  def validators_on(*attributes); end
+end
+module ActiveModel::Validations::Clusivity
+  def check_validity!; end
+  def delimiter; end
+  def include?(record, value); end
+  def inclusion_method(enumerable); end
+end
+class ActiveModel::Validator
+  def initialize(options = nil); end
+  def kind; end
+  def options; end
+  def self.kind; end
+  def validate(record); end
+end
+class ActiveModel::EachValidator < ActiveModel::Validator
+  def attributes; end
+  def check_validity!; end
+  def initialize(options); end
+  def prepare_value_for_validation(value, record, attr_name); end
+  def validate(record); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::BlockValidator < ActiveModel::EachValidator
+  def initialize(options, &block); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::InclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+module ActiveModel::Validations::HelperMethods
+  def _merge_attributes(attr_names); end
+  def validates_absence_of(*attr_names); end
+  def validates_acceptance_of(*attr_names); end
+  def validates_confirmation_of(*attr_names); end
+  def validates_exclusion_of(*attr_names); end
+  def validates_format_of(*attr_names); end
+  def validates_inclusion_of(*attr_names); end
+  def validates_length_of(*attr_names); end
+  def validates_numericality_of(*attr_names); end
+  def validates_presence_of(*attr_names); end
+  def validates_size_of(*attr_names); end
+end
+class ActiveModel::Validations::AbsenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::NumericalityValidator < ActiveModel::EachValidator
+  def allow_only_integer?(record); end
+  def check_validity!; end
+  def filtered_options(value); end
+  def is_hexadecimal_literal?(raw_value); end
+  def is_integer?(raw_value); end
+  def is_number?(raw_value, precision, scale); end
+  def parse_as_number(raw_value, precision, scale); end
+  def parse_float(raw_value, precision, scale); end
+  def prepare_value_for_validation(value, record, attr_name); end
+  def record_attribute_changed_in_place?(record, attr_name); end
+  def round(raw_value, scale); end
+  def validate_each(record, attr_name, value, precision: nil, scale: nil); end
+end
+module ActiveModel::Validations::Callbacks
+  def run_validations!; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::Callbacks::ClassMethods
+  def after_validation(*args, &block); end
+  def before_validation(*args, &block); end
+  def set_options_for_callback(options); end
+end
+class ActiveModel::Validations::ExclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+class ActiveModel::Validations::ConfirmationValidator < ActiveModel::EachValidator
+  def confirmation_value_equal?(record, attribute, value, confirmed); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::FormatValidator < ActiveModel::EachValidator
+  def check_options_validity(name); end
+  def check_validity!; end
+  def option_call(record, name); end
+  def record_error(record, attribute, name, value); end
+  def regexp_using_multiline_anchors?(regexp); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::PresenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::LengthValidator < ActiveModel::EachValidator
+  def check_validity!; end
+  def initialize(options); end
+  def skip_nil_check?(key); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator < ActiveModel::EachValidator
+  def acceptable_option?(value); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes < Module
+  def ==(other); end
+  def attributes; end
+  def define_on(klass); end
+  def included(klass); end
+  def initialize(attributes); end
+  def matches?(method_name); end
+end
+class ActiveModel::Validations::WithValidator < ActiveModel::EachValidator
+  def validate_each(record, attr, val); end
+end
+class ActiveModel::ValidationError < StandardError
+  def initialize(model); end
+  def model; end
+end
+module ActiveModel::Callbacks
+  def _define_after_model_callback(klass, callback); end
+  def _define_around_model_callback(klass, callback); end
+  def _define_before_model_callback(klass, callback); end
+  def define_model_callbacks(*callbacks); end
+  def self.extended(base); end
+end
+class ActiveModel::AttributeMutationTracker
+  def any_changes?; end
+  def attr_names; end
+  def attribute_changed?(attr_name); end
+  def attributes; end
+  def change_to_attribute(attr_name); end
+  def changed?(attr_name, from: nil, to: nil); end
+  def changed_attribute_names; end
+  def changed_in_place?(attr_name); end
+  def changed_values; end
+  def changes; end
+  def fetch_value(attr_name); end
+  def force_change(attr_name); end
+  def forced_changes; end
+  def forget_change(attr_name); end
+  def initialize(attributes); end
+  def original_value(attr_name); end
+end
+class ActiveModel::ForcedMutationTracker < ActiveModel::AttributeMutationTracker
+  def attr_names; end
+  def attribute_changed?(attr_name); end
+  def change_to_attribute(attr_name); end
+  def changed_in_place?(attr_name); end
+  def clone_value(attr_name); end
+  def fetch_value(attr_name); end
+  def finalize_changes; end
+  def finalized_changes; end
+  def force_change(attr_name); end
+  def forget_change(attr_name); end
+  def initialize(attributes); end
+  def original_value(attr_name); end
+end
+class ActiveModel::NullMutationTracker
+  def any_changes?; end
+  def change_to_attribute(attr_name); end
+  def changed?(attr_name, **arg1); end
+  def changed_attribute_names; end
+  def changed_in_place?(attr_name); end
+  def changed_values; end
+  def changes; end
+  def original_value(attr_name); end
+  def self.allocate; end
+  def self.new(*arg0); end
+  extend Singleton::SingletonClassMethods
+  include Singleton
+end
+module ActiveModel::Dirty
+  def attribute_change(attr_name); end
+  def attribute_changed?(attr_name, **options); end
+  def attribute_changed_in_place?(attr_name); end
+  def attribute_previous_change(attr_name); end
+  def attribute_previously_changed?(attr_name, **options); end
+  def attribute_previously_was(attr_name); end
+  def attribute_was(attr_name); end
+  def attribute_will_change!(attr_name); end
+  def changed; end
+  def changed?; end
+  def changed_attributes; end
+  def changes; end
+  def changes_applied; end
+  def clear_attribute_change(attr_name); end
+  def clear_attribute_changes(attr_names); end
+  def clear_changes_information; end
+  def forget_attribute_assignments; end
+  def initialize_dup(other); end
+  def mutations_before_last_save; end
+  def mutations_from_database; end
+  def previous_changes; end
+  def restore_attribute!(attr_name); end
+  def restore_attributes(attr_names = nil); end
+  extend ActiveSupport::Concern
+  include ActiveModel::AttributeMethods
+end
+module ActiveModel::SecurePassword
+  def self.min_cost; end
+  def self.min_cost=(arg0); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::SecurePassword::ClassMethods
+  def has_secure_password(attribute = nil, validations: nil); end
+end
+class ActiveModel::SecurePassword::InstanceMethodsOnActivation < Module
+  def initialize(attribute); end
+end
+module ActiveModel::Serialization
+  def read_attribute_for_serialization(*arg0); end
+  def serializable_add_includes(options = nil); end
+  def serializable_attributes(attribute_names); end
+  def serializable_hash(options = nil); end
+end
+module ActiveModel::Serializers::JSON
+  def as_json(options = nil); end
+  def from_json(json, include_root = nil); end
+  extend ActiveSupport::Concern
+  include ActiveModel::Serialization
+end