tapioca 0.4.27 → 0.5.3

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

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "smart_properties"
 rescue LoadError
@@ -55,7 +53,7 @@ module Tapioca
       #   sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
       #   def published=(published); end
       #
-      #   ssig { returns(T.nilable(T::Boolean)) }
+      #   sig { returns(T.nilable(T::Boolean)) }
       #   def enabled; end
       #
       #   sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
@@ -65,14 +63,7 @@ module Tapioca
       class SmartProperties < Base
         extend T::Sig
 
-        sig do
-          override
-            .params(
-              root: Parlour::RbiGenerator::Namespace,
-              constant: T.class_of(::SmartProperties)
-            )
-            .void
-        end
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::SmartProperties)).void }
         def decorate(root, constant)
           properties = T.let(
             T.unsafe(constant).properties,
@@ -82,7 +73,7 @@ module Tapioca
 
           instance_methods = constant.instance_methods(false).map(&:to_s).to_set
 
-          root.path(constant) do |k|
+          root.create_path(constant) do |k|
             properties.values.each do |property|
               generate_methods_for_property(k, property) do |method_name|
                 !instance_methods.include?(method_name.to_sym)
@@ -93,11 +84,10 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
-          classes.select do |c|
-            c < ::SmartProperties
-          end.reject do |c|
-            c.name.nil? || c == ::SmartProperties::Validations::Ancestor
+          all_modules.select do |c|
+            name_of(c) &&
+              c != ::SmartProperties::Validations::Ancestor &&
+              c < ::SmartProperties && ::SmartProperties::ClassMethods === c
           end
         end
 
@@ -105,7 +95,7 @@ module Tapioca
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             property: ::SmartProperties::Property,
             block: T.proc.params(arg: String).returns(T::Boolean)
           ).void
@@ -119,7 +109,7 @@ module Tapioca
 
             klass.create_method(
               method_name,
-              parameters: [Parlour::RbiGenerator::Parameter.new(name, type: type)],
+              parameters: [create_param(name, type: type)],
               return_type: type
             ) if block.call(method_name)
           end
@@ -134,10 +124,13 @@ module Tapioca
 
         sig { params(property: ::SmartProperties::Property).returns(String) }
         def type_for(property)
-          converter = property.converter
-          return "T.untyped" if converter
+          converter, accepter, required = property.to_h.fetch_values(
+            :converter,
+            :accepter,
+            :required,
+          )
 
-          accepter = property.accepter
+          return "T.untyped" if converter
 
           type = if accepter.nil? || accepter.respond_to?(:to_proc)
             "T.untyped"
@@ -147,25 +140,20 @@ module Tapioca
             "T::Boolean"
           elsif Array(accepter).all? { |a| a.is_a?(Module) }
             accepters = Array(accepter)
-            types = accepters.map { |mod| name_of(mod) }.join(', ')
+            types = accepters.map { |mod| T.must(qualified_name_of(mod)) }.join(", ")
             types = "T.any(#{types})" if accepters.size > 1
             types
           else
             "T.untyped"
           end
 
-          required_attr = property.instance_variable_get(:@required)
-          required = !required_attr.is_a?(Proc) && !!required_attr
-          property_required = type == "T.untyped" || required
-          type = "T.nilable(#{type})" unless property_required
+          # Early return for "T.untyped", nothing more to do.
+          return type if type == "T.untyped"
 
-          type
-        end
+          might_be_optional = Proc === required || !required
+          type = "T.nilable(#{type})" if might_be_optional
 
-        sig { params(type: Module).returns(String) }
-        def name_of(type)
-          name = Module.instance_method(:name).bind(type).call
-          name.start_with?("::") ? name : "::#{name}"
+          type
         end
       end
     end

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

@@ -1,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-require "tapioca/core_ext/class"
-
 begin
   require "state_machines"
 rescue LoadError
@@ -121,16 +118,19 @@ module Tapioca
       class StateMachines < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: ::StateMachines::ClassMethods).void }
+        sig { override.params(root: RBI::Tree, constant: ::StateMachines::ClassMethods).void }
         def decorate(root, constant)
           return if constant.state_machines.empty?
 
-          root.path(constant) do |klass|
+          root.create_path(T.unsafe(constant)) do |klass|
             instance_module_name = "StateMachineInstanceHelperModule"
             class_module_name = "StateMachineClassHelperModule"
 
-            instance_module = klass.create_module(instance_module_name)
-            class_module = klass.create_module(class_module_name)
+            instance_module = RBI::Module.new(instance_module_name)
+            klass << instance_module
+
+            class_module = RBI::Module.new(class_module_name)
+            klass << class_module
 
             constant.state_machines.each_value do |machine|
               state_type = state_type_for(machine)
@@ -160,7 +160,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          Object.descendants.select { |mod| mod < ::StateMachines::InstanceMethods }
+          all_classes.select { |mod| mod < ::StateMachines::InstanceMethods }
         end
 
         private
@@ -172,54 +172,48 @@ module Tapioca
           if value_types.size == 1
             value_types.first
           else
-            "T.any(#{value_types.join(', ')})"
+            "T.any(#{value_types.join(", ")})"
           end
         end
 
-        sig { params(instance_module: Parlour::RbiGenerator::Namespace).void }
+        sig { params(instance_module: RBI::Module).void }
         def define_activerecord_methods(instance_module)
-          create_method(
-            instance_module,
+          instance_module.create_method(
             "changed_for_autosave?",
             return_type: "T::Boolean"
           )
         end
 
-        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
         def define_state_methods(instance_module, machine)
           machine.states.each do |state|
-            create_method(
-              instance_module,
+            instance_module.create_method(
               "#{state.qualified_name}?",
               return_type: "T::Boolean"
             )
           end
         end
 
-        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
         def define_event_methods(instance_module, machine)
           machine.events.each do |event|
-            create_method(
-              instance_module,
+            instance_module.create_method(
               "can_#{event.qualified_name}?",
               return_type: "T::Boolean"
             )
-            create_method(
-              instance_module,
+            instance_module.create_method(
               "#{event.qualified_name}_transition",
-              parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+              parameters: [create_rest_param("args", type: "T.untyped")],
               return_type: "T.nilable(::StateMachines::Transition)"
             )
-            create_method(
-              instance_module,
+            instance_module.create_method(
               event.qualified_name.to_s,
-              parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+              parameters: [create_rest_param("args", type: "T.untyped")],
               return_type: "T::Boolean"
             )
-            create_method(
-              instance_module,
+            instance_module.create_method(
               "#{event.qualified_name}!",
-              parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+              parameters: [create_rest_param("args", type: "T.untyped")],
               return_type: "T::Boolean"
             )
           end
@@ -227,106 +221,95 @@ module Tapioca
 
         sig do
           params(
-            instance_module: Parlour::RbiGenerator::Namespace,
+            instance_module: RBI::Module,
             machine: ::StateMachines::Machine,
             state_type: String
           ).void
         end
         def define_state_accessor(instance_module, machine, state_type)
           attribute = machine.attribute.to_s
-          create_method(
-            instance_module,
+          instance_module.create_method(
             attribute,
             return_type: state_type
           )
-          create_method(
-            instance_module,
+          instance_module.create_method(
             "#{attribute}=",
-            parameters: [Parlour::RbiGenerator::Parameter.new("value", type: state_type)],
+            parameters: [create_param("value", type: state_type)],
             return_type: state_type
           )
         end
 
-        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
         def define_state_predicate(instance_module, machine)
-          create_method(
-            instance_module,
+          instance_module.create_method(
             "#{machine.name}?",
-            parameters: [Parlour::RbiGenerator::Parameter.new("state", type: "T.any(String, Symbol)")],
+            parameters: [create_param("state", type: "T.any(String, Symbol)")],
             return_type: "T::Boolean"
           )
         end
 
-        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
         def define_event_helpers(instance_module, machine)
           events_attribute = machine.attribute(:events).to_s
           transitions_attribute = machine.attribute(:transitions).to_s
           event_attribute = machine.attribute(:event).to_s
           event_transition_attribute = machine.attribute(:event_transition).to_s
 
-          create_method(
-            instance_module,
+          instance_module.create_method(
             events_attribute,
-            parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+            parameters: [create_rest_param("args", type: "T.untyped")],
             return_type: "T::Array[T.any(String, Symbol)]"
           )
-          create_method(
-            instance_module,
+          instance_module.create_method(
             transitions_attribute,
-            parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+            parameters: [create_rest_param("args", type: "T.untyped")],
             return_type: "T::Array[::StateMachines::Transition]"
           )
-          create_method(
-            instance_module,
+          instance_module.create_method(
             "fire_#{event_attribute}",
             parameters: [
-              Parlour::RbiGenerator::Parameter.new("event", type: "T.any(String, Symbol)"),
-              Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
+              create_param("event", type: "T.any(String, Symbol)"),
+              create_rest_param("args", type: "T.untyped"),
             ],
             return_type: "T::Boolean"
           )
           if machine.action
-            create_method(
-              instance_module,
+            instance_module.create_method(
               event_attribute,
               return_type: "T.nilable(Symbol)"
             )
-            create_method(
-              instance_module,
+            instance_module.create_method(
               "#{event_attribute}=",
-              parameters: [Parlour::RbiGenerator::Parameter.new("value", type: "T.any(String, Symbol)")],
+              parameters: [create_param("value", type: "T.any(String, Symbol)")],
               return_type: "T.any(String, Symbol)"
             )
-            create_method(
-              instance_module,
+            instance_module.create_method(
               event_transition_attribute,
               return_type: "T.nilable(::StateMachines::Transition)"
             )
-            create_method(
-              instance_module,
+            instance_module.create_method(
               "#{event_transition_attribute}=",
-              parameters: [Parlour::RbiGenerator::Parameter.new("value", type: "::StateMachines::Transition")],
+              parameters: [create_param("value", type: "::StateMachines::Transition")],
               return_type: "::StateMachines::Transition"
             )
           end
         end
 
-        sig { params(instance_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }
         def define_path_helpers(instance_module, machine)
           paths_attribute = machine.attribute(:paths).to_s
 
-          create_method(
-            instance_module,
+          instance_module.create_method(
             paths_attribute,
-            parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+            parameters: [create_rest_param("args", type: "T.untyped")],
             return_type: "T::Array[::StateMachines::Transition]"
           )
         end
 
         sig do
           params(
-            instance_module: Parlour::RbiGenerator::Namespace,
-            class_module: Parlour::RbiGenerator::Namespace,
+            instance_module: RBI::Module,
+            class_module: RBI::Module,
             machine: ::StateMachines::Machine
           ).void
         end
@@ -334,31 +317,27 @@ module Tapioca
           name_attribute = machine.attribute(:name).to_s
           event_name_attribute = machine.attribute(:event_name).to_s
 
-          create_method(
-            class_module,
+          class_module.create_method(
             "human_#{name_attribute}",
-            parameters: [Parlour::RbiGenerator::Parameter.new("state", type: "T.any(String, Symbol)")],
+            parameters: [create_param("state", type: "T.any(String, Symbol)")],
             return_type: "String"
           )
-          create_method(
-            class_module,
+          class_module.create_method(
             "human_#{event_name_attribute}",
-            parameters: [Parlour::RbiGenerator::Parameter.new("event", type: "T.any(String, Symbol)")],
+            parameters: [create_param("event", type: "T.any(String, Symbol)")],
             return_type: "String"
           )
-          create_method(
-            instance_module,
+          instance_module.create_method(
             name_attribute,
             return_type: "T.any(String, Symbol)"
           )
-          create_method(
-            instance_module,
+          instance_module.create_method(
             "human_#{name_attribute}",
             return_type: "String"
           )
         end
 
-        sig { params(class_module: Parlour::RbiGenerator::Namespace, machine: ::StateMachines::Machine).void }
+        sig { params(class_module: RBI::Module, machine: ::StateMachines::Machine).void }
         def define_scopes(class_module, machine)
           helper_modules = machine.instance_variable_get(:@helper_modules)
           class_methods = helper_modules[:class].instance_methods(false)
@@ -366,10 +345,9 @@ module Tapioca
           class_methods
             .select { |method| method.to_s.start_with?("with_", "without_") }
             .each do |method|
-              create_method(
-                class_module,
+              class_module.create_method(
                 method.to_s,
-                parameters: [Parlour::RbiGenerator::Parameter.new("*states", type: "T.any(String, Symbol)")],
+                parameters: [create_rest_param("states", type: "T.any(String, Symbol)")],
                 return_type: "T.untyped"
               )
             end