tapioca 0.7.3 → 0.8.0

data/lib/tapioca/gemfile.rb

@@ -16,6 +16,50 @@ module Tapioca
       )
     end
 
+    # This is a module that gets prepended to `Bundler::Dependency` and
+    # makes sure even gems marked as `require: false` are required during
+    # `Bundler.require`.
+    module AutoRequireHook
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { ::Bundler::Dependency }
+
+      @exclude = T.let([], T::Array[String])
+
+      class << self
+        extend T::Sig
+
+        sig { params(exclude: T::Array[String]).returns(T::Array[String]) }
+        attr_writer :exclude
+
+        sig { params(name: T.untyped).returns(T::Boolean) }
+        def excluded?(name)
+          @exclude.include?(name)
+        end
+      end
+
+      sig { returns(T.untyped).checked(:never) }
+      def autorequire
+        value = super
+
+        # If the gem is excluded, we don't want to force require it, in case
+        # it has side-effects users don't want. For example, `fakefs` gem, if
+        # loaded, takes over filesystem operations.
+        return value if AutoRequireHook.excluded?(name)
+
+        # If a gem is marked as `require: false`, then its `autorequire`
+        # value will be `[]`. But, we want those gems to be loaded for our
+        # purposes as well, so we return `nil` in those cases, instead, which
+        # means `require: true`.
+        return nil if value == []
+
+        value
+      end
+
+      ::Bundler::Dependency.prepend(self)
+    end
+
     sig { returns(Bundler::Definition) }
     attr_reader(:definition)
 
@@ -25,8 +69,9 @@ module Tapioca
     sig { returns(T::Array[String]) }
     attr_reader(:missing_specs)
 
-    sig { void }
-    def initialize
+    sig { params(exclude: T::Array[String]).void }
+    def initialize(exclude)
+      AutoRequireHook.exclude = exclude
       @gemfile = T.let(File.new(Bundler.default_gemfile), File)
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
       @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)
@@ -94,7 +139,8 @@ module Tapioca
     class GemSpec
       extend(T::Sig)
 
-      IGNORED_GEMS = T.let(["sorbet", "sorbet-static", "sorbet-runtime"].freeze, T::Array[String])
+      IGNORED_GEMS = T.let(["sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime"].freeze,
+        T::Array[String])
 
       sig { returns(String) }
       attr_reader :full_gem_path, :version
@@ -227,6 +273,7 @@ module Tapioca
         # one of those folders to see if the path really belongs in the given gem
         # or not.
         return false unless Bundler::Source::Git === @spec.source
+
         parent = Pathname.new(path)
 
         until parent.root?

data/lib/tapioca/helpers/config_helper.rb

@@ -72,6 +72,7 @@ module Tapioca
     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
@@ -125,6 +126,18 @@ module Tapioca
         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
+
+        case config_option_value_type
+        when :array
+          error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
+            "`Array[String]` but found `#{config_option_value}`"
+          next build_error(error_msg) unless config_option_value.all? { |v| v.is_a?(String) }
+        when :hash
+          error_msg = "invalid value for option `#{config_option_key}` for key `#{config_key}` - expected " \
+            "`Hash[String, String]` but found `#{config_option_value}`"
+          all_strings = (config_option_value.keys + config_option_value.values).all? { |v| v.is_a?(String) }
+          next build_error(error_msg) unless all_strings
+        end
       end.compact
     end
 

data/lib/tapioca/helpers/rbi_helper.rb

@@ -0,0 +1,124 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBIHelper
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Thor::Shell }
+    requires_ancestor { SorbetHelper }
+
+    sig do
+      params(
+        command: String,
+        gem_dir: String,
+        dsl_dir: String,
+        auto_strictness: T::Boolean,
+        gems: T::Array[Gemfile::GemSpec],
+        compilers: T::Enumerable[Class]
+      ).void
+    end
+    def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])
+      error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
+
+      say("Checking generated RBI files... ")
+      res = sorbet(
+        "--no-config",
+        "--error-url-base=#{error_url_base}",
+        "--stop-after namer",
+        dsl_dir,
+        gem_dir
+      )
+      say(" Done", :green)
+
+      errors = Spoom::Sorbet::Errors::Parser.parse_string(res.err)
+
+      if errors.empty?
+        say("  No errors found\n\n", [:green, :bold])
+        return
+      end
+
+      parse_errors = errors.select { |error| error.code < 4000 }
+
+      if parse_errors.any?
+        say_error(<<~ERR, :red)
+
+          ##### INTERNAL ERROR #####
+
+          There are parse errors in the generated RBI files.
+
+          This seems related to a bug in Tapioca.
+          Please open an issue at https://github.com/Shopify/tapioca/issues/new with the following information:
+
+          Tapioca v#{Tapioca::VERSION}
+
+          Command:
+            #{command}
+
+        ERR
+
+        say_error(<<~ERR, :red) if gems.any?
+          Gems:
+          #{gems.map { |gem| "  #{gem.name} (#{gem.version})" }.join("\n")}
+
+        ERR
+
+        say_error(<<~ERR, :red) if compilers.any?
+          Compilers:
+          #{compilers.map { |compiler| "  #{compiler.name}" }.join("\n")}
+
+        ERR
+
+        say_error(<<~ERR, :red)
+          Errors:
+          #{parse_errors.map { |error| "  #{error}" }.join("\n")}
+
+          ##########################
+
+        ERR
+      end
+
+      if auto_strictness
+        redef_errors = errors.select { |error| error.code == 4010 }
+        update_gem_rbis_strictnesses(redef_errors, gem_dir)
+      end
+
+      Kernel.exit(1) if parse_errors.any?
+    end
+
+    private
+
+    sig { params(errors: T::Array[Spoom::Sorbet::Errors::Error], gem_dir: String).void }
+    def update_gem_rbis_strictnesses(errors, gem_dir)
+      files = []
+
+      errors.each do |error|
+        # Collect the file with error
+        files << error.file
+        error.more.each do |line|
+          # Also collect the conflicting definition file paths
+          next unless line.include?("Previous definition")
+
+          files << line.split(":").first&.strip
+        end
+      end
+
+      files
+        .uniq
+        .sort
+        .select { |file| file.start_with?(gem_dir) }
+        .each do |file|
+          Spoom::Sorbet::Sigils.change_sigil_in_file(file, "false")
+          say("\n  Changed strictness of #{file} to `typed: false` (conflicting with DSL files)", [:yellow, :bold])
+        end
+
+      say("\n")
+    end
+
+    sig { params(path: String).returns(String) }
+    def gem_name_from_rbi_path(path)
+      T.must(File.basename(path, ".rbi").split("@").first)
+    end
+  end
+end

data/lib/tapioca/helpers/shims_helper.rb

@@ -8,20 +8,25 @@ module Tapioca
 
     requires_ancestor { Thor::Shell }
 
+    SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
+
+    sig { params(index: RBI::Index, dir: String).void }
+    def index_payload(index, dir)
+      return unless Dir.exist?(dir)
+
+      say("Loading Sorbet payload... ")
+      files = Dir.glob("#{dir}/**/*.rbi").sort
+      parse_and_index_files(index, files)
+      say(" Done", :green)
+    end
+
     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)
+      parse_and_index_files(index, files)
       say(" Done", :green)
     end
 
@@ -32,14 +37,37 @@ module Tapioca
       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
 
+    sig { params(loc: RBI::Loc, path_prefix: T.nilable(String)).returns(String) }
+    def location_to_payload_url(loc, path_prefix:)
+      return loc.to_s unless path_prefix
+
+      url = loc.file || ""
+      return loc.to_s unless url.start_with?(path_prefix)
+
+      url = url.sub(path_prefix, SORBET_PAYLOAD_URL)
+      url = "#{url}#L#{loc.begin_line}"
+      url
+    end
+
     private
 
+    sig { params(index: RBI::Index, files: T::Array[String]).void }
+    def parse_and_index_files(index, files)
+      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)
+    end
+
     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

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -22,19 +22,13 @@ module Tapioca
 
     FEATURE_REQUIREMENTS = T.let({
       to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),         # https://github.com/sorbet/sorbet/pull/4706
+      print_payload_sources: ::Gem::Requirement.new(">= 0.5.9818"),      # https://github.com/sorbet/sorbet/pull/5504
       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) }
+    sig { params(sorbet_args: String).returns(Spoom::ExecResult) }
     def sorbet(*sorbet_args)
-      out, err, status = Open3.capture3([sorbet_path, *sorbet_args].join(" "))
-      CmdResult.new(out: out, err: err, status: status.success? || false)
+      Spoom::Sorbet.srb(sorbet_args.join(" "), sorbet_bin: sorbet_path, capture_err: true)
     end
 
     sig { returns(String) }

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

@@ -41,6 +41,7 @@ module Tapioca
         def add_content_file(name, content)
           file_name = tmp_path("lib/#{name}")
           raise ArgumentError, "a file named '#{name}' was already added; cannot overwrite." if File.exist?(file_name)
+
           FileUtils.mkdir_p(File.dirname(file_name))
           File.write(file_name, content)
           file_name

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

@@ -46,6 +46,7 @@ module Tapioca
         sig { returns(CompilerContext) }
         def context
           raise "Please call `use_dsl_compiler` before" unless @context
+
           @context
         end
 

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

@@ -36,6 +36,7 @@ module Tapioca
         def indented(str, indent)
           str.lines.map! do |line|
             next line if line.chomp.empty?
+
             (" " * indent) + line
           end.join
         end

data/lib/tapioca/internal.rb

@@ -14,7 +14,9 @@ require "tapioca/runtime/generic_type_registry"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
 require "tapioca/helpers/signatures_helper"
+require "tapioca/helpers/rbi_helper"
 require "tapioca/helpers/shims_helper"
+require "tapioca/repo_index"
 require "tapioca/commands"
 require "tapioca/cli"
 require "tapioca/gemfile"

data/lib/tapioca/rbi_ext/model.rb

@@ -108,6 +108,7 @@ module RBI
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
       return true if SPECIAL_METHOD_NAMES.include?(name)
+
       !!name.match(/^[a-zA-Z_][[:word:]]*[?!=]?$/)
     end
 
@@ -120,6 +121,7 @@ module RBI
     def create_node(node)
       cached = nodes_cache[node.to_s]
       return cached if cached
+
       nodes_cache[node.to_s] = node
       self << node
       node

data/lib/tapioca/repo_index.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  class RepoIndex
+    extend T::Sig
+    extend T::Generic
+
+    sig { params(json: String).returns(RepoIndex) }
+    def self.from_json(json)
+      RepoIndex.from_hash(JSON.parse(json))
+    end
+
+    sig { params(hash: T::Hash[String, T::Hash[T.untyped, T.untyped]]).returns(RepoIndex) }
+    def self.from_hash(hash)
+      hash.each_with_object(RepoIndex.new) do |(name, _), index|
+        index << name
+      end
+    end
+
+    sig { void }
+    def initialize
+      @entries = T.let(Set.new, T::Set[String])
+    end
+
+    sig { params(gem_name: String).void }
+    def <<(gem_name)
+      @entries.add(gem_name)
+    end
+
+    sig { returns(T::Enumerable[String]) }
+    def gems
+      @entries.sort
+    end
+
+    sig { params(gem_name: String).returns(T::Boolean) }
+    def has_gem?(gem_name)
+      @entries.include?(gem_name)
+    end
+  end
+end

data/lib/tapioca/runtime/loader.rb

@@ -41,6 +41,7 @@ module Tapioca
       sig { params(file: T.nilable(String)).void }
       def require_helper(file)
         return unless file
+
         file = File.absolute_path(file)
         return unless File.exist?(file)
 
@@ -51,6 +52,8 @@ module Tapioca
       def rails_engines
         return [] unless Object.const_defined?("Rails::Engine")
 
+        safe_require("active_support/core_ext/class/subclasses")
+
         # We can use `Class#descendants` here, since we know Rails is loaded
         Object.const_get("Rails::Engine").descendants.reject(&:abstract_railtie?)
       end

data/lib/tapioca/runtime/reflection.rb

@@ -35,58 +35,58 @@ module Tapioca
 
       sig { params(object: BasicObject).returns(Class).checked(:never) }
       def class_of(object)
-        CLASS_METHOD.bind(object).call
+        CLASS_METHOD.bind_call(object)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def constants_of(constant)
-        CONSTANTS_METHOD.bind(constant).call(false)
+        CONSTANTS_METHOD.bind_call(constant, false)
       end
 
       sig { params(constant: Module).returns(T.nilable(String)) }
       def name_of(constant)
-        name = NAME_METHOD.bind(constant).call
+        name = NAME_METHOD.bind_call(constant)
         name&.start_with?("#<") ? nil : name
       end
 
       sig { params(constant: Module).returns(Class) }
       def singleton_class_of(constant)
-        SINGLETON_CLASS_METHOD.bind(constant).call
+        SINGLETON_CLASS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Module]) }
       def ancestors_of(constant)
-        ANCESTORS_METHOD.bind(constant).call
+        ANCESTORS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Class).returns(T.nilable(Class)) }
       def superclass_of(constant)
-        SUPERCLASS_METHOD.bind(constant).call
+        SUPERCLASS_METHOD.bind_call(constant)
       end
 
       sig { params(object: BasicObject).returns(Integer).checked(:never) }
       def object_id_of(object)
-        OBJECT_ID_METHOD.bind(object).call
+        OBJECT_ID_METHOD.bind_call(object)
       end
 
       sig { params(object: BasicObject, other: BasicObject).returns(T::Boolean).checked(:never) }
       def are_equal?(object, other)
-        EQUAL_METHOD.bind(object).call(other)
+        EQUAL_METHOD.bind_call(object, other)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def public_instance_methods_of(constant)
-        PUBLIC_INSTANCE_METHODS_METHOD.bind(constant).call
+        PUBLIC_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def protected_instance_methods_of(constant)
-        PROTECTED_INSTANCE_METHODS_METHOD.bind(constant).call
+        PROTECTED_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
       def private_instance_methods_of(constant)
-        PRIVATE_INSTANCE_METHODS_METHOD.bind(constant).call
+        PRIVATE_INSTANCE_METHODS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Module]) }
@@ -124,7 +124,7 @@ module Tapioca
 
       sig { params(constant: Module, method: Symbol).returns(Method) }
       def method_of(constant, method)
-        METHOD_METHOD.bind(constant).call(method)
+        METHOD_METHOD.bind_call(constant, method)
       end
 
       # Returns an array with all classes that are < than the supplied class.

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -21,33 +21,47 @@ module T
         Tapioca::Runtime::GenericTypeRegistry.register_type(constant, types)
       end
 
-      def type_member(variance = :invariant, fixed: nil, lower: nil, upper: nil, &bounds_proc)
+      def type_member(variance = :invariant, fixed: nil, lower: nil, upper: nil, &blk)
         # `T::Generic#type_member` just instantiates a `T::Type::TypeMember` instance and returns it.
         # We use that when registering the type member and then later return it from this method.
+        hash = if blk
+          blk.call
+        else
+          {
+            fixed: fixed,
+            lower: lower,
+            upper: upper,
+          }
+        end
+
         Tapioca::TypeVariableModule.new(
           T.cast(self, Module),
           Tapioca::TypeVariableModule::Type::Member,
           variance,
-          fixed,
-          lower,
-          upper,
-          bounds_proc
+          **hash,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
       end
 
-      def type_template(variance = :invariant, fixed: nil, lower: nil, upper: nil, &bounds_proc)
+      def type_template(variance = :invariant, fixed: nil, lower: nil, upper: nil, &blk)
         # `T::Generic#type_template` just instantiates a `T::Type::TypeTemplate` instance and returns it.
         # We use that when registering the type template and then later return it from this method.
+        hash = if blk
+          blk.call
+        else
+          {
+            fixed: fixed,
+            lower: lower,
+            upper: upper,
+          }
+        end
+
         Tapioca::TypeVariableModule.new(
           T.cast(self, Module),
           Tapioca::TypeVariableModule::Type::Template,
           variance,
-          fixed,
-          lower,
-          upper,
-          bounds_proc
+          **hash,
         ).tap do |type_variable|
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
@@ -122,38 +136,25 @@ module Tapioca
       end
     end
 
-    # rubocop:disable Metrics/ParameterLists
     sig do
-      params(
-        context: Module,
-        type: Type,
-        variance: Symbol,
-        fixed: T.untyped,
-        lower: T.untyped,
-        upper: T.untyped,
-        bounds_proc: T.nilable(T.proc.returns(T::Hash[Symbol, T.untyped]))
-      ).void
+      params(context: Module, type: Type, variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void
     end
-    def initialize(context, type, variance, fixed, lower, upper, bounds_proc)
+    def initialize(context, type, variance, fixed: nil, lower: nil, upper: nil)
       @context = context
       @type = type
       @variance = variance
-      @bounds_proc = if bounds_proc
-        bounds_proc
-      else
-        build_bounds_proc(fixed, lower, upper)
-      end
-
+      @fixed = fixed
+      @lower = lower
+      @upper = upper
       super()
     end
-    # rubocop:enable Metrics/ParameterLists
 
     sig { returns(T.nilable(String)) }
     def name
       constant_name = super
 
       # This is a hack to work around modules under anonymous modules not having
-      # names in 2.6 and 2.7: https://bugs.ruby-lang.org/issues/14895
+      # names in 2.7: https://bugs.ruby-lang.org/issues/14895
       #
       # This happens when a type variable is declared under `class << self`, for
       # example.
@@ -169,10 +170,9 @@ module Tapioca
 
     sig { returns(String) }
     def serialize
-      bounds = @bounds_proc.call
-      fixed = bounds[:fixed].to_s if bounds.key?(:fixed)
-      lower = bounds[:lower].to_s if bounds.key?(:lower)
-      upper = bounds[:upper].to_s if bounds.key?(:upper)
+      fixed = @fixed.to_s if @fixed
+      upper = @upper.to_s if @upper
+      lower = @lower.to_s if @lower
 
       TypeVariableHelper.serialize_type_variable(
         @type.serialize,
@@ -190,19 +190,6 @@ module Tapioca
 
     private
 
-    sig do
-      params(fixed: T.untyped, lower: T.untyped, upper: T.untyped)
-        .returns(T.proc.returns(T::Hash[Symbol, T.untyped]))
-    end
-    def build_bounds_proc(fixed, lower, upper)
-      bounds = {}
-      bounds[:fixed] = fixed unless fixed.nil?
-      bounds[:lower] = lower unless lower.nil?
-      bounds[:upper] = upper unless upper.nil?
-
-      -> { bounds }
-    end
-
     sig do
       type_parameters(:Result)
         .params(block: T.proc.returns(T.type_parameter(:Result)))

data/lib/tapioca/static/symbol_table_parser.rb

@@ -16,6 +16,8 @@ module Tapioca
         parser = SymbolTableParser.new
         parser.parse_object(obj)
         parser.symbols
+      rescue JSON::ParserError
+        Set.new
       end
 
       sig { returns(T::Set[String]) }

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.7.3"
+  VERSION = "0.8.0"
 end