tapioca 0.3.0 → 0.4.3

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

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "rails"
+  require "action_controller"
+  require "action_view"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      class UrlHelpers < Base
+        extend T::Sig
+
+        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(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|
+              create_mixins_for(mod, constant, GeneratedUrlHelpersModule)
+              create_mixins_for(mod, constant, GeneratedPathHelpersModule)
+            end
+          end
+        end
+
+        NON_DISCOVERABLE_INCLUDERS = T.let([
+          ActionDispatch::IntegrationTest,
+          ActionView::Helpers,
+        ], T::Array[Module])
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          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
+
+            includes_helper?(mod, GeneratedUrlHelpersModule) ||
+              includes_helper?(mod, GeneratedPathHelpersModule) ||
+              includes_helper?(mod.singleton_class, GeneratedUrlHelpersModule) ||
+              includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
+          end
+
+          constants.concat(NON_DISCOVERABLE_INCLUDERS)
+        end
+
+        private
+
+        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")
+
+            constant.instance_methods(false).each do |method|
+              mod.create_method(
+                method.to_s,
+                parameters: [Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped")],
+                return_type: "String"
+              )
+            end
+          end
+        end
+
+        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(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)
+
+          mod.create_include(T.must(helper_module.name)) if include_helper
+          mod.create_extend(T.must(helper_module.name)) if extend_helper
+        end
+
+        sig { params(mod: Module, helper: Module).returns(T::Boolean) }
+        def includes_helper?(mod, helper)
+          superclass_ancestors = mod.superclass&.ancestors if Class === mod
+          superclass_ancestors ||= []
+          (mod.ancestors - superclass_ancestors).include?(helper)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/dsl_compiler.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# typed: true
+
+require "tapioca/compilers/dsl/base"
+
+module Tapioca
+  module Compilers
+    class DslCompiler
+      extend T::Sig
+
+      sig { returns(T::Enumerable[Dsl::Base]) }
+      attr_reader :generators
+
+      sig { returns(T::Array[Module]) }
+      attr_reader :requested_constants
+
+      sig { returns(T.proc.params(error: String).void) }
+      attr_reader :error_handler
+
+      sig do
+        params(
+          requested_constants: T::Array[Module],
+          requested_generators: T::Array[String],
+          error_handler: T.nilable(T.proc.params(error: String).void)
+        ).void
+      end
+      def initialize(requested_constants:, requested_generators: [], error_handler: nil)
+        @generators = T.let(
+          gather_generators(requested_generators),
+          T::Enumerable[Dsl::Base]
+        )
+        @requested_constants = requested_constants
+        @error_handler = error_handler || $stderr.method(:puts)
+      end
+
+      sig { params(blk: T.proc.params(constant: Module, rbi: String).void).void }
+      def run(&blk)
+        constants_to_process = gather_constants(requested_constants)
+
+        if constants_to_process.empty?
+          report_error(<<~ERROR)
+            No classes/modules can be matched for RBI generation.
+            Please check that the requested classes/modules include processable DSL methods.
+          ERROR
+        end
+
+        constants_to_process.sort_by { |c| c.name.to_s }.each do |constant|
+          rbi = rbi_for_constant(constant)
+          next if rbi.nil?
+
+          blk.call(constant, rbi)
+        end
+      end
+
+      private
+
+      sig { params(requested_generators: T::Array[String]).returns(Proc) }
+      def generator_filter(requested_generators)
+        return proc { 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
+      end
+
+      sig { params(requested_generators: T::Array[String]).returns(T::Enumerable[Dsl::Base]) }
+      def gather_generators(requested_generators)
+        generator_filter = generator_filter(requested_generators)
+
+        Dsl::Base.descendants.select(&generator_filter).map(&:new)
+      end
+
+      sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
+      def gather_constants(requested_constants)
+        constants = generators.map(&:processable_constants).reduce(Set.new, :union)
+        constants &= requested_constants unless requested_constants.empty?
+        constants
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def rbi_for_constant(constant)
+        parlour = Parlour::RbiGenerator.new(sort_namespaces: true)
+
+        generators.each do |generator|
+          next unless generator.handles?(constant)
+          generator.decorate(parlour.root, constant)
+        end
+
+        return if parlour.root.children.empty?
+
+        resolve_conflicts(parlour)
+
+        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
+      end
+
+      sig { params(error: String).returns(T.noreturn) }
+      def report_error(error)
+        handler = error_handler
+        handler.call(error)
+        exit(1)
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/requires_compiler.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# typed: strict
+
+require_relative '../sorbet_config_parser'
+
+module Tapioca
+  module Compilers
+    class RequiresCompiler
+      extend T::Sig
+
+      sig { params(sorbet_path: String).void }
+      def initialize(sorbet_path)
+        @sorbet_path = sorbet_path
+      end
+
+      sig { returns(String) }
+      def compile
+        config = SorbetConfig.parse_file(@sorbet_path)
+        files = collect_files(config)
+        files.flat_map do |file|
+          collect_requires(file).reject do |req|
+            name_in_project?(files, req)
+          end
+        end.sort.uniq.map do |name|
+          "require '#{name}'\n"
+        end.join
+      end
+
+      private
+
+      sig { params(config: SorbetConfig).returns(T::Array[String]) }
+      def collect_files(config)
+        config.paths.flat_map do |path|
+          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)
+            end
+          else
+            [path.to_s]
+          end
+        end.sort.uniq
+      end
+
+      sig { params(file_path: String).returns(T::Enumerable[String]) }
+      def collect_requires(file_path)
+        File.read(file_path).lines.map do |line|
+          /^\s*require\s*(\(\s*)?['"](?<name>[^'"]+)['"](\s*\))?/.match(line) { |m| m["name"] }
+        end.compact
+      end
+
+      sig { params(config: SorbetConfig, file: String).returns(T::Boolean) }
+      def file_ignored_by_sorbet?(config, file)
+        config.ignore.any? do |path|
+          Regexp.new(Regexp.escape(path)) =~ file
+        end
+      end
+
+      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
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/compilers/sorbet.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# typed: true
+
+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"
+
+      class << self
+        extend(T::Sig)
+
+        sig { params(args: String).returns(String) }
+        def run(*args)
+          IO.popen(
+            [
+              sorbet_path,
+              "--quiet",
+              *args,
+            ].join(' '),
+            err: "/dev/null"
+          ).read
+        end
+
+        sig { returns(String) }
+        def sorbet_path
+          SORBET.to_s.shellescape
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@ module Tapioca
         def generate
           symbols
             .sort
-            .map(&method(:generate_from_symbol))
+            .map { |symbol| generate_from_symbol(symbol) }
             .compact
             .join("\n\n")
             .concat("\n")
@@ -176,12 +176,43 @@ module Tapioca
             return if symbol_ignored?(name) && methods.nil?
 
             [
+              compile_module_helpers(constant),
               compile_mixins(constant),
+              compile_mixes_in_class_methods(constant),
+              compile_props(constant),
               methods,
             ].select { |b| b != "" }.join("\n\n")
           end
         end
 
+        sig { params(constant: Module).returns(String) }
+        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
+        end
+
+        sig { params(constant: Module).returns(String) }
+        def compile_props(constant)
+          return "" unless T::Props::ClassMethods === constant
+
+          constant.props.map do |name, prop|
+            method = "prop"
+            method = "const" if prop.fetch(:immutable, false)
+            type = prop.fetch(:type_object, "T.untyped")
+
+            indented("#{method} :#{name}, #{type}")
+          end.join("\n")
+        end
+
         sig { params(name: String, constant: Module).returns(T.nilable(String)) }
         def compile_subconstants(name, constant)
           output = constants_of(constant).sort.uniq.map do |constant_name|
@@ -286,6 +317,7 @@ module Tapioca
             end
 
           prepends = prepend
+            .reverse
             .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
             .select(&method(:public_module?))
             .map do |mod|
@@ -296,6 +328,7 @@ module Tapioca
             end
 
           includes = include
+            .reverse
             .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
             .select(&method(:public_module?))
             .map do |mod|
@@ -303,23 +336,68 @@ module Tapioca
             end
 
           extends = extend
+            .reverse
             .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
             .select(&method(:public_module?))
             .map do |mod|
               indented("extend(#{qualified_name_of(mod)})")
             end
 
-          mixes_class_methods = extend
-            .select do |mod|
-              qualified_name_of(mod) == "::ActiveSupport::Concern" &&
-                Module === resolve_constant("#{name_of(constant)}::ClassMethods")
+          (prepends + includes + extends).join("\n")
+        end
+
+        sig { params(constant: Module).returns(String) }
+        def compile_mixes_in_class_methods(constant)
+          return "" if constant.is_a?(Class)
+
+          mixins_from_modules = {}
+
+          Class.new do
+            # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+            def method_missing(symbol, *args)
             end
-            .first(1)
-            .flat_map do
-              ["", indented("mixes_in_class_methods(ClassMethods)")]
+
+            define_singleton_method(:include) do |mod|
+              before = singleton_class.ancestors
+              super(mod).tap do
+                mixins_from_modules[mod] = singleton_class.ancestors - before
+              end
             end
 
-          (prepends + includes + extends + mixes_class_methods).join("\n")
+            class << self
+              def method_missing(symbol, *args)
+              end
+            end
+            # rubocop:enable Style/MethodMissingSuper, Style/MissingRespondToMissing
+          end.include(constant)
+
+          all_dynamic_extends = mixins_from_modules.delete(constant)
+          all_dynamic_includes = mixins_from_modules.keys
+          dynamic_extends_from_dynamic_includes = mixins_from_modules.values.flatten
+          dynamic_extends = all_dynamic_extends - dynamic_extends_from_dynamic_includes
+
+          result = all_dynamic_includes
+            .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
+            .select(&method(:public_module?))
+            .map do |mod|
+              indented("include(#{qualified_name_of(mod)})")
+            end.join("\n")
+
+          mixed_in_module = dynamic_extends.find do |mod|
+            mod != constant && public_module?(mod)
+          end
+
+          return result if mixed_in_module.nil?
+
+          qualified_name = qualified_name_of(mixed_in_module)
+          return result if qualified_name == ""
+
+          [
+            result,
+            indented("mixes_in_class_methods(#{qualified_name})"),
+          ].select { |b| b != "" }.join("\n\n")
+        rescue
+          ""
         end
 
         sig { params(name: String, constant: Module).returns(T.nilable(String)) }
@@ -331,7 +409,7 @@ module Tapioca
           )
 
           instance_methods = compile_directly_owned_methods(name, constant)
-          singleton_methods = compile_directly_owned_methods(name, singleton_class_of(constant), [:public])
+          singleton_methods = compile_directly_owned_methods(name, singleton_class_of(constant))
 
           return if symbol_ignored?(name) && instance_methods.empty? && singleton_methods.empty?
 
@@ -344,24 +422,44 @@ module Tapioca
 
         sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(String) }
         def compile_directly_owned_methods(module_name, mod, for_visibility = [:public, :protected, :private])
-          method_names_by_visibility(mod)
-            .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
-            .flat_map do |visibility, method_list|
-              compiled = method_list.sort!.map do |name|
-                next if name == :initialize
-                compile_method(module_name, mod, mod.instance_method(name))
-              end
-              compiled.compact!
+          indent_step = 0
+          preamble = nil
+          postamble = nil
+
+          if mod.singleton_class?
+            indent_step = 1
+            preamble = indented("class << self")
+            postamble = indented("end")
+          end
 
-              unless compiled.empty? || visibility == :public
-                # add visibility badge
-                compiled.unshift('', indented(visibility.to_s), '')
+          methods = with_indentation(indent_step) do
+            method_names_by_visibility(mod)
+              .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
+              .flat_map do |visibility, method_list|
+                compiled = method_list.sort!.map do |name|
+                  next if name == :initialize
+                  compile_method(module_name, mod, mod.instance_method(name))
+                end
+                compiled.compact!
+
+                unless compiled.empty? || visibility == :public
+                  # add visibility badge
+                  compiled.unshift('', indented(visibility.to_s), '')
+                end
+
+                compiled
               end
+              .compact
+              .join("\n")
+          end
 
-              compiled
-            end
-            .compact
-            .join("\n")
+          return "" if methods.strip == ""
+
+          [
+            preamble,
+            methods,
+            postamble,
+          ].compact.join("\n")
         end
 
         sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
@@ -373,6 +471,16 @@ module Tapioca
           }
         end
 
+        sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+        def struct_method?(constant, method_name)
+          return false unless T::Props::ClassMethods === constant
+
+          constant
+            .props
+            .keys
+            .include?(method_name.gsub(/=$/, '').to_sym)
+        end
+
         sig do
           params(
             symbol_name: String,
@@ -385,24 +493,52 @@ module Tapioca
           return unless method.owner == constant
           return if symbol_ignored?(symbol_name) && !method_in_gem?(method)
 
+          signature = signature_of(method)
+          method = signature.method if signature
+
           method_name = method.name.to_s
           return unless valid_method_name?(method_name)
+          return if struct_method?(constant, method_name)
+          return if method_name.start_with?("__t_props_generated_")
 
           params = T.let(method.parameters, T::Array[T::Array[Symbol]])
           parameters = params.map do |(type, name)|
-            name ||= :_
+            unless name
+              # For attr_writer methods, Sorbet signatures have the name
+              # of the method (without the trailing = sign) as the name of
+              # the only parameter. So, if the parameter does not have a name
+              # then the replacement name should be the name of the method
+              # (minus trailing =) if and only if there is a signature for the
+              # method and the parameter is required and there is a single
+              # parameter and the signature also defines a single parameter and
+              # the name of the method ends with a = character.
+              writer_method_with_sig = signature &&
+                type == :req &&
+                params.size == 1 &&
+                signature.arg_types.size == 1 &&
+                method_name[-1] == "="
+
+              name = if writer_method_with_sig
+                method_name[0...-1].to_sym
+              else
+                :_
+              end
+            end
+
+            # Sanitize param names
+            name = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
 
             case type
             when :req
-              name.to_s
+              name
             when :opt
-              "#{name} = _"
+              "#{name} = T.unsafe(nil)"
             when :rest
               "*#{name}"
             when :keyreq
               "#{name}:"
             when :key
-              "#{name}: _"
+              "#{name}: T.unsafe(nil)"
             when :keyrest
               "**#{name}"
             when :block
@@ -410,10 +546,54 @@ module Tapioca
             end
           end.join(', ')
 
-          method_name = "#{'self.' if constant.singleton_class?}#{method_name}"
           parameters = "(#{parameters})" if parameters != ""
 
-          indented("def #{method_name}#{parameters}; end")
+          signature_str = indented(compile_signature(signature)) if signature
+          [
+            signature_str,
+            indented("def #{method_name}#{parameters}; end"),
+          ].compact.join("\n")
+        end
+
+        TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
+
+        sig { params(signature: T.untyped).returns(String) }
+        def compile_signature(signature)
+          params = signature.arg_types
+          params += signature.kwarg_types.to_a
+          params << [signature.rest_name, signature.rest_type] if signature.has_rest
+          params << [signature.block_name, signature.block_type] if signature.block_name
+
+          params = params.compact.map { |name, type| "#{name}: #{type}" }.join(", ")
+          returns = signature.return_type.to_s
+
+          type_parameters = (params + returns).scan(TYPE_PARAMETER_MATCHER).flatten.uniq.map { |p| ":#{p}" }.join(", ")
+          type_parameters = ".type_parameters(#{type_parameters})" unless type_parameters.empty?
+
+          mode = case signature.mode
+          when "abstract"
+            ".abstract"
+          when "override"
+            ".override"
+          when "overridable_override"
+            ".overridable.override"
+          when "overridable"
+            ".overridable"
+          else
+            ""
+          end
+
+          signature_body = +""
+          signature_body << mode
+          signature_body << type_parameters
+          signature_body << ".params(#{params})" unless params.empty?
+          signature_body << ".returns(#{returns})"
+          signature_body = signature_body
+            .gsub(".returns(<VOID>)", ".void")
+            .gsub("<NOT-TYPED>", "T.untyped")
+            .gsub(TYPE_PARAMETER_MATCHER, "T.type_parameter(:\\1)")[1..-1]
+
+          "sig { #{signature_body} }"
         end
 
         sig { params(symbol_name: String).returns(T::Boolean) }
@@ -432,16 +612,17 @@ module Tapioca
         sig do
           type_parameters(:U)
             .params(
+              step: Integer,
               _blk: T.proc
                 .returns(T.type_parameter(:U))
             )
             .returns(T.type_parameter(:U))
         end
-        def with_indentation(&_blk)
-          @indent += 2
+        def with_indentation(step = 1, &_blk)
+          @indent += 2 * step
           yield
         ensure
-          @indent -= 2
+          @indent -= 2 * step
         end
 
         sig { params(str: String).returns(String) }
@@ -576,7 +757,7 @@ module Tapioca
             return nil
           end
 
-          name_of(target)
+          raw_name_of(target)
         end
 
         sig { params(constant: Module).returns(T.nilable(String)) }
@@ -596,6 +777,13 @@ module Tapioca
           Class.instance_method(:superclass).bind(constant).call
         end
 
+        sig { params(method: T.any(UnboundMethod, Method)).returns(T.untyped) }
+        def signature_of(method)
+          T::Private::Methods.signature_for_method(method)
+        rescue LoadError, StandardError
+          nil
+        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)