tapioca 0.10.3 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c5b81fee880c497fca1e34c644d6da53e4f155e45f564c95eb886f0f6c30d69
-  data.tar.gz: d0973ab750b577064e5891c0fbd9dd71ddeb82b54d7d8dfcabad4841052e8d6d
+  metadata.gz: bbed9bfddb52a94735d9455ed4351c4ef1389236ceba2e19ce46d999a05536b0
+  data.tar.gz: b1a35528c1e9cfa5fd735a64d4988bfd72c0f980835d58e4a37c62d5694e3daa
 SHA512:
-  metadata.gz: 105ab9194d3e62657fedff6d0fd78b187980b5084af80be294690c00a86ac1544b29bd9d86951f50072c895516ce1541251ac2ff05cbb3a2acbbee5d0e103b51
-  data.tar.gz: 612f856fd4b36301dbfee4cdd80615ee4a684447ea077037c5a72e1c7c216be7c465aae13a5b4462a8db9889929765703293d2935036d7ac1e94b8d21d4ee5fb
+  metadata.gz: 6138060ec0cea66dda6f96484329626d613494404cf99f851d1dbd59249546ffdfa0b0dd58236ef63d65b93acd250eb3a46b5a3eb1a3f8491014125b18a50800
+  data.tar.gz: 266205a5dd212e87836d1d26f1f018ab83d64aaacc9b793e9a01b88c6213bda834991194896a602ce6f267ef96e3ef8f78d14464005cefcfc010bb666ddc6f3e

data/exe/tapioca

@@ -3,19 +3,21 @@
 
 require "sorbet-runtime"
 
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*) {}
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
+unless ENV["ENFORCE_TYPECHECKING"] == "1"
+  begin
+    T::Configuration.default_checked_level = :never
+    # Suppresses call validation errors
+    T::Configuration.call_validation_error_handler = ->(*) {}
+    # Suppresses errors caused by T.cast, T.let, T.must, etc.
+    T::Configuration.inline_type_error_handler = ->(*) {}
+    # Suppresses errors caused by incorrect parameter ordering
+    T::Configuration.sig_validation_error_handler = ->(*) {}
+  rescue
+    # Need this rescue so that if another gem has
+    # already set the checked level by the time we
+    # get to it, we don't fail outright.
+    nil
+  end
 end
 
 require_relative "../lib/tapioca/internal"

data/lib/tapioca/commands/configure.rb

@@ -70,7 +70,7 @@ module Tapioca
           # typed: true
           # frozen_string_literal: true
 
-          # Add your extra requires here (`#{default_command(:require)}` can be used to boostrap this list)
+          # Add your extra requires here (`#{default_command(:require)}` can be used to bootstrap this list)
         CONTENT
       end
 
@@ -92,7 +92,7 @@ module Tapioca
         @installer ||= Bundler::Installer.new(Bundler.root, Bundler.definition)
       end
 
-      sig { returns(Bundler::StubSpecification) }
+      sig { returns(T.any(Bundler::StubSpecification, ::Gem::Specification)) }
       def spec
         @spec ||= Bundler.definition.specs.find { |s| s.name == "tapioca" }
       end

data/lib/tapioca/dsl/compiler.rb

@@ -101,6 +101,9 @@ module Tapioca
         # rest parameter type
         params << signature.rest_type.to_s if signature.has_rest
 
+        # keyrest parameter type
+        params << signature.keyrest_type.to_s if signature.has_keyrest
+
         # special case `.void` in a proc
         unless signature.block_name.nil?
           params << signature.block_type.to_s.gsub("returns(<VOID>)", "void")
@@ -159,10 +162,7 @@ module Tapioca
       def compile_method_return_type_to_rbi(method_def)
         signature = signature_of(method_def)
         return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)
-        return_type = "void" if return_type == "<VOID>"
-        # Map <NOT-TYPED> to `T.untyped`
-        return_type = "T.untyped" if return_type == "<NOT-TYPED>"
-        return_type
+        sanitize_signature_types(return_type)
       end
     end
   end

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

@@ -0,0 +1,163 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+require "tapioca/dsl/helpers/active_record_column_type_helper"
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::DelegatedTypes` defines RBI files for subclasses of
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This compiler is only responsible for defining the methods that would be created for delegated_types that
+      # are defined in the Active Record model.
+      #
+      # For example, with the following model class:
+      #
+      # ~~~rb
+      # class Entry < ActiveRecord::Base
+      #   delegated_type :entryable, types: %w[ Message Comment ]
+      # end
+      # ~~~
+      #
+      # this compiler will produce the following methods in the RBI file
+      # `entry.rbi`:
+      #
+      # ~~~rbi
+      # # entry.rbi
+      # # typed: true
+      #
+      # class Entry
+      #   include GeneratedDelegatedTypeMethods
+      #
+      #   module GeneratedDelegatedTypeMethods
+      #     sig { params(args: T.untyped).returns(T.any(Message, Comment)) }
+      #     def build_entryable(*args); end
+      #
+      #     sig { returns(Class) }
+      #     def entryable_class; end
+      #
+      #     sig { returns(ActiveSupport::StringInquirer) }
+      #     def entryable_name; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def message?; end
+      #
+      #     sig { returns(T.nilable(Message)) }
+      #     def message; end
+      #
+      #     sig { returns(T.nilable(Integer)) }
+      #     def message_id; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def comment?; end
+      #
+      #     sig { returns(T.nilable(Comment)) }
+      #     def comment; end
+      #
+      #     sig { returns(T.nilable(Integer)) }
+      #     def comment_id; end
+      #   end
+      # end
+      #
+      # ~~~
+      class ActiveRecordDelegatedTypes < Compiler
+        extend T::Sig
+        include Helpers::ActiveRecordConstantsHelper
+
+        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
+
+        sig { override.void }
+        def decorate
+          return if constant.__tapioca_delegated_types.nil?
+
+          root.create_path(constant) do |model|
+            model.create_module(DelegatedTypesModuleName) do |mod|
+              constant.__tapioca_delegated_types.each do |role, data|
+                types = data.fetch(:types)
+                options = data.fetch(:options, {})
+                populate_role_accessors(mod, role, types)
+                populate_type_helpers(mod, role, types, options)
+              end
+            end
+
+            model.create_include(DelegatedTypesModuleName)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          end
+        end
+
+        private
+
+        sig { params(mod: RBI::Scope, role: Symbol, types: T::Array[String]).void }
+        def populate_role_accessors(mod, role, types)
+          mod.create_method(
+            "#{role}_name",
+            parameters: [],
+            return_type: "ActiveSupport::StringInquirer",
+          )
+
+          mod.create_method(
+            "#{role}_class",
+            parameters: [],
+            return_type: "Class",
+          )
+
+          mod.create_method(
+            "build_#{role}",
+            parameters: [create_rest_param("args", type: "T.untyped")],
+            return_type: "T.any(#{types.join(", ")})",
+          )
+        end
+
+        sig { params(mod: RBI::Scope, role: Symbol, types: T::Array[String], options: T::Hash[Symbol, T.untyped]).void }
+        def populate_type_helpers(mod, role, types, options)
+          types.each do |type|
+            populate_type_helper(mod, role, type, options)
+          end
+        end
+
+        sig { params(mod: RBI::Scope, role: Symbol, type: String, options: T::Hash[Symbol, T.untyped]).void }
+        def populate_type_helper(mod, role, type, options)
+          singular   = type.tableize.tr("/", "_").singularize
+          query      = "#{singular}?"
+          primary_key = options[:primary_key] || "id"
+          role_id = options[:foreign_key] || "#{role}_id"
+
+          getter_type, _ = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(role_id.to_s)
+
+          mod.create_method(
+            query,
+            parameters: [],
+            return_type: "T::Boolean",
+          )
+
+          mod.create_method(
+            singular,
+            parameters: [],
+            return_type: "T.nilable(#{type})",
+          )
+
+          mod.create_method(
+            "#{singular}_#{primary_key}",
+            parameters: [],
+            return_type: as_nilable_type(getter_type),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -217,6 +217,7 @@ module Tapioca
           T::Array[Symbol],
         )
         FINDER_METHODS = T.let(ActiveRecord::FinderMethods.instance_methods(false), T::Array[Symbol])
+        SIGNED_FINDER_METHODS = T.let(ActiveRecord::SignedId::ClassMethods.instance_methods(false), T::Array[Symbol])
         CALCULATION_METHODS = T.let(ActiveRecord::Calculations.instance_methods(false), T::Array[Symbol])
         ENUMERABLE_QUERY_METHODS = T.let([:any?, :many?, :none?, :one?], T::Array[Symbol])
         FIND_OR_CREATE_METHODS = T.let(
@@ -593,6 +594,31 @@ module Tapioca
             end
           end
 
+          SIGNED_FINDER_METHODS.each do |method_name|
+            case method_name
+            when :find_signed
+              create_common_method(
+                "find_signed",
+                common_relation_methods_module,
+                parameters: [
+                  create_param("signed_id", type: "T.untyped"),
+                  create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
+                ],
+                return_type: as_nilable_type(constant_name),
+              )
+            when :find_signed!
+              create_common_method(
+                "find_signed!",
+                common_relation_methods_module,
+                parameters: [
+                  create_param("signed_id", type: "T.untyped"),
+                  create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
+                ],
+                return_type: constant_name,
+              )
+            end
+          end
+
           CALCULATION_METHODS.each do |method_name|
             case method_name
             when :average, :maximum, :minimum

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

@@ -284,6 +284,11 @@ module Tapioca
             return_type: "void",
           )
 
+          klass.create_method(
+            "clear_#{field.name}",
+            return_type: "void",
+          )
+
           field
         end
 

data/lib/tapioca/dsl/extensions/active_record.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      module Extensions
+        module ActiveRecord
+          attr_reader :__tapioca_delegated_types
+
+          def delegated_type(role, types:, **options)
+            @__tapioca_delegated_types ||= {}
+            @__tapioca_delegated_types[role] = { types: types, options: options }
+
+            super
+          end
+
+          ::ActiveRecord::Base.singleton_class.prepend(self)
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,7 @@ module Tapioca
 
         AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
         AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
+        DelegatedTypesModuleName = T.let("GeneratedDelegatedTypeMethods", String)
 
         RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
         AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)

data/lib/tapioca/dsl/pipeline.rb

@@ -128,9 +128,11 @@ module Tapioca
       def filter_anonymous_and_reloaded_constants(constants)
         # Group constants by their names
         constants_by_name = constants
-          .group_by { |c| T.must(Runtime::Reflection.name_of(c)) }
+          .group_by { |c| Runtime::Reflection.name_of(c) }
           .select { |name, _| !name.nil? }
 
+        constants_by_name = T.cast(constants_by_name, T::Hash[String, T::Array[Module]])
+
         # Find the constants that have been reloaded
         reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
 

data/lib/tapioca/gem/pipeline.rb

@@ -241,8 +241,7 @@ module Tapioca
         klass = class_of(value)
 
         klass_name = if klass == ObjectSpace::WeakMap
-          # WeakMap is an implicit generic with one type variable
-          "ObjectSpace::WeakMap[T.untyped]"
+          sorbet_supports?(:non_generic_weak_map) ? "ObjectSpace::WeakMap" : "ObjectSpace::WeakMap[T.untyped]"
         elsif T::Generic === klass
           generic_name_of(klass)
         else

data/lib/tapioca/helpers/gem_helper.rb

@@ -5,7 +5,7 @@ module Tapioca
   module GemHelper
     extend T::Sig
 
-    sig { params(app_dir: String, full_gem_path: String).returns(T::Boolean) }
+    sig { params(app_dir: T.any(String, Pathname), full_gem_path: String).returns(T::Boolean) }
     def gem_in_app_dir?(app_dir, full_gem_path)
       app_dir = to_realpath(app_dir)
       full_gem_path = to_realpath(full_gem_path)

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -161,7 +161,8 @@ module Tapioca
         RBI::Parser.parse_file(file)
       rescue RBI::ParseError => e
         say_error("\nWarning: #{e} (#{e.location})", :yellow)
-      end
+        nil
+      end.compact
 
       index.visit_all(trees)
     end

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -21,6 +21,7 @@ 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
     }.freeze, T::Hash[Symbol, ::Gem::Requirement])
 
     sig { params(sorbet_args: String).returns(Spoom::ExecResult) }

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -62,8 +62,8 @@ module T
         # we've created a clone of that type with the `name` method returning the
         # appropriate name for that specific concrete type.
         def name
-          if T::Generic === @raw_type || Tapioca::TypeVariableModule === @raw_type
-            # for types that are generic or are type variables, use the name
+          if T::Generic === @raw_type
+            # for types that are generic, use the name
             # returned by the "name" method of this instance
             @name ||= T.unsafe(@raw_type).name.freeze
           else
@@ -78,20 +78,42 @@ module T
   end
 
   module Utils
-    module CoercePatch
-      def coerce(val)
-        if val.is_a?(Tapioca::TypeVariableModule)
-          val.coerce_to_type_variable
-        elsif val.respond_to?(:__tapioca_override_type)
-          val.__tapioca_override_type
-        else
-          super
+    # 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)
+          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
-    end
 
-    class << self
-      prepend(CoercePatch)
+      class << self
+        prepend(CoercePatch)
+      end
     end
   end
 end

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.4
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-10 00:00:00.000000000 Z
+date: 2022-12-19 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.9892
+        version: 0.5.10187
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9892
+        version: 0.5.10187
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
@@ -171,6 +171,7 @@ files:
 - lib/tapioca/dsl/compilers/active_model_secure_password.rb
 - lib/tapioca/dsl/compilers/active_record_associations.rb
 - lib/tapioca/dsl/compilers/active_record_columns.rb
+- lib/tapioca/dsl/compilers/active_record_delegated_types.rb
 - lib/tapioca/dsl/compilers/active_record_enum.rb
 - lib/tapioca/dsl/compilers/active_record_fixtures.rb
 - lib/tapioca/dsl/compilers/active_record_relations.rb
@@ -192,6 +193,7 @@ files:
 - lib/tapioca/dsl/compilers/smart_properties.rb
 - lib/tapioca/dsl/compilers/state_machines.rb
 - lib/tapioca/dsl/compilers/url_helpers.rb
+- lib/tapioca/dsl/extensions/active_record.rb
 - lib/tapioca/dsl/extensions/frozen_record.rb
 - lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
 - lib/tapioca/dsl/helpers/active_record_constants_helper.rb