tapioca 0.4.0 → 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/symbol_table/symbol_generator.rb

@@ -176,13 +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|
@@ -379,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?
 
@@ -392,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]]) }
@@ -421,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,
@@ -433,8 +493,13 @@ 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)|
@@ -447,13 +512,13 @@ module Tapioca
             when :req
               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
@@ -461,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) }
@@ -483,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) }
@@ -627,7 +737,7 @@ module Tapioca
             return nil
           end
 
-          name_of(target)
+          raw_name_of(target)
         end
 
         sig { params(constant: Module).returns(T.nilable(String)) }
@@ -647,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)