gemstar 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c795357616121ccda76004c6fefa92194688472dd45950396c24a1924cf70a6
-  data.tar.gz: d4922547dc024c923d751164698da5b672c48fd4b2e61384345e0de24b1f5430
+  metadata.gz: b290f73ca813d6ef39789e23d883f3bd382fbdcc17f0803cd5fdc296d7f60582
+  data.tar.gz: '058a2d17b98461a62d463ba673d170b621471e8f9693ea294da403382da5a759'
 SHA512:
-  metadata.gz: 6caf7c992dcccd533da3cbcf8ed1e98ee44538faffbdf43c55e1ecc1af899497c70100c62e1ba5bbe9331fba6c78d2a65a571c860f4035b99dc63f44d94cb682
-  data.tar.gz: 88e7f1557e01332a6d5dbd69301b0fcfb30548a80333d835476994a9b9ae92a5fdb8559bfa268d242ad11eaad266b432947277d52b185e40dcc66f166ee01854
+  metadata.gz: fe408b9d9259ab0771e41522238b35c259e624759ac27ffe013d689c76ebe0164905c5ee67bb7868e8cc43ff361568f854f8dccf2e513468176685a395bb9786
+  data.tar.gz: 149884982e1e2d124f7ade0bf565604106a455db2bab04f6b3811b316fb0386f72ed3fdaa0969369c310e3811e7735d97d29c147f9263f32f62c6c2fcb0d7487

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change Log
 
-## Unreleased
+## 1.0.2
+
+- General server performance improvements.
+- Server: Required by / Requires / date added information now hidden in a "Details" section by default.
+- Server: Improve color hilighting in gems list.
+- Server: Improve up/down/left/right arrow key navigation.
+- Fix problem not fetching new changelogs due to extraneous caching.
+- Fix `nil.include?` error fetching changelogs for gems without either `homepage_uri` or `source_code_uri`.
+- Add gem-release as a development dependency. 
 
 ## 1.0.1
 

data/lib/gemstar/cache.rb

@@ -4,7 +4,7 @@ require "digest"
 
 module Gemstar
   class Cache
-    MAX_CACHE_AGE = 60 * 60 * 24 * 7 # 1 week
+    MAX_CACHE_AGE = 60 * 60 * 24 # 1 day
     CACHE_DIR = File.join(Gemstar::Config.home_directory, "cache")
 
     @@initialized = false
@@ -16,12 +16,12 @@ module Gemstar
       @@initialized = true
     end
 
-    def self.fetch(key, &block)
+    def self.fetch(key, force: false, &block)
       init
 
       path = path_for(key)
 
-      if fresh?(path)
+      if !force && fresh?(path)
         content = File.read(path)
         return nil if content == "__404__"
         return content

data/lib/gemstar/cache_warmer.rb

@@ -59,6 +59,12 @@ module Gemstar
       @condition.broadcast
     end
 
+    def pending?(gem_name)
+      @mutex.synchronize do
+        @queued.include?(gem_name) || @in_progress.include?(gem_name)
+      end
+    end
+
     private
 
     def start_workers_unlocked

data/lib/gemstar/change_log.rb

@@ -10,21 +10,21 @@ module Gemstar
 
     attr_reader :metadata
 
-    def content(cache_only: false)
+    def content(cache_only: false, force_refresh: false)
       return @content if !cache_only && defined?(@content)
 
-      result = fetch_changelog_content(cache_only: cache_only)
+      result = fetch_changelog_content(cache_only: cache_only, force_refresh: force_refresh)
       @content = result unless cache_only
       result
     end
 
-    def sections(cache_only: false)
+    def sections(cache_only: false, force_refresh: false)
       return @sections if !cache_only && defined?(@sections)
 
       result = begin
-        s = parse_changelog_sections(cache_only: cache_only)
+        s = parse_changelog_sections(cache_only: cache_only, force_refresh: force_refresh)
         if s.nil? || s.empty?
-          s = parse_github_release_sections(cache_only: cache_only)
+          s = parse_github_release_sections(cache_only: cache_only, force_refresh: force_refresh)
         end
 
         pp @@candidates_found if Gemstar.debug? && !cache_only
@@ -74,10 +74,10 @@ module Gemstar
       nil
     end
 
-    def changelog_uri_candidates(cache_only: false)
+    def changelog_uri_candidates(cache_only: false, force_refresh: false)
       candidates = []
 
-      repo_uri = @metadata.repo_uri(cache_only: cache_only)
+      repo_uri = @metadata.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       return [] if repo_uri.nil? || repo_uri.empty?
 
       if repo_uri =~ %r{https://github\.com/aws/aws-sdk-ruby}
@@ -100,14 +100,14 @@ module Gemstar
 
       remote_repository = RemoteRepository.new(base)
 
-      branches = aws_style ? [""] : remote_repository.find_main_branch
+      branches = aws_style ? [""] : remote_repository.find_main_branch(cache_only: cache_only, force_refresh: force_refresh)
 
       candidates += paths.product(branches).map do |file, branch|
         uri = aws_style ? "#{base}/#{file}" : "#{base}/#{branch}/#{file}"
       end
 
       # Add the gem's changelog_uri last as it's usually not the most parsable:
-      meta = @metadata.meta(cache_only: cache_only)
+      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!
@@ -117,14 +117,14 @@ module Gemstar
       candidates
     end
 
-    def fetch_changelog_content(cache_only: false)
+    def fetch_changelog_content(cache_only: false, force_refresh: false)
       content = nil
 
-      changelog_uri_candidates(cache_only: cache_only).find do |candidate|
+      changelog_uri_candidates(cache_only: cache_only, force_refresh: force_refresh).find do |candidate|
         content = if cache_only
           Cache.peek("changelog-#{candidate}")
         else
-          Cache.fetch("changelog-#{candidate}") do
+          Cache.fetch("changelog-#{candidate}", force: force_refresh) do
             URI.open(candidate, read_timeout: 8)&.read
           rescue => e
             puts "#{candidate}: #{e}" if Gemstar.debug?
@@ -152,11 +152,11 @@ module Gemstar
       /^\s*(?:[-*]\s+)?(?:Version\s+)?v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])(?:\s*[-(].*)?/i
     ]
 
-    def parse_changelog_sections(cache_only: false)
+    def parse_changelog_sections(cache_only: false, force_refresh: 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(cache_only: cache_only)
+      c = content(cache_only: cache_only, force_refresh: force_refresh)
       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/"))
@@ -212,14 +212,14 @@ module Gemstar
       sections
     end
 
-    def parse_github_release_sections(cache_only: false)
+    def parse_github_release_sections(cache_only: false, force_refresh: false)
       begin
         require "nokogiri"
       rescue LoadError
         return {}
       end
 
-      repo_uri = @metadata&.repo_uri(cache_only: cache_only)
+      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)
@@ -228,9 +228,9 @@ module Gemstar
       html = if cache_only
         Cache.peek("releases-#{url}")
       else
-        Cache.fetch("releases-#{url}") do
-          begin
-            URI.open(url, read_timeout: 8)&.read
+          Cache.fetch("releases-#{url}", force: force_refresh) do
+            begin
+              URI.open(url, read_timeout: 8)&.read
           rescue => e
             puts "#{url}: #{e}" if Gemstar.debug?
             nil

data/lib/gemstar/commands/server.rb

@@ -8,6 +8,7 @@ module Gemstar
       DEFAULT_PORT = 2112
       RELOAD_ENV_VAR = "GEMSTAR_RELOAD_ACTIVE"
       RELOAD_GLOB = "{lib/**/*.rb,lib/gemstar/web/templates/**/*,bin/gemstar,README.md}"
+      RELOAD_DIRS = %w[lib bin].freeze
 
       attr_reader :bind
       attr_reader :port
@@ -71,7 +72,7 @@ module Gemstar
         end
 
         puts "Starting gemstar server in reload mode..."
-        puts "Watching changes matching #{RELOAD_GLOB.inspect}"
+        puts "Watching directories #{RELOAD_DIRS.join(", ")} with glob #{RELOAD_GLOB.inspect}"
 
         env = ENV.to_h.merge(RELOAD_ENV_VAR => "1")
         exec env, *rerun_command(rerun_executable)
@@ -86,12 +87,35 @@ module Gemstar
       def rerun_command(rerun_executable)
         [
           rerun_executable,
+          "--dir",
+          RELOAD_DIRS.join(","),
           "--pattern",
           RELOAD_GLOB,
+          "--signal",
+          "INT,KILL",
+          "--wait",
+          "1",
+          "--name",
+          "Gemstar",
+          "--background",
           "--",
-          Gem.ruby,
-          File.expand_path($PROGRAM_NAME)
-        ] + server_arguments_without_reload
+          *server_runner_command,
+          *server_arguments_without_reload
+        ]
+      end
+
+      def server_runner_command
+        return %w[bundle exec gemstar] if ENV["BUNDLE_GEMFILE"]
+
+        repo_executable = File.expand_path("../../../bin/gemstar", __dir__)
+        return [repo_executable] if File.exist?(repo_executable)
+
+        gem_executable = Gem.bin_path("gemstar", "gemstar")
+        return [gem_executable] if gem_executable
+
+        ["gemstar"]
+      rescue Gem::Exception
+        ["gemstar"]
       end
 
       def server_arguments_without_reload

data/lib/gemstar/project.rb

@@ -26,6 +26,10 @@ module Gemstar
       @directory = File.dirname(@gemfile_path)
       @lockfile_path = File.join(@directory, "Gemfile.lock")
       @name = File.basename(@directory)
+      @lockfile_cache = {}
+      @gem_states_cache = {}
+      @gem_added_on_cache = {}
+      @history_cache = {}
     end
 
     def git_repo
@@ -84,7 +88,9 @@ module Gemstar
     end
 
     def lockfile_for_revision(revision_id)
-      return current_lockfile if revision_id.nil? || revision_id == "worktree"
+      cache_key = revision_id || "worktree"
+      return @lockfile_cache[cache_key] if @lockfile_cache.key?(cache_key)
+      return @lockfile_cache[cache_key] = current_lockfile if revision_id.nil? || revision_id == "worktree"
       return nil unless lockfile?
 
       relative_lockfile_path = git_repo.relative_path(lockfile_path)
@@ -93,16 +99,19 @@ module Gemstar
       content = git_repo.try_git_command(["show", "#{revision_id}:#{relative_lockfile_path}"])
       return nil if content.nil? || content.empty?
 
-      Gemstar::LockFile.new(content: content)
+      @lockfile_cache[cache_key] = Gemstar::LockFile.new(content: content)
     end
 
     def gem_states(from_revision_id: default_from_revision_id, to_revision_id: "worktree")
+      cache_key = [from_revision_id, to_revision_id]
+      return @gem_states_cache[cache_key] if @gem_states_cache.key?(cache_key)
+
       from_lockfile = lockfile_for_revision(from_revision_id)
       to_lockfile = lockfile_for_revision(to_revision_id)
       from_specs = from_lockfile&.specs || {}
       to_specs = to_lockfile&.specs || {}
 
-      (from_specs.keys | to_specs.keys).map do |gem_name|
+      @gem_states_cache[cache_key] = (from_specs.keys | to_specs.keys).map do |gem_name|
         old_version = from_specs[gem_name]
         new_version = to_specs[gem_name]
         bundle_origins = to_lockfile&.origins_for(gem_name) || []
@@ -120,23 +129,25 @@ module Gemstar
     end
 
     def gem_added_on(gem_name, revision_id: "worktree")
+      cache_key = [gem_name, revision_id]
+      return @gem_added_on_cache[cache_key] if @gem_added_on_cache.key?(cache_key)
       return nil unless lockfile?
 
       target_lockfile = lockfile_for_revision(revision_id)
-      return nil unless target_lockfile&.specs&.key?(gem_name)
+      return @gem_added_on_cache[cache_key] = nil unless target_lockfile&.specs&.key?(gem_name)
 
       relative_path = git_repo.relative_path(lockfile_path)
-      return nil if relative_path.nil?
+      return @gem_added_on_cache[cache_key] = nil if relative_path.nil?
 
       first_seen_revision = history_for_paths([relative_path], limit: nil, reverse: true).find do |revision|
         lockfile = lockfile_for_revision(revision[:id])
         lockfile&.specs&.key?(gem_name)
       end
 
-      return worktree_added_on_info if first_seen_revision.nil? && revision_id == "worktree"
-      return nil unless first_seen_revision
+      return @gem_added_on_cache[cache_key] = worktree_added_on_info if first_seen_revision.nil? && revision_id == "worktree"
+      return @gem_added_on_cache[cache_key] = nil unless first_seen_revision
 
-      {
+      @gem_added_on_cache[cache_key] = {
         project_name: name,
         date: first_seen_revision[:authored_at].strftime("%Y-%m-%d"),
         revision: first_seen_revision[:short_sha],
@@ -162,10 +173,13 @@ module Gemstar
       return [] if git_root.nil? || git_root.empty?
       return [] if paths.empty?
 
+      cache_key = [paths.sort, limit, reverse]
+      return @history_cache[cache_key] if @history_cache.key?(cache_key)
+
       output = git_repo.log_for_paths(paths, limit: limit, reverse: reverse)
       return [] if output.nil? || output.empty?
 
-      output.lines.filter_map do |line|
+      @history_cache[cache_key] = output.lines.filter_map do |line|
         full_sha, short_sha, authored_at, subject = line.strip.split("\u001f", 4)
         next if full_sha.nil?
 

data/lib/gemstar/remote_repository.rb

@@ -6,11 +6,20 @@ module Gemstar
       @repository_uri = repository_uri
     end
 
-    def find_main_branch
+    def find_main_branch(cache_only: false, force_refresh: false)
       # Attempt loading .gitignore (assumed to be present in all repos) from either
       # main or master branch:
       %w[main master].each do |branch|
-        Cache.fetch("gitignore-#{branch}") do
+        cache_key = "gitignore-#{@repository_uri}-#{branch}"
+
+        if cache_only
+          content = Cache.peek(cache_key)
+          return [branch] unless content.nil?
+
+          next
+        end
+
+        Cache.fetch(cache_key, force: force_refresh) do
           content = begin
                       URI.open("#{@repository_uri}/#{branch}/.gitignore", read_timeout: 8)&.read
                     rescue

data/lib/gemstar/ruby_gems_metadata.rb

@@ -10,14 +10,14 @@ module Gemstar
 
     attr_reader :gem_name
 
-    def meta(cache_only: false)
+    def meta(cache_only: false, force_refresh: false)
       return @meta if !cache_only && defined?(@meta)
 
       json = if cache_only
         Cache.peek("rubygems-#{gem_name}")
       else
         url = "https://rubygems.org/api/v1/gems/#{URI.encode_www_form_component(gem_name)}.json"
-        Cache.fetch("rubygems-#{gem_name}") do
+        Cache.fetch("rubygems-#{gem_name}", force: force_refresh) do
           URI.open(url).read
         end
       end
@@ -32,8 +32,8 @@ module Gemstar
       parsed
     end
 
-    def repo_uri(cache_only: false)
-      resolved_meta = meta(cache_only: cache_only)
+    def repo_uri(cache_only: false, force_refresh: false)
+      resolved_meta = meta(cache_only: cache_only, force_refresh: force_refresh)
       return nil unless resolved_meta
 
       return @repo_uri if !cache_only && defined?(@repo_uri)
@@ -43,7 +43,7 @@ module Gemstar
 
                if uri.nil?
                  uri = resolved_meta["homepage_uri"]
-                 if uri.include?("github.com")
+                 if uri&.include?("github.com")
                    uri = uri[%r{http[s?]://github\.com/[^/]+/[^/]+}]
                  end
                end

data/lib/gemstar/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Gemstar # :nodoc:
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 
   def self.debug?
     return @debug if defined?(@debug)

data/lib/gemstar/web/app.rb

@@ -12,12 +12,18 @@ end
 module Gemstar
   module Web
     class App < Roda
+      MISSING_METADATA = Object.new
+
       class << self
         def build(projects:, config_home:, cache_warmer: nil)
           Class.new(self) do
             opts[:projects] = projects
             opts[:config_home] = config_home
             opts[:cache_warmer] = cache_warmer
+            opts[:change_sections_cache] = {}
+            opts[:detail_html_cache] = {}
+            opts[:detail_request_cache] = {}
+            opts[:metadata_cache] = {}
           end.freeze.app
         end
       end
@@ -26,7 +32,7 @@ module Gemstar
         @projects = self.class.opts.fetch(:projects)
         @config_home = self.class.opts.fetch(:config_home)
         @cache_warmer = self.class.opts[:cache_warmer]
-        @metadata_cache = {}
+        @metadata_cache = self.class.opts[:metadata_cache]
         apply_no_cache_headers!
 
         r.root do
@@ -39,9 +45,17 @@ module Gemstar
         end
 
         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)
+            next request_cache[request_cache_key]
+          end
+
           load_state(r.params)
           prioritize_selected_gem
-          render_detail
+          detail_html = render_detail
+          request_cache[request_cache_key] = detail_html if request_cache_key
+          detail_html
         end
 
         r.get "gemfile" do
@@ -67,6 +81,28 @@ module Gemstar
         response["Expires"] = "0"
       end
 
+      def detail_request_cache_key(params)
+        project_index = selected_project_index(params["project"])
+        project = @projects[project_index]
+        return nil unless project
+
+        lockfile_stamp =
+          if File.file?(project.lockfile_path)
+            File.mtime(project.lockfile_path).to_i
+          else
+            0
+          end
+
+        [
+          project_index,
+          params["from"],
+          params["to"],
+          params["filter"],
+          params["gem"],
+          lockfile_stamp
+        ]
+      end
+
       def page_title
         return "Gemstar" unless @selected_project
 
@@ -385,21 +421,38 @@ module Gemstar
       def render_detail
         return empty_detail_html unless @selected_gem
 
-        metadata = metadata_for(@selected_gem[:name])
-        detail_pending = detail_pending?(@selected_gem[:name], metadata)
+        cache_key = [
+          @selected_project_index,
+          @selected_from_revision_id,
+          @selected_to_revision_id,
+          @selected_filter,
+          @selected_gem[:name],
+          @selected_gem[:old_version],
+          @selected_gem[:new_version],
+          @selected_gem[:status]
+        ]
+        detail_cache = self.class.opts[:detail_html_cache]
+        return detail_cache[cache_key] if detail_cache.key?(cache_key)
+
+        metadata = metadata_for(@selected_gem[:name], refresh_if_missing: true)
+        groups = grouped_change_sections(@selected_gem)
+        detail_pending = detail_pending?(@selected_gem[:name], metadata, groups)
 
-        <<~HTML
-          <section class="detail" data-detail-panel data-detail-pending="#{detail_pending}" data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, gem: @selected_gem[:name]))}">
+        detail_html = <<~HTML
+          <section class="detail" data-detail-panel tabindex="0" data-detail-pending="#{detail_pending}" data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, gem: @selected_gem[:name]))}">
             #{render_detail_hero(metadata)}
             #{render_detail_loading_notice if detail_pending}
-            #{render_detail_revision_panel}
+            #{render_detail_revision_panel(groups)}
           </section>
         HTML
+
+        detail_cache[cache_key] = detail_html unless detail_pending
+        detail_html
       end
 
       def empty_detail_html
         <<~HTML
-          <section class="detail" data-detail-panel>
+          <section class="detail" data-detail-panel tabindex="0">
             <div class="empty-panel">
               <h2>No gem selected</h2>
               <p>Choose a gem from the list to inspect its current version and changelog revisions.</p>
@@ -426,13 +479,13 @@ module Gemstar
           <section class="detail-hero">
             <div class="detail-hero-copy">
               <div class="detail-title-row">
-                <h2>#{title_markup}#{bundled_version ? %(<span class="detail-title-version"> #{h(bundled_version)}</span>) : ""}</h2>
+                <div class="detail-title-lockup">
+                  <h2>#{title_markup}#{bundled_version ? %(<span class="detail-title-version"> #{h(bundled_version)}</span>) : ""}</h2>
+                </div>
                 #{render_detail_links(metadata)}
               </div>
               <p class="detail-subtitle">#{description ? h(description) : "Metadata will appear here when RubyGems information is available."}</p>
-              #{render_added_on(added_on)}
-              #{render_dependency_origins(bundle_origins)}
-              #{render_requirements(requirement_names)}
+              #{render_dependency_details(bundle_origins, requirement_names, added_on)}
             </div>
           </section>
         HTML
@@ -449,12 +502,12 @@ module Gemstar
 
         <<~HTML
           <div class="detail-origin">
-            <p>Added to #{h(added_on[:project_name])} on #{h(added_on[:date])} (#{revision_markup}).</p>
+            <p>Added to project <strong>#{h(added_on[:project_name])}</strong> on #{h(added_on[:date])} (#{revision_markup}).</p>
           </div>
         HTML
       end
 
-      def render_dependency_origins(bundle_origins)
+      def dependency_origin_items(bundle_origins)
         origins = Array(bundle_origins).filter_map do |origin|
           path = Array(origin[:path]).compact
           display_path = path.dup
@@ -465,17 +518,6 @@ module Gemstar
           linked_path = linked_gem_chain(["Gemfile", *display_path])
           origin[:type] == :direct ? gemfile_link("Gemfile") : linked_path
         end.uniq
-        return "" if origins.empty?
-
-        items = origins.map { |origin| "<li>#{origin}</li>" }.join
-        <<~HTML
-          <div class="detail-origin">
-            <strong>Required by</strong>
-            <ul class="detail-origin-list">
-              #{items}
-            </ul>
-          </div>
-        HTML
       end
 
       def render_detail_links(metadata)
@@ -495,18 +537,35 @@ module Gemstar
         HTML
       end
 
-      def render_requirements(requirement_names)
-        names = Array(requirement_names).compact.uniq
-        return "" if names.empty?
+      def render_dependency_details(bundle_origins, requirement_names, added_on)
+        required_by = dependency_origin_items(bundle_origins)
+        requires = Array(requirement_names).compact.uniq.map { |name| internal_gem_link(name) }
+        added_markup = render_added_on(added_on)
+        return "" if required_by.empty? && requires.empty? && added_markup.empty?
 
-        items = names.map { |name| "<li>#{internal_gem_link(name)}</li>" }.join
         <<~HTML
-          <div class="detail-origin">
-            <strong>Requires</strong>
+          <details class="detail-disclosure">
+            <summary><span class="detail-disclosure-caret" aria-hidden="true"></span><h3>Details</h3></summary>
+            <div class="detail-disclosure-panel">
+              #{added_markup}
+              #{render_dependency_popover_section("Required by", required_by)}
+              #{render_dependency_popover_section("Requires", requires)}
+            </div>
+          </details>
+        HTML
+      end
+
+      def render_dependency_popover_section(title, items)
+        return "" if items.empty?
+
+        list_items = items.map { |item| "<li>#{item}</li>" }.join
+        <<~HTML
+          <section class="detail-info-section">
+            <strong>#{h(title)}</strong>
             <ul class="detail-origin-list">
-              #{items}
+              #{list_items}
             </ul>
-          </div>
+          </section>
         HTML
       end
 
@@ -554,14 +613,12 @@ module Gemstar
         %(<a href="#{h(href)}" data-gem-link-inline="true">#{h(name)}</a>)
       end
 
-      def render_detail_revision_panel
-        groups = grouped_change_sections(@selected_gem)
-
+      def render_detail_revision_panel(groups)
         <<~HTML
           <section class="revision-panel">
             #{render_revision_group("Latest", groups[:latest], empty_message: nil) if groups[:latest].any?}
             #{render_revision_group(current_section_title, groups[:current], empty_message: "No changelog entries in this revision range.")}
-            #{render_revision_group("Previous changes", groups[:previous], empty_message: nil) if groups[:previous].any?}
+            #{render_revision_group("Earlier changes", groups[:previous], empty_message: nil) if groups[:previous].any?}
           </section>
         HTML
       end
@@ -637,11 +694,15 @@ module Gemstar
       end
 
       def change_sections(gem_state)
+        cache_key = [gem_state[:name], gem_state[:old_version], gem_state[:new_version], 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 [] if gem_state[:new_version].nil? && gem_state[:old_version].nil?
 
         metadata = Gemstar::RubyGemsMetadata.new(gem_state[:name])
-        sections = Gemstar::ChangeLog.new(metadata).sections(cache_only: true)
-        return [] if sections.nil? || sections.empty?
+        sections = resolved_sections(metadata, gem_state)
+        return change_sections_cache[cache_key] = [] if sections.nil? || sections.empty?
 
         current_version = gem_state[:new_version] || gem_state[:old_version]
         previous_version = gem_state[:old_version]
@@ -660,11 +721,45 @@ module Gemstar
           }
         end
 
-        rendered_sections.sort_by { |section| section_sort_key(section) }
+        change_sections_cache[cache_key] = rendered_sections.sort_by { |section| section_sort_key(section) }
       rescue StandardError
         []
       end
 
+      def resolved_sections(metadata, gem_state)
+        changelog = Gemstar::ChangeLog.new(metadata)
+        cached_sections = changelog.sections(cache_only: true) || {}
+        return cached_sections unless selected_gem_requires_refresh?(gem_state, cached_sections)
+
+        @metadata_cache.delete(gem_state[:name])
+        metadata.meta(cache_only: false, force_refresh: true)
+        metadata.repo_uri(cache_only: false, force_refresh: true)
+        Gemstar::ChangeLog.new(metadata).sections(cache_only: false, force_refresh: true) || cached_sections
+      end
+
+      def selected_gem_requires_refresh?(gem_state, cached_sections)
+        return false unless @selected_gem && gem_state[:name] == @selected_gem[:name]
+
+        bundled_version = gem_state[:new_version] || gem_state[:old_version]
+        return false if bundled_version.nil?
+        metadata = metadata_for(gem_state[:name]) || {}
+        has_upstream_release_source =
+          !metadata["changelog_uri"].to_s.empty? ||
+          !metadata["source_code_uri"].to_s.empty? ||
+          !metadata["homepage_uri"].to_s.empty?
+        return false unless has_upstream_release_source
+        return true if cached_sections.nil? || cached_sections.empty?
+
+        cached_versions = cached_sections.keys
+        return true unless cached_versions.include?(bundled_version)
+
+        compare_versions(bundled_version, newest_version(cached_versions)) == 1
+      end
+
+      def newest_version(versions)
+        Array(versions).max { |left, right| compare_versions(left, right) }
+      end
+
       def section_kind(version, previous_version, current_version, status)
         return :future if compare_versions(version, current_version) == 1
         return :current if status == :added && compare_versions(version, current_version) <= 0
@@ -736,14 +831,25 @@ module Gemstar
         left.to_s <=> right.to_s
       end
 
-      def metadata_for(gem_name)
-        @metadata_cache[gem_name] ||= Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
+      def metadata_for(gem_name, refresh_if_missing: false)
+        cached = @metadata_cache[gem_name]
+        return nil if cached.equal?(MISSING_METADATA)
+        return cached if cached
+
+        metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
+        if metadata.nil? && refresh_if_missing
+          metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: false, force_refresh: true)
+        end
+
+        @metadata_cache[gem_name] = metadata || MISSING_METADATA
+        metadata
       rescue StandardError
+        @metadata_cache[gem_name] = MISSING_METADATA
         nil
       end
 
-      def detail_pending?(gem_name, metadata)
-        metadata.nil? && change_sections({ name: gem_name, old_version: @selected_gem[:old_version], new_version: @selected_gem[:new_version], status: @selected_gem[:status] }).empty?
+      def detail_pending?(gem_name, metadata, groups)
+        false
       end
 
       def icon_button(label, url, icon_type:)
@@ -762,6 +868,8 @@ module Gemstar
           '<svg viewBox="0 0 16 16" aria-hidden="true"><path fill="currentColor" d="M8 .8 1.2 6.3v8.9h4.3V10h5v5.2h4.3V6.3L8 .8Zm5.2 13.3h-1.8V8.9H4.6v5.2H2.8V6.8L8 2.6l5.2 4.2v7.3Z"/></svg>'
         when :rubygems
           '<svg viewBox="0 0 16 16" aria-hidden="true"><rect width="16" height="16" rx="2.6" fill="#fff"/><path fill="#111" d="m8 2.35 4.55 2.63v5.24L8 12.85l-4.55-2.63V4.98L8 2.35Zm0 1.3L4.58 5.62v3.96L8 11.55l3.42-1.97V5.62L8 3.65Zm0 1.07 2.5 1.44v2.88L8 10.48 5.5 9.04V6.16L8 4.72Z"/></svg>'
+        when :info
+          '<svg viewBox="0 0 16 16" aria-hidden="true"><circle cx="8" cy="8" r="6.5" fill="none" stroke="currentColor" stroke-width="1.4"/><circle cx="8" cy="4.5" r="0.9" fill="currentColor"/><path d="M8 7v4" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/></svg>'
         else
           '<svg viewBox="0 0 16 16" aria-hidden="true"><rect width="16" height="16" rx="2.6" fill="#fff"/><path fill="#111" d="m8 2.35 4.55 2.63v5.24L8 12.85l-4.55-2.63V4.98L8 2.35Zm0 1.3L4.58 5.62v3.96L8 11.55l3.42-1.97V5.62L8 3.65Zm0 1.07 2.5 1.44v2.88L8 10.48 5.5 9.04V6.16L8 4.72Z"/></svg>'
         end
@@ -812,11 +920,25 @@ module Gemstar
         return nil if previous_sections.any? { |section| section[:version] == version }
         return nil if latest_sections.any? { |section| section[:version] == version }
 
+        metadata = metadata_for(gem_state[:name]) || {}
         repo_url = Gemstar::RubyGemsMetadata.new(gem_state[:name]).repo_uri(cache_only: true)
-        repo_link = if repo_url.to_s.empty?
+        fallback_url =
+          if !repo_url.to_s.empty?
+            repo_url
+          elsif metadata["project_uri"]
+            metadata["project_uri"]
+          else
+            metadata["documentation_uri"]
+          end
+        fallback_label = if repo_url.to_s.empty?
+          metadata["project_uri"] ? "the RubyGems page" : "the gem documentation"
+        else
           "the gem repository"
+        end
+        fallback_link = if fallback_url.to_s.empty?
+          fallback_label
         else
-          %(<a href="#{h(repo_url)}" target="_blank" rel="noreferrer">the gem repository</a>)
+          %(<a href="#{h(fallback_url)}" target="_blank" rel="noreferrer">#{h(fallback_label)}</a>)
         end
 
         {
@@ -824,7 +946,7 @@ module Gemstar
           title: version,
           kind: :current,
           previous_version: fallback_previous_version_for(gem_state, previous_sections),
-          html: "<p>No release information available. Check #{repo_link} for more information.</p>"
+          html: "<p>No release information available. Check #{fallback_link} for more information.</p>"
         }
       end
 

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

@@ -280,10 +280,12 @@
       .gem-row[hidden] {
         display: none;
       }
-      .gem-row:hover,
-      .gem-row.is-selected {
+      .gem-row:hover {
         background: #faf8f3;
       }
+      .gem-row.is-selected {
+        background: #f2ece0;
+      }
       .gem-name {
         font-weight: 700;
         font-size: 0.9rem;
@@ -343,6 +345,10 @@
         min-width: 0;
         width: 100%;
       }
+      .detail-title-lockup {
+        min-width: 0;
+        flex: 1 1 auto;
+      }
       .detail-hero-copy h2 {
         margin: 0;
         font-size: 2.35rem;
@@ -360,6 +366,50 @@
         align-self: start;
         flex: 0 0 auto;
       }
+      .detail-disclosure {
+        margin-top: 0.2rem;
+        border: 1px solid #ece8df;
+        border-radius: 0.3rem;
+        background: #fff;
+        padding: 0.45rem 0.55rem;
+      }
+      .detail-disclosure summary {
+        cursor: pointer;
+        user-select: none;
+        list-style: none;
+        display: flex;
+        align-items: center;
+        gap: 0.35rem;
+      }
+      .detail-disclosure summary::-webkit-details-marker {
+        display: none;
+      }
+      .detail-disclosure-caret {
+        width: 0;
+        height: 0;
+        border-top: 0.3rem solid transparent;
+        border-bottom: 0.3rem solid transparent;
+        border-left: 0.42rem solid var(--muted);
+        transition: transform 120ms ease;
+        flex: 0 0 auto;
+      }
+      .detail-disclosure[open] .detail-disclosure-caret {
+        transform: rotate(90deg);
+      }
+      .detail-disclosure summary h3 {
+        margin: 0;
+        font-size: 1.1rem;
+        line-height: 1.2;
+        color: var(--ink);
+      }
+      .detail-disclosure-panel {
+        margin-top: 0.45rem;
+      }
+      .detail-info-section + .detail-info-section {
+        margin-top: 0.45rem;
+        padding-top: 0.45rem;
+        border-top: 1px solid #f0ede6;
+      }
       .panel-heading-meta {
         color: var(--muted);
         font-size: 0.76rem;
@@ -370,6 +420,24 @@
         background: #fff;
         padding: 0.5rem;
       }
+      .detail-loading-shell {
+        min-height: 14rem;
+        display: grid;
+        place-items: center;
+      }
+      .detail-loading-spinner {
+        width: 2rem;
+        height: 2rem;
+        border-radius: 999px;
+        border: 0.18rem solid rgba(31, 27, 23, 0.12);
+        border-top-color: rgba(31, 27, 23, 0.62);
+        animation: detail-loading-spin 0.85s linear infinite;
+      }
+      @keyframes detail-loading-spin {
+        to {
+          transform: rotate(360deg);
+        }
+      }
       .link-strip {
         display: flex;
         gap: 0.3rem;
@@ -407,6 +475,7 @@
       .detail-origin-list {
         margin: 0.2rem 0 0 1.1rem;
         padding: 0;
+        font-size: 0.88rem;
       }
       .detail-origin-list li + li {
         margin-top: 0.12rem;

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

@@ -9,6 +9,9 @@
   let detailPanel = document.querySelector("[data-detail-panel]");
   const gemLinks = Array.from(document.querySelectorAll("[data-gem-link]"));
   let detailPollTimer = null;
+  let detailLoadingTimer = null;
+  let detailRequestToken = 0;
+  let activeDetailUrl = detailPanel ? detailPanel.dataset.detailUrl : null;
   let currentFilter = <%= selected_filter_json %>;
   let currentSearch = "";
   const emptyDetailHtml = <%= empty_detail_html_json %>;
@@ -21,6 +24,14 @@
     });
   };
   const requestedGemName = () => new URL(window.location.href).searchParams.get("gem");
+  const isSidebarFocused = () => document.activeElement === sidebarPanel;
+  const isDetailFocused = () => detailPanel && document.activeElement === detailPanel;
+  const focusSidebar = () => {
+    if (sidebarPanel) sidebarPanel.focus({ preventScroll: true });
+  };
+  const focusDetail = () => {
+    if (detailPanel) detailPanel.focus({ preventScroll: true });
+  };
 
   const applyGemFilter = (filter) => {
     currentFilter = filter;
@@ -78,9 +89,14 @@
 
   const replaceDetail = (html) => {
     if (!detailPanel) return;
+    const shouldRestoreDetailFocus = isDetailFocused();
     detailPanel.outerHTML = html;
     detailPanel = document.querySelector("[data-detail-panel]");
     if (detailPanel) detailPanel.scrollTop = 0;
+    activeDetailUrl = detailPanel ? detailPanel.dataset.detailUrl : null;
+    if (shouldRestoreDetailFocus) {
+      focusDetail();
+    }
     scheduleDetailPoll();
   };
 
@@ -91,10 +107,37 @@
     }
   };
 
+  const stopDetailLoading = () => {
+    if (detailLoadingTimer) {
+      clearTimeout(detailLoadingTimer);
+      detailLoadingTimer = null;
+    }
+  };
+
+  const loadingDetailHtml = (url) => `
+    <section class="detail" data-detail-panel tabindex="0" data-detail-pending="false" data-detail-url="${url}">
+      <div class="detail-loading-shell" aria-hidden="true">
+        <div class="detail-loading-spinner"></div>
+      </div>
+    </section>
+  `;
+
   const fetchDetail = (url, pushHistory = true) => {
+    const normalizedUrl = new URL(url, window.location.origin).toString();
+    const requestToken = ++detailRequestToken;
+    activeDetailUrl = normalizedUrl;
+    stopDetailLoading();
+    detailLoadingTimer = setTimeout(() => {
+      if (requestToken !== detailRequestToken || normalizedUrl !== activeDetailUrl) return;
+      replaceDetail(loadingDetailHtml(normalizedUrl));
+    }, 1000);
+
     fetch(url, { headers: { "X-Requested-With": "gemstar-detail" } })
       .then((response) => response.text())
       .then((html) => {
+        stopDetailLoading();
+        if (requestToken !== detailRequestToken || normalizedUrl !== activeDetailUrl) return;
+
         replaceDetail(html);
         if (pushHistory) {
           const pageUrl = new URL(window.location.href);
@@ -105,24 +148,28 @@
         }
         const detailUrl = new URL(url, window.location.origin);
         syncSidebarSelection(detailUrl.searchParams.get("gem"));
+      })
+      .catch(() => {
+        stopDetailLoading();
       });
   };
 
   const activateGemLink = (link, pushHistory = true, keepVisible = false) => {
     if (!link) return;
 
+    stopDetailPoll();
+    stopDetailLoading();
     syncSidebarSelection(link.dataset.gemName, keepVisible);
     fetchDetail(link.dataset.detailUrl || link.href, pushHistory);
 
-    if (sidebarPanel) {
-      sidebarPanel.focus({ preventScroll: true });
-    }
+    focusSidebar();
   };
 
   const scheduleDetailPoll = () => {
     stopDetailPoll();
     if (!detailPanel || detailPanel.dataset.detailPending !== "true") return;
     detailPollTimer = setTimeout(() => {
+      if (!detailPanel || !detailPanel.dataset.detailUrl) return;
       fetchDetail(detailPanel.dataset.detailUrl, false);
     }, 1000);
   };
@@ -204,6 +251,39 @@
   document.addEventListener("keydown", (event) => {
     const tagName = document.activeElement && document.activeElement.tagName;
     if (tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT") return;
+
+    if (event.key === "ArrowRight" && isSidebarFocused()) {
+      event.preventDefault();
+      focusDetail();
+      return;
+    }
+
+    if (event.key === "ArrowLeft" && isDetailFocused()) {
+      event.preventDefault();
+      focusSidebar();
+      return;
+    }
+
+    if (isDetailFocused()) {
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        detailPanel.scrollBy({ top: 80, behavior: "auto" });
+      }
+      if (event.key === "ArrowUp") {
+        event.preventDefault();
+        detailPanel.scrollBy({ top: -80, behavior: "auto" });
+      }
+      return;
+    }
+
+    if (!isSidebarFocused()) {
+      if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+        event.preventDefault();
+        focusSidebar();
+      }
+      return;
+    }
+
     const links = visibleGemLinks();
     if (!links.length) return;
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstar
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Florian Dejako
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.4
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -267,7 +281,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Making sense of gems.
 test_files: []