tapioca 0.4.10 → 0.4.11

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
@@ -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/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.4.10"
+  VERSION = "0.4.11"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.10
+  version: 0.4.11
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-01 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -116,14 +116,15 @@ files:
 - lib/tapioca/compilers/dsl/active_record_associations.rb
 - lib/tapioca/compilers/dsl/active_record_columns.rb
 - lib/tapioca/compilers/dsl/active_record_enum.rb
-- lib/tapioca/compilers/dsl/active_record_identity_cache.rb
 - lib/tapioca/compilers/dsl/active_record_scope.rb
 - lib/tapioca/compilers/dsl/active_record_typed_store.rb
 - lib/tapioca/compilers/dsl/active_resource.rb
 - lib/tapioca/compilers/dsl/active_support_current_attributes.rb
 - lib/tapioca/compilers/dsl/base.rb
 - lib/tapioca/compilers/dsl/frozen_record.rb
+- lib/tapioca/compilers/dsl/identity_cache.rb
 - lib/tapioca/compilers/dsl/protobuf.rb
+- lib/tapioca/compilers/dsl/sidekiq_worker.rb
 - lib/tapioca/compilers/dsl/smart_properties.rb
 - lib/tapioca/compilers/dsl/state_machines.rb
 - lib/tapioca/compilers/dsl/url_helpers.rb