tapioca 0.7.0 → 0.8.0

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

@@ -46,8 +46,12 @@ module Tapioca
       class ActiveStorage < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: T.all(Module,
-          ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods))
+        ConstantType = type_member do
+          {
+            fixed: T.all(Module,
+              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods),
+          }
+        end
 
         sig { override.void }
         def decorate

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

@@ -44,7 +44,7 @@ module Tapioca
       class ActiveSupportConcern < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: Module)
+        ConstantType = type_member { { fixed: Module } }
 
         sig { override.void }
         def decorate

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

@@ -62,7 +62,7 @@ module Tapioca
       class ActiveSupportCurrentAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: T.class_of(::ActiveSupport::CurrentAttributes))
+        ConstantType = type_member { { fixed: T.class_of(::ActiveSupport::CurrentAttributes) } }
 
         sig { override.void }
         def decorate

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

@@ -49,7 +49,7 @@ module Tapioca
 
         CONFIG_OPTIONS_SUFFIX = "ConfigOptions"
 
-        ConstantType = type_member(fixed: Module)
+        ConstantType = type_member { { fixed: Module } }
 
         sig { override.void }
         def decorate
@@ -77,7 +77,7 @@ module Tapioca
             # enumerates the entries, we don't make any assumptions about their
             # types.
             mod.create_extend("T::Generic")
-            mod.create_type_member("Elem", value: "type_member(fixed: T.untyped)")
+            mod.create_type_variable("Elem", type: "type_member", fixed: "T.untyped")
 
             method_names.each do |method_name|
               # Create getter method

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

@@ -65,7 +65,7 @@ module Tapioca
       class FrozenRecord < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: T.class_of(::FrozenRecord::Base))
+        ConstantType = type_member { { fixed: T.class_of(::FrozenRecord::Base) } }
 
         sig { override.void }
         def decorate

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

@@ -69,7 +69,7 @@ module Tapioca
           T.proc.params(type: T.any(Module, String)).returns(String)
         )
 
-        ConstantType = type_member(fixed: T.class_of(::ActiveRecord::Base))
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
         sig { override.void }
         def decorate

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

@@ -51,7 +51,7 @@ module Tapioca
       class MixedInClassAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: Module)
+        ConstantType = type_member { { fixed: Module } }
 
         sig { override.void }
         def decorate

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

@@ -70,7 +70,9 @@ module Tapioca
 
         extend T::Sig
 
-        ConstantType = type_member(fixed: Module)
+        ConstantType = type_member { { fixed: Module } }
+
+        FIELD_RE = /^[a-z_][a-zA-Z0-9_]*$/
 
         sig { override.void }
         def decorate
@@ -81,6 +83,7 @@ module Tapioca
               create_type_members(klass, "Key", "Value")
             else
               descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
+              descriptor.each_oneof { |oneof| create_oneof_method(klass, oneof) }
               fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
               fields.sort_by!(&:name)
 
@@ -88,7 +91,15 @@ module Tapioca
                 create_kw_opt_param(field.name, type: field.init_type, default: field.default)
               end
 
-              klass.create_method("initialize", parameters: parameters, return_type: "void")
+              if fields.all? { |field| FIELD_RE.match?(field.name) }
+                klass.create_method("initialize", parameters: parameters, return_type: "void")
+              else
+                # One of the fields has an incorrect name for a named parameter so creating the default initialize for
+                # it would create a RBI with a syntax error.
+                # The workaround is to create an initialize that takes a **kwargs instead.
+                kwargs_parameter = create_kw_rest_param("fields", type: "T.untyped")
+                klass.create_method("initialize", parameters: [kwargs_parameter], return_type: "void")
+              end
             end
           end
         end
@@ -107,7 +118,7 @@ module Tapioca
           klass.create_extend("T::Generic")
 
           names.each do |name|
-            klass.create_type_member(name)
+            klass.create_type_variable(name, type: "type_member")
           end
         end
 
@@ -206,6 +217,19 @@ module Tapioca
 
           field
         end
+
+        sig do
+          params(
+            klass: RBI::Scope,
+            desc: Google::Protobuf::OneofDescriptor
+          ).void
+        end
+        def create_oneof_method(klass, desc)
+          klass.create_method(
+            desc.name,
+            return_type: "T.nilable(Symbol)"
+          )
+        end
       end
     end
   end

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

@@ -46,7 +46,7 @@ module Tapioca
           Regexp
         )
 
-        ConstantType = type_member(fixed: T.class_of(::Rails::Generators::Base))
+        ConstantType = type_member { { fixed: T.class_of(::Rails::Generators::Base) } }
 
         sig { override.void }
         def decorate

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

@@ -43,7 +43,7 @@ module Tapioca
       class SidekiqWorker < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: T.class_of(::Sidekiq::Worker))
+        ConstantType = type_member { { fixed: T.class_of(::Sidekiq::Worker) } }
 
         sig { override.void }
         def decorate

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

@@ -63,7 +63,7 @@ module Tapioca
       class SmartProperties < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: T.class_of(::SmartProperties))
+        ConstantType = type_member { { fixed: T.class_of(::SmartProperties) } }
 
         sig { override.void }
         def decorate

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

@@ -118,7 +118,7 @@ module Tapioca
       class StateMachines < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: T.all(Module, ::StateMachines::ClassMethods))
+        ConstantType = type_member { { fixed: T.all(Module, ::StateMachines::ClassMethods) } }
 
         sig { override.void }
         def decorate

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

@@ -87,7 +87,7 @@ module Tapioca
       class UrlHelpers < Compiler
         extend T::Sig
 
-        ConstantType = type_member(fixed: Module)
+        ConstantType = type_member { { fixed: Module } }
 
         sig { override.void }
         def decorate
@@ -109,6 +109,8 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def self.gather_constants
+          return [] unless Rails.application
+
           Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
           Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
 
@@ -160,7 +162,8 @@ module Tapioca
             superclass_ancestors = ancestors_of(superclass) if superclass
           end
 
-          (ancestors_of(mod) - superclass_ancestors).any? { |ancestor| helper == ancestor }
+          ancestors = Set.new.compare_by_identity.merge(ancestors_of(mod)).subtract(superclass_ancestors)
+          ancestors.any? { |ancestor| helper == ancestor }
         end
       end
     end

data/lib/tapioca/dsl/helpers/param_helper.rb

@@ -1,11 +1,14 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/helpers/signatures_helper"
+
 module Tapioca
   module Dsl
     module Helpers
       module ParamHelper
         extend T::Sig
+        include SignaturesHelper
 
         sig { params(name: String, type: String).returns(RBI::TypedParam) }
         def create_param(name, type:)
@@ -44,7 +47,7 @@ module Tapioca
 
         sig { params(param: RBI::Param, type: String).returns(RBI::TypedParam) }
         def create_typed_param(param, type)
-          RBI::TypedParam.new(param: param, type: type)
+          RBI::TypedParam.new(param: param, type: sanitize_signature_types(type))
         end
       end
     end

data/lib/tapioca/dsl/pipeline.rb

@@ -53,7 +53,7 @@ module Tapioca
       end
       def run(&blk)
         constants_to_process = gather_constants(requested_constants)
-          .select { |c| Runtime::Reflection.name_of(c) && Module === c } # Filter anonymous or value constants
+          .select { |c| Module === c } # Filter value constants out
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
         if constants_to_process.empty?
@@ -112,18 +112,49 @@ module Tapioca
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
       def gather_constants(requested_constants)
         constants = compilers.map(&:processable_constants).reduce(Set.new, :union)
+        constants = filter_anonymous_and_reloaded_constants(constants)
+
         constants &= requested_constants unless requested_constants.empty?
         constants
       end
 
+      sig { params(constants: T::Set[Module]).returns(T::Set[Module]) }
+      def filter_anonymous_and_reloaded_constants(constants)
+        # Group constants by their names
+        constants_by_name = constants
+          .group_by { |c| T.must(Runtime::Reflection.name_of(c)) }
+          .select { |name, _| !name.nil? }
+
+        # Find the constants that have been reloaded
+        reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
+
+        unless reloaded_constants.empty?
+          reloaded_constant_names = reloaded_constants.map { |name| "`#{name}`" }.join(", ")
+
+          $stderr.puts("WARNING: Multiple constants with the same name: #{reloaded_constant_names}")
+          $stderr.puts("Make sure some object is not holding onto these constants during an app reload.")
+        end
+
+        # Look up all the constants back from their names. The resulting constant set will be the
+        # set of constants that are actually in memory with those names.
+        constants_by_name
+          .keys
+          .map { |name| T.cast(Runtime::Reflection.constantize(name), Module) }
+          .to_set
+      end
+
       sig { params(constant: Module).returns(T.nilable(RBI::File)) }
       def rbi_for_constant(constant)
         file = RBI::File.new(strictness: "true")
 
         compilers.each do |compiler_class|
           next unless compiler_class.handles?(constant)
+
           compiler = compiler_class.new(self, file.root, constant)
           compiler.decorate
+        rescue
+          $stderr.puts("Error: `#{compiler_class.name}` failed to generate RBI for `#{constant}`")
+          raise # This is an unexpected error, so re-raise it
         end
 
         return if file.root.empty?

data/lib/tapioca/dsl.rb

@@ -0,0 +1,6 @@
+# typed: true
+# frozen_string_literal: true
+
+require "tapioca"
+require "tapioca/runtime/reflection"
+require "tapioca/dsl/compiler"

data/lib/tapioca/executor.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "etc"
+require "parallel"
 
 module Tapioca
   class Executor
@@ -20,10 +21,6 @@ module Tapioca
         number_of_workers || [Etc.nprocessors, (queue.length.to_f / MINIMUM_ITEMS_PER_WORKER).ceil].min,
         Integer
       )
-
-      # The number of items that will be processed per worker, so that we can split the queue into groups and assign
-      # them to each one of the workers
-      @items_per_worker = T.let((queue.length.to_f / @number_of_workers).ceil, Integer)
     end
 
     sig do
@@ -32,48 +29,9 @@ module Tapioca
       ).returns(T::Array[T.type_parameter(:T)])
     end
     def run_in_parallel(&block)
-      # If we only have one worker selected, it's not worth forking, just run sequentially
-      return @queue.map { |item| block.call(item) } if @number_of_workers == 1
-
-      read_pipes = []
-      write_pipes = []
-
-      # If we have more than one worker, fork the pool by shifting the expected number of items per worker from the
-      # queue
-      workers = (0...@number_of_workers).map do
-        items = @queue.shift(@items_per_worker)
-
-        # Each worker has their own pair of pipes, so that we can read the result from each worker separately
-        read, write = IO.pipe
-        read_pipes << read
-        write_pipes << write
-
-        fork do
-          read.close
-          result = items.map { |item| block.call(item) }
-
-          # Pack the result as a Base64 string of the Marshal dump of the array of values returned by the block that we
-          # ran in parallel
-          packed = [Marshal.dump(result)].pack("m")
-          write.puts(packed)
-          write.close
-        end
-      end
-
-      # Close all the write pipes, then read and close from all the read pipes
-      write_pipes.each(&:close)
-      result = read_pipes.map do |pipe|
-        content = pipe.read
-        pipe.close
-        content
-      end
-
-      # Wait until all the workers finish. Notice that waiting for the PIDs can only happen after we read and close the
-      # pipe or else we may end up in a condition where writing to the pipe hangs indefinitely
-      workers.each { |pid| Process.waitpid(pid) }
-
-      # Decode the value back into the Ruby objects by doing the inverse of what each worker does
-      result.flat_map { |item| T.unsafe(Marshal.load(item.unpack1("m"))) }
+      # To have the parallel gem run jobs in the parent process, you must pass 0 as the number of processes
+      number_of_processes = @number_of_workers == 1 ? 0 : @number_of_workers
+      Parallel.map(@queue, { in_processes: number_of_processes }, &block)
     end
   end
 end

data/lib/tapioca/gem/listeners/methods.rb

@@ -41,6 +41,7 @@ module Tapioca
             .each do |visibility, method_list|
               method_list.sort!.map do |name|
                 next if name == :initialize
+
                 vis = case visibility
                 when :protected
                   RBI::Protected.new
@@ -65,7 +66,7 @@ module Tapioca
         end
         def compile_method(tree, symbol_name, constant, method, visibility = RBI::Public.new)
           return unless method
-          return unless method.owner == constant
+          return unless method_owned_by_constant?(method, constant)
           return if @pipeline.symbol_in_payload?(symbol_name) && !@pipeline.method_in_gem?(method)
 
           signature = signature_of(method)
@@ -141,6 +142,29 @@ module Tapioca
           tree << rbi_method
         end
 
+        # Check whether the method is defined by the constant.
+        #
+        # In most cases, it works to check that the constant is the method owner. However,
+        # in the case that a method is also defined in a module prepended to the constant, it
+        # will be owned by the prepended module, not the constant.
+        #
+        # This method implements a better way of checking whether a constant defines a method.
+        # It walks up the ancestor tree via the `super_method` method; if any of the super
+        # methods are owned by the constant, it means that the constant declares the method.
+        sig { params(method: UnboundMethod, constant: Module).returns(T::Boolean) }
+        def method_owned_by_constant?(method, constant)
+          # Widen the type of `method` to be nilable
+          method = T.let(method, T.nilable(UnboundMethod))
+
+          while method
+            return true if method.owner == constant
+
+            method = method.super_method
+          end
+
+          false
+        end
+
         sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
         def method_names_by_visibility(mod)
           {
@@ -163,6 +187,7 @@ module Tapioca
         sig { params(name: String).returns(T::Boolean) }
         def valid_method_name?(name)
           return true if SPECIAL_METHOD_NAMES.include?(name)
+
           !!name.match(/^[[:word:]]+[?!=]?$/)
         end
 

data/lib/tapioca/gem/listeners/sorbet_props.rb

@@ -19,7 +19,7 @@ module Tapioca
           constant.props.map do |name, prop|
             type = prop.fetch(:type_object, "T.untyped").to_s.gsub(".returns(<VOID>)", ".void")
 
-            default = prop.key?(:default) ? "T.unsafe(nil)" : nil
+            default = prop.key?(:default) || prop.key?(:factory) ? "T.unsafe(nil)" : nil
             node << if prop.fetch(:immutable, false)
               RBI::TStructConst.new(name.to_s, type, default: default)
             else

data/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb

@@ -14,6 +14,7 @@ module Tapioca
           ancestors = Runtime::Trackers::RequiredAncestor.required_ancestors_by(event.constant)
           ancestors.each do |ancestor|
             next unless ancestor # TODO: We should have a way to warn from here
+
             event.node << RBI::RequiresAncestor.new(ancestor.to_s)
           end
         end

data/lib/tapioca/gem/listeners/sorbet_signatures.rb

@@ -8,7 +8,7 @@ module Tapioca
         extend T::Sig
 
         include Runtime::Reflection
-        include RBIHelper
+        include SignaturesHelper
 
         TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
 

data/lib/tapioca/gem/pipeline.rb

@@ -8,7 +8,7 @@ module Tapioca
     class Pipeline
       extend T::Sig
       include Runtime::Reflection
-      include RBIHelper
+      include SignaturesHelper
 
       IGNORED_SYMBOLS = T.let(["YAML", "MiniTest", "Mutex"], T::Array[String])
 
@@ -87,6 +87,7 @@ module Tapioca
       def symbol_in_payload?(symbol_name)
         symbol_name = symbol_name[2..-1] if symbol_name.start_with?("::")
         return false unless symbol_name
+
         @payload_symbols.include?(symbol_name)
       end
 
@@ -102,9 +103,11 @@ module Tapioca
       def name_of(constant)
         name = name_of_proxy_target(constant, super(class_of(constant)))
         return name if name
+
         name = super(constant)
         return if name.nil?
         return unless are_equal?(constant, constantize(name, inherit: true))
+
         name = "Struct" if name =~ /^(::)?Struct::[^:]+$/
         name
       end
@@ -350,6 +353,7 @@ module Tapioca
       sig { params(constant: Module, class_name: T.nilable(String)).returns(T.nilable(String)) }
       def name_of_proxy_target(constant, class_name)
         return unless class_name == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
+
         # We are dealing with a ActiveSupport::Deprecation::DeprecatedConstantProxy
         # so try to get the name of the target class
         begin

data/lib/tapioca/gemfile.rb

@@ -16,6 +16,50 @@ module Tapioca
       )
     end
 
+    # This is a module that gets prepended to `Bundler::Dependency` and
+    # makes sure even gems marked as `require: false` are required during
+    # `Bundler.require`.
+    module AutoRequireHook
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { ::Bundler::Dependency }
+
+      @exclude = T.let([], T::Array[String])
+
+      class << self
+        extend T::Sig
+
+        sig { params(exclude: T::Array[String]).returns(T::Array[String]) }
+        attr_writer :exclude
+
+        sig { params(name: T.untyped).returns(T::Boolean) }
+        def excluded?(name)
+          @exclude.include?(name)
+        end
+      end
+
+      sig { returns(T.untyped).checked(:never) }
+      def autorequire
+        value = super
+
+        # If the gem is excluded, we don't want to force require it, in case
+        # it has side-effects users don't want. For example, `fakefs` gem, if
+        # loaded, takes over filesystem operations.
+        return value if AutoRequireHook.excluded?(name)
+
+        # If a gem is marked as `require: false`, then its `autorequire`
+        # value will be `[]`. But, we want those gems to be loaded for our
+        # purposes as well, so we return `nil` in those cases, instead, which
+        # means `require: true`.
+        return nil if value == []
+
+        value
+      end
+
+      ::Bundler::Dependency.prepend(self)
+    end
+
     sig { returns(Bundler::Definition) }
     attr_reader(:definition)
 
@@ -25,8 +69,9 @@ module Tapioca
     sig { returns(T::Array[String]) }
     attr_reader(:missing_specs)
 
-    sig { void }
-    def initialize
+    sig { params(exclude: T::Array[String]).void }
+    def initialize(exclude)
+      AutoRequireHook.exclude = exclude
       @gemfile = T.let(File.new(Bundler.default_gemfile), File)
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
       @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)
@@ -94,7 +139,8 @@ module Tapioca
     class GemSpec
       extend(T::Sig)
 
-      IGNORED_GEMS = T.let(["sorbet", "sorbet-static", "sorbet-runtime"].freeze, T::Array[String])
+      IGNORED_GEMS = T.let(["sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime"].freeze,
+        T::Array[String])
 
       sig { returns(String) }
       attr_reader :full_gem_path, :version
@@ -227,6 +273,7 @@ module Tapioca
         # one of those folders to see if the path really belongs in the given gem
         # or not.
         return false unless Bundler::Source::Git === @spec.source
+
         parent = Pathname.new(path)
 
         until parent.root?

data/lib/tapioca/helpers/config_helper.rb

@@ -72,6 +72,7 @@ module Tapioca
     def validate_config!(config_file, config)
       # To ensure that this is not re-entered, we mark during validation
       return if @validating_config
+
       @validating_config = T.let(true, T.nilable(T::Boolean))
 
       commands = T.cast(self, Thor).class.commands
@@ -125,6 +126,18 @@ module Tapioca
         error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
           "`#{command_option.type.capitalize}` but found #{config_option_value_type.capitalize}"
         next build_error(error_msg) unless config_option_value_type == command_option.type
+
+        case config_option_value_type
+        when :array
+          error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
+            "`Array[String]` but found `#{config_option_value}`"
+          next build_error(error_msg) unless config_option_value.all? { |v| v.is_a?(String) }
+        when :hash
+          error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
+            "`Hash[String, String]` but found `#{config_option_value}`"
+          all_strings = (config_option_value.keys + config_option_value.values).all? { |v| v.is_a?(String) }
+          next build_error(error_msg) unless all_strings
+        end
       end.compact
     end