gemstar 0.0.1 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80dede87ff46bc8aefd962ccd46dffcb199357eca04173b9610f85e74c74111a
-  data.tar.gz: dfd221d5ec0cdd3c3511fdd1e7980fb8bc00050afab9d69cdb81c43d1673fee6
+  metadata.gz: 65596efbc0ff5c10ad950ca3cc8bb19e9ca9030db58b73d046ebce447200aa07
+  data.tar.gz: e5ab0cbb7f3db4b3d9949011f3b6446aecb725ee1863fd61dd196660332606de
 SHA512:
-  metadata.gz: 4d160d053c3e60ef38d7b129876159a2d696015857d917f1dceb82afcd3e648d8e5736232535a9d79ef84e11681591019245317f5f15c3d7b24d06292e6c15f7
-  data.tar.gz: bcadfa71fac1e0be9c6777217cba5797e729ead523383a7f049984e47f9b9c24952cb9ae2d7a4eb7f03615cc8f4aeaafa13961cbedcfde9dd94684d601bcb0f2
+  metadata.gz: ef75cdf526345f289eff5f0a8bff44520eb1d0aea55eff617de71d585832721655fd70c680e0e27ef7584c15dd4f304d9ee3b079c70fbafc7e4ccc5c8360c4ad
+  data.tar.gz: 13e3d871e1772c7f8ec183a3801504123896e8bd5365bba2a3e6fae5668415dcf2a40ef29f3494a2e9bef47251a3b913c37ae122879c3e8367cba9cf4490af1e

data/CHANGELOG.md

@@ -1,19 +1,19 @@
 # Change Log
 
-## TODO
-- Diff:
-    - Gems:
-        - benchmark
-        - brakeman
-        - json (not using CHANGES.md?)
-        - nio4r not using releases.md?
-        - parser not using CHANGELOG.md?
-        - actioncable-next uses release tag names?
-        - paper_trail not using CHANGELOG.md?
-        - playwright-ruby-client uses release tags?
-    - support ```ruby ```
+## Unreleased
 
-## 0.1
+- Added `gemstar server`, your interactive Gemfile.lock explorer and more.
+- Default location for `diff` is now a tmp file.
+- Removed Railtie from this gem.
+- Improve how git root dir is determined.
+
+
+## 0.0.2
+
+- Diff: Fix regex warnings shown in terminal.
+- Diff: Simplify and fix change log section parsing.
+
+## 0.0.1
 
 - Initial release
 - Add GEMSTAR_DEBUG_GEM_REGEX to debug specific gems.

data/README.md

@@ -7,32 +7,41 @@ A very preliminary gem to help you keep track of your gems.
 
 ## Installation
 
-Until it's released on RubyGems, you can install it from GitHub:
+The easiest way to install gemstar is to use Bundler:
 
 ```shell
 # Shell
-gem install specific_install
-gem specific_install -l https://github.com/FDj/gemstar.git
+gem install gemstar
 ```
 
-Or adding to your project:
+Alternatively, add it to the development group in your Gemfile:
 
-```ruby
-# Gemfile
-group :development do
-  gem "gemstar", github: "FDj/gemstar"
-end
+```
+gem "gemstar", group: :development
 ```
 
 ## Usage
 
-### `gemstar diff`
+### gemstar server
+
+![Gemstar diff command output](docs/server.png)
+
+Start the interactive web UI:
+
+```shell
+gemstar server
+```
+
+By default, the server listens to http://127.0.0.1:2112/
+
+
+### gemstar diff
 
 Run this after you've updated your gems.
 
 ```shell
-# in your project directory:
-bundle exec gemstar diff
+# 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:
@@ -42,7 +51,13 @@ This will generate an html diff report with changelog entries for each gem that
 You can also specify from and to hashes or tags to generate a diff report for a specific range of commits:
 
 ```shell
-bundle exec gemstar diff --from 8e3aa96b7027834cdbabc0d8cbd5f9455165e930 --to HEAD
+gemstar diff --from 8e3aa96b7027834cdbabc0d8cbd5f9455165e930 --to HEAD
+```
+
+To examine a specific Gemfile.lock, pass it like this:
+
+```shell
+gemstar diff --lockfile=~/MyProject/Gemfile.lock
 ```
 
 ## Contributing

data/lib/gemstar/cache.rb

@@ -1,10 +1,11 @@
+require_relative "config"
 require "fileutils"
 require "digest"
 
 module Gemstar
   class Cache
     MAX_CACHE_AGE = 60 * 60 * 24 * 7 # 1 week
-    CACHE_DIR = ".gem_changelog_cache"
+    CACHE_DIR = File.join(Gemstar::Config.home_directory, "cache")
 
     @@initialized = false
 
@@ -18,15 +19,12 @@ module Gemstar
     def self.fetch(key, &block)
       init
 
-      path = File.join(CACHE_DIR, Digest::SHA256.hexdigest(key))
+      path = path_for(key)
 
-      if File.exist?(path)
-        age = Time.now - File.mtime(path)
-        if age <= MAX_CACHE_AGE
-          content = File.read(path)
-          return nil if content == "__404__"
-          return content
-        end
+      if fresh?(path)
+        content = File.read(path)
+        return nil if content == "__404__"
+        return content
       end
 
       begin
@@ -39,11 +37,50 @@ module Gemstar
       end
     end
 
+    def self.peek(key)
+      init
+
+      path = path_for(key)
+      return nil unless fresh?(path)
+
+      content = File.read(path)
+      return nil if content == "__404__"
+
+      content
+    end
+
+    def self.path_for(key)
+      File.join(CACHE_DIR, Digest::SHA256.hexdigest(key))
+    end
+
+    def self.fresh?(path)
+      return false unless File.exist?(path)
+
+      (Time.now - File.mtime(path)) <= MAX_CACHE_AGE
+    end
+
+    def self.flush!
+      init
+
+      flush_directory(CACHE_DIR)
+    end
+
+    def self.flush_directory(directory)
+      return 0 unless Dir.exist?(directory)
+
+      entries = Dir.children(directory)
+      entries.each do |entry|
+        FileUtils.rm_rf(File.join(directory, entry))
+      end
+
+      entries.count
+    end
+
   end
 
   def edit_gitignore
     gitignore_path = ".gitignore"
-    ignore_entries = %w[.gem_changelog_cache/ gem_update_changelog.html]
+    ignore_entries = %w[gem_update_changelog.html]
 
     existing_lines = File.exist?(gitignore_path) ? File.read(gitignore_path).lines.map(&:chomp) : []
 

data/lib/gemstar/cache_cli.rb

@@ -0,0 +1,12 @@
+require "thor"
+
+module Gemstar
+  class CacheCLI < Thor
+    package_name "gemstar cache"
+
+    desc "flush", "Clear all gemstar cache entries"
+    def flush
+      Gemstar::Commands::Cache.new({}).flush
+    end
+  end
+end

data/lib/gemstar/cache_warmer.rb

@@ -0,0 +1,120 @@
+require "set"
+require "thread"
+
+module Gemstar
+  class CacheWarmer
+    DEFAULT_THREADS = 10
+
+    def initialize(io: $stderr, debug: false, thread_count: DEFAULT_THREADS)
+      @io = io
+      @debug = debug
+      @thread_count = thread_count
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @queue = []
+      @queued = Set.new
+      @in_progress = Set.new
+      @completed = Set.new
+      @workers = []
+      @started = false
+      @total = 0
+      @completed_count = 0
+    end
+
+    def enqueue_many(gem_names)
+      names = gem_names.uniq
+
+      @mutex.synchronize do
+        names.each do |gem_name|
+          next if @completed.include?(gem_name) || @queued.include?(gem_name) || @in_progress.include?(gem_name)
+
+          @queue << gem_name
+          @queued << gem_name
+        end
+        @total += names.count
+        start_workers_unlocked unless @started
+      end
+
+      log "Background cache refresh queued for #{names.count} gems."
+      @condition.broadcast
+      self
+    end
+
+    def prioritize(gem_name)
+      @mutex.synchronize do
+        return if @completed.include?(gem_name) || @in_progress.include?(gem_name)
+
+        if @queued.include?(gem_name)
+          @queue.delete(gem_name)
+        else
+          @queued << gem_name
+          @total += 1
+        end
+
+        @queue.unshift(gem_name)
+        start_workers_unlocked unless @started
+      end
+
+      log "Prioritized #{gem_name}"
+      @condition.broadcast
+    end
+
+    private
+
+    def start_workers_unlocked
+      return if @started
+
+      @started = true
+      @thread_count.times do
+        @workers << Thread.new { worker_loop }
+      end
+    end
+
+    def worker_loop
+      Thread.current.name = "gemstar-cache-worker" if Thread.current.respond_to?(:name=)
+
+      loop do
+        gem_name = @mutex.synchronize do
+          while @queue.empty?
+            @condition.wait(@mutex)
+          end
+
+          next_gem = @queue.shift
+          @queued.delete(next_gem)
+          @in_progress << next_gem
+          next_gem
+        end
+
+        warm_cache_for_gem(gem_name)
+
+        current = @mutex.synchronize do
+          @in_progress.delete(gem_name)
+          @completed << gem_name
+          @completed_count += 1
+        end
+
+        log_progress(gem_name, 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
+    rescue StandardError => e
+      log "Cache refresh failed for #{gem_name}: #{e.class}: #{e.message}"
+    end
+
+    def log_progress(gem_name, current)
+      return unless @debug
+      return unless current <= 5 || (current % 25).zero?
+
+      log "Background cache refresh #{current}/#{@total}: #{gem_name}"
+    end
+
+    def log(message)
+      @io.puts(message)
+    end
+  end
+end

data/lib/gemstar/change_log.rb

@@ -10,21 +10,30 @@ module Gemstar
 
     attr_reader :metadata
 
-    def content
-      @content ||= fetch_changelog_content
+    def content(cache_only: false)
+      return @content if !cache_only && defined?(@content)
+
+      result = fetch_changelog_content(cache_only: cache_only)
+      @content = result unless cache_only
+      result
     end
 
-    def sections
-      @sections ||= begin
-        s = parse_changelog_sections
+    def sections(cache_only: false)
+      return @sections if !cache_only && defined?(@sections)
+
+      result = begin
+        s = parse_changelog_sections(cache_only: cache_only)
         if s.nil? || s.empty?
-          s = parse_github_release_sections
+          s = parse_github_release_sections(cache_only: cache_only)
         end
 
-        pp @@candidates_found if Gemstar.debug?
+        pp @@candidates_found if Gemstar.debug? && !cache_only
 
         s
       end
+
+      @sections = result unless cache_only
+      result
     end
 
     def extract_relevant_sections(old_version, new_version)
@@ -52,23 +61,30 @@ module Gemstar
     def extract_version_from_heading(line)
       return nil unless line
       heading = line.to_s
+      version_token = /(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)/
       # 1) Prefer version inside parentheses after a date: "### 2025-11-07 (2.16.0)"
-      return $1 if heading[/\(\s*v?(\d[\w.\-]+)\s*\)/]
+      #    Ensure we ONLY treat it as a version if it actually looks like a version (has a dot),
+      #    so we don't capture dates like (2025-11-21).
+      return $1 if heading[/\(\s*v?#{version_token}(?![A-Za-z0-9])\s*\)/]
       # 2) Version-first with optional leading markers/labels: "## v1.2.6 - 2025-10-21"
-      return $1 if heading[/^\s*(?:#+|=+)?\s*(?:Version\s+)?\[?v?(\d[\w.\-]+)\]?/i]
+      #    Require a dot in the numeric token to avoid capturing dates like 2025-11-21.
+      return $1 if heading[/^\s*(?:[-*]\s+)?(?:#+|=+)?\s*(?:Version\s+)?\[*v?#{version_token}(?![A-Za-z0-9])\]*/i]
       # 3) Anywhere: first semver-like token with a dot
-      return $1 if heading[/\bv?(\d+\.\d+(?:\.\d+)?(?:[A-Za-z0-9.\-]+)?)\b/]
+      return $1 if heading[/\bv?#{version_token}(?![A-Za-z0-9])\b/]
       nil
     end
 
-    def changelog_uri_candidates
+    def changelog_uri_candidates(cache_only: false)
       candidates = []
 
-      if @metadata.repo_uri =~ %r{https://github\.com/aws/aws-sdk-ruby}
+      repo_uri = @metadata.repo_uri(cache_only: cache_only)
+      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 = @metadata.repo_uri.sub("https://github.com", "https://raw.githubusercontent.com")
+        base = repo_uri.sub("https://github.com", "https://raw.githubusercontent.com")
         aws_style = false
       end
 
@@ -91,7 +107,8 @@ module Gemstar
       end
 
       # Add the gem's changelog_uri last as it's usually not the most parsable:
-      candidates += [Gemstar::GitHub::github_blob_to_raw(@metadata.meta["changelog_uri"])]
+      meta = @metadata.meta(cache_only: cache_only)
+      candidates += [Gemstar::GitHub::github_blob_to_raw(meta["changelog_uri"])] if meta
 
       candidates.flatten!
       candidates.uniq!
@@ -100,15 +117,19 @@ module Gemstar
       candidates
     end
 
-    def fetch_changelog_content
+    def fetch_changelog_content(cache_only: false)
       content = nil
 
-      changelog_uri_candidates.find do |candidate|
-        content = Cache.fetch("changelog-#{candidate}") do
-          URI.open(candidate, read_timeout: 8)&.read
-        rescue => e
-          puts "#{candidate}: #{e}" if Gemstar.debug?
-          nil
+      changelog_uri_candidates(cache_only: cache_only).find do |candidate|
+        content = if cache_only
+          Cache.peek("changelog-#{candidate}")
+        else
+          Cache.fetch("changelog-#{candidate}") do
+            URI.open(candidate, read_timeout: 8)&.read
+          rescue => e
+            puts "#{candidate}: #{e}" if Gemstar.debug?
+            nil
+          end
         end
 
         # puts "fetch_changelog_content #{candidate}:\n#{content}" if Gemstar.debug?
@@ -123,12 +144,19 @@ module Gemstar
       content
     end
 
+    VERSION_PATTERNS = [
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\s*\)/, # prefer this
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/,
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*(?:\s*[-(].*)?/i,
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*(?:\s*[-(].*)?/i,
+      /^\s*(?:[-*]\s+)?(?:Version\s+)?v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])(?:\s*[-(].*)?/i
+    ]
 
-    def parse_changelog_sections
+    def parse_changelog_sections(cache_only: 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
+      c = content(cache_only: cache_only)
       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/"))
@@ -136,108 +164,44 @@ module Gemstar
         return {}
       end
 
+      lines = c.lines
+
+      if lines.count < 4
+        # Skip changelog files that are too short to be useful
+        # This is sometimes the case with changelogs just saying "please see GitHub releases"
+        puts "parse_changelog_sections #{@metadata.gem_name}: Changelog too short; skipping" if Gemstar.debug?
+        return {}
+      end
+
       sections = {}
       current_key = nil
       current_lines = []
 
-      flush_current = lambda do
-        return unless current_key && !current_lines.empty?
-        key = current_key
-        # If key looks like a date or non-version, try to extract a proper version
-        if key =~ /\A\d{4}-\d{2}-\d{2}\z/ || key !~ /\A\d[\w.\-]*\z/
-          v = extract_version_from_heading(current_lines.first)
-          key = v if v
-        end
-        if sections.key?(key)
-          # Collision: merge by appending with a separator to avoid losing data
-          sections[key] += ["\n"] + current_lines
-        else
-          sections[key] = current_lines.dup
-        end
-      end
-
-      c.each_line do |line|
+      lines.each do |line|
         # Convert rdoc to markdown:
         line = line.gsub(/^=+/) { |m| "#" * m.length }
 
-        new_key = nil
-        # Keep-a-Changelog style: version first with trailing date, e.g. "## v1.2.6 - 2025-10-21"
-        if line =~ /^\s*(?:#+|=+)\s*\[?v?(\d[\w.\-]+)\]?\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/
-          new_key = extract_version_from_heading(line) || $1
-        elsif line =~ /^\s*(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[?v?(\d[\w.\-]+)\]?(?:\s*[-(].*)?/i
-          new_key = extract_version_from_heading(line) || $1
-        elsif line =~ /^\s*(?:#+|=+)\s*(?:Version\s+)?\[?v?(\d[\w.\-]+)\]?(?:\s*[-(].*)?/i
-          # header without label words before the version
-          new_key = extract_version_from_heading(line) || $1
-        elsif line =~ /^\s*(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d[\w.\-]+)\s*\)/
-          # headings like "### 2025-11-07 (2.16.0)" — prefer the version in parentheses over the leading date
-          new_key = extract_version_from_heading(line) || $1
-        elsif line =~ /^\s*(?:Version\s+)?v?(\d[\w.\-]+)(?:\s*[-(].*)?/i
-          # fallback for lines like "1.4.0 (2025-06-02)"
+        m = VERSION_PATTERNS.lazy.map { |re| line.match(re) }.find(&:itself)
+
+        if m
           new_key = extract_version_from_heading(line) || $1
-        end
 
-        if new_key
-          # Flush previous section before starting a new one
-          flush_current.call
+          if current_key
+            sections[current_key] ||= []
+            sections[current_key] << current_lines
+            current_lines = []
+          end
+
           current_key = new_key
-          current_lines = [line]
-        elsif current_key
-          current_lines << line
         end
-      end
 
-      # Flush the last captured section
-      flush_current.call
+        current_lines << line if current_key
+      end
 
-      # Normalize keys: ensure all keys are versions; fix any leftover date-like keys conservatively
-      begin
-        normalized = {}
-        sections.each do |k, lines|
-          if k =~ /\A\d{4}-\d{2}-\d{2}\z/ || k !~ /\A\d[\w.\-]*\z/
-            heading = lines.first.to_s
-            # 1) Prefer version inside parentheses, e.g., "### 2025-11-07 (2.16.0)"
-            if heading[/\(\s*v?(\d[\w.\-]+)\s*\)/]
-              key = $1
-              normalized[key] = if normalized.key?(key)
-                                   normalized[key] + ["\n"] + lines
-                                 else
-                                   lines
-                                 end
-              next
-            end
-            # 2) Headings like "## v1.2.5 - 2025-10-21" or "## 1.2.5 — 2025-10-21"
-            if heading[/^\s*(?:#+|=+)\s*(?:Version\s+)?\[?v?(\d+\.\d+(?:\.\d+)?(?:[A-Za-z0-9.\-]+)?)\]?/]
-              key = $1
-              normalized[key] = if normalized.key?(key)
-                                   normalized[key] + ["\n"] + lines
-                                 else
-                                   lines
-                                 end
-              next
-            end
-            # 3) Anywhere in the heading, pick the first semver-like token with a dot
-            if heading[/\bv?(\d+\.\d+(?:\.\d+)?(?:[A-Za-z0-9.\-]+)?)\b/]
-              key = $1
-              normalized[key] = if normalized.key?(key)
-                                   normalized[key] + ["\n"] + lines
-                                 else
-                                   lines
-                                 end
-              next
-            end
-          end
-          # Default: carry over, merging on collision to avoid loss
-          if normalized.key?(k)
-            normalized[k] += ["\n"] + lines
-          else
-            normalized[k] = lines
-          end
-        end
-        sections = normalized unless normalized.empty?
-      rescue => e
-        # Be conservative; if normalization fails for any reason, keep original sections
-        puts "Normalization error in parse_changelog_sections: #{e}" if Gemstar.debug?
+      if current_key
+        # Flush last section
+        sections[current_key] ||= []
+        sections[current_key] << current_lines
       end
 
       if Gemstar.debug?
@@ -248,34 +212,47 @@ module Gemstar
       sections
     end
 
-    def parse_github_release_sections
+    def parse_github_release_sections(cache_only: false)
       begin
         require "nokogiri"
       rescue LoadError
         return {}
       end
 
-      return {} unless @metadata&.repo_uri&.include?("github.com")
+      repo_uri = @metadata&.repo_uri(cache_only: cache_only)
+      return {} unless repo_uri&.include?("github.com")
 
-      url = github_releases_url
+      url = github_releases_url(repo_uri)
       return {} unless url
 
-      html = Cache.fetch("releases-#{url}") do
-        begin
-          URI.open(url, read_timeout: 8)&.read
-        rescue => e
-          puts "#{url}: #{e}" if Gemstar.debug?
-          nil
+      html = if cache_only
+        Cache.peek("releases-#{url}")
+      else
+        Cache.fetch("releases-#{url}") do
+          begin
+            URI.open(url, read_timeout: 8)&.read
+          rescue => e
+            puts "#{url}: #{e}" if Gemstar.debug?
+            nil
+          end
+        end
+      end
+
+      if (html.nil? || html.strip.empty?) && cache_only
+        cached_content = content(cache_only: true)
+        if cached_content&.include?("<html") &&
+           (cached_content.include?('data-test-selector="body-content"') || cached_content.include?("/releases/tag/"))
+          html = cached_content
         end
       end
 
       return {} if html.nil? || html.strip.empty?
 
       doc = begin
-        Nokogiri::HTML5(html)
-      rescue => _
-        Nokogiri::HTML(html)
-      end
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
 
       sections = {}
 
@@ -325,9 +302,9 @@ module Gemstar
       sections
     end
 
-    def github_releases_url
-      return nil unless @metadata&.repo_uri
-      repo = @metadata.repo_uri.chomp("/")
+    def github_releases_url(repo_uri = @metadata&.repo_uri)
+      return nil unless repo_uri
+      repo = repo_uri.chomp("/")
       return nil if repo.empty?
       "#{repo}/releases"
     end