tapioca 0.6.1 → 0.7.0

data/lib/tapioca/gem/pipeline.rb

@@ -0,0 +1,365 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+
+module Tapioca
+  module Gem
+    class Pipeline
+      extend T::Sig
+      include Runtime::Reflection
+      include RBIHelper
+
+      IGNORED_SYMBOLS = T.let(["YAML", "MiniTest", "Mutex"], T::Array[String])
+
+      sig { returns(Gemfile::GemSpec) }
+      attr_reader :gem
+
+      sig { params(gem: Gemfile::GemSpec, include_doc: T::Boolean).void }
+      def initialize(gem, include_doc: false)
+        @root = T.let(RBI::Tree.new, RBI::Tree)
+        @gem = gem
+        @seen = T.let(Set.new, T::Set[String])
+        @alias_namespace = T.let(Set.new, T::Set[String])
+
+        @events = T.let([], T::Array[Gem::Event])
+
+        @payload_symbols = T.let(Static::SymbolLoader.payload_symbols, T::Set[String])
+        @bootstrap_symbols = T.let(Static::SymbolLoader.gem_symbols(@gem).union(Static::SymbolLoader.engine_symbols),
+          T::Set[String])
+        @bootstrap_symbols.each { |symbol| push_symbol(symbol) }
+
+        @node_listeners = T.let([], T::Array[Gem::Listeners::Base])
+        @node_listeners << Gem::Listeners::SorbetTypeVariables.new(self)
+        @node_listeners << Gem::Listeners::Mixins.new(self)
+        @node_listeners << Gem::Listeners::DynamicMixins.new(self)
+        @node_listeners << Gem::Listeners::Methods.new(self)
+        @node_listeners << Gem::Listeners::SorbetHelpers.new(self)
+        @node_listeners << Gem::Listeners::SorbetEnums.new(self)
+        @node_listeners << Gem::Listeners::SorbetProps.new(self)
+        @node_listeners << Gem::Listeners::SorbetRequiredAncestors.new(self)
+        @node_listeners << Gem::Listeners::SorbetSignatures.new(self)
+        @node_listeners << Gem::Listeners::Subconstants.new(self)
+        @node_listeners << Gem::Listeners::YardDoc.new(self) if include_doc
+        @node_listeners << Gem::Listeners::RemoveEmptyPayloadScopes.new(self)
+      end
+
+      sig { returns(RBI::Tree) }
+      def compile
+        dispatch(next_event) until @events.empty?
+        @root
+      end
+
+      sig { params(symbol: String).void }
+      def push_symbol(symbol)
+        @events << Gem::SymbolFound.new(symbol)
+      end
+
+      sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
+      def push_constant(symbol, constant)
+        @events << Gem::ConstantFound.new(symbol, constant)
+      end
+
+      sig { params(symbol: String, constant: Module, node: RBI::Const).void.checked(:never) }
+      def push_const(symbol, constant, node)
+        @events << Gem::ConstNodeAdded.new(symbol, constant, node)
+      end
+
+      sig { params(symbol: String, constant: Module, node: RBI::Scope).void.checked(:never) }
+      def push_scope(symbol, constant, node)
+        @events << Gem::ScopeNodeAdded.new(symbol, constant, node)
+      end
+
+      sig do
+        params(
+          symbol: String,
+          constant: Module,
+          node: RBI::Method,
+          signature: T.untyped,
+          parameters: T::Array[[Symbol, String]]
+        ).void.checked(:never)
+      end
+      def push_method(symbol, constant, node, signature, parameters)
+        @events << Gem::MethodNodeAdded.new(symbol, constant, node, signature, parameters)
+      end
+
+      sig { params(symbol_name: String).returns(T::Boolean) }
+      def symbol_in_payload?(symbol_name)
+        symbol_name = symbol_name[2..-1] if symbol_name.start_with?("::")
+        return false unless symbol_name
+        @payload_symbols.include?(symbol_name)
+      end
+
+      sig { params(method: UnboundMethod).returns(T::Boolean) }
+      def method_in_gem?(method)
+        source_location = method.source_location&.first
+        return false if source_location.nil?
+
+        @gem.contains_path?(source_location)
+      end
+
+      sig { params(constant: Module).returns(T.nilable(String)) }
+      def name_of(constant)
+        name = name_of_proxy_target(constant, super(class_of(constant)))
+        return name if name
+        name = super(constant)
+        return if name.nil?
+        return unless are_equal?(constant, constantize(name, inherit: true))
+        name = "Struct" if name =~ /^(::)?Struct::[^:]+$/
+        name
+      end
+
+      private
+
+      sig { returns(Gem::Event) }
+      def next_event
+        T.must(@events.shift)
+      end
+
+      sig { params(event: Gem::Event).void }
+      def dispatch(event)
+        case event
+        when Gem::SymbolFound
+          on_symbol(event)
+        when Gem::ConstantFound
+          on_constant(event)
+        when Gem::NodeAdded
+          on_node(event)
+        else
+          raise "Unsupported event #{event.class}"
+        end
+      end
+
+      sig { params(event: Gem::SymbolFound).void }
+      def on_symbol(event)
+        symbol = event.symbol.delete_prefix("::")
+        return if symbol_in_payload?(symbol) && !@bootstrap_symbols.include?(symbol)
+
+        constant = constantize(symbol)
+        push_constant(symbol, constant) if constant
+      end
+
+      sig { params(event: Gem::ConstantFound).void.checked(:never) }
+      def on_constant(event)
+        name = event.symbol
+
+        return if name.strip.empty?
+        return if name.start_with?("#<")
+        return if name.downcase == name
+        return if alias_namespaced?(name)
+        return if seen?(name)
+
+        constant = event.constant
+        return if T::Enum === constant # T::Enum instances are defined via `compile_enums`
+
+        mark_seen(name)
+        compile_constant(name, constant)
+      end
+
+      sig { params(event: Gem::NodeAdded).void }
+      def on_node(event)
+        @node_listeners.each { |listener| listener.dispatch(event) }
+      end
+
+      # Compile
+
+      sig { params(symbol: String, constant: BasicObject).void.checked(:never) }
+      def compile_constant(symbol, constant)
+        case constant
+        when Module
+          if name_of(constant) != symbol
+            compile_alias(symbol, constant)
+          else
+            compile_module(symbol, constant)
+          end
+        else
+          compile_object(symbol, constant)
+        end
+      end
+
+      sig { params(name: String, constant: Module).void }
+      def compile_alias(name, constant)
+        return if symbol_in_payload?(name)
+
+        target = name_of(constant)
+        # If target has no name, let's make it an anonymous class or module with `Class.new` or `Module.new`
+        target = "#{constant.class}.new" unless target
+
+        add_to_alias_namespace(name)
+
+        return if IGNORED_SYMBOLS.include?(name)
+
+        node = RBI::Const.new(name, target)
+        push_const(name, constant, node)
+        @root << node
+      end
+
+      sig { params(name: String, value: BasicObject).void.checked(:never) }
+      def compile_object(name, value)
+        return if symbol_in_payload?(name)
+
+        klass = class_of(value)
+
+        klass_name = if klass == ObjectSpace::WeakMap
+          # WeakMap is an implicit generic with one type variable
+          "ObjectSpace::WeakMap[T.untyped]"
+        elsif T::Generic === klass
+          generic_name_of(klass)
+        else
+          name_of(klass)
+        end
+
+        if klass_name == "T::Private::Types::TypeAlias"
+          type_alias = sanitize_signature_types(T.unsafe(value).aliased_type.to_s)
+          node = RBI::Const.new(name, "T.type_alias { #{type_alias} }")
+          push_const(name, klass, node)
+          @root << node
+          return
+        end
+
+        return if klass_name&.start_with?("T::Types::", "T::Private::")
+
+        type_name = klass_name || "T.untyped"
+        node = RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})")
+        push_const(name, klass, node)
+        @root << node
+      end
+
+      sig { params(name: String, constant: Module).void }
+      def compile_module(name, constant)
+        return unless defined_in_gem?(constant, strict: false)
+        return if Tapioca::TypeVariableModule === constant
+
+        scope =
+          if constant.is_a?(Class)
+            superclass = compile_superclass(constant)
+            RBI::Class.new(name, superclass_name: superclass)
+          else
+            RBI::Module.new(name)
+          end
+
+        push_scope(name, constant, scope)
+        @root << scope
+      end
+
+      sig { params(constant: Class).returns(T.nilable(String)) }
+      def compile_superclass(constant)
+        superclass = T.let(nil, T.nilable(Class)) # rubocop:disable Lint/UselessAssignment
+
+        while (superclass = superclass_of(constant))
+          constant_name = name_of(constant)
+          constant = superclass
+
+          # Some types have "themselves" as their superclass
+          # which can happen via:
+          #
+          # class A < Numeric; end
+          # A = Class.new(A)
+          # A.superclass #=> A
+          #
+          # We compare names here to make sure we skip those
+          # superclass instances and walk up the chain.
+          #
+          # The name comparison is against the name of the constant
+          # resolved from the name of the superclass, since
+          # this is also possible:
+          #
+          # B = Class.new
+          # class A < B; end
+          # B = A
+          # A.superclass.name #=> "B"
+          # B #=> A
+          superclass_name = name_of(superclass)
+          next unless superclass_name
+
+          resolved_superclass = constantize(superclass_name)
+          next unless Module === resolved_superclass
+          next if name_of(resolved_superclass) == constant_name
+
+          # We found a suitable superclass
+          break
+        end
+
+        return if superclass == ::Object || superclass == ::Delegator
+        return if superclass.nil?
+
+        name = name_of(superclass)
+        return if name.nil? || name.empty?
+
+        push_symbol(name)
+
+        "::#{name}"
+      end
+
+      sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
+      def defined_in_gem?(constant, strict: true)
+        files = Set.new(get_file_candidates(constant))
+          .merge(Runtime::Trackers::ConstantDefinition.files_for(constant))
+
+        return !strict if files.empty?
+
+        files.any? do |file|
+          @gem.contains_path?(file)
+        end
+      end
+
+      sig { params(constant: Module).returns(T::Array[String]) }
+      def get_file_candidates(constant)
+        wrapped_module = Pry::WrappedModule.new(constant)
+
+        wrapped_module.candidates.map(&:file).to_a.compact
+      rescue ArgumentError, NameError
+        []
+      end
+
+      sig { params(name: String).void }
+      def add_to_alias_namespace(name)
+        @alias_namespace.add("#{name}::")
+      end
+
+      sig { params(name: String).returns(T::Boolean) }
+      def alias_namespaced?(name)
+        @alias_namespace.any? do |namespace|
+          name.start_with?(namespace)
+        end
+      end
+
+      sig { params(name: String).void }
+      def mark_seen(name)
+        @seen.add(name)
+      end
+
+      sig { params(name: String).returns(T::Boolean) }
+      def seen?(name)
+        @seen.include?(name)
+      end
+
+      sig { params(constant: T.all(Module, T::Generic)).returns(String) }
+      def generic_name_of(constant)
+        type_name = T.must(constant.name)
+        return type_name if type_name =~ /\[.*\]$/
+
+        type_variables = Runtime::GenericTypeRegistry.lookup_type_variables(constant)
+        return type_name unless type_variables
+
+        type_variable_names = type_variables.map { "T.untyped" }.join(", ")
+
+        "#{type_name}[#{type_variable_names}]"
+      end
+
+      sig { params(constant: Module, class_name: T.nilable(String)).returns(T.nilable(String)) }
+      def name_of_proxy_target(constant, class_name)
+        return unless class_name == "ActiveSupport::Deprecation::DeprecatedConstantProxy"
+        # We are dealing with a ActiveSupport::Deprecation::DeprecatedConstantProxy
+        # so try to get the name of the target class
+        begin
+          target = constant.__send__(:target)
+        rescue NoMethodError
+          return
+        end
+
+        name_of(target)
+      end
+    end
+  end
+end

data/lib/tapioca/gemfile.rb

@@ -99,6 +99,9 @@ module Tapioca
       sig { returns(String) }
       attr_reader :full_gem_path, :version
 
+      sig { returns(T::Array[Pathname]) }
+      attr_reader :files
+
       sig { params(spec: Spec).void }
       def initialize(spec)
         @spec = T.let(spec, Tapioca::Gemfile::Spec)
@@ -106,6 +109,7 @@ module Tapioca
         @full_gem_path = T.let(real_gem_path, String)
         @version = T.let(version_string, String)
         @exported_rbi_files = T.let(nil, T.nilable(T::Array[String]))
+        @files = T.let(collect_files, T::Array[Pathname])
       end
 
       sig { params(gemfile_dir: String).returns(T::Boolean) }
@@ -113,21 +117,6 @@ module Tapioca
         gem_ignored? || gem_in_app_dir?(gemfile_dir)
       end
 
-      sig { returns(T::Array[Pathname]) }
-      def files
-        if default_gem?
-          # `Bundler::RemoteSpecification` delegates missing methods to
-          # `Gem::Specification`, so `files` actually always exists on spec.
-          T.unsafe(@spec).files.map do |file|
-            ruby_lib_dir.join(file)
-          end
-        else
-          @spec.full_require_paths.flat_map do |path|
-            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
-          end
-        end
-      end
-
       sig { returns(String) }
       def name
         @spec.name
@@ -154,7 +143,7 @@ module Tapioca
 
       sig { returns(T::Array[String]) }
       def exported_rbi_files
-        @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi")
+        @exported_rbi_files ||= Dir.glob("#{full_gem_path}/rbi/**/*.rbi").sort
       end
 
       sig { returns(T::Boolean) }
@@ -176,14 +165,49 @@ module Tapioca
 
       private
 
-      sig { returns(T::Boolean) }
+      sig { returns(T::Array[Pathname]) }
+      def collect_files
+        if default_gem?
+          # `Bundler::RemoteSpecification` delegates missing methods to
+          # `Gem::Specification`, so `files` actually always exists on spec.
+          T.unsafe(@spec).files.map do |file|
+            resolve_to_ruby_lib_dir(file)
+          end
+        else
+          @spec.full_require_paths.flat_map do |path|
+            Pathname.glob((Pathname.new(path) / "**/*.rb").to_s)
+          end
+        end
+      end
+
+      sig { returns(T.nilable(T::Boolean)) }
       def default_gem?
         @spec.respond_to?(:default_gem?) && @spec.default_gem?
       end
 
-      sig { returns(Pathname) }
-      def ruby_lib_dir
-        Pathname.new(RbConfig::CONFIG["rubylibdir"])
+      sig { returns(Regexp) }
+      def require_paths_prefix_matcher
+        @require_paths_prefix_matcher = T.let(@require_paths_prefix_matcher, T.nilable(Regexp))
+
+        @require_paths_prefix_matcher ||= begin
+          require_paths = T.unsafe(@spec).require_paths
+          prefix_matchers = require_paths.map { |rp| Regexp.new("^#{rp}/") }
+          Regexp.union(prefix_matchers)
+        end
+      end
+
+      sig { params(file: String).returns(Pathname) }
+      def resolve_to_ruby_lib_dir(file)
+        # We want to match require prefixes but fallback to an empty match
+        # if none of the require prefixes actually match. This is so that
+        # we can always replace the match with the Ruby lib directory and
+        # we would have properly resolved the file under the Ruby lib dir.
+        prefix_matcher = Regexp.union(require_paths_prefix_matcher, //)
+
+        ruby_lib_dir = RbConfig::CONFIG["rubylibdir"]
+        file = file.sub(prefix_matcher, "#{ruby_lib_dir}/")
+
+        Pathname.new(file).expand_path
       end
 
       sig { returns(String) }

data/lib/tapioca/helpers/cli_helper.rb

@@ -12,15 +12,23 @@ module Tapioca
 
     sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
     def say_error(message = "", *color)
-      force_new_line = (message.to_s !~ /( |\t)\Z/)
-      # NOTE: This is a hack. We're no longer subclassing from Thor::Shell::Color
-      # so we no longer have access to the prepare_message call.
-      # We should update this to remove this.
-      buffer = shell.send(:prepare_message, *T.unsafe([message, *T.unsafe(color)]))
-      buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
+      # Thor has its own `say_error` now, but it has two problems:
+      # 1. it adds the padding around all the messages, even if they continue on
+      #    the same line, and
+      # 2. it accepts a last parameter which breaks the ability to pass color values
+      #    as splats.
+      #
+      # So we implement our own version here to work around those problems.
+      shell.indent(-shell.padding) do
+        super(message, color)
+      end
+    end
 
-      $stderr.print(buffer)
-      $stderr.flush
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(RBIFormatter) }
+    def rbi_formatter(options)
+      rbi_formatter = DEFAULT_RBI_FORMATTER
+      rbi_formatter.max_line_length = options[:rbi_max_line_length]
+      rbi_formatter
     end
   end
 end

data/lib/tapioca/helpers/config_helper.rb

@@ -6,6 +6,9 @@ require "yaml"
 module Tapioca
   module ConfigHelper
     extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor }
 
     sig { returns(String) }
     attr_reader :command_name
@@ -60,9 +63,119 @@ module Tapioca
         config = YAML.load_file(config_file, fallback: {})
       end
 
+      validate_config!(config_file, config)
+
       Thor::CoreExt::HashWithIndifferentAccess.new(config[command_name] || {})
     end
 
+    sig { params(config_file: String, config: T::Hash[T.untyped, T.untyped]).void }
+    def validate_config!(config_file, config)
+      # To ensure that this is not re-entered, we mark during validation
+      return if @validating_config
+      @validating_config = T.let(true, T.nilable(T::Boolean))
+
+      commands = T.cast(self, Thor).class.commands
+
+      errors = config.flat_map do |config_key, config_options|
+        command = commands[config_key.to_s]
+
+        unless command
+          next build_error("unknown key `#{config_key}`")
+        end
+
+        validate_config_options(command.options, config_key, config_options || {})
+      end.compact
+
+      unless errors.empty?
+        print_errors(config_file, errors)
+        exit(1)
+      end
+    ensure
+      @validating_config = false
+    end
+
+    sig do
+      params(
+        command_options: T::Hash[Symbol, Thor::Option],
+        config_key: String,
+        config_options: T::Hash[T.untyped, T.untyped]
+      ).returns(T::Array[ConfigError])
+    end
+    def validate_config_options(command_options, config_key, config_options)
+      config_options.map do |config_option_key, config_option_value|
+        command_option = command_options[config_option_key.to_sym]
+        error_msg = "unknown option `#{config_option_key}` for key `#{config_key}`"
+        next build_error(error_msg) unless command_option
+
+        config_option_value_type = case config_option_value
+        when FalseClass, TrueClass
+          :boolean
+        when Numeric
+          :numeric
+        when Hash
+          :hash
+        when Array
+          :array
+        when String
+          :string
+        else
+          :object
+        end
+
+        error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
+          "`#{command_option.type.capitalize}` but found #{config_option_value_type.capitalize}"
+        next build_error(error_msg) unless config_option_value_type == command_option.type
+      end.compact
+    end
+
+    class ConfigErrorMessagePart < T::Struct
+      const :message, String
+      const :colors, T::Array[Symbol]
+    end
+
+    class ConfigError < T::Struct
+      const :message_parts, T::Array[ConfigErrorMessagePart]
+    end
+
+    sig { params(msg: String).returns(ConfigError) }
+    def build_error(msg)
+      parts = msg.split(/(`[^`]+` ?)/)
+
+      message_parts = parts.map do |part|
+        match = part.match(/`([^`]+)`( ?)/)
+
+        if match
+          ConfigErrorMessagePart.new(
+            message: "#{match[1]}#{match[2]}",
+            colors: [:bold, :blue]
+          )
+        else
+          ConfigErrorMessagePart.new(
+            message: part,
+            colors: [:yellow]
+          )
+        end
+      end
+
+      ConfigError.new(
+        message_parts: message_parts
+      )
+    end
+
+    sig { params(config_file: String, errors: T::Array[ConfigError]).void }
+    def print_errors(config_file, errors)
+      say_error("\nConfiguration file ", :red)
+      say_error("#{config_file} ", :blue, :bold)
+      say_error("has the following errors:\n\n", :red)
+
+      errors.each do |error|
+        say_error("- ")
+        error.message_parts.each do |part|
+          T.unsafe(self).say_error(part.message, *part.colors)
+        end
+      end
+    end
+
     sig do
       params(options: T.nilable(Thor::CoreExt::HashWithIndifferentAccess))
         .returns(Thor::CoreExt::HashWithIndifferentAccess)

data/lib/tapioca/helpers/rbi_helper.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBIHelper
+    extend T::Sig
+
+    sig { params(sig_string: String).returns(String) }
+    def sanitize_signature_types(sig_string)
+      sig_string
+        .gsub(".returns(<VOID>)", ".void")
+        .gsub("<VOID>", "void")
+        .gsub("<NOT-TYPED>", "T.untyped")
+        .gsub(".params()", "")
+    end
+  end
+end