tapioca 0.4.27 → 0.5.0

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "frozen_record"
 rescue LoadError
@@ -67,18 +65,18 @@ module Tapioca
       class FrozenRecord < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::FrozenRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::FrozenRecord::Base)).void }
         def decorate(root, constant)
           attributes = constant.attributes
           return if attributes.empty?
 
-          root.path(constant) do |record|
+          root.create_path(constant) do |record|
             module_name = "FrozenRecordAttributeMethods"
 
             record.create_module(module_name) do |mod|
               attributes.each do |attribute|
-                create_method(mod, "#{attribute}?", return_type: 'T::Boolean')
-                create_method(mod, attribute.to_s, return_type: 'T.untyped')
+                mod.create_method("#{attribute}?", return_type: "T::Boolean")
+                mod.create_method(attribute.to_s, return_type: "T.untyped")
               end
             end
 
@@ -88,7 +86,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::FrozenRecord::Base.descendants.reject(&:abstract_class?)
+          descendants_of(::FrozenRecord::Base).reject(&:abstract_class?)
         end
       end
     end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "rails/railtie"
   require "identity_cache"
@@ -67,23 +65,16 @@ module Tapioca
 
         COLLECTION_TYPE = T.let(
           ->(type) { "T::Array[::#{type}]" },
-          T.proc.params(type: Module).returns(String)
+          T.proc.params(type: T.any(Module, String)).returns(String)
         )
 
-        sig do
-          override
-            .params(
-              root: Parlour::RbiGenerator::Namespace,
-              constant: T.class_of(::ActiveRecord::Base)
-            )
-            .void
-        end
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveRecord::Base)).void }
         def decorate(root, constant)
           caches = constant.send(:all_cached_associations)
           cache_indexes = constant.send(:cache_indexes)
           return if caches.empty? && cache_indexes.empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             cache_manys = constant.send(:cached_has_manys)
             cache_ones = constant.send(:cached_has_ones)
             cache_belongs = constant.send(:cached_belongs_tos)
@@ -108,7 +99,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveRecord::Base.descendants.select do |klass|
+          descendants_of(::ActiveRecord::Base).select do |klass|
             klass < ::IdentityCache::WithoutPrimaryIndex
           end
         end
@@ -119,8 +110,7 @@ module Tapioca
           params(
             field: T.untyped,
             returns_collection: T::Boolean
-          )
-            .returns(String)
+          ).returns(String)
         end
         def type_for_field(field, returns_collection:)
           cache_type = field.reflection.compute_class(field.reflection.class_name)
@@ -136,10 +126,9 @@ module Tapioca
         sig do
           params(
             field: T.untyped,
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             returns_collection: T::Boolean
-          )
-            .void
+          ).void
         end
         def create_fetch_field_methods(field, klass, returns_collection:)
           name = field.cached_accessor_name.to_s
@@ -156,21 +145,36 @@ module Tapioca
         sig do
           params(
             field: T.untyped,
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             constant: T.class_of(::ActiveRecord::Base),
-          )
-            .void
+          ).void
         end
         def create_fetch_by_methods(field, klass, constant)
+          is_cache_index = field.instance_variable_defined?(:@attribute_proc)
+
+          # Both `cache_index` and `cache_attribute` generate aliased methods
+          create_aliased_fetch_by_methods(field, klass, constant)
+
+          # If the method used was `cache_index` a few extra methods are created
+          create_index_fetch_by_methods(field, klass, constant) if is_cache_index
+        end
+
+        sig do
+          params(
+            field: T.untyped,
+            klass: RBI::Scope,
+            constant: T.class_of(::ActiveRecord::Base),
+          ).void
+        end
+        def create_index_fetch_by_methods(field, klass, constant)
           field_length = field.key_fields.length
           fields_name = field.key_fields.join("_and_")
-
+          name = "fetch_by_#{fields_name}"
           parameters = field.key_fields.map do |arg|
-            Parlour::RbiGenerator::Parameter.new(arg.to_s, type: "T.untyped")
+            create_param(arg.to_s, type: "T.untyped")
           end
-          parameters << Parlour::RbiGenerator::Parameter.new("includes:", default: "nil", type: "T.untyped")
+          parameters << create_kw_opt_param("includes", default: "nil", type: "T.untyped")
 
-          name = "fetch_by_#{fields_name}"
           if field.unique
             klass.create_method(
               "#{name}!",
@@ -195,18 +199,51 @@ module Tapioca
           end
 
           if field_length == 1
-            name = "fetch_multi_by_#{fields_name}"
             klass.create_method(
-              name,
+              "fetch_multi_by_#{fields_name}",
               class_method: true,
               parameters: [
-                Parlour::RbiGenerator::Parameter.new("index_values", type: "T.untyped"),
-                Parlour::RbiGenerator::Parameter.new("includes:", default: "nil", type: "T.untyped"),
+                create_param("index_values", type: "T::Enumerable[T.untyped]"),
+                create_kw_opt_param("includes", default: "nil", type: "T.untyped"),
               ],
               return_type: COLLECTION_TYPE.call(constant)
             )
           end
         end
+
+        sig do
+          params(
+            field: T.untyped,
+            klass: RBI::Scope,
+            constant: T.class_of(::ActiveRecord::Base),
+          ).void
+        end
+        def create_aliased_fetch_by_methods(field, klass, constant)
+          type, _ = ActiveRecordColumnTypeHelper.new(constant).type_for(field.alias_name.to_s)
+          multi_type = type.delete_prefix("T.nilable(").delete_suffix(")").delete_prefix("::")
+          length = field.key_fields.length
+          suffix = field.send(:fetch_method_suffix)
+
+          parameters = field.key_fields.map do |arg|
+            create_param(arg.to_s, type: "T.untyped")
+          end
+
+          klass.create_method(
+            "fetch_#{suffix}",
+            class_method: true,
+            parameters: parameters,
+            return_type: type
+          )
+
+          if length == 1
+            klass.create_method(
+              "fetch_multi_#{suffix}",
+              class_method: true,
+              parameters: [create_param("keys", type: "T::Enumerable[T.untyped]")],
+              return_type: COLLECTION_TYPE.call(multi_type)
+            )
+          end
+        end
       end
     end
   end

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

@@ -1,6 +1,5 @@
 # typed: strict
 # frozen_string_literal: true
-require "parlour"
 
 begin
   require "google/protobuf"
@@ -62,67 +61,18 @@ module Tapioca
       # end
       # ~~~
       class Protobuf < Base
-        # Parlour doesn't support type members out of the box, so adding the
-        # ability to do that here. This should be upstreamed.
-        class TypeMember < Parlour::RbiGenerator::RbiObject
-          extend T::Sig
-
-          sig { params(other: Object).returns(T::Boolean) }
-          def ==(other)
-            TypeMember === other && name == other.name
-          end
-
-          sig do
-            override
-              .params(indent_level: Integer, options: Parlour::RbiGenerator::Options)
-              .returns(T::Array[String])
-          end
-          def generate_rbi(indent_level, options)
-            [options.indented(indent_level, "#{name} = type_member")]
-          end
-
-          sig do
-            override
-              .params(others: T::Array[Parlour::RbiGenerator::RbiObject])
-              .returns(T::Boolean)
-          end
-          def mergeable?(others)
-            others.all? { |other| self == other }
-          end
-
-          sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-          def merge_into_self(others); end
-
-          sig { override.returns(String) }
-          def describe
-            "Type Member (#{name})"
-          end
-        end
-
         class Field < T::Struct
           prop :name, String
           prop :type, String
           prop :init_type, String
           prop :default, String
-
-          extend T::Sig
-
-          sig { returns(Parlour::RbiGenerator::Parameter) }
-          def to_init
-            Parlour::RbiGenerator::Parameter.new("#{name}:", type: init_type, default: default)
-          end
         end
 
         extend T::Sig
 
-        sig do
-          override.params(
-            root: Parlour::RbiGenerator::Namespace,
-            constant: Module
-          ).void
-        end
+        sig { override.params(root: RBI::Tree, constant: Module).void }
         def decorate(root, constant)
-          root.path(constant) do |klass|
+          root.create_path(constant) do |klass|
             if constant == Google::Protobuf::RepeatedField
               create_type_members(klass, "Elem")
             elsif constant == Google::Protobuf::Map
@@ -132,7 +82,11 @@ module Tapioca
               fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
               fields.sort_by!(&:name)
 
-              create_method(klass, "initialize", parameters: fields.map!(&:to_init))
+              parameters = fields.map do |field|
+                create_kw_opt_param(field.name, type: field.init_type, default: field.default)
+              end
+
+              klass.create_method("initialize", parameters: parameters, return_type: "void")
             end
           end
         end
@@ -146,12 +100,12 @@ module Tapioca
 
         private
 
-        sig { params(klass: Parlour::RbiGenerator::Namespace, names: String).void }
+        sig { params(klass: RBI::Scope, names: String).void }
         def create_type_members(klass, *names)
           klass.create_extend("T::Generic")
 
           names.each do |name|
-            klass.children << TypeMember.new(klass.generator, name)
+            klass.create_type_member(name)
           end
         end
 
@@ -186,34 +140,34 @@ module Tapioca
             # how Google names map entries.
             # https://github.com/protocolbuffers/protobuf/blob/f82e26/ruby/ext/google/protobuf_c/defs.c#L1963-L1966
             if descriptor.submsg_name.to_s.end_with?("_MapEntry_#{descriptor.name}")
-              key = descriptor.subtype.lookup('key')
-              value = descriptor.subtype.lookup('value')
+              key = descriptor.subtype.lookup("key")
+              value = descriptor.subtype.lookup("value")
 
               key_type = type_of(key)
               value_type = type_of(value)
               type = "Google::Protobuf::Map[#{key_type}, #{value_type}]"
 
               default_args = [key.type.inspect, value.type.inspect]
-              default_args << value_type if %i[enum message].include?(value.type)
+              default_args << value_type if [:enum, :message].include?(value.type)
 
               Field.new(
                 name: descriptor.name,
                 type: type,
                 init_type: "T.any(#{type}, T::Hash[#{key_type}, #{value_type}])",
-                default: "Google::Protobuf::Map.new(#{default_args.join(', ')})"
+                default: "Google::Protobuf::Map.new(#{default_args.join(", ")})"
               )
             else
               elem_type = type_of(descriptor)
               type = "Google::Protobuf::RepeatedField[#{elem_type}]"
 
               default_args = [descriptor.type.inspect]
-              default_args << elem_type if %i[enum message].include?(descriptor.type)
+              default_args << elem_type if [:enum, :message].include?(descriptor.type)
 
               Field.new(
                 name: descriptor.name,
                 type: type,
                 init_type: "T.any(#{type}, T::Array[#{elem_type}])",
-                default: "Google::Protobuf::RepeatedField.new(#{default_args.join(', ')})"
+                default: "Google::Protobuf::RepeatedField.new(#{default_args.join(", ")})"
               )
             end
           else
@@ -230,25 +184,21 @@ module Tapioca
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             desc: Google::Protobuf::FieldDescriptor,
           ).returns(Field)
         end
         def create_descriptor_method(klass, desc)
           field = field_of(desc)
 
-          create_method(
-            klass,
+          klass.create_method(
             field.name,
             return_type: field.type
           )
 
-          create_method(
-            klass,
+          klass.create_method(
             "#{field.name}=",
-            parameters: [
-              Parlour::RbiGenerator::Parameter.new("value", type: field.type),
-            ],
+            parameters: [create_param("value", type: field.type)],
             return_type: field.type
           )
 

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "sidekiq"
 rescue LoadError
@@ -45,37 +43,52 @@ module Tapioca
       class SidekiqWorker < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::Sidekiq::Worker)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::Sidekiq::Worker)).void }
         def decorate(root, constant)
           return unless constant.instance_methods.include?(:perform)
 
-          root.path(constant) do |worker|
+          root.create_path(constant) do |worker|
             method_def = constant.instance_method(:perform)
 
-            async_params = compile_method_parameters_to_parlour(method_def)
+            async_params = compile_method_parameters_to_rbi(method_def)
 
             # `perform_at` and is just an alias for `perform_in` so both methods technically
             # accept a datetime, time, or numeric but we're typing them differently so they
             # semantically make sense.
             at_params = [
-              Parlour::RbiGenerator::Parameter.new('interval', type: 'T.any(DateTime, Time)'),
+              create_param("interval", type: "T.any(DateTime, Time)"),
               *async_params,
             ]
             in_params = [
-              Parlour::RbiGenerator::Parameter.new('interval', type: 'Numeric'),
+              create_param("interval", type: "Numeric"),
               *async_params,
             ]
 
-            create_method(worker, 'perform_async', parameters: async_params, return_type: 'String', class_method: true)
-            create_method(worker, 'perform_at', parameters: at_params, return_type: 'String', class_method: true)
-            create_method(worker, 'perform_in', parameters: in_params, return_type: 'String', class_method: true)
+            generate_perform_method(constant, worker, "perform_async", async_params)
+            generate_perform_method(constant, worker, "perform_at", at_params)
+            generate_perform_method(constant, worker, "perform_in", in_params)
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
-          classes.select { |c| c < Sidekiq::Worker }
+          all_classes.select { |c| c < Sidekiq::Worker }
+        end
+
+        private
+
+        sig do
+          params(
+            constant: T.class_of(::Sidekiq::Worker),
+            worker: RBI::Scope,
+            method_name: String,
+            parameters: T::Array[RBI::TypedParam]
+          ).void
+        end
+        def generate_perform_method(constant, worker, method_name, parameters)
+          if constant.method(method_name.to_sym).owner == Sidekiq::Worker::ClassMethods
+            worker.create_method(method_name, parameters: parameters, return_type: "String", class_method: true)
+          end
         end
       end
     end