tapioca 0.6.4 → 0.7.2

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 SignaturesHelper
+
+      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/helpers/cli_helper.rb

@@ -23,5 +23,12 @@ module Tapioca
         super(message, color)
       end
     end
+
+    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

@@ -104,10 +104,8 @@ module Tapioca
     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]
-
-        unless command_option
-          next build_error("unknown option `#{config_option_key}` for key `#{config_key}`")
-        end
+        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
@@ -124,10 +122,9 @@ module Tapioca
           :object
         end
 
-        unless config_option_value_type == command_option.type
-          next build_error("invalid value for option `#{config_option_key}` for key `#{config_key}` " \
-            "- expected `#{command_option.type.capitalize}` but found #{config_option_value_type.capitalize}")
-        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
 

data/lib/tapioca/helpers/shims_helper.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module ShimsHelper
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor::Shell }
+
+    sig { params(index: RBI::Index, kind: String, dir: String).void }
+    def index_rbis(index, kind, dir)
+      return unless Dir.exist?(dir) && !Dir.empty?(dir)
+
+      say("Loading #{kind} RBIs from #{dir}... ")
+      files = Dir.glob("#{dir}/**/*.rbi").sort
+
+      trees = files.map do |file|
+        RBI::Parser.parse_file(file)
+      rescue RBI::ParseError => e
+        say_error("\nWarning: #{e} (#{e.location})", :yellow)
+      end.compact
+
+      index.visit_all(trees)
+      say(" Done", :green)
+    end
+
+    sig { params(index: RBI::Index, shim_rbi_dir: String).returns(T::Hash[String, T::Array[RBI::Node]]) }
+    def duplicated_nodes_from_index(index, shim_rbi_dir)
+      duplicates = {}
+      say("Looking for duplicates... ")
+      index.keys.each do |key|
+        nodes = index[key]
+        next unless shims_have_duplicates?(nodes, shim_rbi_dir)
+        duplicates[key] = nodes
+      end
+      say(" Done", :green)
+      duplicates
+    end
+
+    private
+
+    sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String).returns(T::Boolean) }
+    def shims_have_duplicates?(nodes, shim_rbi_dir)
+      return false if nodes.size == 1
+
+      shims = extract_shims(nodes, shim_rbi_dir)
+      return false if shims.empty?
+
+      props = extract_methods_and_attrs(shims)
+      return false if props.empty?
+
+      shims_with_sigs = extract_nodes_with_sigs(props)
+      shims_with_sigs.each do |shim|
+        shim_sigs = shim.sigs
+
+        extract_methods_and_attrs(nodes).each do |node|
+          next if node == shim
+          return true if shim_sigs.all? { |sig| node.sigs.include?(sig) }
+        end
+
+        return false
+      end
+
+      true
+    end
+
+    sig { params(nodes: T::Array[RBI::Node], shim_rbi_dir: String).returns(T::Array[RBI::Node]) }
+    def extract_shims(nodes, shim_rbi_dir)
+      nodes.select do |node|
+        node.loc&.file&.start_with?(shim_rbi_dir)
+      end
+    end
+
+    sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
+    def extract_methods_and_attrs(nodes)
+      T.cast(nodes.select do |node|
+        node.is_a?(RBI::Method) || node.is_a?(RBI::Attr)
+      end, T::Array[T.any(RBI::Method, RBI::Attr)])
+    end
+
+    sig { params(nodes: T::Array[T.any(RBI::Method, RBI::Attr)]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
+    def extract_nodes_with_sigs(nodes)
+      nodes.reject { |node| node.sigs.empty? }
+    end
+  end
+end

data/lib/tapioca/helpers/signatures_helper.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module SignaturesHelper
+    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

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+require "shellwords"
+
+module Tapioca
+  module SorbetHelper
+    extend T::Sig
+
+    SORBET_GEM_SPEC = T.let(
+      ::Gem::Specification.find_by_name("sorbet-static"),
+      ::Gem::Specification
+    )
+
+    SORBET_BIN = T.let(
+      Pathname.new(SORBET_GEM_SPEC.full_gem_path) / "libexec" / "sorbet",
+      Pathname
+    )
+
+    SORBET_EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
+
+    FEATURE_REQUIREMENTS = T.let({
+      to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),         # https://github.com/sorbet/sorbet/pull/4706
+      type_variable_block_syntax: ::Gem::Requirement.new(">= 0.5.9892"), # https://github.com/sorbet/sorbet/pull/5639
+    }.freeze, T::Hash[Symbol, ::Gem::Requirement])
+
+    class CmdResult < T::Struct
+      const :out, String
+      const :err, String
+      const :status, T::Boolean
+    end
+
+    sig { params(sorbet_args: String).returns(CmdResult) }
+    def sorbet(*sorbet_args)
+      out, err, status = Open3.capture3([sorbet_path, *sorbet_args].join(" "))
+      CmdResult.new(out: out, err: err, status: status.success? || false)
+    end
+
+    sig { returns(String) }
+    def sorbet_path
+      sorbet_path = ENV.fetch(SORBET_EXE_PATH_ENV_VAR, SORBET_BIN)
+      sorbet_path = SORBET_BIN if sorbet_path.empty?
+      sorbet_path.to_s.shellescape
+    end
+
+    sig { params(feature: Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
+    def sorbet_supports?(feature, version: nil)
+      version = SORBET_GEM_SPEC.version unless version
+      requirement = FEATURE_REQUIREMENTS[feature]
+
+      Kernel.raise "Invalid Sorbet feature #{feature}" unless requirement
+
+      requirement.satisfied_by?(version)
+    end
+  end
+end

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -0,0 +1,118 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/helpers/test/content"
+require "tapioca/helpers/test/isolation"
+require "tapioca/helpers/test/template"
+
+module Tapioca
+  module Helpers
+    module Test
+      module DslCompiler
+        extend T::Sig
+        extend T::Helpers
+
+        include Isolation
+        include Content
+        include Template
+
+        requires_ancestor { Kernel }
+
+        sig { params(compiler_class: T.class_of(Tapioca::Dsl::Compiler)).void }
+        def use_dsl_compiler(compiler_class)
+          @context = T.let(CompilerContext.new(compiler_class), T.nilable(CompilerContext))
+        end
+
+        sig { params(compiler_classes: T.class_of(Tapioca::Dsl::Compiler)).void }
+        def activate_other_dsl_compilers(*compiler_classes)
+          context.activate_other_dsl_compilers(compiler_classes)
+        end
+
+        sig { params(constant_name: T.any(Symbol, String)).returns(String) }
+        def rbi_for(constant_name)
+          context.rbi_for(constant_name)
+        end
+
+        sig { returns(T::Array[String]) }
+        def gathered_constants
+          context.gathered_constants
+        end
+
+        sig { returns(T::Array[String]) }
+        def generated_errors
+          context.errors
+        end
+
+        sig { returns(CompilerContext) }
+        def context
+          raise "Please call `use_dsl_compiler` before" unless @context
+          @context
+        end
+
+        class CompilerContext
+          extend T::Sig
+
+          sig { returns(T.class_of(Tapioca::Dsl::Compiler)) }
+          attr_reader :compiler_class
+
+          sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+          attr_reader :other_compiler_classes
+
+          sig { params(compiler_class: T.class_of(Tapioca::Dsl::Compiler)).void }
+          def initialize(compiler_class)
+            @compiler_class = compiler_class
+            @other_compiler_classes = T.let([], T::Array[T.class_of(Tapioca::Dsl::Compiler)])
+            @pipeline = T.let(nil, T.nilable(Tapioca::Dsl::Pipeline))
+            @errors = T.let([], T::Array[String])
+          end
+
+          sig { params(compiler_classes: T::Array[T.class_of(Tapioca::Dsl::Compiler)]).void }
+          def activate_other_dsl_compilers(compiler_classes)
+            @other_compiler_classes = compiler_classes
+          end
+
+          sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+          def activated_compiler_classes
+            [compiler_class, *other_compiler_classes]
+          end
+
+          sig { returns(T::Array[String]) }
+          def gathered_constants
+            compiler_class.processable_constants.map(&:name).compact.sort
+          end
+
+          sig { params(constant_name: T.any(Symbol, String)).returns(String) }
+          def rbi_for(constant_name)
+            # Make sure this is a constant that we can handle.
+            unless gathered_constants.include?(constant_name.to_s)
+              raise "`#{constant_name}` is not processable by the `#{compiler_class}` compiler."
+            end
+
+            file = RBI::File.new(strictness: "strong")
+            constant = Object.const_get(constant_name)
+
+            compiler = compiler_class.new(pipeline, file.root, constant)
+            compiler.decorate
+
+            Tapioca::DEFAULT_RBI_FORMATTER.print_file(file)
+          end
+
+          sig { returns(T::Array[String]) }
+          def errors
+            pipeline.errors
+          end
+
+          private
+
+          sig { returns(Tapioca::Dsl::Pipeline) }
+          def pipeline
+            @pipeline ||= Tapioca::Dsl::Pipeline.new(
+              requested_constants: [],
+              requested_compilers: activated_compiler_classes
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/helpers/test/isolation.rb

@@ -100,7 +100,7 @@ module Tapioca
                   load_path_args << File.expand_path(p)
                 end
 
-                child = IO.popen([env, Gem.ruby, *load_path_args, $PROGRAM_NAME, *ORIG_ARGV, test_opts])
+                child = IO.popen([env, ::Gem.ruby, *load_path_args, $PROGRAM_NAME, *ORIG_ARGV, test_opts])
 
                 begin
                   Process.wait(child.pid)