gemstar 1.1.1 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba5f74f93dc292f713a6f5d1a824cc04d7601fffac736f075c75f08ea769ff7
-  data.tar.gz: f13a06cba387d9ae4ec744ed6e9703bbe8c1aea95cd8f27ab2f4efd816af33d6
+  metadata.gz: 6eab7d36aeffe59f5863dffb07696c7ed8aab64dfb8828ae962122d607ad0b28
+  data.tar.gz: 9120441dae108fb6ff9d9a009cb9e6988349b884f011c40037460a86c45ef42a
 SHA512:
-  metadata.gz: e45c7adfbfae8779801141084c0097d57be63415398c1a1b695a090042aa1c8fc6c94764275963aca7ef361de4e63f38f39a172b5158814282cd43ce865f5556
-  data.tar.gz: ad082b18db97c9f7a1a1c74de309fad18ca282cdd41c42918b27818b7bcc6da895fc9320660f35a0546028b75ed56726a5a545b7e709f4eb82d9a49237f938f5
+  metadata.gz: 5857f33b3a6b36759b2978b768749d7240f8ce54c73e57c48bce10ca407db846a955b80ba7c93d5db2a03bccbc6cb964ee55759ed4d75deb6982e23da681f5c8
+  data.tar.gz: 61dc580cfbb69aca3535428107a299833343ad132bb5e437cc01380ae4d58d90d525498818aed462793b036348e9f3666d83d8c6a7d2b821b62313f52c289381

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Change Log
 
+## 1.3
+
+- **Python uv projects** are now supported with our new `uv.lock` file parser and pypi package support!
+- **Rust Cargo projects** are now supported with a new `Cargo.lock` parser and crates.io package support!
+- Changelogs in rst format are now supported.
+- Changelogs: Fix parsing of documentation percentages, linked version headings, and version-first headings with dotted dates.
+- Changelogs: Do not treat version-looking prose inside release notes as a new release heading.
+- Changelogs: Prefer repository-branch changelogs when gem metadata points to a release-pinned file that may omit its own release.
+- Changelogs: Discover extensionless changelog files and direct GitHub changelog links, including Roda and Selenium release histories.
+- Changelogs: Correct known upstream release-heading typos through package metadata, including Thruster 0.1.23.
+- Server: Sort changelog cards with semantic version comparison so Selenium's `4.x` releases appear ahead of `3.142.x` and `3.141.x`.
+- Server: Render linked changelog version headings without Markdown brackets.
+- Server: Keep the details focus ring visible around its sticky header.
+- Server: Keep keyboard-selected sidebar packages visible below the sticky filter header.
+- Documentation: List Python package support in the README and gem metadata.
+- Server: Details heading is now sticky.
+- Server: Changed display of available versions to be more clear and concise.
+- CLI: Improve message shown when no supported project files are found.
+- CLI: Add `--version` to print the Gemstar version.
+
+## 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.

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
-Helps you keep track of your gems and JavaScript packages.
+Helps you keep track of your Ruby gems, JavaScript packages, Python packages, and Rust crates.
 
 ## Installation
 
@@ -72,7 +72,7 @@ To examine a specific Gemfile.lock, pass it like this:
 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:
+To diff a project from anywhere, pass the project directory or a supported project file. In project mode, gemstar includes Ruby gems, JS packages from `importmap.rb` and `package-lock.json`, Python packages from `uv.lock`, and Rust crates from `Cargo.lock` when present:
 
 ```shell
 gemstar diff --project ~/Code/my-app
@@ -83,6 +83,8 @@ 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
+gemstar diff --project ~/Code/my-app --ecosystem python
+gemstar diff --project ~/Code/my-app --ecosystem cargo
 ```
 
 To write markdown instead of html:

data/lib/gemstar/cache_warmer.rb

@@ -1,14 +1,17 @@
 require "set"
 require "thread"
+require_relative "crates_io_metadata"
+require_relative "pypi_metadata"
 
 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 = []
@@ -17,14 +20,19 @@ module Gemstar
       @completed = Set.new
       @workers = []
       @started = false
+      @stopping = false
       @total = 0
       @completed_count = 0
     end
 
+    attr_writer :detail_cache_fetcher
+
     def enqueue_many(package_states)
       states = normalize_package_states(package_states)
 
       @mutex.synchronize do
+        return self if @stopping
+
         states.each do |package_state|
           key = package_key(package_state)
           next if @completed.include?(key) || @queued.include?(key) || @in_progress.include?(key)
@@ -71,6 +79,28 @@ module Gemstar
       @condition.broadcast
     end
 
+    def shutdown(timeout: 0.5)
+      workers = nil
+
+      @mutex.synchronize do
+        @stopping = true
+        @queue.clear
+        @queued.clear
+        @condition.broadcast
+        workers = @workers.dup
+      end
+
+      workers.each do |worker|
+        worker.join(timeout)
+        worker.kill if worker.alive?
+      end
+
+      @mutex.synchronize do
+        @workers.clear
+        @started = false
+      end
+    end
+
     def pending?(package_name)
       @mutex.synchronize do
         @queue.any? { |item| item[:name] == package_name || item.dig(:source, :package_name) == package_name } ||
@@ -94,9 +124,10 @@ module Gemstar
 
       loop do
         package_state = @mutex.synchronize do
-          while @queue.empty?
+          while @queue.empty? && !@stopping
             @condition.wait(@mutex)
           end
+          return if @stopping && @queue.empty?
 
           next_package = @queue.shift
           key = package_key(next_package)
@@ -120,13 +151,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?
@@ -168,6 +208,13 @@ module Gemstar
     end
 
     def metadata_adapter_for(package_state)
+      if package_state[:package_scope] == "cargo"
+        package_name = package_state[:metadata_package_name] || package_state.dig(:source, :package_name) || package_state[:name]
+        return Gemstar::CratesIOMetadata.new(package_name)
+      end
+
+      return Gemstar::PyPIMetadata.new(package_state[:name]) if package_state[:package_scope] == "python"
+
       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?

data/lib/gemstar/cargo_lock_file.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Gemstar
+  class CargoLockFile
+    attr_reader :specs
+    attr_reader :spec_sources
+
+    def initialize(path: nil, content: nil)
+      parsed = parse_content(content || File.read(path))
+      @specs = parsed[:specs]
+      @spec_sources = parsed[:spec_sources]
+    end
+
+    def source_for(name)
+      spec_sources[name]
+    end
+
+    private
+
+    def parse_content(content)
+      packages = package_blocks(content).filter_map do |block|
+        name = scalar_value(block, "name")
+        version = scalar_value(block, "version")
+        source = scalar_value(block, "source")
+        next if name.to_s.empty? || version.to_s.empty?
+        next if source.to_s.empty?
+
+        {
+          name: name,
+          version: version,
+          source: source_for_package(source, name, version)
+        }
+      end
+
+      specs = {}
+      spec_sources = {}
+      packages.group_by { |package| package[:name] }.each_value do |named_packages|
+        sorted_packages(named_packages).each_with_index do |package, index|
+          key = package_key(package, index, named_packages.length)
+          specs[key] = package[:version]
+          spec_sources[key] = package[:source]
+        end
+      end
+
+      {specs: specs, spec_sources: spec_sources}
+    end
+
+    def package_blocks(content)
+      content.to_s.split(/^\[\[package\]\]\s*$/).drop(1)
+    end
+
+    def scalar_value(block, key)
+      block[/^#{Regexp.escape(key)}\s*=\s*"((?:\\.|[^"])*)"/, 1]&.gsub('\\"', '"')
+    end
+
+    def source_for_package(raw_source, name, version)
+      if raw_source.start_with?("git+")
+        git_source(raw_source, name, version)
+      else
+        registry_source(raw_source, name, version)
+      end
+    end
+
+    def git_source(raw_source, name, version)
+      remote_with_query, revision = raw_source.delete_prefix("git+").split("#", 2)
+      remote, query = remote_with_query.split("?", 2)
+      params = URI.decode_www_form(query.to_s).to_h
+
+      {
+        type: :git,
+        remote: remote,
+        revision: revision,
+        branch: params["branch"],
+        tag: params["tag"],
+        package_name: name,
+        package_version: version
+      }.compact
+    rescue ArgumentError
+      {
+        type: :git,
+        remote: raw_source.delete_prefix("git+").split(/[?#]/, 2).first,
+        revision: raw_source.split("#", 2)[1],
+        package_name: name,
+        package_version: version
+      }.compact
+    end
+
+    def registry_source(raw_source, name, version)
+      registry = raw_source.sub(/\A(?:registry|sparse)\+/, "")
+      crates_io = crates_io_registry?(registry)
+
+      {
+        type: :cargo,
+        remote: registry,
+        package_name: name,
+        package_version: version,
+        registry_url: crates_io ? "https://crates.io/crates/#{name}" : registry,
+        crates_io: crates_io
+      }
+    end
+
+    def crates_io_registry?(registry)
+      registry.include?("crates.io-index") || registry.include?("index.crates.io")
+    end
+
+    def sorted_packages(packages)
+      packages.sort do |left, right|
+        comparison = compare_versions(right[:version], left[:version])
+        comparison.zero? ? left[:source].to_s <=> right[:source].to_s : comparison
+      end
+    end
+
+    def compare_versions(left, right)
+      Gem::Version.new(left) <=> Gem::Version.new(right)
+    rescue ArgumentError
+      left.to_s <=> right.to_s
+    end
+
+    def package_key(package, index, package_count)
+      return package[:name] if package_count == 1
+
+      key = "#{package[:name]}@#{package[:version]}"
+      if index.zero? || !@used_package_keys&.include?(key)
+        remember_package_key(key)
+      else
+        remember_package_key("#{key}:#{index + 1}")
+      end
+    end
+
+    def remember_package_key(key)
+      @used_package_keys ||= []
+      @used_package_keys << key
+      key
+    end
+  end
+end