tapioca 0.8.3 → 0.9.2

data/lib/tapioca/commands/gem.rb

@@ -5,7 +5,7 @@ module Tapioca
   module Commands
     class Gem < Command
       include SorbetHelper
-      include RBIHelper
+      include RBIFilesHelper
 
       sig do
         params(
@@ -16,7 +16,8 @@ module Tapioca
           typed_overrides: T::Hash[String, String],
           outpath: Pathname,
           file_header: T::Boolean,
-          doc: T::Boolean,
+          include_doc: T::Boolean,
+          include_loc: T::Boolean,
           include_exported_rbis: T::Boolean,
           number_of_workers: T.nilable(Integer),
           auto_strictness: T::Boolean,
@@ -32,7 +33,8 @@ module Tapioca
         typed_overrides:,
         outpath:,
         file_header:,
-        doc:,
+        include_doc:,
+        include_loc:,
         include_exported_rbis:,
         number_of_workers: nil,
         auto_strictness: true,
@@ -57,7 +59,8 @@ module Tapioca
         @bundle = T.let(nil, T.nilable(Gemfile))
         @existing_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
         @expected_rbis = T.let(nil, T.nilable(T::Hash[String, String]))
-        @doc = T.let(doc, T::Boolean)
+        @include_doc = T.let(include_doc, T::Boolean)
+        @include_loc = T.let(include_loc, T::Boolean)
         @include_exported_rbis = include_exported_rbis
       end
 
@@ -94,12 +97,12 @@ module Tapioca
         end
       end
 
-      sig { params(should_verify: T::Boolean).void }
-      def sync(should_verify: false)
+      sig { params(should_verify: T::Boolean, exclude: T::Array[String]).void }
+      def sync(should_verify: false, exclude: [])
         if should_verify
           say("Checking for out-of-date RBIs...")
           say("")
-          perform_sync_verification
+          perform_sync_verification(exclude: exclude)
           return
         end
 
@@ -182,7 +185,7 @@ module Tapioca
           default_command(:gem, gem.name),
           reason: "types exported from the `#{gem.name}` gem",) if @file_header
 
-        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @doc).compile
+        rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
 
         merge_with_exported_rbi(gem, rbi) if @include_exported_rbis
 
@@ -201,11 +204,13 @@ module Tapioca
         end
       end
 
-      sig { void }
-      def perform_sync_verification
+      sig { params(exclude: T::Array[String]).void }
+      def perform_sync_verification(exclude: [])
         diff = {}
 
         removed_rbis.each do |gem_name|
+          next if exclude.include?(gem_name)
+
           filename = existing_rbi(gem_name)
           diff[filename] = :removed
         end

data/lib/tapioca/commands.rb

@@ -5,8 +5,9 @@ module Tapioca
   module Commands
     autoload :Command, "tapioca/commands/command"
     autoload :Annotations, "tapioca/commands/annotations"
+    autoload :CheckShims, "tapioca/commands/check_shims"
     autoload :Dsl, "tapioca/commands/dsl"
-    autoload :Init, "tapioca/commands/init"
+    autoload :Configure, "tapioca/commands/configure"
     autoload :Gem, "tapioca/commands/gem"
     autoload :Require, "tapioca/commands/require"
     autoload :Todo, "tapioca/commands/todo"

data/lib/tapioca/dsl/compiler.rb

@@ -1,12 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "rbi"
-require "tapioca/rbi_ext/model"
-require "tapioca/rbi_formatter"
-require "tapioca/dsl/helpers/param_helper"
-require "tapioca/dsl/pipeline"
-
 module Tapioca
   module Dsl
     class Compiler
@@ -14,6 +8,7 @@ module Tapioca
       extend T::Helpers
       extend T::Generic
 
+      include RBIHelper
       include Runtime::Reflection
       extend Runtime::Reflection
 
@@ -119,8 +114,6 @@ module Tapioca
         )
       end
 
-      include Helpers::ParamHelper
-
       sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
       def compile_method_parameters_to_rbi(method_def)
         signature = signature_of(method_def)
@@ -175,11 +168,6 @@ module Tapioca
           "T.nilable(#{type})"
         end
       end
-
-      sig { params(name: String).returns(T::Boolean) }
-      def valid_parameter_name?(name)
-        name.match?(/^[[[:alnum:]]_]+$/)
-      end
     end
   end
 end

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

@@ -103,7 +103,7 @@ module Tapioca
           when ActiveModel::Type::Date
             "::Date"
           when ActiveModel::Type::DateTime, ActiveModel::Type::Time
-            "::DateTime"
+            "::Time"
           when ActiveModel::Type::Decimal
             "::BigDecimal"
           when ActiveModel::Type::Float

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

@@ -543,6 +543,23 @@ module Tapioca
                 ],
                 return_type: constant_name
               )
+            when :find_sole_by
+              create_common_method(
+                "find_sole_by",
+                common_relation_methods_module,
+                parameters: [
+                  create_param("arg", type: "T.untyped"),
+                  create_rest_param("args", type: "T.untyped"),
+                ],
+                return_type: constant_name
+              )
+            when :sole
+              create_common_method(
+                "sole",
+                common_relation_methods_module,
+                parameters: [],
+                return_type: constant_name
+              )
             when :first, :last, :take
               create_common_method(
                 method_name,

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

@@ -95,17 +95,18 @@ module Tapioca
         sig { override.void }
         def decorate
           stores = constant.typed_stores
-          return if stores.values.flat_map(&:accessors).empty?
+          return if stores.values.all? { |store| store.accessors.empty? }
 
           root.create_path(constant) do |model|
             stores.values.each do |store_data|
-              store_data.accessors.each do |accessor|
-                field = store_data.fields[accessor]
+              store_data.accessors.each do |accessor, name|
+                field = store_data.fields.fetch(accessor)
                 type = type_for(field.type_sym)
                 type = as_nilable_type(type) if field.null
+                name ||= field.name # support < 1.5.0
 
                 store_accessors_module = model.create_module("StoreAccessors")
-                generate_methods(store_accessors_module, field.name.to_s, type)
+                generate_methods(store_accessors_module, name.to_s, type)
                 model.create_include("StoreAccessors")
               end
             end

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

@@ -65,7 +65,7 @@ module Tapioca
       class FrozenRecord < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::FrozenRecord::Base) } }
+        ConstantType = type_member { { fixed: T.all(T.class_of(::FrozenRecord::Base), Extensions::FrozenRecord) } }
 
         sig { override.void }
         def decorate
@@ -97,7 +97,7 @@ module Tapioca
 
         sig { params(record: RBI::Scope).void }
         def decorate_scopes(record)
-          scopes = T.unsafe(constant).__tapioca_scope_names
+          scopes = constant.__tapioca_scope_names
           return if scopes.nil?
 
           module_name = "GeneratedRelationMethods"

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

@@ -146,6 +146,11 @@ module Tapioca
           end
         end
 
+        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(T::Boolean) }
+        def nilable_descriptor?(descriptor)
+          descriptor.label == :optional && descriptor.type == :message
+        end
+
         sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(Field) }
         def field_of(descriptor)
           if descriptor.label == :repeated
@@ -185,6 +190,7 @@ module Tapioca
             end
           else
             type = type_of(descriptor)
+            type = as_nilable_type(type) if nilable_descriptor?(descriptor)
 
             Field.new(
               name: descriptor.name,

data/lib/tapioca/dsl/compilers.rb

@@ -1,10 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "tapioca/rbi_ext/model"
-require "tapioca/dsl/helpers/param_helper"
-require "tapioca/dsl/pipeline"
-
 module Tapioca
   module Dsl
     module Compilers

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

@@ -35,15 +35,23 @@ module Tapioca
             when ActiveRecord::Type::Boolean
               "T::Boolean"
             when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-              "::DateTime"
+              "::Time"
             when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
               "::ActiveSupport::TimeWithZone"
+            when ActiveRecord::Enum::EnumType
+              "::String"
             else
               handle_unknown_type(column_type)
             end
 
           column = @constant.columns_hash[column_name]
-          setter_type = getter_type
+          setter_type =
+            case column_type
+            when ActiveRecord::Enum::EnumType
+              enum_setter_type(column_type)
+            else
+              getter_type
+            end
 
           if column&.null
             return [as_nilable_type(getter_type), as_nilable_type(setter_type)]
@@ -75,7 +83,7 @@ module Tapioca
           end
         end
 
-        sig { params(column_type: Object).returns(String) }
+        sig { params(column_type: BasicObject).returns(String) }
         def handle_unknown_type(column_type)
           return "T.untyped" unless ActiveModel::Type::Value === column_type
           return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(column_type)
@@ -108,6 +116,16 @@ module Tapioca
 
           first_argument_type.to_s
         end
+
+        sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
+        def enum_setter_type(column_type)
+          case column_type.subtype
+          when ActiveRecord::Type::Integer
+            "T.any(::String, ::Symbol, ::Integer)"
+          else
+            "T.any(::String, ::Symbol)"
+          end
+        end
       end
     end
   end

data/lib/tapioca/dsl/pipeline.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "tapioca/dsl/compilers"
-
 module Tapioca
   module Dsl
     class Pipeline

data/lib/tapioca/dsl.rb

@@ -1,6 +1,14 @@
 # typed: true
 # frozen_string_literal: true
 
+require "rbi"
+
 require "tapioca"
 require "tapioca/runtime/reflection"
+require "tapioca/helpers/sorbet_helper"
+require "tapioca/helpers/rbi_helper"
+require "tapioca/rbi_ext/model"
+require "tapioca/rbi_formatter"
+require "tapioca/dsl/compilers"
+require "tapioca/dsl/pipeline"
 require "tapioca/dsl/compiler"

data/lib/tapioca/executor.rb

@@ -1,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "etc"
-require "parallel"
-
 module Tapioca
   class Executor
     extend T::Sig

data/lib/tapioca/gem/events.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "pathname"
-
 module Tapioca
   module Gem
     class Event
@@ -42,6 +40,20 @@ module Tapioca
       end
     end
 
+    class ForeignConstantFound < ConstantFound
+      extend T::Sig
+
+      sig { override.returns(Module) }
+      def constant
+        T.cast(@constant, Module)
+      end
+
+      sig { params(symbol: String, constant: Module).void }
+      def initialize(symbol, constant)
+        super
+      end
+    end
+
     class NodeAdded < Event
       extend T::Helpers
       extend T::Sig
@@ -88,9 +100,14 @@ module Tapioca
       end
     end
 
+    class ForeignScopeNodeAdded < ScopeNodeAdded; end
+
     class MethodNodeAdded < NodeAdded
       extend T::Sig
 
+      sig { returns(UnboundMethod) }
+      attr_reader :method
+
       sig { returns(RBI::Method) }
       attr_reader :node
 
@@ -104,14 +121,16 @@ module Tapioca
         params(
           symbol: String,
           constant: Module,
+          method: UnboundMethod,
           node: RBI::Method,
           signature: T.untyped,
           parameters: T::Array[[Symbol, String]]
         ).void.checked(:never)
       end
-      def initialize(symbol, constant, node, signature, parameters)
+      def initialize(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
         super(symbol, constant)
         @node = node
+        @method = method
         @signature = signature
         @parameters = parameters
       end

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

@@ -17,6 +17,8 @@ module Tapioca
 
         sig { params(event: NodeAdded).void }
         def dispatch(event)
+          return if ignore?(event)
+
           case event
           when ConstNodeAdded
             on_const(event)
@@ -42,6 +44,15 @@ module Tapioca
         sig { params(event: MethodNodeAdded).void }
         def on_method(event)
         end
+
+        sig { params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          # Some listeners do not have to take any action on certain events. For example,
+          # almost every listener should skip ForeignScopeNodeAdded events in order not to generate
+          # unnecessary RBIs for foreign constants. This method should be overridden by listener
+          # subclasses to skip any events that aren't relevant to them.
+          false
+        end
       end
     end
   end

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

@@ -26,6 +26,11 @@ module Tapioca
             @pipeline.push_symbol(name) if name
           end
         end
+
+        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
       end
     end
   end

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

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Gem
+    module Listeners
+      class ForeignConstants < Base
+        extend T::Sig
+
+        include Runtime::Reflection
+
+        private
+
+        sig { override.params(event: ScopeNodeAdded).void }
+        def on_scope(event)
+          mixin = event.constant
+          return if Class === mixin # Classes can't be mixed into other constants
+
+          # There are cases where we want to process constants not declared by the current
+          # gem, i.e. "foreign constant". These are constants defined in another gem to which
+          # this gem is applying a mix-in. This pattern is especially common for gems that add
+          # behavior to Ruby standard library classes by mixing in modules to them.
+          #
+          # The way we identify these "foreign constants" is by asking the mixin tracker which
+          # constants have mixed in the current module that we are handling. We add all the
+          # constants that we discover to the pipeline to be processed.
+          Runtime::Trackers::Mixin.constants_with_mixin(mixin).each_value do |location_info|
+            location_info.each do |constant, location|
+              next unless mixed_in_by_gem?(location)
+
+              name = @pipeline.name_of(constant)
+
+              # Calling Tapioca::Gem::Pipeline#name_of on a singleton class returns `nil`.
+              # To handle this case, use string parsing to get the name of the singleton class's
+              # base constant. Then, generate RBIs as if the base constant is extending the mixin,
+              # which is functionally equivalent to including or prepending to the singleton class.
+              if !name && constant.singleton_class?
+                name = constant_name_from_singleton_class(constant)
+                next unless name
+
+                constant = T.cast(constantize(name), Module)
+              end
+
+              @pipeline.push_foreign_constant(name, constant) if name
+            end
+          end
+        end
+
+        sig do
+          params(
+            location: String,
+          ).returns(T::Boolean)
+        end
+        def mixed_in_by_gem?(location)
+          @pipeline.gem.contains_path?(location)
+        end
+
+        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,9 @@ module Tapioca
       class Methods < Base
         extend T::Sig
 
+        include RBIHelper
         include Runtime::Reflection
 
-        SPECIAL_METHOD_NAMES = T.let([
-          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
-          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`",
-        ], T::Array[String])
-
         private
 
         sig { override.params(event: ScopeNodeAdded).void }
@@ -138,7 +134,7 @@ module Tapioca
             end
           end
 
-          @pipeline.push_method(symbol_name, constant, rbi_method, signature, sanitized_parameters)
+          @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, sanitized_parameters)
           tree << rbi_method
         end
 
@@ -184,24 +180,17 @@ module Tapioca
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
-        sig { params(name: String).returns(T::Boolean) }
-        def valid_method_name?(name)
-          return true if SPECIAL_METHOD_NAMES.include?(name)
-
-          !!name.match(/^[[:word:]]+[?!=]?$/)
-        end
-
-        sig { params(name: String).returns(T::Boolean) }
-        def valid_parameter_name?(name)
-          name.match?(/^[[[:alnum:]]_]+$/)
-        end
-
         sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue
           nil
         end
+
+        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
       end
     end
   end

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

@@ -26,19 +26,20 @@ module Tapioca
           end
 
           node = event.node
-          add_mixins(node, prepends.reverse, Runtime::Trackers::Mixin::Type::Prepend)
-          add_mixins(node, includes.reverse, Runtime::Trackers::Mixin::Type::Include)
-          add_mixins(node, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
+          add_mixins(node, constant, prepends.reverse, Runtime::Trackers::Mixin::Type::Prepend)
+          add_mixins(node, constant, includes.reverse, Runtime::Trackers::Mixin::Type::Include)
+          add_mixins(node, constant, extends.reverse, Runtime::Trackers::Mixin::Type::Extend)
         end
 
         sig do
           params(
             tree: RBI::Tree,
+            constant: Module,
             mods: T::Array[Module],
             mixin_type: Runtime::Trackers::Mixin::Type
           ).void
         end
-        def add_mixins(tree, mods, mixin_type)
+        def add_mixins(tree, constant, mods, mixin_type)
           mods
             .select do |mod|
               name = @pipeline.name_of(mod)
@@ -46,6 +47,8 @@ module Tapioca
               name && !filtered_mixin?(name)
             end
             .map do |mod|
+              next unless mixed_in_by_gem?(constant, mod, mixin_type)
+
               name = @pipeline.name_of(mod)
               @pipeline.push_symbol(name) if name
 
@@ -62,6 +65,25 @@ module Tapioca
             end
         end
 
+        sig do
+          params(
+            constant: Module,
+            mixin: Module,
+            mixin_type: Runtime::Trackers::Mixin::Type
+          ).returns(T::Boolean)
+        end
+        def mixed_in_by_gem?(constant, mixin, mixin_type)
+          mixin_location =
+            T.cast(
+              Runtime::Trackers::Mixin.constants_with_mixin(mixin).dig(mixin_type, constant),
+              T.nilable(String)
+            )
+
+          return true if mixin_location.nil?
+
+          @pipeline.gem.contains_path?(mixin_location)
+        end
+
         sig { params(mixin_name: String).returns(T::Boolean) }
         def filtered_mixin?(mixin_name)
           # filter T:: namespace mixins that aren't T::Props
@@ -71,9 +93,8 @@ module Tapioca
 
         sig { params(constant: Module).returns(T::Array[Module]) }
         def interesting_ancestors_of(constant)
-          inherited_ancestors_ids = Set.new(
-            inherited_ancestors_of(constant).map { |mod| object_id_of(mod) }
-          )
+          inherited_ancestors = Set.new.compare_by_identity.merge(inherited_ancestors_of(constant))
+
           # TODO: There is actually a bug here where this will drop modules that
           # may be included twice. For example:
           #
@@ -91,9 +112,9 @@ module Tapioca
           #
           # Instead, we should only drop the tail matches of the ancestors and
           # inherited ancestors, past the location of the constant itself.
-          constant.ancestors.reject do |mod|
-            inherited_ancestors_ids.include?(object_id_of(mod))
-          end
+          ancestors = Set.new.compare_by_identity.merge(ancestors_of(constant))
+
+          (ancestors - inherited_ancestors).to_a
         end
       end
     end

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

@@ -15,6 +15,11 @@ module Tapioca
         def on_scope(event)
           event.node.detach if @pipeline.symbol_in_payload?(event.symbol) && event.node.empty?
         end
+
+        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
       end
     end
   end

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

@@ -20,6 +20,11 @@ module Tapioca
 
           event.node << RBI::TEnumBlock.new(enums)
         end
+
+        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
       end
     end
   end

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

@@ -23,6 +23,11 @@ module Tapioca
           node << RBI::Helper.new("final") if T::Private::Final.final_module?(constant)
           node << RBI::Helper.new("sealed") if T::Private::Sealed.sealed_module?(constant)
         end
+
+        sig { override.params(event: NodeAdded).returns(T::Boolean) }
+        def ignore?(event)
+          event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)
+        end
       end
     end
   end