scint 0.7.0 → 0.8.0

data/lib/scint/fs.rb

@@ -21,28 +21,75 @@ module Scint
       @mkdir_mutex.synchronize { @mkdir_cache[path] = true }
     end
 
+    # Detect best file copy strategy once per process.
+    # Returns :reflink, :hardlink, or :copy.
+    @copy_strategy = nil
+    @copy_strategy_mutex = Thread::Mutex.new
+
+    def detect_copy_strategy(src_dir, dst_dir)
+      @copy_strategy_mutex.synchronize do
+        return @copy_strategy if @copy_strategy
+
+        @copy_strategy = _probe_copy_strategy(src_dir, dst_dir)
+      end
+    end
+
+    def _probe_copy_strategy(src_dir, dst_dir)
+      # Create a temp file in src to test against dst
+      probe_src = File.join(src_dir, ".scint_probe_#{$$}")
+      probe_dst = File.join(dst_dir, ".scint_probe_#{$$}")
+      begin
+        File.write(probe_src, "x")
+        mkdir_p(dst_dir)
+
+        if Platform.macos?
+          if system("cp", "-c", probe_src, probe_dst, [:out, :err] => File::NULL)
+            return :reflink
+          end
+          File.delete(probe_dst) if File.exist?(probe_dst)
+        elsif Platform.linux?
+          if system("cp", "--reflink=always", probe_src, probe_dst, [:out, :err] => File::NULL)
+            return :reflink
+          end
+          File.delete(probe_dst) if File.exist?(probe_dst)
+        end
+
+        begin
+          File.link(probe_src, probe_dst)
+          return :hardlink
+        rescue SystemCallError
+          File.delete(probe_dst) if File.exist?(probe_dst)
+        end
+
+        :copy
+      ensure
+        File.delete(probe_src) if File.exist?(probe_src)
+        File.delete(probe_dst) if File.exist?(probe_dst)
+      end
+    rescue StandardError
+      :copy
+    end
+
     # APFS clonefile (CoW copy). Falls back to hardlink, then regular copy.
     def clonefile(src, dst)
       src = src.to_s
       dst = dst.to_s
       mkdir_p(File.dirname(dst))
 
-      # Try APFS clonefile via cp -c (macOS)
-      if Platform.macos?
-        return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
-      end
-
-      # Try Linux reflink copy-on-write where supported (btrfs/xfs/etc).
-      if Platform.linux?
-        return if system("cp", "--reflink=always", src, dst, [:out, :err] => File::NULL)
-      end
-
-      # Fallback: hardlink
-      begin
-        File.link(src, dst)
-        return
-      rescue SystemCallError
-        # cross-device or unsupported
+      case detect_copy_strategy(File.dirname(src), File.dirname(dst))
+      when :reflink
+        if Platform.macos?
+          return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          return if system("cp", "--reflink=always", src, dst, [:out, :err] => File::NULL)
+        end
+      when :hardlink
+        begin
+          File.link(src, dst)
+          return
+        rescue SystemCallError
+          # fall through to copy
+        end
       end
 
       # Final fallback: regular copy
@@ -58,21 +105,117 @@ module Scint
       raise Errno::ENOENT, src_dir unless Dir.exist?(src_dir)
       mkdir_p(dst_dir)
 
-      # Fast path on macOS/APFS: copy-on-write clone of full tree.
-      if Platform.macos?
-        src_contents = File.join(src_dir, ".")
-        return if system("cp", "-cR", src_contents, dst_dir, [:out, :err] => File::NULL)
-      end
+      strategy = detect_copy_strategy(src_dir, dst_dir)
 
-      # Fast path on Linux filesystems with reflink support.
-      if Platform.linux?
+      if strategy == :reflink
         src_contents = File.join(src_dir, ".")
-        return if system("cp", "--reflink=always", "-R", src_contents, dst_dir, [:out, :err] => File::NULL)
+        if Platform.macos?
+          return if system("cp", "-cR", src_contents, dst_dir, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          return if system("cp", "--reflink=always", "-R", src_contents, dst_dir, [:out, :err] => File::NULL)
+        end
       end
 
       hardlink_tree(src_dir, dst_dir)
     end
 
+    # Materialize a tree using a manifest to avoid directory scans.
+    # Manifest entries must be hashes with "path" and "type" keys.
+    # Uses the fastest available file copy strategy (reflink > hardlink > copy).
+    def materialize_from_manifest(src_dir, dst_dir, entries)
+      src_dir = src_dir.to_s
+      dst_dir = dst_dir.to_s
+      entries = Array(entries)
+      raise Errno::ENOENT, src_dir unless Dir.exist?(src_dir)
+      mkdir_p(dst_dir)
+
+      strategy = detect_copy_strategy(src_dir, dst_dir)
+
+      entries.each do |entry|
+        rel = entry["path"].to_s
+        next if rel.empty? || rel.start_with?("/") || rel.include?("..")
+
+        src_path = File.join(src_dir, rel)
+        dst_path = File.join(dst_dir, rel)
+
+        case entry["type"]
+        when "dir"
+          mkdir_p(dst_path)
+        when "symlink"
+          mkdir_p(File.dirname(dst_path))
+          next if File.exist?(dst_path) || File.symlink?(dst_path)
+
+          target = File.readlink(src_path)
+          begin
+            File.symlink(target, dst_path)
+          rescue Errno::EEXIST
+            next
+          end
+        else
+          mkdir_p(File.dirname(dst_path))
+          next if File.exist?(dst_path)
+
+          begin
+            _link_or_copy(src_path, dst_path, strategy)
+          rescue Errno::EEXIST
+            next
+          rescue SystemCallError
+            next if File.exist?(dst_path)
+            raise
+          end
+        end
+      end
+    end
+
+    # Fast file link/copy using a pre-detected strategy (no per-file probing).
+    def _link_or_copy(src, dst, strategy)
+      case strategy
+      when :reflink
+        if Platform.macos?
+          return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          return if system("cp", "--reflink=always", src, dst, [:out, :err] => File::NULL)
+        end
+        # reflink failed for this file, try hardlink
+        begin
+          File.link(src, dst)
+          return
+        rescue SystemCallError; end
+        FileUtils.cp(src, dst)
+      when :hardlink
+        begin
+          File.link(src, dst)
+          return
+        rescue SystemCallError; end
+        FileUtils.cp(src, dst)
+      else
+        FileUtils.cp(src, dst)
+      end
+    end
+
+    LINKER_SCRIPT = File.expand_path("linker.sh", __dir__).freeze
+
+    # Bulk-link cached gem directories into dst_parent.
+    # Opens one helper process (linker.sh) and writes gem basenames to its
+    # stdin. The helper probes the fastest FS strategy once then applies it
+    # to every gem.
+    def bulk_link_gems(src_parent, dst_parent, gem_names)
+      src_parent = src_parent.to_s
+      dst_parent = dst_parent.to_s
+      gem_names = Array(gem_names)
+      return 0 if gem_names.empty?
+
+      mkdir_p(dst_parent)
+
+      IO.popen(["/bin/bash", LINKER_SCRIPT], "w") do |io|
+        io.puts src_parent
+        io.puts dst_parent
+        gem_names.each { |name| io.puts name }
+      end
+
+      gem_names.size
+    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.
@@ -86,6 +229,8 @@ module Scint
       return 0 if sources.empty?
 
       copied = 0
+      strategy = sources.first ? detect_copy_strategy(sources.first, dst_parent) : :copy
+
       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)))
@@ -93,10 +238,12 @@ module Scint
         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)
+        if strategy == :reflink
+          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
         end
 
         unless ok

data/lib/scint/gem/package.rb

@@ -17,7 +17,9 @@ module Scint
           tar.each do |entry|
             if entry.full_name == "metadata.gz"
               gz = Zlib::GzipReader.new(StringIO.new(entry.read))
-              return ::Gem::Specification.from_yaml(gz.read)
+              yaml = gz.read
+              yaml.force_encoding("UTF-8") if yaml.encoding == Encoding::US_ASCII
+              return ::Gem::Specification.from_yaml(yaml)
             end
           end
         end
@@ -38,7 +40,9 @@ module Scint
             case entry.full_name
             when "metadata.gz"
               gz = Zlib::GzipReader.new(StringIO.new(entry.read))
-              gemspec = ::Gem::Specification.from_yaml(gz.read)
+              yaml = gz.read
+              yaml.force_encoding("UTF-8") if yaml.encoding == Encoding::US_ASCII
+              gemspec = ::Gem::Specification.from_yaml(yaml)
             when "data.tar.gz"
               # Write data.tar.gz to a temp file for extraction
               tmp = File.join(dest_dir, ".data.tar.gz.tmp")

data/lib/scint/gemfile/parser.rb

@@ -6,7 +6,7 @@ require_relative "../source/path"
 module Scint
   module Gemfile
     # Result of parsing a Gemfile.
-    ParseResult = Struct.new(:dependencies, :sources, :ruby_version, :platforms, keyword_init: true)
+    ParseResult = Struct.new(:dependencies, :sources, :ruby_version, :platforms, :optional_groups, keyword_init: true)
 
     # Evaluates a Gemfile using instance_eval, just like stock bundler.
     # Supports the full Gemfile DSL: source, gem, group, platforms, git_source,
@@ -20,14 +20,16 @@ module Scint
           sources: parser.parsed_sources.uniq,
           ruby_version: parser.parsed_ruby_version,
           platforms: parser.parsed_platforms,
+          optional_groups: parser.parsed_optional_groups,
         )
       end
 
       # Accessors that don't collide with DSL method names
-      def parsed_dependencies;  @dependencies;  end
-      def parsed_sources;       @sources;       end
-      def parsed_ruby_version;  @ruby_version;  end
-      def parsed_platforms;     @declared_platforms; end
+      def parsed_dependencies;    @dependencies;      end
+      def parsed_sources;         @sources;           end
+      def parsed_ruby_version;    @ruby_version;      end
+      def parsed_platforms;       @declared_platforms; end
+      def parsed_optional_groups; @optional_groups;   end
 
       def initialize(gemfile_path)
         @gemfile_path = File.expand_path(gemfile_path)
@@ -39,6 +41,7 @@ module Scint
         @current_source_options = {}
         @ruby_version = nil
         @declared_platforms = []
+        @optional_groups = []
 
         add_default_git_sources
       end
@@ -167,7 +170,11 @@ module Scint
 
       def group(*names, **opts, &blk)
         old_groups = @current_groups.dup
-        @current_groups.concat(names.map(&:to_sym))
+        group_syms = names.map(&:to_sym)
+        @current_groups.concat(group_syms)
+        if opts[:optional]
+          group_syms.each { |g| @optional_groups << g unless @optional_groups.include?(g) }
+        end
         yield
       ensure
         @current_groups = old_groups

data/lib/scint/index/client.rb

@@ -143,8 +143,19 @@ module Scint
       private
 
       def default_cache_dir
-        xdg = ENV["XDG_CACHE_HOME"] || File.join(Dir.home, ".cache")
-        File.join(xdg, "scint", "index", Cache.slug_for(@uri))
+        root =
+          if Scint.respond_to?(:cache_root)
+            Scint.cache_root
+          else
+            explicit = ENV["SCINT_CACHE"]
+            if explicit && !explicit.empty?
+              File.expand_path(explicit)
+            else
+              xdg = ENV["XDG_CACHE_HOME"] || File.join(Dir.home, ".cache")
+              File.join(xdg, "scint")
+            end
+          end
+        File.join(root, "index", Cache.slug_for(@uri))
       end
 
       # Fetch a top-level endpoint (names or versions).

data/lib/scint/installer/extension_builder.rb

@@ -11,24 +11,22 @@ module Scint
     module ExtensionBuilder
       module_function
 
+      BUILD_MARKER = ".scint.build_complete"
+
       # Build native extensions for a prepared gem.
       # prepared_gem: PreparedGem struct
       # bundle_path:  .bundle/ root
       # 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 = Platform.ruby_install_dir(bundle_path)
         build_ruby_dir = cache_layout.install_ruby_dir
+        source_ruby_dir = Platform.ruby_install_dir(bundle_path)
+        src_dir = prepared_gem.extracted_path
 
-        # Check global extension cache first
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        if Dir.exist?(cached_ext) && File.exist?(File.join(cached_ext, "gem.build_complete"))
-          link_extensions(cached_ext, ruby_dir, spec, abi_key)
-          return true
-        end
+        marker = build_marker_path(src_dir)
+        return true if File.exist?(marker)
 
-        # Build in a temp dir, then cache
-        src_dir = prepared_gem.extracted_path
+        # Build in a temp dir, then sync artifacts into the source tree.
         FS.with_tempdir("scint-ext") do |tmpdir|
           # Stage the full gem source tree in an isolated workspace.
           # Many extconf scripts use paths like ../../vendor relative to ext/,
@@ -50,37 +48,37 @@ module Scint
             # 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)
+            compile_extension(
+              ext_dir,
+              ext_build_dir,
+              install_dir,
+              staged_src_dir,
+              spec,
+              build_ruby_dir,
+              compile_slots,
+              output_tail,
+              source_ruby_dir,
+            )
           end
 
-          # Write marker
-          File.write(File.join(install_dir, "gem.build_complete"), "")
-
-          # Cache globally
-          FS.mkdir_p(File.dirname(cached_ext))
-          FS.atomic_move(install_dir, cached_ext)
+          sync_extensions_into_gem(install_dir, src_dir)
         end
 
-        link_extensions(cached_ext, ruby_dir, spec, abi_key)
+        File.write(marker, "")
         true
       end
 
       # True when a completed global extension build exists for this spec + ABI.
       def cached_build_available?(spec, cache_layout, abi_key: Platform.abi_key)
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        Dir.exist?(cached_ext) && File.exist?(File.join(cached_ext, "gem.build_complete"))
+        cached_dir = cache_layout.cached_path(spec, abi_key)
+        File.exist?(build_marker_path(cached_dir))
       end
 
-      # Link already-compiled extensions from global cache into bundle_path.
-      # Returns true when cache was present and linked, false otherwise.
-      def link_cached_build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key)
+      # Link already-compiled extensions from the cached gem tree.
+      # Returns true when cache marker is present, false otherwise.
+      def link_cached_build(prepared_gem, _bundle_path, cache_layout, abi_key: Platform.abi_key)
         spec = prepared_gem.spec
-        return false unless cached_build_available?(spec, cache_layout, abi_key: abi_key)
-
-        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
+        cached_build_available?(spec, cache_layout, abi_key: abi_key)
       end
 
       # True when a gem has native extension sources that need compiling.
@@ -157,9 +155,9 @@ module Scint
         dirs.uniq
       end
 
-      def compile_extension(ext_dir, build_dir, install_dir, gem_dir, spec, build_ruby_dir, compile_slots, output_tail = nil)
+      def compile_extension(ext_dir, build_dir, install_dir, gem_dir, spec, build_ruby_dir, compile_slots, output_tail = nil, source_ruby_dir = nil)
         make_jobs = adaptive_make_jobs(compile_slots)
-        env = build_env(gem_dir, build_ruby_dir, make_jobs)
+        env = build_env(gem_dir, build_ruby_dir, make_jobs, source_ruby_dir: source_ruby_dir)
 
         if File.exist?(File.join(ext_dir, "extconf.rb"))
           compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail)
@@ -235,28 +233,37 @@ module Scint
                                     Platform.gem_arch, Platform.extension_api_version,
                                     spec_full_name(spec))
         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)
+        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+        sync_extensions_into_gem(cached_ext, gem_dir)
       end
 
-      def sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
-        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+      # Sync compiled extension artifacts into a gem's lib directory.
+      # source_dir should contain the compiled artifacts (from build output
+      # or a cached gem tree).
+      def sync_extensions_into_gem(cached_ext, gem_dir)
         lib_dir = File.join(gem_dir, "lib")
-        return unless Dir.exist?(lib_dir)
+        FS.mkdir_p(lib_dir)
 
-        Dir.glob(File.join(ext_install_dir, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
-          rel = artifact.delete_prefix("#{ext_install_dir}/")
+        Dir.glob(File.join(cached_ext, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
+          rel = artifact.delete_prefix("#{cached_ext}/")
           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)
+      def build_marker_path(gem_dir)
+        File.join(gem_dir, BUILD_MARKER)
+      end
+
+      def build_env(gem_dir, build_ruby_dir, make_jobs, source_ruby_dir: nil)
         ruby_bin = File.join(build_ruby_dir, "bin")
         path = [ruby_bin, ENV["PATH"]].compact.reject(&:empty?).join(File::PATH_SEPARATOR)
+        inherited_gem_paths = ENV.fetch("GEM_PATH", "").split(File::PATH_SEPARATOR)
+        gem_path_entries = [build_ruby_dir, source_ruby_dir, *inherited_gem_paths].compact.reject(&:empty?).uniq
         {
           "GEM_HOME" => build_ruby_dir,
-          "GEM_PATH" => build_ruby_dir,
+          "GEM_PATH" => gem_path_entries.join(File::PATH_SEPARATOR),
           "BUNDLE_PATH" => build_ruby_dir,
           "BUNDLE_GEMFILE" => "",
           "MAKEFLAGS" => "-j#{make_jobs}",
@@ -286,16 +293,17 @@ module Scint
 
         # Stream output line-by-line so the UX gets live compile progress
         # instead of waiting for the entire subprocess to finish.
-        all_output = +""
+        all_output = +"".b
         tail_lines = []
         cmd_label = "$ #{cmd.join(" ")}"
 
         Open3.popen2e(env, *cmd, **opts) do |stdin, out_err, wait_thr|
           stdin.close
+          out_err.set_encoding("ASCII-8BIT")
 
           out_err.each_line do |line|
-            stripped = line.rstrip
             all_output << line
+            stripped = sanitize_output(line).rstrip
             next if stripped.empty?
 
             tail_lines << stripped
@@ -308,7 +316,7 @@ module Scint
 
           status = wait_thr.value
           unless status.success?
-            details = all_output.strip
+            details = sanitize_output(all_output).strip
             message = "Command failed (exit #{status.exitstatus}): #{cmd.join(" ")}"
             message = "#{message}\n#{details}" unless details.empty?
             raise ExtensionBuildError, message
@@ -316,14 +324,26 @@ module Scint
         end
       end
 
+      def sanitize_output(raw)
+        return "" if raw.nil? || raw.empty?
+
+        raw.to_s
+           .dup
+           .force_encoding(Encoding::BINARY)
+           .encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+      rescue EncodingError
+        raw.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+      end
+
       def spec_full_name(spec)
         SpecUtils.full_name(spec)
       end
 
       private_class_method :find_extension_dirs, :compile_extension,
                            :compile_extconf, :compile_cmake, :compile_rake,
-                           :find_rake_executable, :link_extensions, :sync_extension_artifacts_into_gem,
-                           :build_env, :run_cmd, :prebuilt_missing_for_ruby?
+                           :find_rake_executable, :link_extensions,
+                           :build_env, :run_cmd, :sanitize_output,
+                           :prebuilt_missing_for_ruby?
     end
   end
 end

data/lib/scint/installer/linker.rb

@@ -3,6 +3,8 @@
 require_relative "../fs"
 require_relative "../platform"
 require_relative "../spec_utils"
+require_relative "../cache/layout"
+require_relative "../cache/validity"
 require "pathname"
 
 module Scint
@@ -34,7 +36,7 @@ module Scint
         # 1. Link gem files into gems/{full_name}/
         gem_dest = File.join(ruby_dir, "gems", full_name)
         unless Dir.exist?(gem_dest)
-          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
+          materialize_gem_dir(prepared_gem, gem_dest)
         end
 
         # 2. Write gemspec into specifications/
@@ -60,6 +62,44 @@ module Scint
 
       # --- private helpers ---
 
+      def materialize_gem_dir(prepared_gem, gem_dest)
+        manifest = cached_manifest_for(prepared_gem)
+        if manifest && manifest["files"].is_a?(Array)
+          FS.materialize_from_manifest(prepared_gem.extracted_path, gem_dest, manifest["files"])
+        else
+          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
+        end
+      end
+
+      def cached_manifest_for(prepared_gem)
+        return nil unless prepared_gem.from_cache
+
+        layout = cache_layout_for(prepared_gem)
+        cached_path = layout.cached_path(prepared_gem.spec)
+        return nil unless File.expand_path(prepared_gem.extracted_path) == File.expand_path(cached_path)
+
+        manifest = Cache::Validity.read_manifest(layout.cached_manifest_path(prepared_gem.spec))
+        return nil unless manifest
+        return nil unless Cache::Validity.manifest_matches?(manifest, prepared_gem.spec, Platform.abi_key, layout)
+
+        manifest
+      rescue StandardError
+        nil
+      end
+
+      def cache_layout_for(prepared_gem)
+        extracted = File.expand_path(prepared_gem.extracted_path)
+        abi_dir = File.dirname(extracted)
+        cached_dir = File.dirname(abi_dir)
+        root = File.dirname(cached_dir)
+
+        if File.basename(abi_dir) == Platform.abi_key && File.basename(cached_dir) == "cached"
+          Cache::Layout.new(root: root)
+        else
+          Cache::Layout.new
+        end
+      end
+
       def write_gemspec(prepared_gem, ruby_dir, full_name)
         spec_dir = File.join(ruby_dir, "specifications")
         FS.mkdir_p(spec_dir)
@@ -201,7 +241,8 @@ module Scint
         RUBY
       end
 
-      private_class_method :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
+      private_class_method :materialize_gem_dir, :cached_manifest_for, :cache_layout_for,
+                           :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
                            :write_bundle_bin_wrapper, :extract_executables,
                            :detect_executables_from_files, :augment_executable_metadata, :infer_bindir,
                            :minimal_gemspec