tapioca 0.17.8 → 0.17.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 489bd75ab0b8322c633ee51dbdb7f0bf4701fbca5cf64401c418d8a7fb454418
-  data.tar.gz: 62e4137c4fb603186d93b2f470148f5a8b7baa73bcfb6ed8b000a519dc1f106a
+  metadata.gz: 3668f1f1916b284b762a3ed370a2f658b2edd25d1c0c44be37fd7ca321be9200
+  data.tar.gz: ce3540ff4aaebab9b9e506c4192ffdee93ef17c09b2399fb114d2b735fbf0b0e
 SHA512:
-  metadata.gz: ef5107149d789dda2d5c426a14b611ab1062f8aaa919ec179805c95bf7ad7d22eaae368ac9e0ed86b61cfac38b5bbbfc2fa65fa262837ce22ff4ee054b5cbf31
-  data.tar.gz: e568320ce79f3e9afa07d1ea1fc58aa7aef422f782b77c4b93707016b680bd2e3c2c971b136016dbf754ed82199e461178467195166f2c7738dec40632ac5de1
+  metadata.gz: 648c2bd8e7ef7f14c0bce4736ea47636c043a5ee1e529e676569c85f398b1380838631fab7146439162491523446ac40c112fb8247ca55402947d372b235f5c7
+  data.tar.gz: 11370dc255bf5e5508139480e4e9def8a51f145de3574c1f4dd17ad72572f1b64b30d0d876244426542b35d1e639d18662719f47137049d5aaac1fb6bdc7d5c6

data/lib/tapioca/commands/abstract_gem.rb

@@ -70,7 +70,7 @@ module Tapioca
           reason: "types exported from the `#{gem.name}` gem",
         ) if @file_header
 
-        rbi.root = Tapioca.with_disabled_exits do
+        rbi.root = Runtime.with_disabled_exits do
           Tapioca::Gem::Pipeline.new(
             gem,
             include_doc: @include_doc,

data/lib/tapioca/commands/command.rb

@@ -21,7 +21,7 @@ module Tapioca
       # @final
       #: -> void
       def run
-        Tapioca.silence_warnings do
+        Runtime.silence_warnings do
           execute
         end
       end

data/lib/tapioca/dsl/compilers/active_model_secure_password.rb

@@ -95,6 +95,12 @@ module Tapioca
           # @override
           #: -> T::Enumerable[Module]
           def gather_constants
+            # In some versions of Rails 8.1, `ActiveModel::SecurePassword` uses `Numeric#minutes`
+            # which isn't explicitly required in the gem, and it might not be loaded already.
+            # We might need to require it before referencing the constant to avoid a NoMethodError when
+            # the constant is autoloaded.
+            require "active_support/core_ext/numeric/time" unless defined?(1.minutes)
+
             # This selects all classes that are `ActiveModel::SecurePassword::ClassMethods === klass`.
             # In other words, we select all classes that have `ActiveModel::SecurePassword::ClassMethods`
             # as an ancestor of its singleton class, i.e. all classes that have extended the

data/lib/tapioca/dsl/compilers/active_record_enum.rb

@@ -13,7 +13,7 @@ module Tapioca
       #
       # ~~~rb
       # class Post < ApplicationRecord
-      #   enum title_type: %i(book all web), _suffix: :title
+      #   enum :title_type, %i(book all web), suffix: :title
       # end
       # ~~~
       #

data/lib/tapioca/dsl/compilers/active_record_relations.rb

@@ -229,15 +229,7 @@ module Tapioca
           use_ranges: ["T.untyped", "nil"],
         } #: Hash[Symbol, [String, String]]
         CALCULATION_METHODS = ActiveRecord::Calculations.instance_methods(false) #: Array[Symbol]
-        ENUMERABLE_QUERY_METHODS = [:any?, :many?, :none?, :one?] #: Array[Symbol]
-        FIND_OR_CREATE_METHODS = [
-          :find_or_create_by,
-          :find_or_create_by!,
-          :find_or_initialize_by,
-          :create_or_find_by,
-          :create_or_find_by!,
-        ] #: Array[Symbol]
-        BUILDER_METHODS = [:new, :create, :create!, :build] #: Array[Symbol]
+        RELATION_METHODS = ActiveRecord::Relation.instance_methods(false) #: Array[Symbol]
         TO_ARRAY_METHODS = [:to_ary, :to_a] #: Array[Symbol]
 
         private
@@ -907,61 +899,132 @@ module Tapioca
             end
           end
 
-          ENUMERABLE_QUERY_METHODS.each do |method_name|
-            block_type = "T.nilable(T.proc.params(record: #{constant_name}).returns(T.untyped))"
-            create_common_method(
-              method_name,
-              parameters: [
-                create_block_param("block", type: block_type),
-              ],
-              return_type: "T::Boolean",
-            )
-          end
+          RELATION_METHODS.each do |method_name|
+            case method_name
+            when :any?, :many?, :none?, :one? # enumerable query methods
+              block_type = "T.nilable(T.proc.params(record: #{constant_name}).returns(T.untyped))"
+              create_common_method(
+                method_name,
+                parameters: [
+                  create_block_param("block", type: block_type),
+                ],
+                return_type: "T::Boolean",
+              )
+            when :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :create_or_find_by, :create_or_find_by! # find or create methods
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_param("attributes")
+                method.add_block_param("block")
 
-          FIND_OR_CREATE_METHODS.each do |method_name|
-            common_relation_methods_module.create_method(method_name.to_s) do |method|
-              method.add_param("attributes")
-              method.add_block_param("block")
+                # `T.untyped` matches `T::Array[T.untyped]` so the array signature
+                # must be defined first for Sorbet to pick it, if valid.
+                method.add_sig do |sig|
+                  sig.add_param("attributes", "T::Array[T.untyped]")
+                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.return_type = "T::Array[#{constant_name}]"
+                end
 
-              # `T.untyped` matches `T::Array[T.untyped]` so the array signature
-              # must be defined first for Sorbet to pick it, if valid.
-              method.add_sig do |sig|
-                sig.add_param("attributes", "T::Array[T.untyped]")
-                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                sig.return_type = "T::Array[#{constant_name}]"
+                method.add_sig do |sig|
+                  sig.add_param("attributes", "T.untyped")
+                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.return_type = constant_name
+                end
               end
+            when :new, :create, :create!, :build # builder methods
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("attributes", "nil")
+                method.add_block_param("block")
 
-              method.add_sig do |sig|
-                sig.add_param("attributes", "T.untyped")
-                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                sig.return_type = constant_name
-              end
-            end
-          end
+                method.add_sig do |sig|
+                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.return_type = constant_name
+                end
 
-          BUILDER_METHODS.each do |method_name|
-            common_relation_methods_module.create_method(method_name.to_s) do |method|
-              method.add_opt_param("attributes", "nil")
-              method.add_block_param("block")
+                # `T.untyped` matches `T::Array[T.untyped]` so the array signature
+                # must be defined first for Sorbet to pick it, if valid.
+                method.add_sig do |sig|
+                  sig.add_param("attributes", "T::Array[T.untyped]")
+                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.return_type = "T::Array[#{constant_name}]"
+                end
 
-              method.add_sig do |sig|
-                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                sig.return_type = constant_name
+                method.add_sig do |sig|
+                  sig.add_param("attributes", "T.untyped")
+                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.return_type = constant_name
+                end
               end
+            when :insert_all, :insert_all!, :upsert_all # insert all methods
+              returning_type = "T.nilable(T.any(T::Array[Symbol], FalseClass))"
+              unique_by_type = "T.nilable(T.any(T::Array[Symbol], Symbol))"
 
-              # `T.untyped` matches `T::Array[T.untyped]` so the array signature
-              # must be defined first for Sorbet to pick it, if valid.
-              method.add_sig do |sig|
-                sig.add_param("attributes", "T::Array[T.untyped]")
-                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                sig.return_type = "T::Array[#{constant_name}]"
+              parameters = [
+                create_param("attributes", type: "T::Array[Hash]"),
+                create_kw_opt_param("returning", type: returning_type, default: "nil"),
+              ]
+
+              # Bang methods don't have the `unique_by` parameter
+              unless bang_method?(method_name)
+                parameters << create_kw_opt_param("unique_by", type: unique_by_type, default: "nil")
               end
 
-              method.add_sig do |sig|
-                sig.add_param("attributes", "T.untyped")
-                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                sig.return_type = constant_name
+              common_relation_methods_module.create_method(
+                method_name.to_s,
+                parameters: parameters,
+                return_type: "ActiveRecord::Result",
+              )
+            when :insert, :insert!, :upsert # insert methods
+              returning_type = "T.nilable(T.any(T::Array[Symbol], FalseClass))"
+              unique_by_type = "T.nilable(T.any(T::Array[Symbol], Symbol))"
+
+              parameters = [
+                create_param("attributes", type: "Hash"),
+                create_kw_opt_param("returning", type: returning_type, default: "nil"),
+              ]
+
+              # Bang methods don't have the `unique_by` parameter
+              unless bang_method?(method_name)
+                parameters << create_kw_opt_param("unique_by", type: unique_by_type, default: "nil")
               end
+
+              common_relation_methods_module.create_method(
+                method_name.to_s,
+                parameters: parameters,
+                return_type: "ActiveRecord::Result",
+              )
+            when :delete, :destroy
+              # For these cases, it is valid to pass the above kind of things, but also:
+              # - a model identifier, which can be:
+              #   - a numeric id, thus `Integer`
+              #   - a string id, thus `String`
+              # - a collection of identifiers
+              #   - a collection of identifiers, thus `T::Enumerable[T.any(Integer, String)]`
+              # which, coupled with the above case, gives us:
+              #   `T.any(Model, Integer, String, T::Enumerable[T.any(Model, Integer, String, T::Enumerable[Model])])`
+
+              common_relation_methods_module.create_method(
+                method_name.to_s,
+                parameters: [
+                  create_rest_param(
+                    "records",
+                    type: "T.any(#{constant_name}, Integer, String" \
+                      ", T::Enumerable[T.any(#{constant_name}, Integer, String, T::Enumerable[#{constant_name}])])",
+                  ),
+                ],
+                return_type: method_name == :delete ? "Integer" : "T::Array[#{constant_name}]",
+              )
+            when :delete_all, :destroy_all
+              common_relation_methods_module.create_method(
+                method_name.to_s,
+                return_type: method_name == :delete_all ? "Integer" : "T::Array[#{constant_name}]",
+              )
+            when :delete_by, :destroy_by
+              common_relation_methods_module.create_method(
+                method_name.to_s,
+                parameters: [
+                  create_param("args", type: "T.untyped"),
+                ],
+                return_type: method_name == :delete_by ? "Integer" : "T::Array[#{constant_name}]",
+              )
             end
           end
 

data/lib/tapioca/dsl/compilers/protobuf.rb

@@ -269,7 +269,11 @@ module Tapioca
               Field.new(
                 name: descriptor.name,
                 type: type,
-                init_type: "T.nilable(T.any(#{type}, T::Array[#{elem_type}]))",
+                # The FFI implementation accepts Enumerables:
+                # https://github.com/protocolbuffers/protobuf/blob/fc0eda1fd4eff075f1fb2e9249fa4209f0227e33/ruby/lib/google/protobuf/ffi/repeated_field.rb#L361-L366
+                # However the C implementation of the initializer specifically checks for Arrays:
+                # https://github.com/protocolbuffers/protobuf/blob/fc0eda1fd4eff075f1fb2e9249fa4209f0227e33/ruby/ext/google/protobuf_c/message.c#L568-L573
+                init_type: "T.nilable(T::Array[#{elem_type}])",
                 default: "T.unsafe(nil)",
               )
             end

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -152,8 +152,10 @@ module Tapioca
           when ActiveRecord::Type::Serialized
             serialized_column_type(column_type)
           when ->(type) {
-                 defined?(ActiveRecord::Normalization::NormalizedValueType) &&
-                   ActiveRecord::Normalization::NormalizedValueType === type
+                 (defined?(ActiveRecord::Normalization::NormalizedValueType) &&
+                   ActiveRecord::Normalization::NormalizedValueType === type) ||
+                   (defined?(ActiveModel::Attributes::Normalization::NormalizedValueType) &&
+                     ActiveModel::Attributes::Normalization::NormalizedValueType === type)
                }
             type_for_activerecord_value(column_type.cast_type, column_nullability:)
           when ->(type) {

data/lib/tapioca/helpers/test/content.rb

@@ -28,7 +28,7 @@ module Tapioca
         #: (String name, String content, ?require_file: bool) -> String
         def add_ruby_file(name, content, require_file: true)
           add_content_file(name, content).tap do |file_name|
-            Tapioca.silence_warnings { require(file_name) } if require_file
+            Runtime.silence_warnings { require(file_name) } if require_file
           end
         end
 

data/lib/tapioca/internal.rb

@@ -4,6 +4,7 @@
 require "set"
 
 require "tapioca"
+require "tapioca/runtime/helpers"
 require "tapioca/runtime/reflection"
 require "tapioca/runtime/trackers"
 

data/lib/tapioca/loaders/gem.rb

@@ -47,7 +47,7 @@ module Tapioca
 
         bundle_loaded = true #: bool
 
-        Tapioca.with_disabled_exits do
+        Runtime.with_disabled_exits do
           load_bundle(@bundle, @prerequire, @postrequire, @halt_upon_load_error)
         rescue LoadError => e
           bundle_loaded = false

data/lib/tapioca/runtime/helpers.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Runtime
+    NOOP_METHOD = ->(*_args, **_kwargs, &_block) {} #: ^() -> void
+    private_constant :NOOP_METHOD
+
+    class << self
+      #: [Result] { -> Result } -> Result
+      def silence_warnings(&blk)
+        original_verbosity = $VERBOSE
+        $VERBOSE = nil
+        ::Gem::DefaultUserInteraction.use_ui(::Gem::SilentUI.new) do
+          blk.call
+        end
+      ensure
+        $VERBOSE = original_verbosity
+      end
+
+      #: [Result] { -> Result } -> Result
+      def with_disabled_exits(&block)
+        original_abort = Kernel.instance_method(:abort)
+        original_exit = Kernel.instance_method(:exit)
+
+        begin
+          Kernel.define_method(:abort, NOOP_METHOD)
+          Kernel.define_method(:exit, NOOP_METHOD)
+
+          silence_warnings do
+            block.call
+          end
+        ensure
+          Kernel.define_method(:exit, original_exit)
+          Kernel.define_method(:abort, original_abort)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/runtime/trackers/autoload.rb

@@ -15,7 +15,7 @@ module Tapioca
 
           #: -> void
           def eager_load_all!
-            Tapioca.with_disabled_exits do
+            Runtime.with_disabled_exits do
               until @constant_names_registered_for_autoload.empty?
                 # Grab the next constant name
                 constant_name = T.must(@constant_names_registered_for_autoload.shift)

data/lib/tapioca/runtime/trackers/required_ancestor.rb

@@ -52,7 +52,7 @@ end
 
 module T
   module Helpers
-    prepend(Module.new do
+    prepend(::Module.new do
       def requires_ancestor(&block)
         # We can't directly call the block since the ancestor might not be loaded yet.
         # We save the block in the map and will resolve it later.

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -22,7 +22,7 @@ module T
         # `T::Generic#type_member` just instantiates a `T::Type::TypeMember` instance and returns it.
         # We use that when registering the type member and then later return it from this method.
         Tapioca::TypeVariableModule.new(
-          T.cast(self, Module),
+          T.cast(self, ::Module),
           Tapioca::TypeVariableModule::Type::Member,
           variance,
           bounds_proc,
@@ -35,7 +35,7 @@ module T
         # `T::Generic#type_template` just instantiates a `T::Type::TypeTemplate` instance and returns it.
         # We use that when registering the type template and then later return it from this method.
         Tapioca::TypeVariableModule.new(
-          T.cast(self, Module),
+          T.cast(self, ::Module),
           Tapioca::TypeVariableModule::Type::Template,
           variance,
           bounds_proc,
@@ -48,7 +48,7 @@ module T
         Tapioca::Runtime::GenericTypeRegistry.register_type_variable(
           self,
           Tapioca::TypeVariableModule.new(
-            T.cast(self, Module),
+            T.cast(self, ::Module),
             Tapioca::TypeVariableModule::Type::HasAttachedClass,
             variance,
             bounds_proc,

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -5,24 +5,13 @@ module T
   module Types
     class Simple
       module NamePatch
-        NAME_METHOD = Module.instance_method(:name) #: UnboundMethod
-
         def name
           # Sorbet memoizes this method into the `@name` instance variable but
           # doing so means that types get memoized before this patch is applied
-          qualified_name_of(@raw_type)
-        end
-
-        def qualified_name_of(constant)
-          name = NAME_METHOD.bind_call(constant)
-          name = nil if name&.start_with?("#<")
-          return "::T.untyped" if name.nil?
+          name = Tapioca::Runtime::Reflection.qualified_name_of(@raw_type)
+          name = "::T.untyped" if name.nil?
 
-          if name.start_with?("::")
-            name
-          else
-            "::#{name}"
-          end
+          name
         end
       end
 

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.17.8"
+  VERSION = "0.17.9"
 end

data/lib/tapioca.rb

@@ -9,42 +9,6 @@ module Tapioca
 
   @traces = [] #: Array[TracePoint]
 
-  NOOP_METHOD = ->(*_args, **_kwargs, &_block) {} #: ^() -> void
-  private_constant :NOOP_METHOD
-
-  class << self
-    extend T::Sig
-
-    #: [Result] { -> Result } -> Result
-    def silence_warnings(&blk)
-      original_verbosity = $VERBOSE
-      $VERBOSE = nil
-      ::Gem::DefaultUserInteraction.use_ui(::Gem::SilentUI.new) do
-        blk.call
-      end
-    ensure
-      $VERBOSE = original_verbosity
-    end
-
-    #: [Result] { -> Result } -> Result
-    def with_disabled_exits(&block)
-      original_abort = Kernel.instance_method(:abort)
-      original_exit = Kernel.instance_method(:exit)
-
-      begin
-        Kernel.define_method(:abort, NOOP_METHOD)
-        Kernel.define_method(:exit, NOOP_METHOD)
-
-        Tapioca.silence_warnings do
-          block.call
-        end
-      ensure
-        Kernel.define_method(:exit, original_exit)
-        Kernel.define_method(:abort, original_abort)
-      end
-    end
-  end
-
   class Error < StandardError; end
 
   LIB_ROOT_DIR = T.must(__dir__) #: String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.17.8
+  version: 0.17.9
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -69,89 +69,89 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.21.0
 - !ruby/object:Gem::Dependency
-  name: rbi
+  name: require-hooks
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
-  name: require-hooks
+  name: sorbet-static-and-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.5.11087
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.5.11087
 - !ruby/object:Gem::Dependency
-  name: sorbet-static-and-runtime
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.11087
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.11087
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
-  name: spoom
+  name: yard-sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: rbi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 0.3.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 0.3.7
 - !ruby/object:Gem::Dependency
-  name: yard-sorbet
+  name: spoom
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.7.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.7.9
 email:
 - ruby@shopify.com
 executables:
@@ -280,6 +280,7 @@ files:
 - lib/tapioca/runtime/attached_class_of_legacy.rb
 - lib/tapioca/runtime/dynamic_mixin_compiler.rb
 - lib/tapioca/runtime/generic_type_registry.rb
+- lib/tapioca/runtime/helpers.rb
 - lib/tapioca/runtime/reflection.rb
 - lib/tapioca/runtime/source_location.rb
 - lib/tapioca/runtime/trackers.rb