gemstar 1.0.4 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bea143c3f9b89aca665d0b74402cb7f16ec65b6994139a187f406c3de800eca
-  data.tar.gz: f9bc3eeba8f76decc7dbbe215e377a3130e1ffbbaa5d22f405604974ab99741a
+  metadata.gz: bd80f7bf53281fd8f5b80138f9f564ff8e393ffaec44276168dc020765c6ae7a
+  data.tar.gz: 3d6b9c2f9a2e0955d6ace8c34100c05390cd9579aa8c8993361799450e36c625
 SHA512:
-  metadata.gz: b857d1cc340eab567266177d927710b13d9f569d07bea5d59332a679c3f57e827c26d9ce6d8154968cd624ac1e1b41723778d9bbc3c6ed6fede5af147fdffbba
-  data.tar.gz: d2da645e58549938abf27c2c10a53c1eca1b2a8d842ef7f41ce85298e0a47e4b4d8a0bf152843ad080c0cf2b112f6882a5628a93cd617f1933e727d2e2992d39
+  metadata.gz: 79d87285b961fdd88c6e898b2016d2bc4cc65b508a5f2c7480f865f0144b12ca5a53be3ff7833d48ed1a66cf4851134a6dbe41fdfc44d807f720e0c63fe52a05
+  data.tar.gz: 4803b9f217fef1aae5b671fdc5a356229697aba7d5cec4b2f1a05588d63a9ca88c38f876ed4aa1d2579451d6196097818a3d9aa866f8071004c45a9966c66a95

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Change Log
 
+## 1.1
+
+- Server: Add **JavaScript package support** to browse change logs for your project's packages. This currently
+  supports packages in `importmap.rb` and `package-lock.json`.
+- Server: Change launch behavior to more reliably start cache warmer at launch.
+- Server: Add `--open` option to open the server root in a local browser at launch.
+- Server: Defer initial detail rendering so the page becomes interactive sooner on startup.
+- Server: Persist the Details disclosure state between gem views.
+- Server: Continue background warming with cached parsed release sections, not just raw fetched pages.
+- Server: Improve GitHub release discovery with direct tag-page fallback and paginated GitHub tags support.
+- Server: Prefer real changelog file entries over GitHub-derived placeholders when both exist.
+- Server: Short gem description now rendered as markdown (for minitest gem).
+- Server: Improve section parsing for simplecov and similar gems.
+- Server: Increase limit for number of recent commits to show in menu to 100.
+- Server: Add page icon.
+- Server: Unless a port has been specified, server will now attempt binding from ports 2112 up.
+- Diff: Add **JavaScript package support.** Like with Server, this supports `importmap.rb` and `package-lock.json`.
+- Diff: Add `--ecosystem` parameter to choose js/gems/all.
+- Diff: Add `--project` directive to point at the project root to diff.
+- Diff: Add `--since` parameter to limit diff to commits since a specific date, e.g. `--since "3 weeks ago"`.
+- Diff: Add "file://" to generated report output to fix click-to-open in certain terminal apps.
+- Diff: Add list of considered git commits to diff report.
+- Special cases for specific packages now moved into json configuration files.
+- `gemstar` is now a shortcut for `gemstar server --open`.
+
 ## 1.0.4
 
 - Server: Improve layout, detail panel state management, and initial gem selection
@@ -35,7 +60,6 @@
 - Removed Railtie from this gem.
 - Improve how git root dir is determined.
 
-
 ## 0.0.2
 
 - Diff: Fix regex warnings shown in terminal.

data/README.md

@@ -3,7 +3,7 @@
 [![JRuby Build](https://github.com/FDj/gemstar/workflows/JRuby%20Build/badge.svg)](https://github.com/FDj/gemstar/actions)
 
 # Gemstar
-A very preliminary gem to help you keep track of your gems.
+Helps you keep track of your gems and JavaScript packages.
 
 ## Installation
 
@@ -34,17 +34,23 @@ gemstar server
 
 By default, the server listens to http://127.0.0.1:2112/
 
+To open the root page in your browser after startup:
+
+```shell
+gemstar server --open
+```
+
 
 ### gemstar diff
 
-Run this after you've updated your gems.
+Run this after you've updated your dependencies.
 
 ```shell
 # in your project directory, after bundle update:
 gemstar diff
 ```
 
-This will generate an html diff report with changelog entries for each gem that was updated:
+This will generate an html diff report with changelog entries for each updated package:
 
 ![Gemstar diff command output](docs/diff.png)
 
@@ -54,12 +60,31 @@ You can also specify from and to hashes or tags to generate a diff report for a
 gemstar diff --from 8e3aa96b7027834cdbabc0d8cbd5f9455165e930 --to HEAD
 ```
 
+To use a time range instead of choosing the starting commit yourself:
+
+```shell
+gemstar diff --project ~/Code/my-app --since "3 weeks"
+```
+
 To examine a specific Gemfile.lock, pass it like this:
 
 ```shell
 gemstar diff --lockfile=~/MyProject/Gemfile.lock
 ```
 
+To diff a project from anywhere, pass the project directory or a supported project file. In project mode, gemstar includes Ruby gems plus JS packages from `importmap.rb` and `package-lock.json` when present:
+
+```shell
+gemstar diff --project ~/Code/my-app
+```
+
+To filter a project diff down to one ecosystem:
+
+```shell
+gemstar diff --project ~/Code/my-app --ecosystem js
+gemstar diff --project ~/Code/my-app --ecosystem gems
+```
+
 To write markdown instead of html:
 
 ```shell

data/bin/gemstar

@@ -4,4 +4,8 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require_relative "../lib/gemstar"
 
-Gemstar::CLI.start(ARGV)
+if ARGV.empty?
+  Gemstar::Commands::Server.new(open: true).run
+else
+  Gemstar::CLI.start(ARGV)
+end

data/lib/gemstar/cache_warmer.rb

@@ -21,47 +21,60 @@ module Gemstar
       @completed_count = 0
     end
 
-    def enqueue_many(gem_names)
-      names = gem_names.uniq
+    def enqueue_many(package_states)
+      states = normalize_package_states(package_states)
 
       @mutex.synchronize do
-        names.each do |gem_name|
-          next if @completed.include?(gem_name) || @queued.include?(gem_name) || @in_progress.include?(gem_name)
+        states.each do |package_state|
+          key = package_key(package_state)
+          next if @completed.include?(key) || @queued.include?(key) || @in_progress.include?(key)
 
-          @queue << gem_name
-          @queued << gem_name
+          @queue << package_state
+          @queued << key
         end
-        @total += names.count
+        @total += states.count
         start_workers_unlocked unless @started
       end
 
-      log "Background cache refresh queued for #{names.count} gems."
+      log "Background cache refresh queued for #{states.count} packages."
       @condition.broadcast
       self
     end
 
-    def prioritize(gem_name)
+    def prioritize(package_name)
       @mutex.synchronize do
-        return if @completed.include?(gem_name) || @in_progress.include?(gem_name)
+        existing = @queue.find do |item|
+          item[:name] == package_name || item.dig(:source, :package_name) == package_name
+        end
 
-        if @queued.include?(gem_name)
-          @queue.delete(gem_name)
+        if existing
+          key = package_key(existing)
+          return if @completed.include?(key) || @in_progress.include?(key)
+          @queue.delete(existing)
+          @queue.unshift(existing)
         else
-          @queued << gem_name
+          synthetic = {
+            name: package_name,
+            package_scope: "gems",
+            source: {}
+          }
+          key = package_key(synthetic)
+          return if @completed.include?(key) || @in_progress.include?(key)
+          @queued << key
+          @queue.unshift(synthetic)
           @total += 1
         end
-
-        @queue.unshift(gem_name)
         start_workers_unlocked unless @started
       end
 
-      log "Prioritized #{gem_name}"
+      log "Prioritized #{package_name}"
       @condition.broadcast
     end
 
-    def pending?(gem_name)
+    def pending?(package_name)
       @mutex.synchronize do
-        @queued.include?(gem_name) || @in_progress.include?(gem_name)
+        @queue.any? { |item| item[:name] == package_name || item.dig(:source, :package_name) == package_name } ||
+          @in_progress.any? { |key| key.end_with?(":#{package_name}") }
       end
     end
 
@@ -80,47 +93,92 @@ module Gemstar
       Thread.current.name = "gemstar-cache-worker" if Thread.current.respond_to?(:name=)
 
       loop do
-        gem_name = @mutex.synchronize do
+        package_state = @mutex.synchronize do
           while @queue.empty?
             @condition.wait(@mutex)
           end
 
-          next_gem = @queue.shift
-          @queued.delete(next_gem)
-          @in_progress << next_gem
-          next_gem
+          next_package = @queue.shift
+          key = package_key(next_package)
+          @queued.delete(key)
+          @in_progress << key
+          next_package
         end
 
-        warm_cache_for_gem(gem_name)
+        warm_cache_for_package(package_state)
 
         current = @mutex.synchronize do
-          @in_progress.delete(gem_name)
-          @completed << gem_name
+          key = package_key(package_state)
+          @in_progress.delete(key)
+          @completed << key
           @completed_count += 1
         end
 
-        log_progress(gem_name, current)
+        log_progress(package_label(package_state), current)
       end
     end
 
-    def warm_cache_for_gem(gem_name)
-      metadata = Gemstar::RubyGemsMetadata.new(gem_name)
-      metadata.meta
-      metadata.repo_uri
-      Gemstar::ChangeLog.new(metadata).sections
+    def warm_cache_for_package(package_state)
+      metadata = metadata_adapter_for(package_state)
+      return unless metadata
+
+      metadata.warm_cache(versions: package_versions(package_state))
     rescue StandardError => e
-      log "Cache refresh failed for #{gem_name}: #{e.class}: #{e.message}"
+      log "Cache refresh failed for #{package_label(package_state)}: #{e.class}: #{e.message}"
     end
 
-    def log_progress(gem_name, current)
+    def log_progress(package_name, current)
       return unless @debug
       return unless current <= 5 || (current % 25).zero?
 
-      log "Background cache refresh #{current}/#{@total}: #{gem_name}"
+      log "Background cache refresh #{current}/#{@total}: #{package_name}"
     end
 
     def log(message)
       @io.puts(message)
     end
+
+    def normalize_package_states(package_states)
+      Array(package_states).filter_map do |package_state|
+        next unless package_state.is_a?(Hash)
+
+        package_state
+      end.uniq { |package_state| package_key(package_state) }
+    end
+
+    def package_key(package_state)
+      scope = package_state[:package_scope].to_s
+      source_type = package_state[:package_source_file].to_s
+      package_name = package_state.dig(:source, :package_name) || package_state[:name]
+      "#{scope}:#{source_type}:#{package_name}"
+    end
+
+    def package_label(package_state)
+      package_state.dig(:source, :package_name) || package_state[:name]
+    end
+
+    def package_versions(package_state)
+      [
+        package_state[:old_version],
+        package_state[:new_version],
+        package_state[:raw_old_version],
+        package_state[:raw_new_version],
+        package_state.dig(:source, :package_version)
+      ].compact
+    end
+
+    def metadata_adapter_for(package_state)
+      if package_state[:package_scope] == "js"
+        provider_gem = package_state.dig(:source, :provider_gem)
+        return Gemstar::RubyGemsMetadata.new(provider_gem) unless provider_gem.to_s.empty?
+
+        package_name = package_state.dig(:source, :package_name) || package_state[:name]
+        return nil if package_name.to_s.empty?
+
+        return Gemstar::NpmMetadata.new(package_name)
+      end
+
+      Gemstar::RubyGemsMetadata.new(package_state[:name])
+    end
   end
 end

data/lib/gemstar/change_log.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 require "cgi"
+require "json"
 
 module Gemstar
   class ChangeLog
     @@candidates_found = Hash.new(0)
+    DEFAULT_CHANGELOG_PATHS = %w[
+      CHANGELOG.md releases.md CHANGES.md
+      Changelog.md changelog.md ChangeLog.md
+      Changes.md changes.md
+      HISTORY.md History.md history.md
+      History CHANGELOG.rdoc
+    ].freeze
 
     def initialize(metadata)
       @metadata = metadata
@@ -20,23 +28,77 @@ module Gemstar
     end
 
     def sections(cache_only: false, force_refresh: false)
-      return @sections if !cache_only && defined?(@sections)
+      return @sections if !cache_only && defined?(@sections) && !force_refresh
 
-      result = begin
-        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) || {}
+      metadata_key = @metadata.respond_to?(:cache_key) ? @metadata.cache_key : @metadata.gem_name
+      cache_key = "sections-v4-#{metadata_key}"
+      serialized = if cache_only
+        Cache.peek(cache_key)
+      else
+        Cache.fetch(cache_key, force: force_refresh) do
+          JSON.generate(compute_sections(force_refresh: force_refresh))
+        end
+      end
 
-        s = merge_section_sources(changelog_sections, github_sections)
+      result = if serialized
+        decode_sections(serialized)
+      elsif cache_only
+        nil
+      else
+        compute_sections(force_refresh: force_refresh)
+      end
 
-        pp @@candidates_found if Gemstar.debug? && !cache_only
+      @sections = result unless cache_only
+      result
+    end
+
+    def sections_for_versions(versions, cache_only: false, force_refresh: false)
+      requested_versions = normalize_requested_versions(versions)
+      return {} if requested_versions.empty?
+
+      cached_sections = sections(cache_only: true) || {}
+      result = cached_sections.select { |version, _| requested_versions.include?(normalize_version_key(version)) }
+      return result if cache_only
 
-        s
+      changelog_sections = parse_changelog_sections(cache_only: false, force_refresh: force_refresh) || {}
+      changelog_sections.each do |version, lines|
+        result[version] ||= lines if requested_versions.include?(normalize_version_key(version))
+      end
+
+      repo_uri = @metadata&.repo_uri(cache_only: false, force_refresh: force_refresh)
+      if repo_uri&.include?("github.com")
+        missing_versions = requested_versions - result.keys.map { |version| normalize_version_key(version) }
+        missing_versions.each do |version|
+          specific_release = parse_specific_github_release_pages(
+            repo_uri,
+            version,
+            cache_only: false,
+            force_refresh: force_refresh
+          )
+          result.merge!(specific_release) if specific_release
+        end
       end
 
-      @sections = result unless cache_only
       result
     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) || {}
+
+      sections = merge_section_sources(changelog_sections, github_sections)
+
+      pp @@candidates_found if Gemstar.debug?
+
+      sections
+    end
+
+    def decode_sections(serialized)
+      JSON.parse(serialized)
+    rescue JSON::ParserError
+      nil
+    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?
@@ -64,6 +126,17 @@ module Gemstar
 
     private
 
+    def normalize_requested_versions(versions)
+      Array(versions).filter_map { |version| normalize_version_key(version) }.uniq
+    end
+
+    def normalize_version_key(version)
+      value = version.to_s.strip
+      return nil if value.empty?
+
+      value.sub(/\Av/i, "")
+    end
+
     # Extract a version token from a heading line, preferring explicit version forms
     # and avoiding returning a date string when both are present.
     def extract_version_from_heading(line)
@@ -88,30 +161,11 @@ module Gemstar
       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}
-        base = "https://raw.githubusercontent.com/aws/aws-sdk-ruby/refs/heads/version-3/gems/#{@metadata.gem_name}"
-        aws_style = true
-      else
-        base = repo_uri.sub("https://github.com", "https://raw.githubusercontent.com")
-        aws_style = false
-      end
-
-      base = base.chomp("/")
+      changelog_source = metadata_changelog_source(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
+      return [] unless changelog_source
 
-      paths = aws_style ? ["CHANGELOG.md"] : %w[
-        CHANGELOG.md releases.md CHANGES.md
-        Changelog.md changelog.md ChangeLog.md
-        Changes.md changes.md
-        HISTORY.md History.md history.md
-        History CHANGELOG.rdoc
-      ]
-
-      remote_repository = RemoteRepository.new(base)
-
-      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}"
+      candidates += changelog_source[:paths].product(changelog_source[:branches]).map do |file, branch|
+        [changelog_source[:base], branch, file].reject { |segment| segment.to_s.empty? }.join("/")
       end
 
       # Add the gem's changelog_uri last as it's usually not the most parsable:
@@ -125,6 +179,19 @@ module Gemstar
       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)
+      end
+
+      base = repo_uri.sub("https://github.com", "https://raw.githubusercontent.com").chomp("/")
+      {
+        base: base,
+        paths: DEFAULT_CHANGELOG_PATHS,
+        branches: RemoteRepository.new(base).find_main_branch(cache_only: cache_only, force_refresh: force_refresh)
+      }
+    end
+
     def fetch_changelog_content(cache_only: false, force_refresh: false)
       content = nil
 
@@ -269,6 +336,7 @@ module Gemstar
         heading = sec.at_css('h2.sr-only')
         next unless heading
         text = heading.text.to_s.strip
+        next unless github_tag_matches_metadata?(text)
         next unless text[/v?(\d[\w.\-]+)/i]
         version = $1
 
@@ -292,6 +360,7 @@ module Gemstar
           link = container.at_xpath('ancestor::*[self::section or self::div][.//a[contains(@href, "/releases/tag/")]][1]//a[contains(@href, "/releases/tag/")]')
           text = link&.text.to_s
           text = File.basename(URI(link["href"]).path) if (text.nil? || text.empty?) && link
+          next unless github_tag_matches_metadata?(text)
           next unless text && text[/v?(\d[\w.\-]+)/i]
           version = $1
 
@@ -316,6 +385,13 @@ module Gemstar
           force_refresh: force_refresh
         )
         sections = tag_sections.merge(current_release_sections)
+      elsif discover_github_tag_sections?
+        tag_sections = parse_github_tag_sections(
+          repo_uri,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        sections = tag_sections.merge(sections)
       end
 
       if Gemstar.debug?
@@ -436,6 +512,7 @@ module Gemstar
             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?
@@ -490,21 +567,34 @@ module Gemstar
 
     def github_release_tag_urls(repo_url, version)
       github_tag_candidates(version).map do |tag|
-        "#{repo_url}/releases/tag/#{tag}"
+        encoded_tag = URI.encode_www_form_component(tag)
+        "#{repo_url}/releases/tag/#{encoded_tag}"
       end.uniq
     end
 
     def github_tag_candidates(version)
+      return @metadata.github_tag_candidates(version) if @metadata.respond_to?(:github_tag_candidates)
+
       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 = decoded.match(/\A(?:.+@)?v?(\d[\w.\-]*)\z/i)
       match && match[1]
     end
 
+    def github_tag_matches_metadata?(tag_name)
+      return @metadata.github_tag_matches?(tag_name) if @metadata.respond_to?(:github_tag_matches?)
+
+      true
+    end
+
+    def discover_github_tag_sections?
+      @metadata.respond_to?(:discover_github_tag_sections?) && @metadata.discover_github_tag_sections?
+    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)

data/lib/gemstar/cli.rb

@@ -13,6 +13,9 @@ module Gemstar
     desc "diff", "Show changelogs for updated gems"
     method_option :from, type: :string, desc: "Git ref or lockfile"
     method_option :to, type: :string, desc: "Git ref or lockfile"
+    method_option :since, type: :string, desc: "Set --from to the latest commit before this relative time (for example: '3 weeks')"
+    method_option :project, type: :string, desc: "Project directory or supported project file path"
+    method_option :ecosystem, type: :string, desc: "Filter packages by ecosystem (all, gems, js)"
     method_option :format, type: :string, desc: "Output format (html or markdown)"
     method_option :output_file, type: :string, desc: "Output file path"
     method_option :debug_gem_regex, type: :string, desc: "Debug matching gems", hide: true
@@ -22,9 +25,10 @@ module Gemstar
 
     desc "server", "Start the interactive web server"
     method_option :bind, type: :string, default: "127.0.0.1", desc: "Bind address"
-    method_option :port, type: :numeric, default: 2112, desc: "Port"
+    method_option :port, type: :numeric, desc: "Port (default: 2112; auto-increments when omitted)"
     method_option :project, type: :string, repeatable: true, desc: "Project directories or Gemfile paths"
     method_option :reload, type: :boolean, default: false, desc: "Restart automatically when files change"
+    method_option :open, type: :boolean, default: false, desc: "Open the server root in a browser after startup"
     def server
       Gemstar::Commands::Server.new(options).run
     end