tapioca 0.2.7 → 0.4.1

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

@@ -0,0 +1,83 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "parlour"
+
+begin
+  require "rails"
+  require "action_controller"
+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
+
+        sig { override.returns(T::Enumerable[T.untyped]) }
+        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)
+
+          constants = ObjectSpace.each_object(Module).select do |mod|
+            mod = T.cast(mod, T.class_of(Module))
+            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 << ActionDispatch::IntegrationTest
+        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)
+          mod.create_include(T.must(helper_module.name)) if constant.ancestors.include?(helper_module)
+          mod.create_extend(T.must(helper_module.name)) if constant.singleton_class.ancestors.include?(helper_module)
+        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

@@ -137,14 +137,11 @@ module Tapioca
         end
         def compile_object(name, value)
           return if symbol_ignored?(name)
-          indented("#{name} = T.let(T.unsafe(nil), #{type_name_of(value)})")
-        end
-
-        sig { params(value: BasicObject).returns(String).checked(:never) }
-        def type_name_of(value)
           klass = class_of(value)
+          return if name_of(klass)&.start_with?("T::Types::", "T::Private::")
 
-          public_module?(klass) && name_of(klass) || "T.untyped"
+          type_name = public_module?(klass) && name_of(klass) || "T.untyped"
+          indented("#{name} = T.let(T.unsafe(nil), #{type_name})")
         end
 
         sig { params(name: String, constant: Module).returns(T.nilable(String)) }
@@ -179,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|
@@ -289,7 +317,8 @@ module Tapioca
             end
 
           prepends = prepend
-            .select(&method(:name_of))
+            .reverse
+            .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
             .select(&method(:public_module?))
             .map do |mod|
               # TODO: Sorbet currently does not handle prepend
@@ -299,30 +328,76 @@ module Tapioca
             end
 
           includes = include
-            .select(&method(:name_of))
+            .reverse
+            .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
             .select(&method(:public_module?))
             .map do |mod|
               indented("include(#{qualified_name_of(mod)})")
             end
 
           extends = extend
-            .select(&method(:name_of))
+            .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
+
+            define_singleton_method(:include) do |mod|
+              before = singleton_class.ancestors
+              super(mod).tap do
+                mixins_from_modules[mod] = singleton_class.ancestors - before
+              end
             end
-            .first(1)
-            .flat_map do
-              ["", indented("mixes_in_class_methods(ClassMethods)")]
+
+            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
 
-          (prepends + includes + extends + mixes_class_methods).join("\n")
+          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)) }
@@ -334,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?
 
@@ -347,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]]) }
@@ -376,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,
@@ -388,24 +493,32 @@ 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 ||= :_
 
+            # 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
@@ -413,10 +526,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) }
@@ -424,11 +581,6 @@ module Tapioca
           SymbolLoader.ignore_symbol?(symbol_name)
         end
 
-        sig { params(path: String).returns(T::Boolean) }
-        def path_in_gem?(path)
-          path.start_with?(gem.full_gem_path)
-        end
-
         SPECIAL_METHOD_NAMES = %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `]
 
         sig { params(name: String).returns(T::Boolean) }
@@ -440,16 +592,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) }
@@ -462,7 +615,7 @@ module Tapioca
           source_location = method.source_location&.first
           return false if source_location.nil?
 
-          path_in_gem?(source_location)
+          gem.contains_path?(source_location)
         end
 
         sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
@@ -473,7 +626,7 @@ module Tapioca
           return !strict if files.empty?
 
           files.any? do |file|
-            path_in_gem?(file)
+            gem.contains_path?(file)
           end
         end
 
@@ -584,7 +737,7 @@ module Tapioca
             return nil
           end
 
-          name_of(target)
+          raw_name_of(target)
         end
 
         sig { params(constant: Module).returns(T.nilable(String)) }
@@ -604,6 +757,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)