tapioca 0.11.13 → 0.11.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 071fd87cab365673ec36e85a0cf657865d2c71d1650d02ae7c17ac3133f124f3
-  data.tar.gz: 34a3b5e83928cb38eefbf57568ca8dc5d16c20ee6653da2ee591d6e3265d8d2a
+  metadata.gz: 4f089694c098df2b42355826c7622448368a7f766bd44de3cd2ece4242ebc0fa
+  data.tar.gz: 0140650be1098b51150d5a74fac1f349e9a8da6400fcc5ad3ed1e0da84fb7a91
 SHA512:
-  metadata.gz: d97568a53647ceb3fe4e7bfd33dc3503cb95d8c95791dc0c0bf8429f9974c4a39d5d5e5aca16251ae866a07761f00ddbd5a224925b11c4a8378f682fd4deef1c
-  data.tar.gz: f44cccf226efaa3b0ccda730daf3419acb3cdcaeec7c699c91ba9e2f8b4fe59a7e157331afff1723f69f09ff2fc3ff5a208222b2eb86c1738806170578a3ec2b
+  metadata.gz: 95bbca796e14a6af94dbbaa9f15a3cd15c46d414472b03385ab7ff6b8ab495ba885ee362e7349bbdc7ed0c60639d22fb2db52e0d901faab582fca96a93dfd408
+  data.tar.gz: 179e7b4ef4c30819d7a3e1c3cb856b800ffc17c63d20419341002b4273b56c9cec2d9d06e03d28678275ac2c9e8e82030f7cfb2d8f5bf4bdc99ead5e361d001a

data/lib/tapioca/dsl/compiler.rb

@@ -36,7 +36,7 @@ module Tapioca
         sig { returns(T::Set[Module]) }
         def processable_constants
           @processable_constants ||= T.let(
-            T::Set[Module].new(gather_constants).compare_by_identity,
+            T::Set[Module].new.compare_by_identity.merge(gather_constants),
             T.nilable(T::Set[Module]),
           )
         end

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

@@ -30,8 +30,13 @@ module Tapioca
       # # notify_user_job.rbi
       # # typed: true
       # class NotifyUserJob
-      #   sig { params(user: User).returns(T.any(NotifyUserJob, FalseClass)) }
-      #   def self.perform_later(user); end
+      #   sig do
+      #     params(
+      #       user: User,
+      #       block: T.nilable(T.proc.params(job: NotifyUserJob).void),
+      #     ).returns(T.any(NotifyUserJob, FalseClass))
+      #   end
+      #   def self.perform_later(user, &block); end
       #
       #   sig { params(user: User).returns(Mail) }
       #   def self.perform_now(user); end
@@ -48,13 +53,14 @@ module Tapioca
 
           root.create_path(constant) do |job|
             method = constant.instance_method(:perform)
+            constant_name = name_of(constant)
             parameters = compile_method_parameters_to_rbi(method)
             return_type = compile_method_return_type_to_rbi(method)
 
             job.create_method(
               "perform_later",
-              parameters: parameters,
-              return_type: "T.any(#{name_of(constant)}, FalseClass)",
+              parameters: perform_later_parameters(parameters, constant_name),
+              return_type: "T.any(#{constant_name}, FalseClass)",
               class_method: true,
             )
 
@@ -67,6 +73,25 @@ module Tapioca
           end
         end
 
+        private
+
+        sig do
+          params(
+            parameters: T::Array[RBI::TypedParam],
+            constant_name: T.nilable(String),
+          ).returns(T::Array[RBI::TypedParam])
+        end
+        def perform_later_parameters(parameters, constant_name)
+          if ::Gem::Requirement.new(">= 7.0").satisfied_by?(::ActiveJob.gem_version)
+            parameters + [create_block_param(
+              "block",
+              type: "T.nilable(T.proc.params(job: #{constant_name}).void)",
+            )]
+          else
+            parameters
+          end
+        end
+
         class << self
           extend T::Sig
 

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

@@ -72,9 +72,9 @@ module Tapioca
         def attribute_methods_for_constant
           patterns = if constant.respond_to?(:attribute_method_patterns)
             # https://github.com/rails/rails/pull/44367
-            T.unsafe(constant).attribute_method_patterns
+            constant.attribute_method_patterns
           else
-            constant.attribute_method_matchers
+            T.unsafe(constant).attribute_method_matchers
           end
           patterns.flat_map do |pattern|
             constant.attribute_types.filter_map do |name, value|
@@ -101,8 +101,13 @@ module Tapioca
           HANDLED_METHOD_TARGETS.include?(target.to_s)
         end
 
-        sig { params(attribute_type_value: ::ActiveModel::Type::Value).returns(::String) }
+        sig { params(attribute_type_value: T.untyped).returns(::String) }
         def type_for(attribute_type_value)
+          # This guarantees that the type will remain as T.untyped for attributes in the following form:
+          # attribute :name
+          # This is because for a generic attribute with no specified type, ActiveModel::Type::Value.new is returned
+          return "T.untyped" if attribute_type_value.instance_of?(ActiveModel::Type::Value)
+
           type = case attribute_type_value
           when ActiveModel::Type::Boolean
             "T::Boolean"
@@ -119,8 +124,7 @@ module Tapioca
           when ActiveModel::Type::String
             "::String"
           else
-            # we don't want untyped to be wrapped by T.nilable, so just return early
-            return "T.untyped"
+            attribute_type_value.class.name.to_s
           end
 
           as_nilable_type(type)

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

@@ -108,6 +108,11 @@ module Tapioca
         def decorate
           return unless constant.table_exists?
 
+          # We need to call this to ensure that some attribute aliases are defined, e.g.
+          # `id_value` as an alias for `id`.
+          # I think this is a regression on Rails 7.1, but we are where we are.
+          constant.define_attribute_methods
+
           root.create_path(constant) do |model|
             model.create_module(AttributeMethodsModuleName) do |mod|
               (constant.attribute_names + ["id"]).uniq.each do |attribute_name|
@@ -119,9 +124,9 @@ module Tapioca
                 column_name = column_name.to_s
                 patterns = if constant.respond_to?(:attribute_method_patterns)
                   # https://github.com/rails/rails/pull/44367
-                  T.unsafe(constant).attribute_method_patterns
+                  constant.attribute_method_patterns
                 else
-                  constant.attribute_method_matchers
+                  T.unsafe(constant).attribute_method_matchers
                 end
                 new_method_names = patterns.map { |m| m.method_name(attribute_name) }
                 old_method_names = patterns.map { |m| m.method_name(column_name) }

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

@@ -110,11 +110,10 @@ module Tapioca
             return_type: "ActiveSupport::StringInquirer",
           )
 
-          return_type = sorbet_supports?(:generic_class) ? "T::Class[T.anything]" : "Class"
           mod.create_method(
             "#{role}_class",
             parameters: [],
-            return_type: return_type,
+            return_type: "T::Class[T.anything]",
           )
 
           mod.create_method(

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

@@ -76,7 +76,12 @@ module Tapioca
             Class.new do
               T.unsafe(self).include(ActiveRecord::TestFixtures)
 
-              T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+              if respond_to?(:fixture_paths=)
+                T.unsafe(self).fixture_paths = [Rails.root.join("test", "fixtures")]
+              else
+                T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+              end
+
               # https://github.com/rails/rails/blob/7c70791470fc517deb7c640bead9f1b47efb5539/activerecord/lib/active_record/test_fixtures.rb#L46
               singleton_class.define_method(:file_fixture_path) do
                 Rails.root.join("test", "fixtures", "files")

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

@@ -55,7 +55,7 @@ module Tapioca
           root.create_path(constant) do |input_object|
             arguments.each do |argument|
               name = argument.keyword.to_s
-              input_object.create_method(name, return_type: Helpers::GraphqlTypeHelper.type_for(argument))
+              input_object.create_method(name, return_type: Helpers::GraphqlTypeHelper.type_for(argument, constant))
             end
           end
         end

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

@@ -59,7 +59,7 @@ module Tapioca
           params = compile_method_parameters_to_rbi(method_def).map do |param|
             name = param.param.name
             argument = arguments_by_name.fetch(name, nil)
-            create_typed_param(param.param, argument_type(argument))
+            create_typed_param(param.param, argument_type(argument, constant))
           end
 
           root.create_path(constant) do |mutation|
@@ -67,11 +67,16 @@ module Tapioca
           end
         end
 
-        sig { params(argument: T.nilable(GraphQL::Schema::Argument)).returns(String) }
-        def argument_type(argument)
+        sig do
+          params(
+            argument: T.nilable(GraphQL::Schema::Argument),
+            constant: T.class_of(GraphQL::Schema::Mutation),
+          ).returns(String)
+        end
+        def argument_type(argument, constant)
           return "T.untyped" unless argument
 
-          Helpers::GraphqlTypeHelper.type_for(argument)
+          Helpers::GraphqlTypeHelper.type_for(argument, constant)
         end
 
         class << self

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

@@ -9,8 +9,13 @@ module Tapioca
 
         extend T::Sig
 
-        sig { params(argument: GraphQL::Schema::Argument).returns(String) }
-        def type_for(argument)
+        sig do
+          params(
+            argument: GraphQL::Schema::Argument,
+            constant: T.any(T.class_of(GraphQL::Schema::Mutation), T.class_of(GraphQL::Schema::InputObject)),
+          ).returns(String)
+        end
+        def type_for(argument, constant)
           type = if argument.loads
             loads_type = ::GraphQL::Schema::Wrapper.new(argument.loads)
             loads_type = loads_type.to_list_type if argument.type.list?
@@ -60,6 +65,17 @@ module Tapioca
             "T.untyped"
           end
 
+          if argument.prepare.is_a?(Symbol) || argument.prepare.is_a?(String)
+            if constant.respond_to?(argument.prepare)
+              prepare_method = constant.method(argument.prepare)
+              prepare_signature = Runtime::Reflection.signature_of(prepare_method)
+
+              if valid_return_type?(prepare_signature&.return_type)
+                parsed_type = prepare_signature.return_type&.to_s
+              end
+            end
+          end
+
           if type.list?
             parsed_type = "T::Array[#{parsed_type}]"
           end
@@ -77,6 +93,7 @@ module Tapioca
         def type_for_constant(constant)
           if constant.instance_methods.include?(:prepare)
             prepare_method = constant.instance_method(:prepare)
+
             prepare_signature = Runtime::Reflection.signature_of(prepare_method)
 
             return prepare_signature.return_type&.to_s if valid_return_type?(prepare_signature&.return_type)

data/lib/tapioca/dsl/pipeline.rb

@@ -130,7 +130,10 @@ module Tapioca
 
       sig { params(requested_constants: T::Array[Module], requested_paths: T::Array[Pathname]).returns(T::Set[Module]) }
       def gather_constants(requested_constants, requested_paths)
-        constants = active_compilers.map(&:processable_constants).reduce(Set.new, :union)
+        constants = Set.new.compare_by_identity
+        active_compilers.each do |compiler|
+          constants.merge(compiler.processable_constants)
+        end
         constants = filter_anonymous_and_reloaded_constants(constants)
 
         constants &= requested_constants unless requested_constants.empty? && requested_paths.empty?
@@ -158,11 +161,12 @@ module Tapioca
 
         # Look up all the constants back from their names. The resulting constant set will be the
         # set of constants that are actually in memory with those names.
-        constants_by_name
+        filtered_constants = constants_by_name
           .keys
           .map { |name| T.cast(Runtime::Reflection.constantize(name), Module) }
           .select { |mod| Runtime::Reflection.constant_defined?(mod) }
-          .to_set
+
+        Set.new.compare_by_identity.merge(filtered_constants)
       end
 
       sig { params(constant: Module).returns(T.nilable(RBI::File)) }

data/lib/tapioca/gem/listeners/methods.rb

@@ -97,12 +97,11 @@ module Tapioca
               # method and the parameter is required and there is a single
               # parameter and the signature also defines a single parameter and
               # the name of the method ends with a = character.
-              writer_method_with_sig = (
+              writer_method_with_sig =
                 signature && type == :req &&
                 parameters.size == 1 &&
                 signature.arg_types.size == 1 &&
                 method_name[-1] == "="
-              )
 
               if writer_method_with_sig
                 method_name.delete_suffix("=")

data/lib/tapioca/gem/listeners/sorbet_signatures.rb

@@ -67,8 +67,9 @@ module Tapioca
         sig { params(signature: T.untyped).returns(T::Boolean) }
         def signature_final?(signature)
           modules_with_final = T::Private::Methods.instance_variable_get(:@modules_with_final)
-          final_methods = modules_with_final[signature.owner.object_id]
-
+          # In https://github.com/sorbet/sorbet/pull/7531, Sorbet changed internal hashes to be compared by identity,
+          # starting on version 0.5.11155
+          final_methods = modules_with_final[signature.owner] || modules_with_final[signature.owner.object_id]
           return false unless final_methods
 
           final_methods.include?(signature.method_name)

data/lib/tapioca/gem/pipeline.rb

@@ -271,9 +271,7 @@ module Tapioca
 
         klass = class_of(value)
 
-        klass_name = if klass == ObjectSpace::WeakMap
-          sorbet_supports?(:non_generic_weak_map) ? "ObjectSpace::WeakMap" : "ObjectSpace::WeakMap[T.untyped]"
-        elsif T::Generic === klass
+        klass_name = if T::Generic === klass
           generic_name_of(klass)
         else
           name_of(klass)

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -24,8 +24,6 @@ module Tapioca
     FEATURE_REQUIREMENTS = T.let(
       {
         # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
-        non_generic_weak_map: ::Gem::Requirement.new(">= 0.5.10587"), # https://github.com/sorbet/sorbet/pull/6610
-        generic_class: ::Gem::Requirement.new(">= 0.5.10820"), # https://github.com/sorbet/sorbet/pull/6781
       }.freeze,
       T::Hash[Symbol, ::Gem::Requirement],
     )

data/lib/tapioca/internal.rb

@@ -32,7 +32,6 @@ require "tapioca/helpers/git_attributes"
 require "tapioca/helpers/sorbet_helper"
 require "tapioca/helpers/rbi_helper"
 require "tapioca/sorbet_ext/backcompat_patches"
-require "tapioca/sorbet_ext/fixed_hash_patch"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/proc_bind_patch"

data/lib/tapioca/sorbet_ext/backcompat_patches.rb

@@ -1,24 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-unless defined?(T.anything)
-  module T
-    class << self
-      def anything
-        T.untyped
-      end
-    end
-  end
-end
+# This file contains patches to make Tapioca work with older versions of Sorbet.
 
-unless defined?(T::Class)
-  module T
-    module Class
-      class << self
-        def [](type)
-          T.untyped
-        end
-      end
-    end
-  end
-end
+# NOTE: If there is currently no need for any patches, this file will be empty.

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -18,32 +18,26 @@ module T
         Tapioca::Runtime::GenericTypeRegistry.register_type(constant, types)
       end
 
-      def type_member(variance = :invariant, fixed: nil, lower: nil, upper: nil, &bounds_proc)
+      def type_member(variance = :invariant, &bounds_proc)
         # `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),
           Tapioca::TypeVariableModule::Type::Member,
           variance,
-          fixed,
-          lower,
-          upper,
           bounds_proc,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
       end
 
-      def type_template(variance = :invariant, fixed: nil, lower: nil, upper: nil, &bounds_proc)
+      def type_template(variance = :invariant, &bounds_proc)
         # `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),
           Tapioca::TypeVariableModule::Type::Template,
           variance,
-          fixed,
-          lower,
-          upper,
           bounds_proc,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
@@ -57,9 +51,6 @@ module T
             T.cast(self, Module),
             Tapioca::TypeVariableModule::Type::HasAttachedClass,
             variance,
-            nil,
-            nil,
-            nil,
             bounds_proc,
           ),
         )
@@ -93,29 +84,9 @@ module T
   end
 
   module Utils
-    # This duplication is required to preserve backwards compatibility with sorbet-runtime versions prior to the
-    # introduction of the `Private` module in https://github.com/sorbet/sorbet/pull/6559.
-    if defined?(T::Utils::Private)
-      module Private
-        module PrivateCoercePatch
-          def coerce_and_check_module_types(val, check_val, check_module_type)
-            if val.is_a?(Tapioca::TypeVariableModule)
-              val.coerce_to_type_variable
-            elsif val.respond_to?(:__tapioca_override_type)
-              val.__tapioca_override_type
-            else
-              super
-            end
-          end
-        end
-
-        class << self
-          prepend(PrivateCoercePatch)
-        end
-      end
-    else
-      module CoercePatch
-        def coerce(val)
+    module Private
+      module PrivateCoercePatch
+        def coerce_and_check_module_types(val, check_val, check_module_type)
           if val.is_a?(Tapioca::TypeVariableModule)
             val.coerce_to_type_variable
           elsif val.respond_to?(:__tapioca_override_type)
@@ -127,7 +98,7 @@ module T
       end
 
       class << self
-        prepend(CoercePatch)
+        prepend(PrivateCoercePatch)
       end
     end
   end
@@ -159,35 +130,27 @@ module Tapioca
       end
     end
 
+    DEFAULT_BOUNDS_PROC = T.let(-> { {} }, T.proc.returns(T::Hash[Symbol, T.untyped]))
+
     sig { returns(Type) }
     attr_reader :type
 
-    # rubocop:disable Metrics/ParameterLists
     sig do
       params(
         context: Module,
         type: Type,
         variance: Symbol,
-        fixed: T.untyped,
-        lower: T.untyped,
-        upper: T.untyped,
         bounds_proc: T.nilable(T.proc.returns(T::Hash[Symbol, T.untyped])),
       ).void
     end
-    def initialize(context, type, variance, fixed, lower, upper, bounds_proc)
+    def initialize(context, type, variance, bounds_proc)
       @context = context
       @type = type
       @variance = variance
-      @bounds_proc = if bounds_proc
-        bounds_proc
-      else
-        build_bounds_proc(fixed, lower, upper)
-      end
+      @bounds_proc = bounds_proc || DEFAULT_BOUNDS_PROC
 
       super()
     end
-    # rubocop:enable Metrics/ParameterLists
-
     sig { returns(T.nilable(String)) }
     def name
       constant_name = super
@@ -221,19 +184,6 @@ module Tapioca
 
     private
 
-    sig do
-      params(fixed: T.untyped, lower: T.untyped, upper: T.untyped)
-        .returns(T.proc.returns(T::Hash[Symbol, T.untyped]))
-    end
-    def build_bounds_proc(fixed, lower, upper)
-      bounds = {}
-      bounds[:fixed] = fixed unless fixed.nil?
-      bounds[:lower] = lower unless lower.nil?
-      bounds[:upper] = upper unless upper.nil?
-
-      -> { bounds }
-    end
-
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def bounds
       @bounds ||= @bounds_proc.call

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.11.13
+  version: 0.11.15
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-06 00:00:00.000000000 Z
+date: 2024-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,14 +81,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.10187
+        version: 0.5.10820
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.10187
+        version: 0.5.10820
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
@@ -265,7 +265,6 @@ files:
 - lib/tapioca/runtime/trackers/required_ancestor.rb
 - lib/tapioca/runtime/trackers/tracker.rb
 - lib/tapioca/sorbet_ext/backcompat_patches.rb
-- lib/tapioca/sorbet_ext/fixed_hash_patch.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
 - lib/tapioca/sorbet_ext/proc_bind_patch.rb
@@ -293,7 +292,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.4
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard

data/lib/tapioca/sorbet_ext/fixed_hash_patch.rb

@@ -1,20 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module T
-  module Types
-    class FixedHash
-      def name
-        entries = @types.map do |(k, v)|
-          if Symbol === k && ":#{k}" == k.inspect
-            "#{k}: #{v}"
-          else
-            "#{k.inspect} => #{v}"
-          end
-        end
-
-        "{#{entries.join(", ")}}"
-      end
-    end
-  end
-end