tapioca 0.4.10 → 0.4.15

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

@@ -15,7 +15,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::SmartProperties` generates RBI files for classes that include
-      # `SmartProperties` (see https://github.com/t6d/smart_properties).
+      # [`SmartProperties`](https://github.com/t6d/smart_properties).
       #
       # For example, with the following class that includes `SmartProperties`:
       #

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

@@ -15,10 +15,12 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `RbiGenerator::StateMachines` generates RBI files for classes that setup a `state_machine`
-      # (see https://github.com/state-machines/state_machines). The generator also processes the extra
-      # methods generated by [StateMachines Active Record](https://github.com/state-machines/state_machines-activerecord)
-      # and [StateMachines ActiveModel](https://github.com/state-machines/state_machines-activemodel) integrations.
+      # `Tapioca::Compilers::Dsl::StateMachines` generates RBI files for classes that setup a
+      # [`state_machine`](https://github.com/state-machines/state_machines). The generator also
+      # processes the extra methods generated by
+      # [StateMachines Active Record](https://github.com/state-machines/state_machines-activerecord)
+      # and [StateMachines Active Model](https://github.com/state-machines/state_machines-activemodel)
+      # integrations.
       #
       # For example, with the following `Vehicle` class:
       #
@@ -45,75 +47,75 @@ module Tapioca
       # # vehicle.rbi
       # # typed: true
       # class Vehicle
-      #   include Vehicle::StateMachineInstanceHelperModule
-      #   extend Vehicle::StateMachineClassHelperModule
-      # end
+      #   include StateMachineInstanceHelperModule
+      #   extend StateMachineClassHelperModule
       #
-      # module Vehicle::StateMachineClassHelperModule
-      #   sig { params(event: T.any(String, Symbol)).returns(String) }
-      #   def human_alarm_state_event_name(event); end
+      #   module StateMachineClassHelperModule
+      #     sig { params(event: T.any(String, Symbol)).returns(String) }
+      #     def human_alarm_state_event_name(event); end
       #
-      #   sig { params(state: T.any(String, Symbol)).returns(String) }
-      #   def human_alarm_state_name(state); end
-      # end
+      #     sig { params(state: T.any(String, Symbol)).returns(String) }
+      #     def human_alarm_state_name(state); end
+      #   end
       #
-      # module Vehicle::StateMachineInstanceHelperModule
-      #   sig { returns(T::Boolean) }
-      #   def alarm_active?; end
+      #   module StateMachineInstanceHelperModule
+      #     sig { returns(T::Boolean) }
+      #     def alarm_active?; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def alarm_off?; end
+      #     sig { returns(T::Boolean) }
+      #     def alarm_off?; end
       #
-      #   sig { returns(Integer) }
-      #   def alarm_state; end
+      #     sig { returns(Integer) }
+      #     def alarm_state; end
       #
-      #   sig { params(value: Integer).returns(Integer) }
-      #   def alarm_state=(value); end
+      #     sig { params(value: Integer).returns(Integer) }
+      #     def alarm_state=(value); end
       #
-      #   sig { params(state: T.any(String, Symbol)).returns(T::Boolean) }
-      #   def alarm_state?(state); end
+      #     sig { params(state: T.any(String, Symbol)).returns(T::Boolean) }
+      #     def alarm_state?(state); end
       #
-      #   sig { params(args: T.untyped).returns(T::Array[T.any(String, Symbol)]) }
-      #   def alarm_state_events(*args); end
+      #     sig { params(args: T.untyped).returns(T::Array[T.any(String, Symbol)]) }
+      #     def alarm_state_events(*args); end
       #
-      #   sig { returns(T.any(String, Symbol)) }
-      #   def alarm_state_name; end
+      #     sig { returns(T.any(String, Symbol)) }
+      #     def alarm_state_name; end
       #
-      #   sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
-      #   def alarm_state_paths(*args); end
+      #     sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+      #     def alarm_state_paths(*args); end
       #
-      #   sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
-      #   def alarm_state_transitions(*args); end
+      #     sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+      #     def alarm_state_transitions(*args); end
       #
-      #   sig { returns(T::Boolean) }
-      #   def can_disable_alarm?; end
+      #     sig { returns(T::Boolean) }
+      #     def can_disable_alarm?; end
       #
-      #   sig { returns(T::Boolean) }
-      #   def can_enable_alarm?; end
+      #     sig { returns(T::Boolean) }
+      #     def can_enable_alarm?; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def disable_alarm(*args); end
+      #     sig { params(args: T.untyped).returns(T::Boolean) }
+      #     def disable_alarm(*args); end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def disable_alarm!(*args); end
+      #     sig { params(args: T.untyped).returns(T::Boolean) }
+      #     def disable_alarm!(*args); end
       #
-      #   sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
-      #   def disable_alarm_transition(*args); end
+      #     sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
+      #     def disable_alarm_transition(*args); end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def enable_alarm(*args); end
+      #     sig { params(args: T.untyped).returns(T::Boolean) }
+      #     def enable_alarm(*args); end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def enable_alarm!(*args); end
+      #     sig { params(args: T.untyped).returns(T::Boolean) }
+      #     def enable_alarm!(*args); end
       #
-      #   sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
-      #   def enable_alarm_transition(*args); end
+      #     sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
+      #     def enable_alarm_transition(*args); end
       #
-      #   sig { params(event: T.any(String, Symbol), args: T.untyped).returns(T::Boolean) }
-      #   def fire_alarm_state_event(event, *args); end
+      #     sig { params(event: T.any(String, Symbol), args: T.untyped).returns(T::Boolean) }
+      #     def fire_alarm_state_event(event, *args); end
       #
-      #   sig { returns(String) }
-      #   def human_alarm_state_name; end
+      #     sig { returns(String) }
+      #     def human_alarm_state_name; end
+      #   end
       # end
       # ~~~
       class StateMachines < Base
@@ -123,34 +125,34 @@ module Tapioca
         def decorate(root, constant)
           return if constant.state_machines.empty?
 
-          instance_module_name = "#{constant}::StateMachineInstanceHelperModule"
-          class_module_name = "#{constant}::StateMachineClassHelperModule"
+          root.path(constant) do |klass|
+            instance_module_name = "StateMachineInstanceHelperModule"
+            class_module_name = "StateMachineClassHelperModule"
 
-          instance_module = root.create_module(instance_module_name)
-          class_module = root.create_module(class_module_name)
+            instance_module = klass.create_module(instance_module_name)
+            class_module = klass.create_module(class_module_name)
 
-          constant.state_machines.each_value do |machine|
-            state_type = state_type_for(machine)
+            constant.state_machines.each_value do |machine|
+              state_type = state_type_for(machine)
 
-            define_state_accessor(instance_module, machine, state_type)
-            define_state_predicate(instance_module, machine)
-            define_event_helpers(instance_module, machine)
-            define_path_helpers(instance_module, machine)
-            define_name_helpers(instance_module, class_module, machine)
-            define_scopes(class_module, machine)
+              define_state_accessor(instance_module, machine, state_type)
+              define_state_predicate(instance_module, machine)
+              define_event_helpers(instance_module, machine)
+              define_path_helpers(instance_module, machine)
+              define_name_helpers(instance_module, class_module, machine)
+              define_scopes(class_module, machine)
 
-            define_state_methods(instance_module, machine)
-            define_event_methods(instance_module, machine)
-          end
+              define_state_methods(instance_module, machine)
+              define_event_methods(instance_module, machine)
+            end
 
-          matching_integration_name = ::StateMachines::Integrations.match(constant)&.integration_name
+            matching_integration_name = ::StateMachines::Integrations.match(constant)&.integration_name
 
-          case matching_integration_name
-          when :active_record
-            define_activerecord_methods(instance_module)
-          end
+            case matching_integration_name
+            when :active_record
+              define_activerecord_methods(instance_module)
+            end
 
-          root.path(constant) do |klass|
             klass.create_include(instance_module_name)
             klass.create_extend(class_module_name)
           end

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

@@ -15,8 +15,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::UrlHelpers` generates RBI files for classes that include or extend
-      # `Rails.application.routes.url_helpers`
-      # (see https://api.rubyonrails.org/v5.1.7/classes/ActionDispatch/Routing/UrlFor.html#module-ActionDispatch::Routing::UrlFor-label-URL+generation+for+named+routes).
+      # [`Rails.application.routes.url_helpers`](https://api.rubyonrails.org/v5.1.7/classes/ActionDispatch/Routing/UrlFor.html#module-ActionDispatch::Routing::UrlFor-label-URL+generation+for+named+routes).
       #
       # For example, with the following setup:
       #
@@ -32,7 +31,12 @@ module Tapioca
       # ~~~rb
       # app/models/post.rb
       # class Post
-      #   include Rails.application.routes.url_helpers
+      #   # Use `T.unsafe` so that Sorbet does not complain about a dynamic
+      #   # module being included. This allows the `include` to happen properly
+      #   # at runtime but Sorbet won't see the include. However, since this
+      #   # generator will generate the proper RBI files for the include,
+      #   # static type checking will work as expected.
+      #   T.unsafe(self).include Rails.application.routes.url_helpers
       # end
       # ~~~
       #
@@ -126,8 +130,8 @@ module Tapioca
         sig { params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(Module)).void }
         def generate_module_for(root, constant)
           root.create_module(T.must(constant.name)) do |mod|
-            mod.create_include("ActionDispatch::Routing::UrlFor")
-            mod.create_include("ActionDispatch::Routing::PolymorphicRoutes")
+            mod.create_include("::ActionDispatch::Routing::UrlFor")
+            mod.create_include("::ActionDispatch::Routing::PolymorphicRoutes")
 
             constant.instance_methods(false).each do |method|
               mod.create_method(

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -74,9 +74,9 @@ module Tapioca
           compile(symbol, constant)
         end
 
-        sig { params(symbol: String).returns(BasicObject).checked(:never) }
-        def resolve_constant(symbol)
-          Object.const_get(symbol, false)
+        sig { params(symbol: String, inherit: T::Boolean).returns(BasicObject).checked(:never) }
+        def resolve_constant(symbol, inherit: false)
+          Object.const_get(symbol, inherit)
         rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
           nil
         end
@@ -122,12 +122,15 @@ module Tapioca
         def compile_alias(name, constant)
           return if symbol_ignored?(name)
 
-          constant_name = name_of(constant)
+          target = name_of(constant)
+          # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
+          target = "#{constant.class}.new" unless target
+
           add_to_alias_namespace(name)
 
           return if IGNORED_SYMBOLS.include?(name)
 
-          indented("#{name} = #{constant_name}")
+          indented("#{name} = #{target}")
         end
 
         sig do
@@ -189,15 +192,12 @@ module Tapioca
         def compile_module_helpers(constant)
           abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type)
 
-          if abstract_type
-            indented("#{abstract_type}!")
-          elsif T::Private::Final.final_module?(constant)
-            indented("final!")
-          elsif T::Private::Sealed.sealed_module?(constant)
-            indented("sealed!")
-          else
-            ""
-          end
+          helpers = []
+          helpers << indented("#{abstract_type}!") if abstract_type
+          helpers << indented("final!") if T::Private::Final.final_module?(constant)
+          helpers << indented("sealed!") if T::Private::Sealed.sealed_module?(constant)
+
+          helpers.join("\n")
         end
 
         sig { params(constant: Module).returns(String) }
@@ -207,7 +207,7 @@ module Tapioca
           constant.props.map do |name, prop|
             method = "prop"
             method = "const" if prop.fetch(:immutable, false)
-            type = prop.fetch(:type_object, "T.untyped")
+            type = prop.fetch(:type_object, "T.untyped").to_s.gsub(".returns(<VOID>)", ".void")
 
             if prop.key?(:default)
               indented("#{method} :#{name}, #{type}, default: T.unsafe(nil)")
@@ -292,33 +292,16 @@ module Tapioca
 
         sig { params(constant: Module).returns(String) }
         def compile_mixins(constant)
-          ignorable_ancestors =
-            if constant.is_a?(Class)
-              ancestors = constant.superclass&.ancestors || Object.ancestors
-              Set.new(ancestors)
-            else
-              Module.ancestors
-            end
+          singleton_class = singleton_class_of(constant)
 
-          inherited_singleton_class_ancestors =
-            if constant.is_a?(Class)
-              Set.new(singleton_class_of(constant.superclass).ancestors)
-            else
-              Module.ancestors
-            end
-
-          interesting_ancestors =
-            constant.ancestors.reject { |mod| ignorable_ancestors.include?(mod) }
+          interesting_ancestors = interesting_ancestors_of(constant)
+          interesting_singleton_class_ancestors = interesting_ancestors_of(singleton_class)
 
           prepend = interesting_ancestors.take_while { |c| !are_equal?(constant, c) }
           include = interesting_ancestors.drop(prepend.size + 1)
-          extend  = singleton_class_of(constant).ancestors
-            .reject do |mod|
-              mod == singleton_class_of(constant) ||
-                inherited_singleton_class_ancestors.include?(mod) ||
-                !public_module?(mod) ||
-                Module != class_of(mod)
-            end
+          extend  = interesting_singleton_class_ancestors.reject do |mod|
+            !public_module?(mod) || Module != class_of(mod) || are_equal?(mod, singleton_class)
+          end
 
           prepends = prepend
             .reverse
@@ -757,18 +740,59 @@ module Tapioca
           Module.instance_method(:name).bind(constant).call
         end
 
-        sig { params(constant: BasicObject).returns(Class).checked(:never) }
+        sig { params(constant: Module).returns(Class) }
         def singleton_class_of(constant)
           Object.instance_method(:singleton_class).bind(constant).call
         end
 
+        sig { params(constant: Module).returns(T::Array[Module]) }
+        def ancestors_of(constant)
+          Module.instance_method(:ancestors).bind(constant).call
+        end
+
+        sig { params(constant: Module).returns(T::Array[Module]) }
+        def inherited_ancestors_of(constant)
+          if Class === constant
+            ancestors_of(superclass_of(constant) || Object)
+          else
+            Module.ancestors
+          end
+        end
+
+        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) }
+          )
+          # TODO: There is actually a bug here where this will drop modules that
+          # may be included twice. For example:
+          #
+          # ```ruby
+          # class Foo
+          #   prepend Kernel
+          # end
+          # ````
+          # would give:
+          # ```ruby
+          # Foo.ancestors #=> [Kernel, Foo, Object, Kernel, BasicObject]
+          # ````
+          # but since we drop `Kernel` whenever we match it, we would miss
+          # the `prepend Kernel` in the output.
+          #
+          # 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
+        end
+
         sig { params(constant: Module).returns(T.nilable(String)) }
         def name_of(constant)
           name = name_of_proxy_target(constant)
           return name if name
           name = raw_name_of(constant)
           return if name.nil?
-          return unless are_equal?(constant, resolve_constant(name))
+          return unless are_equal?(constant, resolve_constant(name, inherit: true))
           name = "Struct" if name =~ /^(::)?Struct::[^:]+$/
           name
         end
@@ -817,6 +841,11 @@ module Tapioca
           constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
         end
 
+        sig { params(object: Object).returns(T::Boolean).checked(:never) }
+        def object_id_of(object)
+          Object.instance_method(:object_id).bind(object).call
+        end
+
         sig { params(constant: Module, other: BasicObject).returns(T::Boolean).checked(:never) }
         def are_equal?(constant, other)
           BasicObject.instance_method(:equal?).bind(constant).call(other)

data/lib/tapioca/gemfile.rb

@@ -17,27 +17,23 @@ module Tapioca
       )
     end
 
+    sig { returns(Bundler::Definition) }
+    attr_reader(:definition)
+
+    sig { returns(T::Array[Gem]) }
+    attr_reader(:dependencies)
+
+    sig { returns(T::Array[String]) }
+    attr_reader(:missing_specs)
+
     sig { void }
     def initialize
       @gemfile = T.let(File.new(Bundler.default_gemfile), File)
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
-      @dependencies = T.let(nil, T.nilable(T::Array[Gem]))
-      @definition = T.let(nil, T.nilable(Bundler::Definition))
-    end
-
-    sig { returns(T::Array[Gem]) }
-    def dependencies
-      @dependencies ||= begin
-        specs = definition.locked_gems.specs.to_a
-
-        definition
-          .resolve
-          .materialize(specs)
-          .map { |spec| Gem.new(spec) }
-          .reject { |gem| gem.ignore?(dir) }
-          .uniq(&:rbi_file_name)
-          .sort_by(&:rbi_file_name)
-      end
+      @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)
+      dependencies, missing_specs = load_dependencies
+      @dependencies = T.let(dependencies, T::Array[Gem])
+      @missing_specs = T.let(missing_specs, T::Array[String])
     end
 
     sig { params(gem_name: String).returns(T.nilable(Gem)) }
@@ -55,6 +51,23 @@ module Tapioca
     sig { returns(File) }
     attr_reader(:gemfile, :lockfile)
 
+    sig { returns([T::Array[Gem], T::Array[String]]) }
+    def load_dependencies
+      deps = definition.locked_gems.dependencies.values
+
+      missing_specs = T::Array[String].new
+
+      dependencies = definition
+        .resolve
+        .materialize(deps, missing_specs)
+        .map { |spec| Gem.new(spec) }
+        .reject { |gem| gem.ignore?(dir) }
+        .uniq(&:rbi_file_name)
+        .sort_by(&:rbi_file_name)
+
+      [dependencies, missing_specs]
+    end
+
     sig { returns(Bundler::Runtime) }
     def runtime
       Bundler::Runtime.new(File.dirname(gemfile.path), definition)
@@ -65,11 +78,6 @@ module Tapioca
       definition.groups
     end
 
-    sig { returns(Bundler::Definition) }
-    def definition
-      @definition ||= Bundler::Dsl.evaluate(gemfile, lockfile, {})
-    end
-
     sig { returns(String) }
     def dir
       File.expand_path(gemfile.path + "/..")