scint 0.6.0 → 0.7.0

data/lib/scint/credentials.rb

@@ -13,9 +13,10 @@ module Scint
   # Lookup order (first match wins):
   #   1. Inline credentials in the request URI itself (user:pass@host)
   #   2. Credentials registered at runtime (from Gemfile source: URIs)
-  #   3. Scint config:   $XDG_CONFIG_HOME/scint/credentials
-  #   4. Bundler config:  ~/.bundle/config
-  #   5. Environment variables (BUNDLE_HOST__NAME format)
+  #   3. Bundler local config: $BUNDLE_APP_CONFIG/config or ./.bundle/config
+  #   4. Scint config:   $XDG_CONFIG_HOME/scint/credentials
+  #   5. Bundler global config: ~/.bundle/config
+  #   6. Environment variables (BUNDLE_HOST__NAME / BUNDLE_HTTPS://... format)
   #
   # All config files use Bundler's key format:
   #   BUNDLE_PKGS__SHOPIFY__IO: "token:secret"
@@ -80,7 +81,7 @@ module Scint
       end
 
       # 2–5. Registered + config files + env
-      auth = lookup_host(uri.host)
+      auth = lookup_uri(uri)
       return nil unless auth
 
       user, password = auth.split(":", 2)
@@ -99,27 +100,35 @@ module Scint
 
     private
 
-    def lookup_host(host)
-      return nil unless host
+    def lookup_uri(uri)
+      return nil unless uri&.host
 
       # 2. Runtime-registered (from Gemfile inline URIs)
-      registered = @mutex.synchronize { @registered[host] }
+      registered = @mutex.synchronize { @registered[uri.host] }
       return registered if registered
 
-      # 3–4. Config files (scint, then bundler)
-      key = self.class.key_for_host(host)
-      val = @file_config[key]
-      return val if val
+      # 3–5. Config files (bundler local, scint, bundler global)
+      keys = self.class.keys_for_uri_lookup(uri)
+      keys.each do |key|
+        val = @file_config[key]
+        return val if val
+      end
+
+      # 6. Environment variable
+      keys.each do |key|
+        val = ENV[key]
+        return val if val
+      end
 
-      # 5. Environment variable
-      ENV[key]
+      nil
     end
 
     def load_config_files
       config = {}
       # Load in reverse priority (later overrides earlier)
-      load_yaml_into(config, bundler_config_path)
+      load_yaml_into(config, bundler_global_config_path)
       load_yaml_into(config, scint_credentials_path)
+      load_yaml_into(config, bundler_local_config_path)
       config
     end
 
@@ -137,7 +146,17 @@ module Scint
       File.join(xdg, "scint", "credentials")
     end
 
-    def bundler_config_path
+    def bundler_local_config_path
+      app_config = ENV["BUNDLE_APP_CONFIG"]
+      dir = if app_config && !app_config.empty?
+        app_config
+      else
+        File.join(Dir.pwd, ".bundle")
+      end
+      File.join(dir, "config")
+    end
+
+    def bundler_global_config_path
       File.join(Dir.home, ".bundle", "config")
     end
 
@@ -149,5 +168,49 @@ module Scint
       key.upcase!
       "BUNDLE_#{key}"
     end
+
+    def self.key_for_uri_string(uri_string)
+      key = uri_string.to_s.dup
+      key.gsub!(".", "__")
+      key.gsub!("-", "___")
+      key.upcase!
+      "BUNDLE_#{key}"
+    end
+
+    def self.key_for_source_uri(uri)
+      uri = URI.parse(uri.to_s) unless uri.is_a?(URI)
+      keys_for_uri_lookup(uri).find { |key| key != key_for_host(uri.host) }
+    rescue StandardError
+      nil
+    end
+
+    def self.keys_for_uri_lookup(uri)
+      uri = URI.parse(uri.to_s) unless uri.is_a?(URI)
+      keys = []
+
+      normalized = "#{uri.scheme || 'https'}://#{uri.host}"
+      default_port = (uri.scheme == "http" ? 80 : 443)
+      normalized += ":#{uri.port}" if uri.port && uri.port != default_port
+
+      path = uri.path.to_s
+      path = "/" if path.empty?
+      path = "/#{path}" unless path.start_with?("/")
+      path += "/" unless path.end_with?("/")
+
+      segments = path.split("/").reject(&:empty?)
+      candidate_paths = ["/"]
+      unless segments.empty?
+        1.upto(segments.length) do |i|
+          candidate_paths << "/#{segments.first(i).join('/')}/"
+        end
+      end
+
+      candidate_paths.reverse_each do |candidate_path|
+        keys << key_for_uri_string("#{normalized}#{candidate_path}")
+      end
+
+      keys << key_for_host(uri.host) if uri.host
+      keys.compact.uniq
+    end
   end
 end

data/lib/scint/debug/io_trace.rb

@@ -110,7 +110,9 @@ module Scint
 
           next unless container.method_defined?(original_name) || container.private_method_defined?(original_name)
 
-          container.send(:alias_method, method_name, original_name)
+          with_silenced_warnings do
+            container.send(:alias_method, method_name, original_name)
+          end
           container.send(:remove_method, original_name)
 
           visibility = entry[:visibility]
@@ -146,12 +148,21 @@ module Scint
         visibility = method_visibility(container, method_name)
 
         container.send(:alias_method, original_name, method_name)
-        container.send(:define_method, method_name) do |*args, **kwargs, &block|
-          Scint::Debug::IOTrace.log(op_name, args: args, kwargs: kwargs)
-          if kwargs.empty?
-            send(original_name, *args, &block)
-          else
-            send(original_name, *args, **kwargs, &block)
+        if container.instance_methods(false).include?(method_name) ||
+           container.private_instance_methods(false).include?(method_name) ||
+           container.protected_instance_methods(false).include?(method_name)
+          container.send(:remove_method, method_name)
+        elsif container.method_defined?(method_name) || container.private_method_defined?(method_name) || container.protected_method_defined?(method_name)
+          container.send(:undef_method, method_name)
+        end
+        with_silenced_warnings do
+          container.send(:define_method, method_name) do |*args, **kwargs, &block|
+            Scint::Debug::IOTrace.log(op_name, args: args, kwargs: kwargs)
+            if kwargs.empty?
+              send(original_name, *args, &block)
+            else
+              send(original_name, *args, **kwargs, &block)
+            end
           end
         end
 
@@ -173,6 +184,14 @@ module Scint
         nil
       end
 
+      def with_silenced_warnings
+        verbose = $VERBOSE
+        $VERBOSE = nil
+        yield
+      ensure
+        $VERBOSE = verbose
+      end
+
       def disable_unlocked
         return unless @enabled || @log_io
 

data/lib/scint/downloader/fetcher.rb

@@ -54,7 +54,13 @@ module Scint
               current_uri = URI.parse(location)
               next
             else
-              raise NetworkError, "HTTP #{response.code} for #{uri}: #{response.message}"
+              raise NetworkError.new(
+                http_error_message(current_uri, response),
+                uri: current_uri.to_s,
+                http_status: response.code.to_i,
+                response_headers: response_headers_hash(response),
+                response_body: response.body.to_s,
+              )
             end
           end
 
@@ -108,6 +114,24 @@ module Scint
           http
         end
       end
+
+      def http_error_message(uri, response)
+        message = "HTTP #{response.code} for #{uri}: #{response.message}"
+        body = response.body.to_s
+        return message if body.empty?
+
+        excerpt = body.gsub(/\s+/, " ").strip
+        return message if excerpt.empty?
+
+        excerpt = "#{excerpt[0, 277]}..." if excerpt.length > 280
+        "#{message} -- #{excerpt}"
+      end
+
+      def response_headers_hash(response)
+        headers = {}
+        response.each_header { |k, v| headers[k] = v }
+        headers
+      end
     end
   end
 end

data/lib/scint/downloader/pool.rb

@@ -4,41 +4,59 @@ require_relative "fetcher"
 require_relative "../worker_pool"
 require_relative "../platform"
 require_relative "../errors"
+require "uri"
 
 module Scint
   module Downloader
     class Pool
       MAX_RETRIES = 3
       BACKOFF_BASE = 0.5 # seconds
+      DEFAULT_PER_HOST_LIMIT = 4
 
       attr_reader :size
 
-      def initialize(size: nil, on_progress: nil, credentials: nil)
+      def initialize(size: nil, on_progress: nil, credentials: nil, per_host_limit: DEFAULT_PER_HOST_LIMIT)
         @size = size || [Platform.cpu_count * 2, 50].min
         @on_progress = on_progress
         @credentials = credentials
+        @per_host_limit = [per_host_limit.to_i, 1].max
         @fetchers = {} # thread_id => Fetcher
         @fetcher_mutex = Thread::Mutex.new
+        @host_slots = Hash.new(0)
+        @host_waiters = {}
+        @host_mutex = Thread::Mutex.new
       end
 
       # Download a single URI to dest_path with retry logic.
       # Returns { path:, size: }
       def download(uri, dest_path, checksum: nil)
-        retries = 0
-        begin
-          fetcher = thread_fetcher
-          fetcher.fetch(uri, dest_path, checksum: checksum)
-        rescue NetworkError, Errno::ECONNRESET, Errno::ECONNREFUSED,
-               Errno::ETIMEDOUT, Net::ReadTimeout, Net::OpenTimeout,
-               SocketError, IOError => e
-          retries += 1
-          if retries <= MAX_RETRIES
-            sleep(BACKOFF_BASE * (2**(retries - 1)))
-            # Reset connection on retry
-            reset_thread_fetcher
-            retry
+        with_host_slot(uri) do
+          retries = 0
+          begin
+            fetcher = thread_fetcher
+            fetcher.fetch(uri, dest_path, checksum: checksum)
+          rescue NetworkError, Errno::ECONNRESET, Errno::ECONNREFUSED,
+                 Errno::ETIMEDOUT, Net::ReadTimeout, Net::OpenTimeout,
+                 SocketError, IOError => e
+            retries += 1
+            if retries <= MAX_RETRIES
+              sleep(BACKOFF_BASE * (2**(retries - 1)))
+              # Reset connection on retry
+              reset_thread_fetcher
+              retry
+            end
+            if e.is_a?(NetworkError)
+              raise NetworkError.new(
+                "Failed to download #{uri} after #{MAX_RETRIES} retries: #{e.message}",
+                uri: (e.uri || uri.to_s),
+                http_status: e.http_status,
+                response_headers: e.response_headers,
+                response_body: e.response_body,
+              )
+            end
+
+            raise NetworkError, "Failed to download #{uri} after #{MAX_RETRIES} retries: #{e.message}"
           end
-          raise NetworkError, "Failed to download #{uri} after #{MAX_RETRIES} retries: #{e.message}"
         end
       end
 
@@ -107,6 +125,40 @@ module Scint
           old&.close
         end
       end
+
+      def with_host_slot(uri)
+        key = host_slot_key(uri)
+        return yield unless key
+
+        waiter = nil
+        @host_mutex.synchronize do
+          waiter = (@host_waiters[key] ||= Thread::ConditionVariable.new)
+          while @host_slots[key] >= @per_host_limit
+            waiter.wait(@host_mutex)
+          end
+          @host_slots[key] += 1
+        end
+
+        begin
+          yield
+        ensure
+          @host_mutex.synchronize do
+            @host_slots[key] -= 1 if @host_slots[key] > 0
+            waiter.broadcast
+          end
+        end
+      end
+
+      def host_slot_key(uri)
+        parsed = uri.is_a?(URI) ? uri : URI.parse(uri.to_s)
+        return nil unless parsed.host
+
+        scheme = parsed.scheme || "https"
+        port = parsed.port || (scheme == "https" ? 443 : 80)
+        "#{scheme}://#{parsed.host}:#{port}"
+      rescue URI::InvalidURIError
+        nil
+      end
     end
   end
 end

data/lib/scint/errors.rb

@@ -26,6 +26,16 @@ module Scint
   end
 
   class NetworkError < BundlerError
+    attr_reader :uri, :http_status, :response_headers, :response_body
+
+    def initialize(message = nil, uri: nil, http_status: nil, response_headers: nil, response_body: nil)
+      super(message)
+      @uri = uri
+      @http_status = http_status
+      @response_headers = response_headers
+      @response_body = response_body
+    end
+
     def status_code
       7
     end

data/lib/scint/fs.rb

@@ -73,11 +73,49 @@ module Scint
       hardlink_tree(src_dir, dst_dir)
     end
 
+    # Clone many source directories into one destination parent directory.
+    # This is significantly faster than one process per gem on large warm
+    # installs because it batches cp invocations while preserving CoW/reflink.
+    # Returns the number of source trees requested.
+    def clone_many_trees(src_dirs, dst_parent, chunk_size: 64)
+      dst_parent = dst_parent.to_s
+      mkdir_p(dst_parent)
+
+      sources = Array(src_dirs).map(&:to_s).uniq
+      sources.select! { |src| Dir.exist?(src) }
+      return 0 if sources.empty?
+
+      copied = 0
+      sources.each_slice([chunk_size.to_i, 1].max) do |slice|
+        pending = slice.reject do |src|
+          Dir.exist?(File.join(dst_parent, File.basename(src)))
+        end
+        next if pending.empty?
+
+        ok = false
+        if Platform.macos?
+          ok = system("cp", "-cR", *pending, dst_parent, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          ok = system("cp", "--reflink=always", "-R", *pending, dst_parent, [:out, :err] => File::NULL)
+        end
+
+        unless ok
+          pending.each do |src|
+            clone_tree(src, File.join(dst_parent, File.basename(src)))
+          end
+        end
+
+        copied += pending.length
+      end
+
+      copied
+    end
+
     # Recursively hardlink all files from src_dir into dst_dir.
     # Directory structure is recreated; files are hardlinked.
     def hardlink_tree(src_dir, dst_dir)
-      src_dir = src_dir.to_s
-      dst_dir = dst_dir.to_s
+      src_dir = File.expand_path(src_dir.to_s)
+      dst_dir = File.expand_path(dst_dir.to_s)
       raise Errno::ENOENT, src_dir unless Dir.exist?(src_dir)
       mkdir_p(dst_dir)
 
@@ -88,6 +126,10 @@ module Scint
         Dir.each_child(src_root) do |entry|
           src_path = File.join(src_root, entry)
           dst_path = File.join(dst_root, entry)
+
+          # Guard against recursive copy when destination is nested under source.
+          next if dst_dir == src_path || dst_dir.start_with?("#{src_path}/")
+
           stat = File.lstat(src_path)
 
           if stat.directory?

data/lib/scint/gemfile/parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "dependency"
+require_relative "../source/path"
 
 module Scint
   module Gemfile
@@ -134,6 +135,11 @@ module Scint
           source_opts[:path] = path_val
         end
 
+        # Internal/source metadata used by lockfile generation.
+        source_opts[:glob] = options.delete(:glob) if options.key?(:glob)
+        source_opts[:gemspec_generated] = options.delete(:gemspec_generated) if options.key?(:gemspec_generated)
+        source_opts[:gemspec_primary] = options.delete(:gemspec_primary) if options.key?(:gemspec_primary)
+
         if options[:source]
           source_opts[:source] = options.delete(:source)
         end
@@ -213,24 +219,39 @@ module Scint
         instance_eval(contents, expanded, 1)
       end
 
-      def ruby(version, **opts)
-        @ruby_version = version.to_s
+      def ruby(*versions, **opts)
+        version_parts = versions.flatten.compact.map(&:to_s)
+        @ruby_version = version_parts.join(", ") unless version_parts.empty?
       end
 
       def gemspec(opts = {})
         path = opts[:path] || "."
         name = opts[:name]
+        glob = opts[:glob] || Scint::Source::Path::DEFAULT_GLOB
         dir = File.expand_path(path, File.dirname(@gemfile_path))
-        gemspecs = Dir.glob(File.join(dir, "{,*}.gemspec"))
+        gemspecs = Dir.glob(File.join(dir, glob)).sort
         # Just record we have a gemspec source -- full spec loading is
         # deferred to the resolver/installer.
         gemspecs.each do |gs|
           spec_name = File.basename(gs, ".gemspec")
           next if name && spec_name != name
-          gem(spec_name, path: dir)
+          gem(
+            spec_name,
+            path: File.dirname(gs),
+            glob: glob,
+            gemspec_generated: true,
+            gemspec_primary: File.expand_path(File.dirname(gs)) == dir,
+          )
         end
       end
 
+      def install_if(*conditions, &blk)
+        raise GemfileError, "install_if requires a block" unless block_given?
+        return unless conditions.all? { |condition| condition_truthy?(condition) }
+
+        yield
+      end
+
       # Silently ignore plugin declarations
       def plugin(*args); end
 
@@ -247,6 +268,12 @@ module Scint
 
       private
 
+      def condition_truthy?(condition)
+        return condition.call if condition.respond_to?(:call)
+
+        !!condition
+      end
+
       def add_default_git_sources
         git_source(:github) do |repo_name|
           if repo_name =~ %r{\Ahttps://github\.com/([^/]+/[^/]+)/pull/(\d+)\z}

data/lib/scint/installer/extension_builder.rb

@@ -3,6 +3,7 @@
 require_relative "../fs"
 require_relative "../platform"
 require_relative "../errors"
+require_relative "../spec_utils"
 require "open3"
 
 module Scint
@@ -16,7 +17,7 @@ module Scint
       # abi_key:      e.g. "ruby-3.3.0-arm64-darwin24" (defaults to Platform.abi_key)
       def build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key, compile_slots: 1, output_tail: nil)
         spec = prepared_gem.spec
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         build_ruby_dir = cache_layout.install_ruby_dir
 
         # Check global extension cache first
@@ -28,17 +29,28 @@ module Scint
 
         # Build in a temp dir, then cache
         src_dir = prepared_gem.extracted_path
-        ext_dirs = find_extension_dirs(src_dir)
-        raise ExtensionBuildError, "No extension directories found for #{spec.name}" if ext_dirs.empty?
-
         FS.with_tempdir("scint-ext") do |tmpdir|
-          build_dir = File.join(tmpdir, "build")
+          # Stage the full gem source tree in an isolated workspace.
+          # Many extconf scripts use paths like ../../vendor relative to ext/,
+          # which only work when the full gem layout is preserved.
+          staged_src_dir = File.join(tmpdir, "source")
+          FS.clone_tree(src_dir, staged_src_dir)
+
+          ext_dirs = find_extension_dirs(staged_src_dir)
+          raise ExtensionBuildError, "No extension directories found for #{spec.name}" if ext_dirs.empty?
+
+          build_root = File.join(tmpdir, "build")
           install_dir = File.join(tmpdir, "install")
-          FS.mkdir_p(build_dir)
+          FS.mkdir_p(build_root)
           FS.mkdir_p(install_dir)
 
-          ext_dirs.each do |ext_dir|
-            compile_extension(ext_dir, build_dir, install_dir, src_dir, spec, build_ruby_dir, compile_slots, output_tail)
+          ext_dirs.each_with_index do |ext_dir, idx|
+            # Keep isolated build trees per extension directory. Some gems
+            # invoke multiple CMake projects under ext/ and CMake caches are
+            # source-tree specific.
+            ext_build_dir = File.join(build_root, idx.to_s)
+            FS.mkdir_p(ext_build_dir)
+            compile_extension(ext_dir, ext_build_dir, install_dir, staged_src_dir, spec, build_ruby_dir, compile_slots, output_tail)
           end
 
           # Write marker
@@ -65,7 +77,7 @@ module Scint
         spec = prepared_gem.spec
         return false unless cached_build_available?(spec, cache_layout, abi_key: abi_key)
 
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         cached_ext = cache_layout.ext_path(spec, abi_key)
         link_extensions(cached_ext, ruby_dir, spec, abi_key)
         true
@@ -120,9 +132,18 @@ module Scint
           dirs << File.dirname(path)
         end
 
-        # CMakeLists.txt in ext/
-        Dir.glob(File.join(gem_dir, "ext", "**", "CMakeLists.txt")).each do |path|
-          dir = File.dirname(path)
+        # CMakeLists.txt in ext/. Keep only top-level CMake roots, so vendored
+        # subprojects (e.g. deps/*) are not built standalone.
+        cmake_dirs = Dir.glob(File.join(gem_dir, "ext", "**", "CMakeLists.txt"))
+                        .map { |path| File.dirname(path) }
+                        .uniq
+                        .sort_by { |dir| [dir.length, dir] }
+        cmake_roots = []
+        cmake_dirs.each do |dir|
+          next if cmake_roots.any? { |root| dir.start_with?("#{root}/") }
+          cmake_roots << dir
+        end
+        cmake_roots.each do |dir|
           dirs << dir unless dirs.include?(dir)
         end
 
@@ -141,7 +162,7 @@ module Scint
         env = build_env(gem_dir, build_ruby_dir, make_jobs)
 
         if File.exist?(File.join(ext_dir, "extconf.rb"))
-          compile_extconf(ext_dir, build_dir, install_dir, env, make_jobs, output_tail)
+          compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail)
         elsif File.exist?(File.join(ext_dir, "CMakeLists.txt"))
           compile_cmake(ext_dir, build_dir, install_dir, env, make_jobs, output_tail)
         elsif File.exist?(File.join(ext_dir, "Rakefile"))
@@ -151,13 +172,18 @@ module Scint
         end
       end
 
-      def compile_extconf(ext_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
+      def compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
+        # Build in-place within the staged ext directory so extconf scripts
+        # that navigate relative paths (../../vendor, ../..) behave like
+        # Bundler's install layout.
+        _ = gem_dir
+        _ = build_dir
         run_cmd(env, RbConfig.ruby, File.join(ext_dir, "extconf.rb"),
                 "--with-opt-dir=#{RbConfig::CONFIG["prefix"]}",
-                chdir: build_dir, output_tail: output_tail)
-        run_cmd(env, "make", "-j#{make_jobs}", "-C", build_dir, output_tail: output_tail)
+                chdir: ext_dir, output_tail: output_tail)
+        run_cmd(env, "make", "-j#{make_jobs}", "-C", ext_dir, output_tail: output_tail)
         run_cmd(env, "make", "install", "DESTDIR=", "sitearchdir=#{install_dir}", "sitelibdir=#{install_dir}",
-                chdir: build_dir, output_tail: output_tail)
+                chdir: ext_dir, output_tail: output_tail)
       end
 
       def compile_cmake(ext_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
@@ -208,9 +234,21 @@ module Scint
         ext_install_dir = File.join(ruby_dir, "extensions",
                                     Platform.gem_arch, Platform.extension_api_version,
                                     spec_full_name(spec))
-        return if Dir.exist?(ext_install_dir)
+        FS.clone_tree(cached_ext, ext_install_dir) unless Dir.exist?(ext_install_dir)
+        sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
+      end
 
-        FS.clone_tree(cached_ext, ext_install_dir)
+      def sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
+        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+        lib_dir = File.join(gem_dir, "lib")
+        return unless Dir.exist?(lib_dir)
+
+        Dir.glob(File.join(ext_install_dir, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
+          rel = artifact.delete_prefix("#{ext_install_dir}/")
+          dest = File.join(lib_dir, rel)
+          FS.mkdir_p(File.dirname(dest))
+          FS.clonefile(artifact, dest)
+        end
       end
 
       def build_env(gem_dir, build_ruby_dir, make_jobs)
@@ -279,21 +317,13 @@ module Scint
       end
 
       def spec_full_name(spec)
-        name = spec.name
-        version = spec.version
-        plat = spec.respond_to?(:platform) ? spec.platform : nil
-        base = "#{name}-#{version}"
-        (plat.nil? || plat.to_s == "ruby" || plat.to_s.empty?) ? base : "#{base}-#{plat}"
-      end
-
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
+        SpecUtils.full_name(spec)
       end
 
       private_class_method :find_extension_dirs, :compile_extension,
                            :compile_extconf, :compile_cmake, :compile_rake,
-                           :find_rake_executable, :link_extensions, :build_env, :run_cmd,
-                           :spec_full_name, :ruby_install_dir, :prebuilt_missing_for_ruby?
+                           :find_rake_executable, :link_extensions, :sync_extension_artifacts_into_gem,
+                           :build_env, :run_cmd, :prebuilt_missing_for_ruby?
     end
   end
 end