gemstar 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b290f73ca813d6ef39789e23d883f3bd382fbdcc17f0803cd5fdc296d7f60582
-  data.tar.gz: '058a2d17b98461a62d463ba673d170b621471e8f9693ea294da403382da5a759'
+  metadata.gz: 2bea143c3f9b89aca665d0b74402cb7f16ec65b6994139a187f406c3de800eca
+  data.tar.gz: f9bc3eeba8f76decc7dbbe215e377a3130e1ffbbaa5d22f405604974ab99741a
 SHA512:
-  metadata.gz: fe408b9d9259ab0771e41522238b35c259e624759ac27ffe013d689c76ebe0164905c5ee67bb7868e8cc43ff361568f854f8dccf2e513468176685a395bb9786
-  data.tar.gz: 149884982e1e2d124f7ade0bf565604106a455db2bab04f6b3811b316fb0386f72ed3fdaa0969369c310e3811e7735d97d29c147f9263f32f62c6c2fcb0d7487
+  metadata.gz: b857d1cc340eab567266177d927710b13d9f569d07bea5d59332a679c3f57e827c26d9ce6d8154968cd624ac1e1b41723778d9bbc3c6ed6fede5af147fdffbba
+  data.tar.gz: d2da645e58549938abf27c2c10a53c1eca1b2a8d842ef7f41ce85298e0a47e4b4d8a0bf152843ad080c0cf2b112f6882a5628a93cd617f1933e727d2e2992d39

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## 1.0.4
+
+- Server: Improve layout, detail panel state management, and initial gem selection
+- Server: Gem details now in collapsible panel
+- Server: Arrow left/right navigation improved
+- Enhance changelog parsing with GitHub tag and release support
+- Extend `LockFile` with dependency requirements, spec sources, and platform parsing
+- Refactor dependency processing to include platform and source details
+- Refactor changelog parsing to merge GitHub release and changelog sections
+
+## 1.0.3
+
+- Load our own WEBrick to avoid conflicts with hosting puma.rb etc.
+
 ## 1.0.2
 
 - General server performance improvements.

data/lib/gemstar/change_log.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "cgi"
 
 module Gemstar
   class ChangeLog
@@ -22,10 +23,10 @@ module Gemstar
       return @sections if !cache_only && defined?(@sections)
 
       result = begin
-        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, force_refresh: force_refresh)
-        end
+        changelog_sections = parse_changelog_sections(cache_only: cache_only, force_refresh: force_refresh) || {}
+        github_sections = parse_github_release_sections(cache_only: cache_only, force_refresh: force_refresh) || {}
+
+        s = merge_section_sources(changelog_sections, github_sections)
 
         pp @@candidates_found if Gemstar.debug? && !cache_only
 
@@ -36,6 +37,13 @@ module Gemstar
       result
     end
 
+    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)
+    end
+
     def extract_relevant_sections(old_version, new_version)
       from = Gem::Version.new(old_version.gsub(/-[\w\-]+$/, "")) rescue nil if old_version
       from ||= Gem::Version.new("0.0.0")
@@ -294,6 +302,22 @@ module Gemstar
         end
       end
 
+      if sections.empty?
+        current_version = @metadata&.meta(cache_only: cache_only, force_refresh: force_refresh)&.dig("version")
+        current_release_sections = parse_specific_github_release_pages(
+          repo_uri,
+          current_version,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        tag_sections = parse_github_tag_sections(
+          repo_uri,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        sections = tag_sections.merge(current_release_sections)
+      end
+
       if Gemstar.debug?
         puts "parse_github_release_sections #{@metadata.gem_name}:"
         pp sections.keys
@@ -308,5 +332,197 @@ module Gemstar
       return nil if repo.empty?
       "#{repo}/releases"
     end
+
+    def github_tags_url(repo_uri = @metadata&.repo_uri)
+      return nil unless repo_uri
+      repo = repo_uri.chomp("/")
+      return nil if repo.empty?
+      "#{repo}/tags"
+    end
+
+    def parse_specific_github_release_pages(repo_uri, version, cache_only:, force_refresh:)
+      return {} unless repo_uri&.include?("github.com")
+      return {} if version.to_s.empty?
+
+      github_release_tag_urls(repo_uri, version).each do |url|
+        html = if cache_only
+          Cache.peek("releases-#{url}")
+        else
+          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
+            end
+          end
+        end
+
+        next if html.nil? || html.strip.empty?
+
+        section = parse_single_github_release_page(html, version)
+        return { version => section } if section
+      end
+
+      {}
+    end
+
+    def parse_github_tag_sections(repo_uri, cache_only:, force_refresh:)
+      return {} unless repo_uri&.include?("github.com")
+
+      url = github_tags_url(repo_uri)
+      return {} unless url
+
+      sections = {}
+      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_sections, next_url = parse_single_github_tags_page(html, repo_uri)
+        sections.merge!(page_sections) { |_version, existing, _new| existing }
+        url = next_url
+      end
+
+      sections.keys.each do |version|
+        specific_release = parse_specific_github_release_pages(
+          repo_uri,
+          version,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        next if specific_release.nil? || specific_release.empty?
+
+        sections[version] = specific_release[version] if specific_release[version]
+      end
+
+      sections
+    end
+
+    def parse_single_github_tags_page(html, repo_uri)
+      require "nokogiri"
+
+      doc = begin
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
+
+      sections = {}
+      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?
+
+        version = normalize_github_tag_version(tag_name)
+        next if version.to_s.empty?
+
+        sections[version] ||= [
+          "## #{version}\n",
+          "<p>No release information available. Check the release page for more information.</p>"
+        ]
+      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
+
+      [sections, next_url]
+    rescue LoadError
+      [{}, nil]
+    end
+
+    def parse_single_github_release_page(html, version)
+      require "nokogiri"
+
+      doc = begin
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
+
+      body = doc.at_css('[data-test-selector="body-content"] .markdown-body') ||
+             doc.at_css('[data-test-selector="body-content"]') ||
+             doc.at_css('.markdown-body')
+      if body
+        html_chunk = body.inner_html.to_s.strip
+        return ["## #{version}\n", html_chunk] unless html_chunk.empty?
+      end
+
+      title = doc.at_css("title")&.text.to_s.strip
+      synthetic_title = normalize_github_release_title(title, version)
+      return nil if synthetic_title.nil? || synthetic_title.empty?
+
+      ["## #{version}\n", "<p>#{CGI.escapeHTML(synthetic_title)}</p>"]
+    rescue LoadError
+      nil
+    end
+
+    def github_release_tag_urls(repo_url, version)
+      github_tag_candidates(version).map do |tag|
+        "#{repo_url}/releases/tag/#{tag}"
+      end.uniq
+    end
+
+    def github_tag_candidates(version)
+      raw = version.to_s
+      [raw, (raw.start_with?("v") ? raw : "v#{raw}")].uniq
+    end
+
+    def normalize_github_tag_version(tag_name)
+      decoded = URI.decode_www_form_component(tag_name.to_s.split("?").first.to_s)
+      match = decoded.match(/\Av?(\d[\w.\-]*)\z/i)
+      match && match[1]
+    end
+
+    def prefer_github_releases_first?(cache_only:, force_refresh:)
+      meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
+      repo_uri = @metadata.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
+
+      repo_uri.to_s.include?("github.com") && meta["changelog_uri"].to_s.empty?
+    rescue StandardError
+      false
+    end
+
+    def normalize_github_release_title(title, version)
+      return nil if title.to_s.empty?
+
+      cleaned = title.sub(/\s*·\s*[^·]+\s*·\s*GitHub\z/, "")
+      cleaned = cleaned.sub(/\ARelease\s+/, "")
+      cleaned = cleaned.strip
+      return nil if cleaned.empty? || cleaned == version.to_s
+
+      cleaned
+    end
   end
 end

data/lib/gemstar/commands/server.rb

@@ -45,6 +45,7 @@ module Gemstar
         puts "Config home: #{Gemstar::Config.home_directory}"
         Rackup::Server.start(
           app: app,
+          server: "webrick",
           Host: bind,
           Port: port,
           AccessLog: [],

data/lib/gemstar/lock_file.rb

@@ -5,26 +5,72 @@ module Gemstar
       parsed = content ? parse_content(content) : parse_lockfile(path)
       @specs = parsed[:specs]
       @dependency_graph = parsed[:dependency_graph]
+      @dependency_requirements = parsed[:dependency_requirements]
       @direct_dependencies = parsed[:direct_dependencies]
+      @direct_dependency_requirements = parsed[:direct_dependency_requirements]
+      @spec_sources = parsed[:spec_sources]
     end
 
     attr_reader :specs
     attr_reader :dependency_graph
+    attr_reader :dependency_requirements
     attr_reader :direct_dependencies
+    attr_reader :direct_dependency_requirements
+    attr_reader :spec_sources
 
     def origins_for(gem_name)
-      return [{ type: :direct, path: [gem_name] }] if direct_dependencies.include?(gem_name)
+      if direct_dependencies.include?(gem_name)
+        return [{
+          type: :direct,
+          path: [gem_name],
+          requirement: direct_dependency_requirements[gem_name]
+        }]
+      end
 
       direct_dependencies.filter_map do |root_dependency|
         path = shortest_path_from(root_dependency, gem_name)
         next if path.nil?
 
-        { type: :transitive, path: path }
+        parent_name = path[-2]
+        {
+          type: :transitive,
+          path: path,
+          requirement: dependency_requirements.dig(parent_name, gem_name)
+        }
       end
     end
 
+    def source_for(gem_name)
+      spec_sources[gem_name]
+    end
+
+    def platform_for(gem_name)
+      version = specs[gem_name].to_s
+      parts = version.split("-")
+      return nil if parts.length < 2
+
+      1.upto(parts.length - 1) do |index|
+        candidate_version = parts[0...index].join("-")
+        candidate_platform = parts[index..].join("-")
+        next unless plausible_platform_suffix?(candidate_platform)
+
+        begin
+          Gem::Version.new(candidate_version)
+          return candidate_platform
+        rescue ArgumentError
+          next
+        end
+      end
+
+      nil
+    end
+
     private
 
+    def plausible_platform_suffix?(suffix)
+      suffix.match?(/darwin|linux|mingw|mswin|musl|java|x86|arm|universal/i)
+    end
+
     def shortest_path_from(root_dependency, target_gem)
       queue = [[root_dependency, [root_dependency]]]
       visited = {}
@@ -53,9 +99,13 @@ module Gemstar
     def parse_content(content)
       specs = {}
       dependency_graph = Hash.new { |hash, key| hash[key] = [] }
+      dependency_requirements = Hash.new { |hash, key| hash[key] = {} }
       direct_dependencies = []
+      direct_dependency_requirements = {}
+      spec_sources = {}
       current_section = nil
       current_spec = nil
+      current_source = nil
 
       content.each_line do |line|
         stripped = line.strip
@@ -68,12 +118,28 @@ module Gemstar
         if stripped == "GEM"
           current_section = :gem
           current_spec = nil
+          current_source = { type: :rubygems }
+          next
+        end
+
+        if stripped == "PATH"
+          current_section = :path
+          current_spec = nil
+          current_source = { type: :path }
+          next
+        end
+
+        if stripped == "GIT"
+          current_section = :git
+          current_spec = nil
+          current_source = { type: :git }
           next
         end
 
         if stripped == "DEPENDENCIES"
           current_section = :dependencies
           current_spec = nil
+          current_source = nil
           next
         end
 
@@ -83,17 +149,30 @@ module Gemstar
         end
 
         case current_section
-        when :gem
-          if line =~ /^\s{4}(\S+) \((.+)\)/
+        when :gem, :path, :git
+          if line =~ /^\s{2}remote:\s+(.+)$/
+            current_source = (current_source || {}).merge(remote: Regexp.last_match(1))
+          elsif line =~ /^\s{2}(revision|branch|tag|ref|glob|submodules):\s+(.+)$/
+            current_source = (current_source || {}).merge(Regexp.last_match(1).to_sym => Regexp.last_match(2))
+          elsif line =~ /^\s{2}path:\s+(.+)$/
+            current_source = (current_source || {}).merge(path: Regexp.last_match(1))
+          elsif line =~ /^\s{4}(\S+) \((.+)\)/
             name, version = Regexp.last_match(1), Regexp.last_match(2)
             specs[name] = version
+            spec_sources[name] = (current_source || {}).dup
             current_spec = name
-          elsif current_spec && line =~ /^\s{6}([^\s(]+)/
-            dependency_graph[current_spec] << Regexp.last_match(1)
+          elsif current_spec && line =~ /^\s{6}([^\s(]+)(?: \(([^)]+)\))?/
+            dependency_name = Regexp.last_match(1)
+            requirement = Regexp.last_match(2)
+            dependency_graph[current_spec] << dependency_name
+            dependency_requirements[current_spec][dependency_name] = requirement if requirement && !requirement.empty?
           end
         when :dependencies
-          if line =~ /^\s{2}([^\s!(]+)/
-            direct_dependencies << Regexp.last_match(1)
+          if line =~ /^\s{2}([^\s!(]+)(?: \(([^)]+)\))?/
+            dependency_name = Regexp.last_match(1)
+            requirement = Regexp.last_match(2)
+            direct_dependencies << dependency_name
+            direct_dependency_requirements[dependency_name] = requirement if requirement && !requirement.empty?
           end
         end
       end
@@ -101,7 +180,10 @@ module Gemstar
       {
         specs: specs,
         dependency_graph: dependency_graph.transform_values(&:uniq),
-        direct_dependencies: direct_dependencies.uniq
+        dependency_requirements: dependency_requirements,
+        direct_dependencies: direct_dependencies.uniq,
+        direct_dependency_requirements: direct_dependency_requirements,
+        spec_sources: spec_sources
       }
     end
   end

data/lib/gemstar/project.rb

@@ -114,7 +114,8 @@ module Gemstar
       @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) || []
+        effective_lockfile = new_version ? to_lockfile : from_lockfile
+        bundle_origins = effective_lockfile&.origins_for(gem_name) || []
 
         {
           name: gem_name,
@@ -122,6 +123,8 @@ module Gemstar
           new_version: new_version,
           status: gem_status(old_version, new_version),
           version_label: version_label(old_version, new_version),
+          platform: effective_lockfile&.platform_for(gem_name),
+          source: effective_lockfile&.source_for(gem_name),
           bundle_origins: bundle_origins,
           bundle_origin_labels: bundle_origin_labels(bundle_origins)
         }
@@ -233,7 +236,8 @@ module Gemstar
       Array(origins).map do |origin|
         next "Gemfile" if origin[:type] == :direct
 
-        ["Gemfile", *origin[:path]].join(" → ")
+        label = ["Gemfile", *origin[:path]].join(" → ")
+        origin[:requirement] ? "#{label} (#{origin[:requirement]})" : label
       end.compact.uniq
     end
 

data/lib/gemstar/version.rb

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

data/lib/gemstar/web/app.rb

@@ -227,7 +227,7 @@ module Gemstar
             </div>
             <div class="picker-row">
               <label class="picker picker-project">
-                <span class="picker-prefix">📁</span>
+                <span class="picker-prefix" data-text-label="true">Project:</span>
                 <select data-project-select>
                   #{project_options_html}
                   <option value="" disabled>────────</option>
@@ -516,7 +516,8 @@ module Gemstar
           next if origin[:type] != :direct && display_path.empty?
 
           linked_path = linked_gem_chain(["Gemfile", *display_path])
-          origin[:type] == :direct ? gemfile_link("Gemfile") : linked_path
+          label = origin[:type] == :direct ? gemfile_link("Gemfile") : linked_path
+          origin[:requirement] ? "#{label} (#{h(origin[:requirement])})" : label
         end.uniq
       end
 
@@ -540,14 +541,18 @@ module Gemstar
       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) }
+        platforms = selected_gem_platform_items
+        source_items = selected_gem_source_items
         added_markup = render_added_on(added_on)
-        return "" if required_by.empty? && requires.empty? && added_markup.empty?
+        return "" if required_by.empty? && requires.empty? && platforms.empty? && source_items.empty? && added_markup.empty?
 
         <<~HTML
           <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("Platforms", platforms)}
+              #{render_dependency_popover_section("Source", source_items)}
               #{render_dependency_popover_section("Required by", required_by)}
               #{render_dependency_popover_section("Requires", requires)}
             </div>
@@ -584,6 +589,39 @@ module Gemstar
         @selected_project&.gem_added_on(@selected_gem[:name], revision_id: revision_id)
       end
 
+      def selected_gem_platform_items
+        platform = @selected_gem[:platform]
+        return [] if platform.to_s.empty?
+
+        [h(platform)]
+      end
+
+      def selected_gem_source_items
+        source = @selected_gem[:source] || {}
+        source_type = source[:type]
+
+        case source_type
+        when :path
+          location = source[:path] || source[:remote]
+          return [] if location.to_s.empty?
+
+          ["Path (#{h(location)})"]
+        when :git
+          remote = source[:remote]
+          pieces = ["Git"]
+          pieces << h(remote) unless remote.to_s.empty?
+          pieces << "@#{h(source[:branch])}" if source[:branch]
+          pieces << "##{h(source[:tag])}" if source[:tag]
+          pieces << h(source[:revision].to_s[0, 8]) if source[:revision]
+          [pieces.join(" ")]
+        when :rubygems
+          remote = source[:remote]
+          [remote.to_s.empty? ? "RubyGems" : "RubyGems (#{h(remote)})"]
+        else
+          []
+        end
+      end
+
       def linked_gem_chain(names)
         Array(names).map.with_index do |name, index|
           if index.zero?

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

@@ -52,9 +52,9 @@
         align-items: center;
         justify-content: space-between;
         gap: 0.6rem;
-        padding: 0.4rem 0.65rem;
-        border-bottom: 1px solid #ece8df;
-        background: #fff;
+        padding: 0.55rem 0.75rem;
+        border-bottom: 1px solid #e6d5c2;
+        background: #fbf1e4;
         position: sticky;
         top: 0;
         z-index: 2;
@@ -316,7 +316,7 @@
         font-weight: 600;
       }
       .detail {
-        padding: 0.5rem 0.8rem 0.5rem 0.5rem;
+        padding: 0.62rem 0.8rem 0.5rem 0.5rem;
         display: grid;
         gap: 0.45rem;
         align-content: start;
@@ -367,7 +367,7 @@
         flex: 0 0 auto;
       }
       .detail-disclosure {
-        margin-top: 0.2rem;
+        margin-top: 0.38rem;
         border: 1px solid #ece8df;
         border-radius: 0.3rem;
         background: #fff;

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

@@ -15,6 +15,7 @@
   let currentFilter = <%= selected_filter_json %>;
   let currentSearch = "";
   const emptyDetailHtml = <%= empty_detail_html_json %>;
+  const detailDisclosureStorageKey = "gemstar.detailDisclosureOpen";
 
   const visibleGemLinks = () => gemLinks.filter((link) => !link.hidden);
   const currentSelectedIndex = () => visibleGemLinks().findIndex((link) => link.classList.contains("is-selected"));
@@ -24,6 +25,15 @@
     });
   };
   const requestedGemName = () => new URL(window.location.href).searchParams.get("gem");
+  const currentDetailGemName = () => {
+    if (!detailPanel || !detailPanel.dataset.detailUrl) return null;
+
+    try {
+      return new URL(detailPanel.dataset.detailUrl, window.location.origin).searchParams.get("gem");
+    } catch (_error) {
+      return null;
+    }
+  };
   const isSidebarFocused = () => document.activeElement === sidebarPanel;
   const isDetailFocused = () => detailPanel && document.activeElement === detailPanel;
   const focusSidebar = () => {
@@ -32,6 +42,31 @@
   const focusDetail = () => {
     if (detailPanel) detailPanel.focus({ preventScroll: true });
   };
+  const storedDetailDisclosureOpen = () => {
+    try {
+      return window.localStorage.getItem(detailDisclosureStorageKey) === "true";
+    } catch (_error) {
+      return false;
+    }
+  };
+  const persistDetailDisclosureOpen = (open) => {
+    try {
+      window.localStorage.setItem(detailDisclosureStorageKey, open ? "true" : "false");
+    } catch (_error) {
+      // ignore storage failures
+    }
+  };
+  const bindDetailDisclosure = () => {
+    if (!detailPanel) return;
+
+    const disclosure = detailPanel.querySelector(".detail-disclosure");
+    if (!disclosure) return;
+
+    disclosure.open = storedDetailDisclosureOpen();
+    disclosure.addEventListener("toggle", () => {
+      persistDetailDisclosureOpen(disclosure.open);
+    });
+  };
 
   const applyGemFilter = (filter) => {
     currentFilter = filter;
@@ -94,6 +129,7 @@
     detailPanel = document.querySelector("[data-detail-panel]");
     if (detailPanel) detailPanel.scrollTop = 0;
     activeDetailUrl = detailPanel ? detailPanel.dataset.detailUrl : null;
+    bindDetailDisclosure();
     if (shouldRestoreDetailFocus) {
       focusDetail();
     }
@@ -122,7 +158,7 @@
     </section>
   `;
 
-  const fetchDetail = (url, pushHistory = true) => {
+  const fetchDetail = (url, historyMode = "push") => {
     const normalizedUrl = new URL(url, window.location.origin).toString();
     const requestToken = ++detailRequestToken;
     activeDetailUrl = normalizedUrl;
@@ -139,12 +175,13 @@
         if (requestToken !== detailRequestToken || normalizedUrl !== activeDetailUrl) return;
 
         replaceDetail(html);
-        if (pushHistory) {
+        if (historyMode !== "none") {
           const pageUrl = new URL(window.location.href);
           const detailUrl = new URL(url, window.location.origin);
           pageUrl.search = detailUrl.search;
           pageUrl.searchParams.set("filter", currentFilter);
-          window.history.pushState({}, "", pageUrl);
+          const historyMethod = historyMode === "replace" ? "replaceState" : "pushState";
+          window.history[historyMethod]({}, "", pageUrl);
         }
         const detailUrl = new URL(url, window.location.origin);
         syncSidebarSelection(detailUrl.searchParams.get("gem"));
@@ -154,17 +191,39 @@
       });
   };
 
-  const activateGemLink = (link, pushHistory = true, keepVisible = false) => {
+  const activateGemLink = (link, historyMode = "push", keepVisible = false) => {
     if (!link) return;
 
     stopDetailPoll();
     stopDetailLoading();
     syncSidebarSelection(link.dataset.gemName, keepVisible);
-    fetchDetail(link.dataset.detailUrl || link.href, pushHistory);
+    fetchDetail(link.dataset.detailUrl || link.href, historyMode);
 
     focusSidebar();
   };
 
+  const ensureInitialGemSelection = () => {
+    if (requestedGemName()) return;
+
+    const detailGemName = currentDetailGemName();
+    const detailLink = detailGemName ? visibleGemLinks().find((link) => link.dataset.gemName === detailGemName) : null;
+
+    if (detailLink) {
+      syncSidebarSelection(detailGemName, true);
+      const pageUrl = new URL(window.location.href);
+      const detailUrl = new URL(detailLink.dataset.detailUrl || detailLink.href, window.location.origin);
+      pageUrl.search = detailUrl.search;
+      pageUrl.searchParams.set("filter", currentFilter);
+      window.history.replaceState({}, "", pageUrl);
+      return;
+    }
+
+    const firstVisibleLink = visibleGemLinks()[0];
+    if (firstVisibleLink) {
+      activateGemLink(firstVisibleLink, "replace", true);
+    }
+  };
+
   const scheduleDetailPoll = () => {
     stopDetailPoll();
     if (!detailPanel || detailPanel.dataset.detailPending !== "true") return;
@@ -176,11 +235,13 @@
 
   if (detailPanel) {
     detailPanel.scrollTop = 0;
+    bindDetailDisclosure();
     scheduleDetailPoll();
   }
 
   syncSidebarSelection(null, true);
   applyGemFilter(currentFilter);
+  ensureInitialGemSelection();
 
   gemLinks.forEach((link) => {
     link.addEventListener("click", (event) => {
@@ -277,6 +338,14 @@
     }
 
     if (!isSidebarFocused()) {
+      if (event.key === "ArrowLeft") {
+        event.preventDefault();
+        focusSidebar();
+      }
+      if (event.key === "ArrowRight") {
+        event.preventDefault();
+        focusDetail();
+      }
       if (event.key === "ArrowDown" || event.key === "ArrowUp") {
         event.preventDefault();
         focusSidebar();
@@ -296,7 +365,7 @@
 
     if (nextIndex !== null && nextIndex !== currentIndex) {
       event.preventDefault();
-      activateGemLink(links[nextIndex], true, true);
+      activateGemLink(links[nextIndex], "push", true);
     }
   });
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstar
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Florian Dejako
@@ -281,7 +281,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Making sense of gems.
 test_files: []