tapioca 0.8.3 → 0.9.0

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/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,7 +35,7 @@ module Tapioca
             when ActiveRecord::Type::Boolean
               "T::Boolean"
             when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-              "::DateTime"
+              "::Time"
             when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
               "::ActiveSupport::TimeWithZone"
             else
@@ -75,7 +75,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)

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,6 +100,8 @@ module Tapioca
       end
     end
 
+    class ForeignScopeNodeAdded < ScopeNodeAdded; end
+
     class MethodNodeAdded < NodeAdded
       extend T::Sig
 

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 }
@@ -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

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

@@ -27,6 +27,11 @@ module Tapioca
             end
           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/sorbet_required_ancestors.rb

@@ -18,6 +18,11 @@ module Tapioca
             event.node << RBI::RequiresAncestor.new(ancestor.to_s)
           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/sorbet_signatures.rb

@@ -8,7 +8,7 @@ module Tapioca
         extend T::Sig
 
         include Runtime::Reflection
-        include SignaturesHelper
+        include RBIHelper
 
         TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
 
@@ -73,6 +73,11 @@ module Tapioca
 
           final_methods.include?(signature.method_name)
         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_type_variables.rb

@@ -45,6 +45,11 @@ module Tapioca
 
           tree << RBI::Extend.new("T::Generic")
         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/subconstants.rb

@@ -31,6 +31,11 @@ module Tapioca
             @pipeline.push_constant(name, subconstant)
           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/yard_doc.rb

@@ -90,6 +90,11 @@ module Tapioca
 
           comments
         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.rb

@@ -13,4 +13,5 @@ require "tapioca/gem/listeners/sorbet_required_ancestors"
 require "tapioca/gem/listeners/sorbet_signatures"
 require "tapioca/gem/listeners/sorbet_type_variables"
 require "tapioca/gem/listeners/subconstants"
+require "tapioca/gem/listeners/foreign_constants"
 require "tapioca/gem/listeners/yard_doc"