tapioca 0.4.27 → 0.5.3

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)

data/lib/tapioca/compilers/dsl_compiler.rb

@@ -20,20 +20,21 @@ module Tapioca
       sig do
         params(
           requested_constants: T::Array[Module],
-          requested_generators: T::Array[String],
+          requested_generators: T::Array[T.class_of(Dsl::Base)],
+          excluded_generators: T::Array[T.class_of(Dsl::Base)],
           error_handler: T.nilable(T.proc.params(error: String).void)
         ).void
       end
-      def initialize(requested_constants:, requested_generators: [], error_handler: nil)
+      def initialize(requested_constants:, requested_generators: [], excluded_generators: [], error_handler: nil)
         @generators = T.let(
-          gather_generators(requested_generators),
+          gather_generators(requested_generators, excluded_generators),
           T::Enumerable[Dsl::Base]
         )
         @requested_constants = requested_constants
         @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 }
+      sig { params(blk: T.proc.params(constant: Module, rbi: RBI::File).void).void }
       def run(&blk)
         constants_to_process = gather_constants(requested_constants)
 
@@ -50,27 +51,27 @@ module Tapioca
 
           blk.call(constant, rbi)
         end
+
+        generators.flat_map(&:errors).each do |msg|
+          report_error(msg)
+        end
       end
 
       private
 
-      sig { params(requested_generators: T::Array[String]).returns(T.proc.params(klass: Class).returns(T::Boolean)) }
-      def generator_filter(requested_generators)
-        return ->(_klass) { true } if requested_generators.empty?
-
-        generators = requested_generators.map(&:downcase)
-
-        proc do |klass|
-          generator = klass.name&.sub(/^Tapioca::Compilers::Dsl::/, '')&.downcase
-          generators.include?(generator)
-        end
+      sig do
+        params(
+          requested_generators: T::Array[T.class_of(Dsl::Base)],
+          excluded_generators: T::Array[T.class_of(Dsl::Base)]
+        ).returns(T::Enumerable[Dsl::Base])
       end
+      def gather_generators(requested_generators, excluded_generators)
+        generator_klasses = ::Tapioca::Reflection.descendants_of(Dsl::Base).select do |klass|
+          (requested_generators.empty? || requested_generators.include?(klass)) &&
+            !excluded_generators.include?(klass)
+        end.sort_by { |klass| T.must(klass.name) }
 
-      sig { params(requested_generators: T::Array[String]).returns(T::Enumerable[Dsl::Base]) }
-      def gather_generators(requested_generators)
-        generator_filter = generator_filter(requested_generators)
-
-        T.cast(Dsl::Base.descendants.select(&generator_filter).map(&:new), T::Enumerable[Dsl::Base])
+        generator_klasses.map(&:new)
       end
 
       sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
@@ -80,34 +81,18 @@ module Tapioca
         constants
       end
 
-      sig { params(constant: Module).returns(T.nilable(String)) }
+      sig { params(constant: Module).returns(T.nilable(RBI::File)) }
       def rbi_for_constant(constant)
-        parlour = Parlour::RbiGenerator.new(sort_namespaces: true)
+        file = RBI::File.new(strictness: "true")
 
         generators.each do |generator|
           next unless generator.handles?(constant)
-          generator.decorate(parlour.root, constant)
+          generator.decorate(file.root, constant)
         end
 
-        return if parlour.root.children.empty?
-
-        resolve_conflicts(parlour)
+        return if file.root.empty?
 
-        parlour.rbi("true").strip
-      end
-
-      sig { params(parlour: Parlour::RbiGenerator).void }
-      def resolve_conflicts(parlour)
-        Parlour::ConflictResolver.new.resolve_conflicts(parlour.root) do |msg, candidates|
-          error = StringIO.new
-          error.puts "=== Error ==="
-          error.puts msg
-          error.puts "# Candidates"
-          candidates.each_with_index do |candidate, index|
-            error.puts "  #{index}. #{candidate.describe}"
-          end
-          report_error(error.string)
-        end
+        file
       end
 
       sig { params(error: String).returns(T.noreturn) }

data/lib/tapioca/compilers/dynamic_mixin_compiler.rb

@@ -0,0 +1,198 @@
+# typed: strict
+# frozen_string_literal: true
+
+class DynamicMixinCompiler
+  extend T::Sig
+  include Tapioca::Reflection
+
+  sig { returns(T::Array[Module]) }
+  attr_reader :dynamic_extends, :dynamic_includes
+
+  sig { returns(T::Array[Symbol]) }
+  attr_reader :class_attribute_readers, :class_attribute_writers, :class_attribute_predicates
+
+  sig { returns(T::Array[Symbol]) }
+  attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
+
+  sig { params(constant: Module).void }
+  def initialize(constant)
+    @constant = constant
+    mixins_from_modules = {}.compare_by_identity
+    class_attribute_readers = T.let([], T::Array[Symbol])
+    class_attribute_writers = T.let([], T::Array[Symbol])
+    class_attribute_predicates = T.let([], T::Array[Symbol])
+
+    instance_attribute_readers = T.let([], T::Array[Symbol])
+    instance_attribute_writers = T.let([], T::Array[Symbol])
+    instance_attribute_predicates = T.let([], T::Array[Symbol])
+
+    Class.new do
+      # Override the `self.include` method
+      define_singleton_method(:include) do |mod|
+        # Take a snapshot of the list of singleton class ancestors
+        # before the actual include
+        before = singleton_class.ancestors
+        # Call the actual `include` method with the supplied module
+        super(mod).tap do
+          # Take a snapshot of the list of singleton class ancestors
+          # after the actual include
+          after = singleton_class.ancestors
+          # The difference is the modules that are added to the list
+          # of ancestors of the singleton class. Those are all the
+          # modules that were `extend`ed due to the `include` call.
+          #
+          # We record those modules on our lookup table keyed by
+          # the included module with the values being all the modules
+          # that that module pulls into the singleton class.
+          #
+          # We need to reverse the order, since the extend order should
+          # be the inverse of the ancestor order. That is, earlier
+          # extended modules would be later in the ancestor chain.
+          mixins_from_modules[mod] = (after - before).reverse!
+        end
+      rescue Exception # rubocop:disable Lint/RescueException
+        # this is a best effort, bail if we can't perform this
+      end
+
+      define_singleton_method(:class_attribute) do |*attrs, **kwargs|
+        class_attribute_readers.concat(attrs)
+        class_attribute_writers.concat(attrs)
+
+        instance_predicate = kwargs.fetch(:instance_predicate, true)
+        instance_accessor = kwargs.fetch(:instance_accessor, true)
+        instance_reader = kwargs.fetch(:instance_reader, instance_accessor)
+        instance_writer = kwargs.fetch(:instance_writer, instance_accessor)
+
+        if instance_reader
+          instance_attribute_readers.concat(attrs)
+        end
+
+        if instance_writer
+          instance_attribute_writers.concat(attrs)
+        end
+
+        if instance_predicate
+          class_attribute_predicates.concat(attrs)
+
+          if instance_reader
+            instance_attribute_predicates.concat(attrs)
+          end
+        end
+
+        super(*attrs, **kwargs) if defined?(super)
+      end
+
+      # rubocop:disable Style/MissingRespondToMissing
+      T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+      def method_missing(symbol, *args)
+        # We need this here so that we can handle any random instance
+        # method calls on the fake including class that may be done by
+        # the included module during the `self.included` hook.
+      end
+
+      class << self
+        extend T::Sig
+
+        T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+        def method_missing(symbol, *args)
+          # Similarly, we need this here so that we can handle any
+          # random class method calls on the fake including class
+          # that may be done by the included module during the
+          # `self.included` hook.
+        end
+      end
+      # rubocop:enable Style/MissingRespondToMissing
+    end.include(constant)
+
+    # The value that corresponds to the original included constant
+    # is the list of all dynamically extended modules because of that
+    # constant. We grab that value by deleting the key for the original
+    # constant.
+    @dynamic_extends = T.let(mixins_from_modules.delete(constant) || [], T::Array[Module])
+
+    # Since we deleted the original constant from the list of keys, all
+    # the keys that remain are the ones that are dynamically included modules
+    # during the include of the original constant.
+    @dynamic_includes = T.let(mixins_from_modules.keys, T::Array[Module])
+
+    @class_attribute_readers = T.let(class_attribute_readers, T::Array[Symbol])
+    @class_attribute_writers = T.let(class_attribute_writers, T::Array[Symbol])
+    @class_attribute_predicates = T.let(class_attribute_predicates, T::Array[Symbol])
+
+    @instance_attribute_readers = T.let(instance_attribute_readers, T::Array[Symbol])
+    @instance_attribute_writers = T.let(instance_attribute_writers, T::Array[Symbol])
+    @instance_attribute_predicates = T.let(instance_attribute_predicates, T::Array[Symbol])
+  end
+
+  sig { returns(T::Boolean) }
+  def empty_attributes?
+    @class_attribute_readers.empty? && @class_attribute_writers.empty?
+  end
+
+  sig { params(tree: RBI::Tree).void }
+  def compile_class_attributes(tree)
+    return if empty_attributes?
+
+    # Create a synthetic module to hold the generated class methods
+    tree << RBI::Module.new("GeneratedClassMethods") do |mod|
+      class_attribute_readers.each do |attribute|
+        mod << RBI::Method.new(attribute.to_s)
+      end
+
+      class_attribute_writers.each do |attribute|
+        mod << RBI::Method.new("#{attribute}=") do |method|
+          method << RBI::Param.new("value")
+        end
+      end
+
+      class_attribute_predicates.each do |attribute|
+        mod << RBI::Method.new("#{attribute}?")
+      end
+    end
+
+    # Create a synthetic module to hold the generated instance methods
+    tree << RBI::Module.new("GeneratedInstanceMethods") do |mod|
+      instance_attribute_readers.each do |attribute|
+        mod << RBI::Method.new(attribute.to_s)
+      end
+
+      instance_attribute_writers.each do |attribute|
+        mod << RBI::Method.new("#{attribute}=") do |method|
+          method << RBI::Param.new("value")
+        end
+      end
+
+      instance_attribute_predicates.each do |attribute|
+        mod << RBI::Method.new("#{attribute}?")
+      end
+    end
+
+    # Add a mixes_in_class_methods and include for the generated modules
+    tree << RBI::MixesInClassMethods.new("GeneratedClassMethods")
+    tree << RBI::Include.new("GeneratedInstanceMethods")
+  end
+
+  sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
+  def compile_mixes_in_class_methods(tree)
+    includes = dynamic_includes.select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
+    includes.each do |mod|
+      qname = qualified_name_of(mod)
+      tree << RBI::Include.new(T.must(qname))
+    end
+
+    # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
+    # constant itself
+    mixed_in_class_methods = dynamic_extends.select { |mod| mod != @constant }
+    return [[], []] if mixed_in_class_methods.empty?
+
+    mixed_in_class_methods.each do |mod|
+      qualified_name = qualified_name_of(mod)
+      next if qualified_name.nil? || qualified_name.empty?
+      tree << RBI::MixesInClassMethods.new(qualified_name)
+    end
+
+    [mixed_in_class_methods, includes]
+  rescue
+    [[], []] # silence errors
+  end
+end

data/lib/tapioca/compilers/requires_compiler.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'spoom'
+require "spoom"
 
 module Tapioca
   module Compilers
@@ -87,7 +87,7 @@ module Tapioca
       sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
       def name_in_project?(files, name)
         files.any? do |file|
-          File.basename(file, '.rb') == name
+          File.basename(file, ".rb") == name
         end
       end
     end

data/lib/tapioca/compilers/sorbet.rb

@@ -1,15 +1,25 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require 'pathname'
-require 'shellwords'
+require "pathname"
+require "shellwords"
 
 module Tapioca
   module Compilers
     module Sorbet
-      SORBET = Pathname.new(Gem::Specification.find_by_name("sorbet-static").full_gem_path) / "libexec" / "sorbet"
+      SORBET_GEM_SPEC = T.let(
+        Gem::Specification.find_by_name("sorbet-static"),
+        Gem::Specification
+      )
+      SORBET = T.let(
+        Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
+        Pathname
+      )
       EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
+      FEATURE_REQUIREMENTS = T.let({
+      }.freeze, T::Hash[Symbol, Gem::Requirement])
+
       class << self
         extend(T::Sig)
 
@@ -20,7 +30,7 @@ module Tapioca
               sorbet_path,
               "--quiet",
               *args,
-            ].join(' '),
+            ].join(" "),
             err: "/dev/null"
           ).read
         end
@@ -31,6 +41,16 @@ module Tapioca
           sorbet_path = SORBET if sorbet_path.empty?
           sorbet_path.to_s.shellescape
         end
+
+        sig { params(feature: Symbol, version: T.nilable(Gem::Version)).returns(T::Boolean) }
+        def supports?(feature, version: nil)
+          version = SORBET_GEM_SPEC.version unless version
+          requirement = FEATURE_REQUIREMENTS[feature]
+
+          raise "Invalid Sorbet feature #{feature}" unless requirement
+
+          requirement.satisfied_by?(version)
+        end
       end
     end
   end