tapioca 0.4.24 → 0.5.1

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|
+          all_classes.select do |c|
             c < ::SmartProperties
           end.reject do |c|
-            c.name.nil? || c == ::SmartProperties::Validations::Ancestor
+            name_of(c).nil? || c == ::SmartProperties::Validations::Ancestor
           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

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "rails"
   require "action_controller"
@@ -89,13 +87,13 @@ module Tapioca
       class UrlHelpers < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
+        sig { override.params(root: RBI::Tree, constant: Module).void }
         def decorate(root, constant)
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
             generate_module_for(root, constant)
           else
-            root.path(constant) do |mod|
+            root.create_path(constant) do |mod|
               create_mixins_for(mod, constant, GeneratedUrlHelpersModule)
               create_mixins_for(mod, constant, GeneratedPathHelpersModule)
             end
@@ -112,9 +110,8 @@ module Tapioca
           Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
           Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
 
-          module_enumerator = T.cast(ObjectSpace.each_object(Module), T::Enumerator[Module])
-          constants = module_enumerator.select do |mod|
-            next unless Module.instance_method(:name).bind(mod).call
+          constants = all_modules.select do |mod|
+            next unless name_of(mod)
 
             includes_helper?(mod, GeneratedUrlHelpersModule) ||
               includes_helper?(mod, GeneratedPathHelpersModule) ||
@@ -127,7 +124,7 @@ module Tapioca
 
         private
 
-        sig { params(root: Parlour::RbiGenerator::Namespace, constant: Module).void }
+        sig { params(root: RBI::Tree, constant: Module).void }
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
             mod.create_include("::ActionDispatch::Routing::UrlFor")
@@ -136,14 +133,14 @@ module Tapioca
             constant.instance_methods(false).each do |method|
               mod.create_method(
                 method.to_s,
-                parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+                parameters: [create_rest_param("args", type: "T.untyped")],
                 return_type: "String"
               )
             end
           end
         end
 
-        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: Module, helper_module: Module).void }
+        sig { params(mod: RBI::Scope, constant: Module, helper_module: Module).void }
         def create_mixins_for(mod, constant, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)