tapioca 0.4.6 → 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/dsl_compiler.rb

@@ -1,5 +1,5 @@
+# typed: strict
 # frozen_string_literal: true
-# typed: true
 
 require "tapioca/compilers/dsl/base"
 
@@ -30,7 +30,7 @@ module Tapioca
           T::Enumerable[Dsl::Base]
         )
         @requested_constants = requested_constants
-        @error_handler = error_handler || $stderr.method(:puts)
+        @error_handler = T.let(error_handler || $stderr.method(:puts), T.proc.params(error: String).void)
       end
 
       sig { params(blk: T.proc.params(constant: Module, rbi: String).void).void }
@@ -54,9 +54,9 @@ module Tapioca
 
       private
 
-      sig { params(requested_generators: T::Array[String]).returns(Proc) }
+      sig { params(requested_generators: T::Array[String]).returns(T.proc.params(klass: Class).returns(T::Boolean)) }
       def generator_filter(requested_generators)
-        return proc { true } if requested_generators.empty?
+        return ->(_klass) { true } if requested_generators.empty?
 
         generators = requested_generators.map(&:downcase)
 
@@ -70,7 +70,7 @@ module Tapioca
       def gather_generators(requested_generators)
         generator_filter = generator_filter(requested_generators)
 
-        Dsl::Base.descendants.select(&generator_filter).map(&:new)
+        T.cast(Dsl::Base.descendants.select(&generator_filter).map(&:new), T::Enumerable[Dsl::Base])
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }

data/lib/tapioca/compilers/requires_compiler.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 require 'spoom'
 
@@ -34,7 +34,8 @@ module Tapioca
           path = (Pathname.new(@sorbet_path) / "../.." / path).cleanpath
           if path.directory?
             Dir.glob("#{path}/**/*.rb", File::FNM_EXTGLOB).reject do |file|
-              file_ignored_by_sorbet?(config, file)
+              relative_file_path = Pathname.new(file).relative_path_from(path)
+              file_ignored_by_sorbet?(config, relative_file_path)
             end
           else
             [path.to_s]
@@ -49,13 +50,40 @@ module Tapioca
         end.compact
       end
 
-      sig { params(config: Spoom::Sorbet::Config, file: String).returns(T::Boolean) }
-      def file_ignored_by_sorbet?(config, file)
-        config.ignore.any? do |path|
-          Regexp.new(Regexp.escape(path)) =~ file
+      sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
+      def file_ignored_by_sorbet?(config, file_path)
+        file_path_parts = path_parts(file_path)
+
+        config.ignore.any? do |ignore|
+          # Sorbet --ignore matching method:
+          # ---
+          # Ignores input files that contain the given
+          # string in their paths (relative to the input
+          # path passed to Sorbet).
+          #
+          # Strings beginning with / match against the
+          # prefix of these relative paths; others are
+          # substring matchs.
+
+          # Matches must be against whole folder and file
+          # names, so `foo` matches `/foo/bar.rb` and
+          # `/bar/foo/baz.rb` but not `/foo.rb` or
+          # `/foo2/bar.rb`.
+          ignore_parts = path_parts(Pathname.new(ignore))
+          file_path_part_sequences = file_path_parts.each_cons(ignore_parts.size)
+          # if ignore string begins with /, we only want the first sequence to match
+          file_path_part_sequences = [file_path_part_sequences.first].to_enum if ignore.start_with?("/")
+
+          # we need to match whole segments
+          file_path_part_sequences.include?(ignore_parts)
         end
       end
 
+      sig { params(path: Pathname).returns(T::Array[String]) }
+      def path_parts(path)
+        T.unsafe(path).descend.map { |part| part.basename.to_s }
+      end
+
       sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
       def name_in_project?(files, name)
         files.any? do |file|

data/lib/tapioca/compilers/sorbet.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'pathname'
 require 'shellwords'

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

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'pathname'
 
@@ -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
@@ -209,7 +209,11 @@ module Tapioca
             method = "const" if prop.fetch(:immutable, false)
             type = prop.fetch(:type_object, "T.untyped")
 
-            indented("#{method} :#{name}, #{type}")
+            if prop.key?(:default)
+              indented("#{method} :#{name}, #{type}, default: T.unsafe(nil)")
+            else
+              indented("#{method} :#{name}, #{type}")
+            end
           end.join("\n")
         end
 
@@ -288,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
@@ -513,7 +500,9 @@ module Tapioca
 
           parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
 
-          sanitized_parameters = parameters.map do |type, name|
+          sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
+            fallback_arg_name = "_arg#{index}"
+
             unless name
               # For attr_writer methods, Sorbet signatures have the name
               # of the method (without the trailing = sign) as the name of
@@ -533,12 +522,12 @@ module Tapioca
               name = if writer_method_with_sig
                 T.must(method_name[0...-1]).to_sym
               else
-                :_
+                fallback_arg_name
               end
             end
 
             # Sanitize param names
-            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, fallback_arg_name)
 
             [type, name]
           end
@@ -612,6 +601,7 @@ module Tapioca
           signature_body = signature_body
             .gsub(".returns(<VOID>)", ".void")
             .gsub("<NOT-TYPED>", "T.untyped")
+            .gsub(".params()", "")
             .gsub(TYPE_PARAMETER_MATCHER, "T.type_parameter(:\\1)")[1..-1]
 
           "sig { #{signature_body} }"
@@ -750,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
@@ -810,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)