gemstar 0.0.2 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9eeb335df1b34923f36572389fdf30489fd5e3d2b88e72e602d7cff4c9ace2b
-  data.tar.gz: 34c0bf38181ce5f9516967f94acc5ad08ae57230f7d5d6adadacf6d932860125
+  metadata.gz: 65596efbc0ff5c10ad950ca3cc8bb19e9ca9030db58b73d046ebce447200aa07
+  data.tar.gz: e5ab0cbb7f3db4b3d9949011f3b6446aecb725ee1863fd61dd196660332606de
 SHA512:
-  metadata.gz: 23fad51445796f654d61318b33129d9a9f02136162982623aecafa0afa6271e9244bc6f272fb77e2ff049c944e44164018289be5306a124311c30340572eaf04
-  data.tar.gz: 436bb8487ba91671e6ab319775460c2b13f34d0873812edf3d0e429f8c6dba5707da5ed599033153fc86cd3bb276f04c227f8e4a029756b67c9b7989e6153484
+  metadata.gz: ef75cdf526345f289eff5f0a8bff44520eb1d0aea55eff617de71d585832721655fd70c680e0e27ef7584c15dd4f304d9ee3b079c70fbafc7e4ccc5c8360c4ad
+  data.tar.gz: 13e3d871e1772c7f8ec183a3801504123896e8bd5365bba2a3e6fae5668415dcf2a40ef29f3494a2e9bef47251a3b913c37ae122879c3e8367cba9cf4490af1e

data/CHANGELOG.md

@@ -1,21 +1,13 @@
 # Change Log
 
-## TODO
-- Diff:
-    - Gems:
-        - benchmark
-        - brakeman
-        - json (not using CHANGES.md?)
-        - nio4r not using releases.md?
-        - parser not using CHANGELOG.md?
-        - actioncable-next uses release tag names?
-        - paper_trail not using CHANGELOG.md?
-        - playwright-ruby-client uses release tags?
-    - bundler itself
-    - use changelog files from installed gems where present
-
 ## Unreleased
 
+- Added `gemstar server`, your interactive Gemfile.lock explorer and more.
+- Default location for `diff` is now a tmp file.
+- Removed Railtie from this gem.
+- Improve how git root dir is determined.
+
+
 ## 0.0.2
 
 - Diff: Fix regex warnings shown in terminal.

data/README.md

@@ -22,6 +22,19 @@ gem "gemstar", group: :development
 
 ## Usage
 
+### gemstar server
+
+![Gemstar diff command output](docs/server.png)
+
+Start the interactive web UI:
+
+```shell
+gemstar server
+```
+
+By default, the server listens to http://127.0.0.1:2112/
+
+
 ### gemstar diff
 
 Run this after you've updated your gems.

data/lib/gemstar/cache.rb

@@ -1,10 +1,11 @@
+require_relative "config"
 require "fileutils"
 require "digest"
 
 module Gemstar
   class Cache
     MAX_CACHE_AGE = 60 * 60 * 24 * 7 # 1 week
-    CACHE_DIR = ".gem_changelog_cache"
+    CACHE_DIR = File.join(Gemstar::Config.home_directory, "cache")
 
     @@initialized = false
 
@@ -18,15 +19,12 @@ module Gemstar
     def self.fetch(key, &block)
       init
 
-      path = File.join(CACHE_DIR, Digest::SHA256.hexdigest(key))
+      path = path_for(key)
 
-      if File.exist?(path)
-        age = Time.now - File.mtime(path)
-        if age <= MAX_CACHE_AGE
-          content = File.read(path)
-          return nil if content == "__404__"
-          return content
-        end
+      if fresh?(path)
+        content = File.read(path)
+        return nil if content == "__404__"
+        return content
       end
 
       begin
@@ -39,11 +37,50 @@ module Gemstar
       end
     end
 
+    def self.peek(key)
+      init
+
+      path = path_for(key)
+      return nil unless fresh?(path)
+
+      content = File.read(path)
+      return nil if content == "__404__"
+
+      content
+    end
+
+    def self.path_for(key)
+      File.join(CACHE_DIR, Digest::SHA256.hexdigest(key))
+    end
+
+    def self.fresh?(path)
+      return false unless File.exist?(path)
+
+      (Time.now - File.mtime(path)) <= MAX_CACHE_AGE
+    end
+
+    def self.flush!
+      init
+
+      flush_directory(CACHE_DIR)
+    end
+
+    def self.flush_directory(directory)
+      return 0 unless Dir.exist?(directory)
+
+      entries = Dir.children(directory)
+      entries.each do |entry|
+        FileUtils.rm_rf(File.join(directory, entry))
+      end
+
+      entries.count
+    end
+
   end
 
   def edit_gitignore
     gitignore_path = ".gitignore"
-    ignore_entries = %w[.gem_changelog_cache/ gem_update_changelog.html]
+    ignore_entries = %w[gem_update_changelog.html]
 
     existing_lines = File.exist?(gitignore_path) ? File.read(gitignore_path).lines.map(&:chomp) : []
 

data/lib/gemstar/cache_cli.rb

@@ -0,0 +1,12 @@
+require "thor"
+
+module Gemstar
+  class CacheCLI < Thor
+    package_name "gemstar cache"
+
+    desc "flush", "Clear all gemstar cache entries"
+    def flush
+      Gemstar::Commands::Cache.new({}).flush
+    end
+  end
+end

data/lib/gemstar/cache_warmer.rb

@@ -0,0 +1,120 @@
+require "set"
+require "thread"
+
+module Gemstar
+  class CacheWarmer
+    DEFAULT_THREADS = 10
+
+    def initialize(io: $stderr, debug: false, thread_count: DEFAULT_THREADS)
+      @io = io
+      @debug = debug
+      @thread_count = thread_count
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @queue = []
+      @queued = Set.new
+      @in_progress = Set.new
+      @completed = Set.new
+      @workers = []
+      @started = false
+      @total = 0
+      @completed_count = 0
+    end
+
+    def enqueue_many(gem_names)
+      names = gem_names.uniq
+
+      @mutex.synchronize do
+        names.each do |gem_name|
+          next if @completed.include?(gem_name) || @queued.include?(gem_name) || @in_progress.include?(gem_name)
+
+          @queue << gem_name
+          @queued << gem_name
+        end
+        @total += names.count
+        start_workers_unlocked unless @started
+      end
+
+      log "Background cache refresh queued for #{names.count} gems."
+      @condition.broadcast
+      self
+    end
+
+    def prioritize(gem_name)
+      @mutex.synchronize do
+        return if @completed.include?(gem_name) || @in_progress.include?(gem_name)
+
+        if @queued.include?(gem_name)
+          @queue.delete(gem_name)
+        else
+          @queued << gem_name
+          @total += 1
+        end
+
+        @queue.unshift(gem_name)
+        start_workers_unlocked unless @started
+      end
+
+      log "Prioritized #{gem_name}"
+      @condition.broadcast
+    end
+
+    private
+
+    def start_workers_unlocked
+      return if @started
+
+      @started = true
+      @thread_count.times do
+        @workers << Thread.new { worker_loop }
+      end
+    end
+
+    def worker_loop
+      Thread.current.name = "gemstar-cache-worker" if Thread.current.respond_to?(:name=)
+
+      loop do
+        gem_name = @mutex.synchronize do
+          while @queue.empty?
+            @condition.wait(@mutex)
+          end
+
+          next_gem = @queue.shift
+          @queued.delete(next_gem)
+          @in_progress << next_gem
+          next_gem
+        end
+
+        warm_cache_for_gem(gem_name)
+
+        current = @mutex.synchronize do
+          @in_progress.delete(gem_name)
+          @completed << gem_name
+          @completed_count += 1
+        end
+
+        log_progress(gem_name, current)
+      end
+    end
+
+    def warm_cache_for_gem(gem_name)
+      metadata = Gemstar::RubyGemsMetadata.new(gem_name)
+      metadata.meta
+      metadata.repo_uri
+      Gemstar::ChangeLog.new(metadata).sections
+    rescue StandardError => e
+      log "Cache refresh failed for #{gem_name}: #{e.class}: #{e.message}"
+    end
+
+    def log_progress(gem_name, current)
+      return unless @debug
+      return unless current <= 5 || (current % 25).zero?
+
+      log "Background cache refresh #{current}/#{@total}: #{gem_name}"
+    end
+
+    def log(message)
+      @io.puts(message)
+    end
+  end
+end

data/lib/gemstar/change_log.rb

@@ -10,21 +10,30 @@ module Gemstar
 
     attr_reader :metadata
 
-    def content
-      @content ||= fetch_changelog_content
+    def content(cache_only: false)
+      return @content if !cache_only && defined?(@content)
+
+      result = fetch_changelog_content(cache_only: cache_only)
+      @content = result unless cache_only
+      result
     end
 
-    def sections
-      @sections ||= begin
-                      s = parse_changelog_sections
-                      if s.nil? || s.empty?
-                        s = parse_github_release_sections
-                      end
+    def sections(cache_only: false)
+      return @sections if !cache_only && defined?(@sections)
+
+      result = begin
+        s = parse_changelog_sections(cache_only: cache_only)
+        if s.nil? || s.empty?
+          s = parse_github_release_sections(cache_only: cache_only)
+        end
+
+        pp @@candidates_found if Gemstar.debug? && !cache_only
 
-                      pp @@candidates_found if Gemstar.debug?
+        s
+      end
 
-                      s
-                    end
+      @sections = result unless cache_only
+      result
     end
 
     def extract_relevant_sections(old_version, new_version)
@@ -52,26 +61,30 @@ module Gemstar
     def extract_version_from_heading(line)
       return nil unless line
       heading = line.to_s
+      version_token = /(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)/
       # 1) Prefer version inside parentheses after a date: "### 2025-11-07 (2.16.0)"
       #    Ensure we ONLY treat it as a version if it actually looks like a version (has a dot),
       #    so we don't capture dates like (2025-11-21).
-      return $1 if heading[/\(\s*v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\s*\)/]
+      return $1 if heading[/\(\s*v?#{version_token}(?![A-Za-z0-9])\s*\)/]
       # 2) Version-first with optional leading markers/labels: "## v1.2.6 - 2025-10-21"
       #    Require a dot in the numeric token to avoid capturing dates like 2025-11-21.
-      return $1 if heading[/^\s*(?:#+|=+)?\s*(?:Version\s+)?\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?/i]
+      return $1 if heading[/^\s*(?:[-*]\s+)?(?:#+|=+)?\s*(?:Version\s+)?\[*v?#{version_token}(?![A-Za-z0-9])\]*/i]
       # 3) Anywhere: first semver-like token with a dot
-      return $1 if heading[/\bv?(\d+\.\d+(?:\.\d+)?(?:[A-Za-z0-9.\-])*)\b/]
+      return $1 if heading[/\bv?#{version_token}(?![A-Za-z0-9])\b/]
       nil
     end
 
-    def changelog_uri_candidates
+    def changelog_uri_candidates(cache_only: false)
       candidates = []
 
-      if @metadata.repo_uri =~ %r{https://github\.com/aws/aws-sdk-ruby}
+      repo_uri = @metadata.repo_uri(cache_only: cache_only)
+      return [] if repo_uri.nil? || repo_uri.empty?
+
+      if repo_uri =~ %r{https://github\.com/aws/aws-sdk-ruby}
         base = "https://raw.githubusercontent.com/aws/aws-sdk-ruby/refs/heads/version-3/gems/#{@metadata.gem_name}"
         aws_style = true
       else
-        base = @metadata.repo_uri.sub("https://github.com", "https://raw.githubusercontent.com")
+        base = repo_uri.sub("https://github.com", "https://raw.githubusercontent.com")
         aws_style = false
       end
 
@@ -94,7 +107,8 @@ module Gemstar
       end
 
       # Add the gem's changelog_uri last as it's usually not the most parsable:
-      candidates += [Gemstar::GitHub::github_blob_to_raw(@metadata.meta["changelog_uri"])]
+      meta = @metadata.meta(cache_only: cache_only)
+      candidates += [Gemstar::GitHub::github_blob_to_raw(meta["changelog_uri"])] if meta
 
       candidates.flatten!
       candidates.uniq!
@@ -103,15 +117,19 @@ module Gemstar
       candidates
     end
 
-    def fetch_changelog_content
+    def fetch_changelog_content(cache_only: false)
       content = nil
 
-      changelog_uri_candidates.find do |candidate|
-        content = Cache.fetch("changelog-#{candidate}") do
-          URI.open(candidate, read_timeout: 8)&.read
-        rescue => e
-          puts "#{candidate}: #{e}" if Gemstar.debug?
-          nil
+      changelog_uri_candidates(cache_only: cache_only).find do |candidate|
+        content = if cache_only
+          Cache.peek("changelog-#{candidate}")
+        else
+          Cache.fetch("changelog-#{candidate}") do
+            URI.open(candidate, read_timeout: 8)&.read
+          rescue => e
+            puts "#{candidate}: #{e}" if Gemstar.debug?
+            nil
+          end
         end
 
         # puts "fetch_changelog_content #{candidate}:\n#{content}" if Gemstar.debug?
@@ -127,18 +145,18 @@ module Gemstar
     end
 
     VERSION_PATTERNS = [
-      /^\s*(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d[\w.\-]+)\s*\)/, # prefer this
-      /^\s*(?:#+|=+)\s*\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/,
-      /^\s*(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?(?:\s*[-(].*)?/i,
-      /^\s*(?:#+|=+)\s*(?:Version\s+)?\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?(?:\s*[-(].*)?/i,
-      /^\s*(?:Version\s+)?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)(?:\s*[-(].*)?/i
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\s*\)/, # prefer this
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/,
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*(?:\s*[-(].*)?/i,
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*(?:\s*[-(].*)?/i,
+      /^\s*(?:[-*]\s+)?(?:Version\s+)?v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])(?:\s*[-(].*)?/i
     ]
 
-    def parse_changelog_sections
+    def parse_changelog_sections(cache_only: false)
       # If the fetched content looks like a GitHub Releases HTML page, return {}
       # so that the GitHub releases scraper can handle it. This avoids
       # accidentally parsing HTML from /releases pages as a markdown changelog.
-      c = content
+      c = content(cache_only: cache_only)
       return {} if c.nil? || c.strip.empty?
       if (c.include?("<html") || c.include?("<!DOCTYPE html")) &&
          (c.include?('data-test-selector="body-content"') || c.include?("/releases/tag/"))
@@ -194,24 +212,37 @@ module Gemstar
       sections
     end
 
-    def parse_github_release_sections
+    def parse_github_release_sections(cache_only: false)
       begin
         require "nokogiri"
       rescue LoadError
         return {}
       end
 
-      return {} unless @metadata&.repo_uri&.include?("github.com")
+      repo_uri = @metadata&.repo_uri(cache_only: cache_only)
+      return {} unless repo_uri&.include?("github.com")
 
-      url = github_releases_url
+      url = github_releases_url(repo_uri)
       return {} unless url
 
-      html = Cache.fetch("releases-#{url}") do
-        begin
-          URI.open(url, read_timeout: 8)&.read
-        rescue => e
-          puts "#{url}: #{e}" if Gemstar.debug?
-          nil
+      html = if cache_only
+        Cache.peek("releases-#{url}")
+      else
+        Cache.fetch("releases-#{url}") do
+          begin
+            URI.open(url, read_timeout: 8)&.read
+          rescue => e
+            puts "#{url}: #{e}" if Gemstar.debug?
+            nil
+          end
+        end
+      end
+
+      if (html.nil? || html.strip.empty?) && cache_only
+        cached_content = content(cache_only: true)
+        if cached_content&.include?("<html") &&
+           (cached_content.include?('data-test-selector="body-content"') || cached_content.include?("/releases/tag/"))
+          html = cached_content
         end
       end
 
@@ -271,9 +302,9 @@ module Gemstar
       sections
     end
 
-    def github_releases_url
-      return nil unless @metadata&.repo_uri
-      repo = @metadata.repo_uri.chomp("/")
+    def github_releases_url(repo_uri = @metadata&.repo_uri)
+      return nil unless repo_uri
+      repo = repo_uri.chomp("/")
       return nil if repo.empty?
       "#{repo}/releases"
     end

data/lib/gemstar/cli.rb

@@ -19,6 +19,18 @@ module Gemstar
       Gemstar::Commands::Diff.new(options).run
     end
 
+    desc "server", "Start the interactive web server"
+    method_option :bind, type: :string, default: "127.0.0.1", desc: "Bind address"
+    method_option :port, type: :numeric, default: 2112, desc: "Port"
+    method_option :project, type: :string, repeatable: true, desc: "Project directories or Gemfile paths"
+    method_option :reload, type: :boolean, default: false, desc: "Restart automatically when files change"
+    def server
+      Gemstar::Commands::Server.new(options).run
+    end
+
+    desc "cache SUBCOMMAND ...ARGS", "Manage gemstar caches"
+    subcommand "cache", Gemstar::CacheCLI
+
     # desc "pick", "Interactively cherry-pick and upgrade gems"
     # option :gem, type: :string, desc: "Gem name to cherry-pick"
     # def pick

data/lib/gemstar/commands/cache.rb

@@ -0,0 +1,12 @@
+require_relative "command"
+
+module Gemstar
+  module Commands
+    class Cache < Command
+      def flush
+        removed_entries = Gemstar::Cache.flush!
+        puts "Flushed #{removed_entries} cache entr#{removed_entries == 1 ? 'y' : 'ies'} from #{Gemstar::Cache::CACHE_DIR}"
+      end
+    end
+  end
+end

data/lib/gemstar/commands/diff.rb

@@ -2,7 +2,7 @@
 
 require_relative "command"
 require "concurrent-ruby"
-require "tempfile"
+require "tmpdir"
 
 module Gemstar
   module Commands
@@ -24,7 +24,7 @@ module Gemstar
         @from = options[:from] || "HEAD"
         @to = options[:to]
         @lockfile = options[:lockfile] || "Gemfile.lock"
-        @output_file = options[:output_file] || "gem_update_changelog.html"
+        @output_file = options[:output_file] || File.join(Dir.tmpdir, "gem_update_changelog.html")
 
         @git_repo = Gemstar::GitRepo.new(File.dirname(@lockfile))
       end
@@ -46,7 +46,7 @@ module Gemstar
 
         html = Outputs::HTML.new.render_diff(self)
         File.write(output_file, html)
-        puts "✅ gem_update_changelog.html created."
+        puts "✅ Changelog report created: #{File.expand_path(output_file)}"
 
         if failed.any?
           puts "\n⚠️ The following gems failed to process:"

data/lib/gemstar/commands/server.rb

@@ -0,0 +1,136 @@
+require_relative "command"
+require "shellwords"
+
+module Gemstar
+  module Commands
+    class Server < Command
+      DEFAULT_BIND = "127.0.0.1"
+      DEFAULT_PORT = 2112
+      RELOAD_ENV_VAR = "GEMSTAR_RELOAD_ACTIVE"
+      RELOAD_GLOB = "{lib/**/*.rb,lib/gemstar/web/templates/**/*,bin/gemstar,README.md}"
+
+      attr_reader :bind
+      attr_reader :port
+      attr_reader :project_inputs
+      attr_reader :reload
+
+      def initialize(options)
+        super
+
+        @bind = options[:bind] || DEFAULT_BIND
+        @port = (options[:port] || DEFAULT_PORT).to_i
+        @project_inputs = normalize_project_inputs(options[:project])
+        @reload = options[:reload]
+      end
+
+      def run
+        restart_with_rerun if reload_requested?
+
+        require "rackup"
+        require "webrick"
+        require "gemstar/request_logger"
+        require "gemstar/webrick_logger"
+        require "gemstar/web/app"
+
+        Gemstar::Config.ensure_home_directory!
+
+        projects = load_projects
+        log_loaded_projects(projects)
+        cache_warmer = start_background_cache_refresh(projects)
+        app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
+        app = Gemstar::RequestLogger.new(app, io: $stderr) if debug_request_logging?
+
+        puts "Gemstar server listening on http://#{bind}:#{port}"
+        puts "Config home: #{Gemstar::Config.home_directory}"
+        Rackup::Server.start(
+          app: app,
+          Host: bind,
+          Port: port,
+          AccessLog: [],
+          Logger: Gemstar::WEBrickLogger.new($stderr, WEBrick::BasicLog::INFO)
+        )
+      end
+
+      private
+
+      def normalize_project_inputs(project_option)
+        inputs = Array(project_option).compact.map(&:to_s)
+        return ["."] if inputs.empty?
+
+        inputs.uniq
+      end
+
+      def reload_requested?
+        reload && ENV[RELOAD_ENV_VAR] != "1"
+      end
+
+      def restart_with_rerun
+        rerun_executable = find_rerun_executable
+        unless rerun_executable
+          raise Thor::Error, "The `rerun` gem is not installed. Run `bundle install` and try `gemstar server --reload` again."
+        end
+
+        puts "Starting gemstar server in reload mode..."
+        puts "Watching changes matching #{RELOAD_GLOB.inspect}"
+
+        env = ENV.to_h.merge(RELOAD_ENV_VAR => "1")
+        exec env, *rerun_command(rerun_executable)
+      end
+
+      def find_rerun_executable
+        Gem.bin_path("rerun", "rerun")
+      rescue Gem::Exception
+        nil
+      end
+
+      def rerun_command(rerun_executable)
+        [
+          rerun_executable,
+          "--pattern",
+          RELOAD_GLOB,
+          "--",
+          Gem.ruby,
+          File.expand_path($PROGRAM_NAME)
+        ] + server_arguments_without_reload
+      end
+
+      def server_arguments_without_reload
+        args = [
+          "server",
+          "--bind", bind,
+          "--port", port.to_s
+        ]
+        project_inputs.each do |project|
+          args << "--project"
+          args << project
+        end
+        args
+      end
+
+      def load_projects
+        project_inputs.map { |input| Gemstar::Project.from_cli_argument(input) }
+      end
+
+      def log_loaded_projects(projects)
+        return unless debug_request_logging?
+
+        $stderr.puts "[gemstar] project inputs: #{project_inputs.inspect}"
+        $stderr.puts "[gemstar] loaded projects (#{projects.count}): #{projects.map(&:directory).inspect}"
+      end
+
+      def debug_request_logging?
+        ENV["DEBUG"] == "1"
+      end
+
+      def start_background_cache_refresh(projects)
+        gem_names = projects.flat_map do |project|
+          project.current_lockfile&.specs&.keys || []
+        end.uniq.sort
+
+        return nil if gem_names.empty?
+
+        Gemstar::CacheWarmer.new(io: $stderr, debug: debug_request_logging? || Gemstar.debug?, thread_count: 10).enqueue_many(gem_names)
+      end
+    end
+  end
+end