gemstar 1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd80f7bf53281fd8f5b80138f9f564ff8e393ffaec44276168dc020765c6ae7a
-  data.tar.gz: 3d6b9c2f9a2e0955d6ace8c34100c05390cd9579aa8c8993361799450e36c625
+  metadata.gz: c6157dce9498afdbda3d014af6e1e4e20e7477d73bd3b12129c0d754df28f4f7
+  data.tar.gz: c7fcc69688c21fea79ead9b9f762d026a5b57e5c597206171fe6faaeb5555db1
 SHA512:
-  metadata.gz: 79d87285b961fdd88c6e898b2016d2bc4cc65b508a5f2c7480f865f0144b12ca5a53be3ff7833d48ed1a66cf4851134a6dbe41fdfc44d807f720e0c63fe52a05
-  data.tar.gz: 4803b9f217fef1aae5b671fdc5a356229697aba7d5cec4b2f1a05588d63a9ca88c38f876ed4aa1d2579451d6196097818a3d9aa866f8071004c45a9966c66a95
+  metadata.gz: 89b29cc2ff749b326e1e8dfd2cc98279b45d05a961b1d1aab8ea0cfcc9e4c2acab238fbaf40c4b947b0c9201a6254a80beb5102aa8c28c348d1afde67ced305a
+  data.tar.gz: 55182c82a720bd6a5baf9ab26e7369df6c834c24ae959b05301a40da16ac0e447a6ada98ac2461064ba137f9e944191026c48084d1ec2f95e923c0cda6b19265

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## 1.2
+
+- Server: Cache warmer now pre-fetches package detail pages so browsing warmed gems is faster.
+- Server: Manual browser reloads now refresh the selected package details, including metadata and release notes caches.
+- Server: Fetch GitHub release bodies through the GitHub Releases API before falling back to HTML scraping.
+- Server: Add explicit "Use GitHub CLI" fallback for GitHub-backed release notes when automatic release discovery misses a page.
+
+## 1.1.1
+
+- Server: Show release dates for changelog entries.
+- Fix GitHub release discovery with direct tag-page fallback and paginated GitHub tags support.
+- Add changelog_uri fallback for GitHub repos with no changelog_uri metadata.
+- Fix change log display for aws, herb, and pagy gems.
+
 ## 1.1
 
 - Server: Add **JavaScript package support** to browse change logs for your project's packages. This currently

data/lib/gemstar/cache_warmer.rb

@@ -5,10 +5,11 @@ module Gemstar
   class CacheWarmer
     DEFAULT_THREADS = 10
 
-    def initialize(io: $stderr, debug: false, thread_count: DEFAULT_THREADS)
+    def initialize(io: $stderr, debug: false, thread_count: DEFAULT_THREADS, detail_cache_fetcher: nil)
       @io = io
       @debug = debug
       @thread_count = thread_count
+      @detail_cache_fetcher = detail_cache_fetcher
       @mutex = Mutex.new
       @condition = ConditionVariable.new
       @queue = []
@@ -21,6 +22,8 @@ module Gemstar
       @completed_count = 0
     end
 
+    attr_writer :detail_cache_fetcher
+
     def enqueue_many(package_states)
       states = normalize_package_states(package_states)
 
@@ -120,13 +123,22 @@ module Gemstar
 
     def warm_cache_for_package(package_state)
       metadata = metadata_adapter_for(package_state)
-      return unless metadata
+      metadata&.warm_cache(versions: package_versions(package_state))
 
-      metadata.warm_cache(versions: package_versions(package_state))
+      warm_detail_cache_for_package(package_state)
     rescue StandardError => e
       log "Cache refresh failed for #{package_label(package_state)}: #{e.class}: #{e.message}"
     end
 
+    def warm_detail_cache_for_package(package_state)
+      fetcher = @detail_cache_fetcher
+      return unless fetcher
+
+      Array(package_state[:detail_cache_contexts]).each do |context|
+        fetcher.call(package_state, context)
+      end
+    end
+
     def log_progress(package_name, current)
       return unless @debug
       return unless current <= 5 || (current % 25).zero?

data/lib/gemstar/change_log.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
 require "cgi"
+require "date"
 require "json"
+require "open3"
+require "time"
+require "timeout"
+require "uri"
+require_relative "cache"
 
 module Gemstar
   class ChangeLog
     @@candidates_found = Hash.new(0)
+    GITHUB_CLI_TIMEOUT = 8
     DEFAULT_CHANGELOG_PATHS = %w[
       CHANGELOG.md releases.md CHANGES.md
       Changelog.md changelog.md ChangeLog.md
@@ -31,7 +38,7 @@ module Gemstar
       return @sections if !cache_only && defined?(@sections) && !force_refresh
 
       metadata_key = @metadata.respond_to?(:cache_key) ? @metadata.cache_key : @metadata.gem_name
-      cache_key = "sections-v4-#{metadata_key}"
+      cache_key = "sections-v5-#{metadata_key}"
       serialized = if cache_only
         Cache.peek(cache_key)
       else
@@ -52,7 +59,7 @@ module Gemstar
       result
     end
 
-    def sections_for_versions(versions, cache_only: false, force_refresh: false)
+    def sections_for_versions(versions, cache_only: false, force_refresh: false, use_github_cli: false)
       requested_versions = normalize_requested_versions(versions)
       return {} if requested_versions.empty?
 
@@ -73,7 +80,8 @@ module Gemstar
             repo_uri,
             version,
             cache_only: false,
-            force_refresh: force_refresh
+            force_refresh: force_refresh,
+            use_github_cli: use_github_cli
           )
           result.merge!(specific_release) if specific_release
         end
@@ -82,6 +90,31 @@ module Gemstar
       result
     end
 
+    def release_dates(versions: nil, cache_only: false, force_refresh: false)
+      requested_versions = normalize_requested_versions(versions)
+      metadata_key = @metadata.respond_to?(:cache_key) ? @metadata.cache_key : @metadata.gem_name
+      cache_key = "release-dates-v2-#{metadata_key}"
+      serialized = if cache_only
+        Cache.peek(cache_key)
+      else
+        Cache.fetch(cache_key, force: force_refresh) do
+          JSON.generate(compute_release_dates(force_refresh: force_refresh))
+        end
+      end
+
+      dates = if serialized
+        decode_sections(serialized) || {}
+      elsif cache_only
+        {}
+      else
+        compute_release_dates(force_refresh: force_refresh)
+      end
+
+      return dates if requested_versions.empty?
+
+      dates.select { |version, _date| requested_versions.include?(normalize_version_key(version)) }
+    end
+
     def compute_sections(force_refresh: false)
       changelog_sections = parse_changelog_sections(cache_only: false, force_refresh: force_refresh) || {}
       github_sections = parse_github_release_sections(cache_only: false, force_refresh: force_refresh) || {}
@@ -93,6 +126,23 @@ module Gemstar
       sections
     end
 
+    def compute_release_dates(force_refresh: false)
+      registry_dates = if @metadata.respond_to?(:registry_release_dates)
+        @metadata.registry_release_dates(cache_only: false, force_refresh: force_refresh)
+      else
+        {}
+      end
+      return registry_dates unless registry_dates.nil? || registry_dates.empty?
+
+      changelog_dates = parse_changelog_release_dates(cache_only: false, force_refresh: force_refresh)
+      return changelog_dates unless changelog_dates.nil? || changelog_dates.empty?
+
+      repo_uri = @metadata&.repo_uri(cache_only: false, force_refresh: force_refresh)
+      return {} unless repo_uri&.include?("github.com")
+
+      parse_github_tag_dates(repo_uri, cache_only: false, force_refresh: force_refresh)
+    end
+
     def decode_sections(serialized)
       JSON.parse(serialized)
     rescue JSON::ParserError
@@ -101,9 +151,7 @@ module Gemstar
 
     def merge_section_sources(changelog_sections, github_sections)
       return github_sections if changelog_sections.nil? || changelog_sections.empty?
-      return changelog_sections if github_sections.nil? || github_sections.empty?
-
-      github_sections.merge(changelog_sections)
+      changelog_sections
     end
 
     def extract_relevant_sections(old_version, new_version)
@@ -155,12 +203,22 @@ module Gemstar
       nil
     end
 
+    def extract_release_date_from_heading(line)
+      return nil unless line
+
+      raw_date = line.to_s[/\b(\d{4}-\d{2}-\d{2})\b/, 1]
+      format_release_date(raw_date)
+    end
+
     def changelog_uri_candidates(cache_only: false, force_refresh: false)
       candidates = []
 
       repo_uri = @metadata.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       return [] if repo_uri.nil? || repo_uri.empty?
 
+      meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
+      candidates += changelog_uri_markdown_candidates(meta["changelog_uri"]) if meta
+
       changelog_source = metadata_changelog_source(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
       return [] unless changelog_source
 
@@ -169,7 +227,6 @@ module Gemstar
       end
 
       # Add the gem's changelog_uri last as it's usually not the most parsable:
-      meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
       candidates += [Gemstar::GitHub::github_blob_to_raw(meta["changelog_uri"])] if meta
 
       candidates.flatten!
@@ -179,6 +236,30 @@ module Gemstar
       candidates
     end
 
+    def changelog_uri_markdown_candidates(changelog_uri)
+      raw_uri = Gemstar::GitHub::github_blob_to_raw(changelog_uri)
+      return [] if raw_uri.to_s.empty?
+
+      candidates = []
+      candidates << raw_uri if raw_uri.match?(/\.(?:md|markdown|rdoc|txt)\z/i)
+
+      begin
+        uri = URI(raw_uri)
+        path = uri.path.to_s
+        if path.end_with?("/")
+          uri.path = "#{path.chomp("/")}.md"
+          candidates << uri.to_s
+        elsif File.extname(path).empty?
+          uri.path = "#{path}.md"
+          candidates << uri.to_s
+        end
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      candidates
+    end
+
     def metadata_changelog_source(repo_uri, cache_only:, force_refresh:)
       if @metadata.respond_to?(:changelog_source)
         return @metadata.changelog_source(repo_uri: repo_uri, cache_only: cache_only, force_refresh: force_refresh)
@@ -287,19 +368,37 @@ module Gemstar
       sections
     end
 
-    def parse_github_release_sections(cache_only: false, force_refresh: false)
-      begin
-        require "nokogiri"
-      rescue LoadError
-        return {}
+    def parse_changelog_release_dates(cache_only: false, force_refresh: false)
+      c = content(cache_only: cache_only, force_refresh: force_refresh)
+      return {} if c.nil? || c.strip.empty?
+      return {} if c.include?("<html") || c.include?("<!DOCTYPE html")
+
+      c.lines.each_with_object({}) do |line, dates|
+        line = line.gsub(/^=+/) { |m| "#" * m.length }
+        next unless VERSION_PATTERNS.any? { |re| line.match?(re) }
+
+        version = extract_version_from_heading(line)
+        date = extract_release_date_from_heading(line)
+        dates[version] ||= date if version && date
       end
+    end
 
+    def parse_github_release_sections(cache_only: false, force_refresh: false)
       repo_uri = @metadata&.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       return {} unless repo_uri&.include?("github.com")
 
       url = github_releases_url(repo_uri)
       return {} unless url
 
+      api_sections = parse_github_api_release_sections(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
+      return api_sections unless api_sections.empty?
+
+      begin
+        require "nokogiri"
+      rescue LoadError
+        return {}
+      end
+
       html = if cache_only
         Cache.peek("releases-#{url}")
       else
@@ -416,11 +515,90 @@ module Gemstar
       "#{repo}/tags"
     end
 
-    def parse_specific_github_release_pages(repo_uri, version, cache_only:, force_refresh:)
+    def github_releases_api_url(repo_uri = @metadata&.repo_uri)
+      repo_path = github_repo_path(repo_uri)
+      return nil unless repo_path
+
+      "https://api.github.com/repos/#{repo_path}/releases"
+    end
+
+    def github_release_api_url(repo_uri, tag)
+      repo_path = github_repo_path(repo_uri)
+      return nil unless repo_path
+
+      "https://api.github.com/repos/#{repo_path}/releases/tags/#{URI.encode_www_form_component(tag)}"
+    end
+
+    def github_repo_path(repo_uri)
+      uri = URI(repo_uri.to_s)
+      return nil unless uri.host.to_s.end_with?("github.com")
+
+      segments = uri.path.to_s.split("/").reject(&:empty?)
+      return nil if segments.length < 2
+
+      segments.take(2).join("/")
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def parse_github_api_release_sections(repo_uri, cache_only:, force_refresh:)
+      url = github_releases_api_url(repo_uri)
+      return {} unless url
+
+      json = if cache_only
+        Cache.peek("releases-api-#{url}")
+      else
+        Cache.fetch("releases-api-#{url}", force: force_refresh) do
+          begin
+            URI.open(url, "Accept" => "application/vnd.github+json", read_timeout: 8)&.read
+          rescue => e
+            puts "#{url}: #{e}" if Gemstar.debug?
+            nil
+          end
+        end
+      end
+
+      parse_github_api_releases(json)
+    end
+
+    def parse_github_api_releases(json)
+      releases = JSON.parse(json.to_s)
+      releases = [releases] if releases.is_a?(Hash)
+      return {} unless releases.is_a?(Array)
+
+      releases.each_with_object({}) do |release, sections|
+        next unless release.is_a?(Hash)
+
+        tag_name = (release["tag_name"] || release["tagName"]).to_s
+        next if tag_name.empty?
+        next unless github_tag_matches_metadata?(tag_name)
+
+        version = normalize_github_tag_version(tag_name)
+        next if version.to_s.empty?
+
+        body = release["body"].to_s.strip
+        title = release["name"].to_s.strip
+        content = body.empty? ? title : body
+        next if content.empty?
+
+        sections[version] ||= ["## #{version}\n", content]
+      end
+    rescue JSON::ParserError
+      {}
+    end
+
+    def parse_specific_github_release_pages(repo_uri, version, cache_only:, force_refresh:, use_github_cli: false)
       return {} unless repo_uri&.include?("github.com")
       return {} if version.to_s.empty?
 
-      github_release_tag_urls(repo_uri, version).each do |url|
+      github_tag_candidates(version).each do |tag|
+        cli_section = parse_specific_github_cli_release(repo_uri, tag, cache_only: cache_only, force_refresh: force_refresh) if use_github_cli
+        return cli_section if cli_section && !cli_section.empty?
+
+        api_section = parse_specific_github_api_release(repo_uri, tag, cache_only: cache_only, force_refresh: force_refresh)
+        return api_section unless api_section.empty?
+
+        url = github_release_tag_url(repo_uri, tag)
         html = if cache_only
           Cache.peek("releases-#{url}")
         else
@@ -443,6 +621,62 @@ module Gemstar
       {}
     end
 
+    def parse_specific_github_cli_release(repo_uri, tag_name, cache_only:, force_refresh:)
+      repo_path = github_repo_path(repo_uri)
+      return {} unless repo_path
+
+      cache_key = "releases-gh-#{repo_path}-#{tag_name}"
+      json = if cache_only
+        Cache.peek(cache_key)
+      else
+        Cache.fetch(cache_key, force: force_refresh) do
+          fetch_github_cli_release_json(repo_path, tag_name)
+        end
+      end
+
+      parse_github_api_releases(json)
+    end
+
+    def fetch_github_cli_release_json(repo_path, tag_name)
+      stdout, _stderr, status = nil
+      Timeout.timeout(GITHUB_CLI_TIMEOUT) do
+        stdout, _stderr, status = Open3.capture3(
+          "gh",
+          "release",
+          "view",
+          tag_name,
+          "--repo",
+          repo_path,
+          "--json",
+          "body,name,tagName"
+        )
+      end
+
+      status.success? ? stdout : nil
+    rescue Errno::ENOENT, Timeout::Error
+      nil
+    end
+
+    def parse_specific_github_api_release(repo_uri, tag_name, cache_only:, force_refresh:)
+      url = github_release_api_url(repo_uri, URI.decode_www_form_component(tag_name.to_s))
+      return {} unless url
+
+      json = if cache_only
+        Cache.peek("releases-api-#{url}")
+      else
+        Cache.fetch("releases-api-#{url}", force: force_refresh) do
+          begin
+            URI.open(url, "Accept" => "application/vnd.github+json", read_timeout: 8)&.read
+          rescue => e
+            puts "#{url}: #{e}" if Gemstar.debug?
+            nil
+          end
+        end
+      end
+
+      parse_github_api_releases(json)
+    end
+
     def parse_github_tag_sections(repo_uri, cache_only:, force_refresh:)
       return {} unless repo_uri&.include?("github.com")
 
@@ -489,6 +723,40 @@ module Gemstar
       sections
     end
 
+    def parse_github_tag_dates(repo_uri, cache_only:, force_refresh:)
+      return {} unless repo_uri&.include?("github.com")
+
+      url = github_tags_url(repo_uri)
+      return {} unless url
+
+      dates = {}
+      seen_urls = {}
+
+      while url && !seen_urls[url]
+        seen_urls[url] = true
+        html = if cache_only
+          Cache.peek("tags-#{url}")
+        else
+          Cache.fetch("tags-#{url}", force: force_refresh) do
+            begin
+              URI.open(url, read_timeout: 8)&.read
+            rescue => e
+              puts "#{url}: #{e}" if Gemstar.debug?
+              nil
+            end
+          end
+        end
+
+        break if html.nil? || html.strip.empty?
+
+        page_dates, next_url = parse_single_github_tag_dates_page(html, repo_uri)
+        dates.merge!(page_dates) { |_version, existing, _new| existing }
+        url = next_url
+      end
+
+      dates
+    end
+
     def parse_single_github_tags_page(html, repo_uri)
       require "nokogiri"
 
@@ -539,6 +807,75 @@ module Gemstar
       [{}, nil]
     end
 
+    def parse_single_github_tag_dates_page(html, repo_uri)
+      require "nokogiri"
+
+      doc = begin
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
+
+      dates = {}
+      repo_path = URI(repo_uri).path
+      release_prefix = "#{repo_path}/releases/tag/"
+      tree_prefix = "#{repo_path}/tree/"
+
+      doc.css("a[href]").each do |link|
+        href = link["href"].to_s
+        tag_name =
+          if href.start_with?(release_prefix)
+            href.delete_prefix(release_prefix)
+          elsif href.start_with?(tree_prefix)
+            href.delete_prefix(tree_prefix)
+          end
+        next if tag_name.to_s.empty?
+        next unless github_tag_matches_metadata?(tag_name)
+
+        version = normalize_github_tag_version(tag_name)
+        next if version.to_s.empty?
+
+        datetime = github_tag_datetime_for(link)
+        next if datetime.to_s.empty?
+
+        dates[version] ||= format_release_date(datetime)
+      end
+
+      next_href =
+        doc.at_css('a[rel="next"], a.next_page')&.[]("href") ||
+        doc.css("a[href]").find do |link|
+          href = link["href"].to_s
+          text = link.text.to_s.gsub(/\s+/, " ").strip
+          href.include?("/tags?after=") && text == "Next"
+        end&.[]("href")
+      next_url = if next_href && !next_href.empty?
+        URI.join(repo_uri, next_href).to_s
+      end
+
+      [dates.compact, next_url]
+    rescue LoadError
+      [{}, nil]
+    end
+
+    def github_tag_datetime_for(link)
+      container = link.at_xpath('ancestor::*[self::li or self::div][.//relative-time or .//time-ago][1]')
+      time_node = container&.at_css("relative-time[datetime], time-ago[datetime]") ||
+                  link.xpath('following::relative-time[@datetime] | following::time-ago[@datetime]').first
+      time_node&.[]("datetime")
+    end
+
+    def format_release_date(datetime)
+      if datetime.to_s.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        date = Date.strptime(datetime.to_s, "%Y-%m-%d")
+        return date.strftime("%b #{date.day}, %Y")
+      end
+
+      time = Time.parse(datetime.to_s).utc
+      time.strftime("%b #{time.day}, %Y")
+    rescue ArgumentError
+      nil
+    end
+
     def parse_single_github_release_page(html, version)
       require "nokogiri"
 
@@ -567,11 +904,15 @@ module Gemstar
 
     def github_release_tag_urls(repo_url, version)
       github_tag_candidates(version).map do |tag|
-        encoded_tag = URI.encode_www_form_component(tag)
-        "#{repo_url}/releases/tag/#{encoded_tag}"
+        github_release_tag_url(repo_url, tag)
       end.uniq
     end
 
+    def github_release_tag_url(repo_url, tag)
+      encoded_tag = URI.encode_www_form_component(tag)
+      "#{repo_url}/releases/tag/#{encoded_tag}"
+    end
+
     def github_tag_candidates(version)
       return @metadata.github_tag_candidates(version) if @metadata.respond_to?(:github_tag_candidates)
 

data/lib/gemstar/commands/server.rb

@@ -1,6 +1,8 @@
 require_relative "command"
+require "rack/mock"
 require "socket"
 require "shellwords"
+require "uri"
 require "rbconfig"
 
 module Gemstar
@@ -45,7 +47,9 @@ module Gemstar
         projects = load_projects
         log_loaded_projects(projects)
         cache_warmer = build_cache_warmer
-        app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
+        web_app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
+        cache_warmer.detail_cache_fetcher = build_detail_cache_fetcher(web_app)
+        app = web_app
         app = Gemstar::RequestLogger.new(app, io: $stderr) if debug_request_logging?
 
         puts "Gemstar server listening on http://#{bind}:#{port}"
@@ -183,8 +187,21 @@ module Gemstar
       end
 
       def start_background_cache_refresh(projects, cache_warmer)
-        package_states = projects.flat_map do |project|
-          project.gem_states(from_revision_id: "worktree", to_revision_id: "worktree")
+        package_states = projects.flat_map.with_index do |project, project_index|
+          from_revision_id = project.default_from_revision_id
+          to_revision_id = "worktree"
+          states = project.gem_states(from_revision_id: from_revision_id, to_revision_id: to_revision_id)
+          detail_cache_contexts = detail_cache_contexts_for(
+            project: project,
+            project_index: project_index,
+            from_revision_id: from_revision_id,
+            to_revision_id: to_revision_id,
+            package_states: states
+          )
+
+          states.map do |state|
+            state.merge(detail_cache_contexts: detail_cache_contexts_for_package(state, detail_cache_contexts))
+          end
         end
 
         return nil if package_states.empty?
@@ -192,6 +209,53 @@ module Gemstar
         cache_warmer.enqueue_many(package_states)
       end
 
+      def detail_cache_contexts_for(project:, project_index:, from_revision_id:, to_revision_id:, package_states:)
+        default_filter = package_states.any? { |state| state[:status] != :unchanged } ? "updated" : "all"
+        default_scope = project.package_scope_options.map { |option| option[:id] } == ["gems"] ? "gems" : "all"
+
+        [
+          {
+            project: project_index,
+            from: from_revision_id,
+            to: to_revision_id,
+            filter: default_filter,
+            scope: default_scope
+          },
+          {
+            project: project_index,
+            from: from_revision_id,
+            to: to_revision_id,
+            filter: "all",
+            scope: default_scope
+          }
+        ].uniq
+      end
+
+      def detail_cache_contexts_for_package(package_state, base_contexts)
+        package_scope = package_state[:package_scope]
+
+        base_contexts.flat_map do |context|
+          [
+            context,
+            context.merge(scope: package_scope)
+          ]
+        end.uniq
+      end
+
+      def build_detail_cache_fetcher(app)
+        lambda do |package_state, context|
+          params = context.merge(package: package_state[:name])
+          env = Rack::MockRequest.env_for(
+            "/detail?#{URI.encode_www_form(params)}",
+            "REQUEST_METHOD" => "GET",
+            "gemstar.detail_cache_warm" => true
+          )
+          response = app.call(env)
+          body = response[2]
+          body.close if body.respond_to?(:close)
+        end
+      end
+
       def server_start_callback(projects, cache_warmer)
         proc do
           Thread.new do

data/lib/gemstar/git_hub.rb

@@ -8,11 +8,12 @@ module Gemstar
       uri = URI(url)
       return url unless uri.host == "github.com"
 
-      owner, repo, blob, *rest = uri.path.split("/")[1..]
-      return url unless blob == "blob"
+      owner, repo, view, *rest = uri.path.split("/")[1..]
+      return url unless %w[blob tree].include?(view)
 
       ref  = rest.shift
       path = rest.join("/")
+      return url if path.empty?
 
       ref_prefix = ref_is_tag ? "refs/tags/" : ""
 

data/lib/gemstar/npm_metadata.rb

@@ -64,13 +64,13 @@ module Gemstar
       repo
     end
 
-    def changelog_sections(versions: nil, cache_only: false, force_refresh: false)
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: false)
       requested_versions = Array(versions).compact
       changelog = Gemstar::ChangeLog.new(self)
       if requested_versions.empty?
         changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
       else
-        changelog.sections_for_versions(requested_versions, cache_only: cache_only, force_refresh: force_refresh)
+        changelog.sections_for_versions(requested_versions, cache_only: cache_only, force_refresh: force_refresh, use_github_cli: use_github_cli)
       end
     end
 

data/lib/gemstar/ruby_gems_metadata.rb

@@ -1,6 +1,8 @@
 require "open-uri"
 require "uri"
 require "json"
+require "date"
+require "time"
 require_relative "remote_repository"
 
 module Gemstar
@@ -86,8 +88,35 @@ module Gemstar
       repo
     end
 
-    def changelog_sections(versions: nil, cache_only: false, force_refresh: false)
-      Gemstar::ChangeLog.new(self).sections(cache_only: cache_only, force_refresh: force_refresh)
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: false)
+      changelog = Gemstar::ChangeLog.new(self)
+      if use_github_cli && Array(versions).compact.any?
+        changelog.sections_for_versions(versions, cache_only: cache_only, force_refresh: force_refresh, use_github_cli: true)
+      else
+        changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
+      end
+    end
+
+    def registry_release_dates(cache_only: false, force_refresh: false)
+      cache_key = "rubygems-versions-#{gem_name}"
+      json = if cache_only
+        Cache.peek(cache_key)
+      else
+        url = "https://rubygems.org/api/v1/versions/#{URI.encode_www_form_component(gem_name)}.json"
+        Cache.fetch(cache_key, force: force_refresh) do
+          URI.open(url, read_timeout: 8).read
+        end
+      end
+
+      Array(JSON.parse(json)).each_with_object({}) do |version, dates|
+        number = version["number"].to_s
+        created_at = version["created_at"].to_s
+        next if number.empty? || created_at.empty?
+
+        dates[number] = format_registry_release_date(created_at)
+      end.compact
+    rescue JSON::ParserError
+      {}
     end
 
     def warm_cache(versions: nil)
@@ -146,5 +175,17 @@ module Gemstar
       value.to_s.gsub("{gem_name}", gem_name)
     end
 
+    def format_registry_release_date(datetime)
+      if datetime.to_s.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        date = Date.strptime(datetime.to_s, "%Y-%m-%d")
+        return date.strftime("%b #{date.day}, %Y")
+      end
+
+      time = Time.parse(datetime.to_s).utc
+      time.strftime("%b #{time.day}, %Y")
+    rescue ArgumentError
+      nil
+    end
+
   end
 end

data/lib/gemstar/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Gemstar # :nodoc:
-  VERSION = "1.1"
+  VERSION = "1.2"
   def self.debug?
     return @debug if defined?(@debug)
     @debug = ENV["GEMSTAR_DEBUG"] == "true"

data/lib/gemstar/web/app.rb

@@ -2,6 +2,7 @@ require "cgi"
 require "erb"
 require "uri"
 require "kramdown"
+require "nokogiri"
 require "roda"
 
 begin
@@ -13,7 +14,7 @@ module Gemstar
   module Web
     class App < Roda
       MISSING_METADATA = Object.new
-      CACHE_VERSION = "v6"
+      CACHE_VERSION = "v7"
 
       class << self
         def build(projects:, config_home:, cache_warmer: nil)
@@ -58,13 +59,15 @@ module Gemstar
         r.get "detail" do
           request_cache_key = detail_request_cache_key(r.params)
           request_cache = self.class.opts[:detail_request_cache]
-          if request_cache_key && request_cache.key?(request_cache_key)
+          refresh_detail = detail_refresh_requested?(r.params)
+          if request_cache_key && !refresh_detail && request_cache.key?(request_cache_key)
             next request_cache[request_cache_key]
           end
+          request_cache.delete(request_cache_key) if request_cache_key && refresh_detail
 
           load_state(r.params)
-          prioritize_selected_gem
-          detail_html = render_detail
+          prioritize_selected_gem unless r.env["gemstar.detail_cache_warm"]
+          detail_html = render_detail(force_refresh: refresh_detail, use_github_cli: detail_use_github_cli_requested?(r.params))
           request_cache[request_cache_key] = detail_html if request_cache_key
           detail_html
         end
@@ -130,6 +133,14 @@ module Gemstar
         0
       end
 
+      def detail_refresh_requested?(params)
+        %w[1 true yes].include?(params["refresh"].to_s.downcase)
+      end
+
+      def detail_use_github_cli_requested?(params)
+        %w[1 true yes].include?(params["use_gh"].to_s.downcase)
+      end
+
       def page_title
         return "Gemstar" unless @selected_project
 
@@ -479,10 +490,10 @@ module Gemstar
         HTML
       end
 
-      def render_detail
+      def render_detail(force_refresh: false, use_github_cli: false)
         return empty_detail_html unless @selected_gem
 
-        metadata = metadata_for(@selected_gem, refresh_if_missing: true)
+        metadata = metadata_for(@selected_gem, refresh_if_missing: true, force_refresh: force_refresh)
         cache_key = [
           CACHE_VERSION,
           @selected_project_index,
@@ -501,9 +512,9 @@ module Gemstar
           @selected_gem[:status]
         ]
         detail_cache = self.class.opts[:detail_html_cache]
-        return detail_cache[cache_key] if detail_cache.key?(cache_key)
+        return detail_cache[cache_key] if !force_refresh && detail_cache.key?(cache_key)
 
-        groups = grouped_change_sections(@selected_gem)
+        groups = grouped_change_sections(@selected_gem, force_refresh: force_refresh, use_github_cli: use_github_cli)
         detail_pending = detail_pending?(@selected_gem[:name], metadata, groups)
 
         detail_html = <<~HTML
@@ -837,7 +848,10 @@ module Gemstar
           <article class="revision-card revision-#{section[:kind]}#{status_class}">
             <header class="revision-card-header">
               <div class="revision-card-titlebar">
-                <h5>#{h(section[:title] || section[:version])}</h5>
+                <div class="revision-card-heading">
+                  <h5>#{h(section[:title] || section[:version])}</h5>
+                  #{render_release_date(section[:release_date])}
+                </div>
                 <div class="revision-card-actions">
                   #{title_links.join}
                 </div>
@@ -850,8 +864,14 @@ module Gemstar
         HTML
       end
 
-      def grouped_change_sections(gem_state)
-        sections = change_sections(gem_state)
+      def render_release_date(release_date)
+        return "" if release_date.to_s.empty?
+
+        %(<span class="revision-release-date" title="Estimated release date">#{h(release_date)}</span>)
+      end
+
+      def grouped_change_sections(gem_state, force_refresh: false, use_github_cli: false)
+        sections = change_sections(gem_state, force_refresh: force_refresh, use_github_cli: use_github_cli)
         latest = sections.select { |section| section[:kind] == :future }
         current = sections.select { |section| section[:kind] == :current }
         previous = sections.select { |section| section[:kind] == :previous }
@@ -868,8 +888,8 @@ module Gemstar
         }
       end
 
-      def change_sections(gem_state)
-        metadata_hash = metadata_for(gem_state) || {}
+      def change_sections(gem_state, force_refresh: false, use_github_cli: false)
+        metadata_hash = metadata_for(gem_state, refresh_if_missing: force_refresh, force_refresh: force_refresh) || {}
         current_version = effective_package_version(gem_state, metadata_hash)
         cache_key = [
           CACHE_VERSION,
@@ -884,17 +904,18 @@ module Gemstar
           gem_state[:status]
         ]
         change_sections_cache = self.class.opts[:change_sections_cache]
-        return change_sections_cache[cache_key] if change_sections_cache.key?(cache_key)
+        return change_sections_cache[cache_key] if !force_refresh && change_sections_cache.key?(cache_key)
 
         return [] if gem_state[:new_version].nil? &&
           gem_state[:old_version].nil? &&
           (current_version.nil? || current_version.to_s.empty?)
         metadata = metadata_adapter_for(gem_state)
         return change_sections_cache[cache_key] = [] unless metadata
-        sections = resolved_sections(metadata, gem_state)
+        sections = resolved_sections(metadata, gem_state, force_refresh: force_refresh, use_github_cli: use_github_cli)
         return change_sections_cache[cache_key] = [] if sections.nil? || sections.empty?
 
         previous_version = gem_state[:old_version]
+        release_dates = resolved_release_dates(metadata, sections.keys, gem_state, force_refresh: force_refresh)
 
         rendered_sections = sections.keys.filter_map do |version|
           kind = section_kind(version, previous_version, current_version, gem_state[:status])
@@ -906,6 +927,7 @@ module Gemstar
             title: content[:title],
             kind: kind,
             previous_version: previous_section_version(sections.keys, version),
+            release_date: release_date_for(release_dates, version),
             html: content[:html]
           }
         end
@@ -915,10 +937,10 @@ module Gemstar
         []
       end
 
-      def resolved_sections(metadata, gem_state)
+      def resolved_sections(metadata, gem_state, force_refresh: false, use_github_cli: false)
         changelog = Gemstar::ChangeLog.new(metadata)
-        cached_sections = changelog.sections(cache_only: true) || {}
-        return cached_sections unless selected_gem_requires_refresh?(gem_state, cached_sections)
+        cached_sections = force_refresh ? {} : changelog.sections(cache_only: true) || {}
+        return cached_sections unless force_refresh || selected_gem_requires_refresh?(gem_state, cached_sections)
 
         @metadata_cache.delete([gem_state[:package_scope], gem_state[:name]])
         metadata.meta(cache_only: false, force_refresh: true)
@@ -926,11 +948,44 @@ module Gemstar
         refreshed_sections = metadata.changelog_sections(
           versions: relevant_package_versions(gem_state, metadata),
           cache_only: false,
-          force_refresh: true
+          force_refresh: true,
+          use_github_cli: use_github_cli
         )
         cached_sections.merge(refreshed_sections || {})
       end
 
+      def resolved_release_dates(metadata, versions, gem_state, force_refresh: false)
+        changelog = Gemstar::ChangeLog.new(metadata)
+        cached_dates = force_refresh ? {} : changelog.release_dates(versions: versions, cache_only: true) || {}
+        return cached_dates unless selected_gem_missing_release_dates?(gem_state, versions, cached_dates)
+
+        fetched_dates = changelog.release_dates(versions: versions, cache_only: false, force_refresh: force_refresh) || {}
+        cached_dates.merge(fetched_dates)
+      rescue StandardError
+        {}
+      end
+
+      def release_date_for(release_dates, version)
+        release_dates.find do |candidate_version, _date|
+          normalize_release_version_key(candidate_version) == normalize_release_version_key(version)
+        end&.last
+      end
+
+      def selected_gem_missing_release_dates?(gem_state, versions, release_dates)
+        return false unless @selected_gem && gem_state[:name] == @selected_gem[:name]
+
+        requested_versions = Array(versions).map { |version| normalize_release_version_key(version) }.compact
+        dated_versions = release_dates.keys.map { |version| normalize_release_version_key(version) }.compact
+        (requested_versions - dated_versions).any?
+      end
+
+      def normalize_release_version_key(version)
+        value = version.to_s.strip
+        return nil if value.empty?
+
+        value.sub(/\Av/i, "")
+      end
+
       def relevant_package_versions(gem_state, metadata)
         metadata_hash = metadata_for(gem_state) || {}
         [
@@ -1033,26 +1088,26 @@ module Gemstar
       end
 
       def strip_leading_version_heading(text, heading_version)
-        stripped = text.sub(/\A\s*#+\s*v?#{Regexp.escape(heading_version)}\s*\n+/i, "")
-        return strip_leading_hash_separator(stripped) unless stripped == text
+        stripped = text.sub(/\A\s*#+\s*(?:Version\s+)?v?#{Regexp.escape(heading_version)}\b[^\n]*\n+/i, "")
+        return strip_leading_heading_separator(stripped) unless stripped == text
 
         lines = text.lines
         return text if lines.empty?
 
         first_line = lines.first.to_s
         heading_like =
-          first_line.match?(/\A\s*v?#{Regexp.escape(heading_version)}\b/i) ||
-          first_line.match?(/\A\s*[\[(]?v?#{Regexp.escape(heading_version)}\b/i)
+          first_line.match?(/\A\s*(?:Version\s+)?v?#{Regexp.escape(heading_version)}\b/i) ||
+          first_line.match?(/\A\s*[\[(]?(?:Version\s+)?v?#{Regexp.escape(heading_version)}\b/i)
 
         return text unless heading_like
 
         remaining = lines.drop(1)
         remaining.shift while remaining.first&.strip&.empty?
-        strip_leading_hash_separator(remaining.join)
+        strip_leading_heading_separator(remaining.join)
       end
 
-      def strip_leading_hash_separator(text)
-        text.sub(/\A\s*#{Regexp.escape("#")}{4,}\s*\n+/, "")
+      def strip_leading_heading_separator(text)
+        text.sub(/\A\s*(?:#{Regexp.escape("#")}{4,}|[-=]{3,})\s*\n+/, "")
       end
 
       def compare_versions(left, right)
@@ -1061,26 +1116,26 @@ module Gemstar
         left.to_s <=> right.to_s
       end
 
-      def metadata_for(package_state_or_name, refresh_if_missing: false)
+      def metadata_for(package_state_or_name, refresh_if_missing: false, force_refresh: false)
         package_state = package_state_or_name.is_a?(Hash) ? package_state_or_name : { name: package_state_or_name, package_scope: "gems" }
         gem_name = package_state[:name]
         cache_key = [package_state[:package_scope], gem_name]
         cached = @metadata_cache[cache_key]
-        return nil if cached.equal?(MISSING_METADATA)
-        return cached if cached
+        return nil if !force_refresh && cached.equal?(MISSING_METADATA)
+        return cached if !force_refresh && cached
 
         if package_state[:package_scope] != "gems"
           metadata = local_package_metadata(package_state)
           adapter = metadata_adapter_for(package_state)
-          remote_metadata = adapter&.meta(cache_only: true)
+          remote_metadata = force_refresh ? nil : adapter&.meta(cache_only: true)
           remote_metadata = adapter&.meta(cache_only: false, force_refresh: true) if remote_metadata.nil? && refresh_if_missing
           metadata = metadata.compact.merge(remote_metadata || {})
           @metadata_cache[cache_key] = metadata || MISSING_METADATA
           return metadata
         end
 
-        metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
-        if metadata.nil? && refresh_if_missing
+        metadata = force_refresh ? nil : Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
+        if metadata.nil? && (refresh_if_missing || force_refresh)
           metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: false, force_refresh: true)
         end
 
@@ -1261,16 +1316,27 @@ module Gemstar
         else
           %(<a href="#{h(fallback_url)}" target="_blank" rel="noreferrer">#{h(fallback_label)}</a>)
         end
+        github_cli_action = render_github_cli_release_button(version, repo_url)
 
         {
           version: version,
           title: version,
           kind: :current,
           previous_version: fallback_previous_version_for(gem_state, previous_sections),
-          html: "<p>No release information available. Check #{fallback_link} for more information.</p>"
+          html: "<p>No release information available. Check #{fallback_link} for more information.</p>#{github_cli_action}"
         }
       end
 
+      def render_github_cli_release_button(version, repo_url)
+        return "" unless repo_url.to_s.include?("github.com")
+
+        <<~HTML
+          <div class="detail-inline-actions">
+            <button type="button" class="action" data-detail-use-gh data-release-version="#{h(version)}">Use GitHub CLI</button>
+          </div>
+        HTML
+      end
+
       def fallback_previous_version_for(gem_state, previous_sections)
         return gem_state[:old_version] if gem_state[:new_version]
         return previous_sections.first[:version] if previous_sections.any?

data/lib/gemstar/web/templates/app.css

@@ -455,6 +455,12 @@
         background: #fff;
         padding: 0.5rem;
       }
+      .detail-inline-actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.35rem;
+        margin-top: 0.55rem;
+      }
       .detail-loading-shell {
         min-height: 14rem;
         display: grid;
@@ -566,6 +572,13 @@
         flex: 0 0 auto;
         margin-left: auto;
       }
+      .revision-card-heading {
+        display: inline-flex;
+        align-items: baseline;
+        flex-wrap: wrap;
+        gap: 0.45rem;
+        min-width: 0;
+      }
       .revision-card h5 {
         margin: 0;
         font-size: 1.55rem;
@@ -573,6 +586,12 @@
         color: var(--ink);
         min-width: 0;
       }
+      .revision-release-date {
+        color: var(--grey);
+        font-size: 0.86rem;
+        font-weight: 600;
+        white-space: nowrap;
+      }
       .revision-markup {
         padding: 0.7rem;
       }

data/lib/gemstar/web/templates/app.js.erb

@@ -19,6 +19,12 @@
   const emptyDetailHtml = <%= empty_detail_html_json %>;
   const packageCollectionLabel = <%= (@selected_project&.package_collection_label || "Packages").downcase.dump %>;
   const detailDisclosureStorageKey = "gemstar.detailDisclosureOpen";
+  const pageWasReloaded = (() => {
+    const navigationEntry = performance.getEntriesByType && performance.getEntriesByType("navigation")[0];
+    if (navigationEntry) return navigationEntry.type === "reload";
+    return performance.navigation && performance.navigation.type === 1;
+  })();
+  let pendingManualDetailRefresh = pageWasReloaded;
 
   const visibleGemLinks = () => gemLinks.filter((link) => !link.hidden);
   const currentSelectedIndex = () => visibleGemLinks().findIndex((link) => link.classList.contains("is-selected"));
@@ -170,7 +176,15 @@
     </section>
   `;
 
-  const fetchDetail = (url, historyMode = "push") => {
+  const fetchDetail = (url, historyMode = "push", options = {}) => {
+    const requestUrl = new URL(url, window.location.origin);
+    if (options.refresh) {
+      requestUrl.searchParams.set("refresh", "1");
+    }
+    if (options.useGh) {
+      requestUrl.searchParams.set("use_gh", "1");
+      requestUrl.searchParams.set("refresh", "1");
+    }
     const normalizedUrl = new URL(url, window.location.origin).toString();
     const requestToken = ++detailRequestToken;
     activeDetailUrl = normalizedUrl;
@@ -180,7 +194,7 @@
       replaceDetail(loadingDetailHtml(normalizedUrl));
     }, 1000);
 
-    fetch(url, { headers: { "X-Requested-With": "gemstar-detail" } })
+    fetch(requestUrl.toString(), { headers: { "X-Requested-With": "gemstar-detail" } })
       .then((response) => response.text())
       .then((html) => {
         stopDetailLoading();
@@ -232,7 +246,8 @@
         window.history.replaceState({}, "", pageUrl);
       }
       if (detailNeedsInitialFetch()) {
-        fetchDetail(detailLink.dataset.detailUrl || detailLink.href, requested ? "none" : "replace");
+        fetchDetail(detailLink.dataset.detailUrl || detailLink.href, requested ? "none" : "replace", { refresh: pendingManualDetailRefresh });
+        pendingManualDetailRefresh = false;
       }
       return;
     }
@@ -241,7 +256,11 @@
 
     const firstVisibleLink = visibleGemLinks()[0];
     if (firstVisibleLink) {
-      activateGemLink(firstVisibleLink, "replace", true);
+      const refresh = pendingManualDetailRefresh;
+      pendingManualDetailRefresh = false;
+      syncSidebarSelection(firstVisibleLink.dataset.gemName, true);
+      fetchDetail(firstVisibleLink.dataset.detailUrl || firstVisibleLink.href, "replace", { refresh });
+      focusSidebar();
     }
   };
 
@@ -309,6 +328,16 @@
     });
   }
 
+  document.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-detail-use-gh]");
+    if (!button || !detailPanel || !detailPanel.dataset.detailUrl) return;
+
+    event.preventDefault();
+    button.disabled = true;
+    button.textContent = "Checking...";
+    fetchDetail(detailPanel.dataset.detailUrl, "none", { refresh: true, useGh: true });
+  });
+
   const navigate = (params) => {
     const url = new URL(window.location.href);
     Object.entries(params).forEach(([key, value]) => {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstar
 version: !ruby/object:Gem::Version
-  version: '1.1'
+  version: '1.2'
 platform: ruby
 authors:
 - Florian Dejako