tapioca 0.4.0 → 0.4.5

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

@@ -0,0 +1,160 @@
+# 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
+      # `Tapioca::Compilers::Dsl::UrlHelpers` generates RBI files for classes that include or extend
+      # `Rails.application.routes.url_helpers`
+      # (see https://api.rubyonrails.org/v5.1.7/classes/ActionDispatch/Routing/UrlFor.html#module-ActionDispatch::Routing::UrlFor-label-URL+generation+for+named+routes).
+      #
+      # For example, with the following setup:
+      #
+      # ~~~rb
+      # # config/application.rb
+      # class Application < Rails::Application
+      #   routes.draw do
+      #     resource :index
+      #   end
+      # end
+      # ~~~
+      #
+      # ~~~rb
+      # app/models/post.rb
+      # class Post
+      #   include Rails.application.routes.url_helpers
+      # end
+      # ~~~
+      #
+      # this generator will produce the following RBI files:
+      #
+      # ~~~rbi
+      # # generated_path_helpers_module.rbi
+      # # typed: true
+      # module GeneratedPathHelpersModule
+      #   include ActionDispatch::Routing::PolymorphicRoutes
+      #   include ActionDispatch::Routing::UrlFor
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def edit_index_path(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def index_path(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def new_index_path(*args); end
+      # end
+      # ~~~
+      #
+      # ~~~rbi
+      # # generated_url_helpers_module.rbi
+      # # typed: true
+      # module GeneratedUrlHelpersModule
+      #   include ActionDispatch::Routing::PolymorphicRoutes
+      #   include ActionDispatch::Routing::UrlFor
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def edit_index_url(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def index_url(*args); end
+      #
+      #   sig { params(args: T.untyped).returns(String) }
+      #   def new_index_url(*args); end
+      # end
+      # ~~~
+      #
+      # ~~~rbi
+      # # post.rbi
+      # # typed: true
+      # class Post
+      #   include GeneratedPathHelpersModule
+      #   include GeneratedUrlHelpersModule
+      # end
+      # ~~~
+      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 'spoom'
+
+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 = Spoom::Sorbet::Config.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: Spoom::Sorbet::Config).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: Spoom::Sorbet::Config, 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

@@ -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,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|
@@ -353,8 +383,18 @@ module Tapioca
               indented("include(#{qualified_name_of(mod)})")
             end.join("\n")
 
-          mixed_in_module = dynamic_extends.find do |mod|
-            mod != constant && public_module?(mod)
+          ancestors = singleton_class_of(constant).ancestors
+          extends_as_concern = ancestors.any? do |mod|
+            qualified_name_of(mod) == "::ActiveSupport::Concern"
+          end
+          class_methods_module = resolve_constant("#{name_of(constant)}::ClassMethods")
+
+          mixed_in_module = if extends_as_concern && Module === class_methods_module
+            class_methods_module
+          else
+            dynamic_extends.find do |mod|
+              mod != constant && public_module?(mod)
+            end
           end
 
           return result if mixed_in_module.nil?
@@ -379,7 +419,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 +432,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 +481,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,27 +503,58 @@ module Tapioca
           return unless method.owner == constant
           return if symbol_ignored?(symbol_name) && !method_in_gem?(method)
 
+          signature = signature_of(method)
+          method = T.let(signature.method, UnboundMethod) if signature
+
           method_name = method.name.to_s
           return unless valid_method_name?(method_name)
-
-          params = T.let(method.parameters, T::Array[T::Array[Symbol]])
-          parameters = params.map do |(type, name)|
-            name ||= :_
+          return if struct_method?(constant, method_name)
+          return if method_name.start_with?("__t_props_generated_")
+
+          parameters = T.let(method.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+          sanitized_parameters = parameters.map do |type, 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 &&
+                parameters.size == 1 &&
+                signature.arg_types.size == 1 &&
+                method_name[-1] == "="
+              )
+
+              name = if writer_method_with_sig
+                T.must(method_name[0...-1]).to_sym
+              else
+                :_
+              end
+            end
 
             # Sanitize param names
             name = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
 
+            [type, name]
+          end
+
+          parameter_list = sanitized_parameters.map do |type, name|
             case type
             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 +562,59 @@ module Tapioca
             end
           end.join(', ')
 
-          method_name = "#{'self.' if constant.singleton_class?}#{method_name}"
-          parameters = "(#{parameters})" if parameters != ""
+          parameter_list = "(#{parameter_list})" if parameter_list != ""
+          signature_str = indented(compile_signature(signature, sanitized_parameters)) if signature
+
+          [
+            signature_str,
+            indented("def #{method_name}#{parameter_list}; end"),
+          ].compact.join("\n")
+        end
+
+        TYPE_PARAMETER_MATCHER = /T\.type_parameter\(:?([[:word:]]+)\)/
+
+        sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(String) }
+        def compile_signature(signature, parameters)
+          parameter_types = T.let(signature.arg_types.to_h, T::Hash[Symbol, T::Types::Base])
+          parameter_types.merge!(signature.kwarg_types)
+          parameter_types[signature.rest_name] = signature.rest_type if signature.has_rest
+          parameter_types[signature.keyrest_name] = signature.keyrest_type if signature.has_keyrest
+          parameter_types[signature.block_name] = signature.block_type if signature.block_name
+
+          params = parameters.map do |_, name|
+            type = parameter_types[name.to_sym]
+            "#{name}: #{type}"
+          end.join(", ")
+
+          returns = type_of(signature.return_type)
+
+          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
 
-          indented("def #{method_name}#{parameters}; 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 +633,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 +778,7 @@ module Tapioca
             return nil
           end
 
-          name_of(target)
+          raw_name_of(target)
         end
 
         sig { params(constant: Module).returns(T.nilable(String)) }
@@ -647,6 +798,18 @@ 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).returns(String) }
+        def type_of(constant)
+          constant.to_s.gsub(/\bAttachedClass\b/, "T.attached_class")
+        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)