gemstar 0.0.2 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9eeb335df1b34923f36572389fdf30489fd5e3d2b88e72e602d7cff4c9ace2b
-  data.tar.gz: 34c0bf38181ce5f9516967f94acc5ad08ae57230f7d5d6adadacf6d932860125
+  metadata.gz: 4c795357616121ccda76004c6fefa92194688472dd45950396c24a1924cf70a6
+  data.tar.gz: d4922547dc024c923d751164698da5b672c48fd4b2e61384345e0de24b1f5430
 SHA512:
-  metadata.gz: 23fad51445796f654d61318b33129d9a9f02136162982623aecafa0afa6271e9244bc6f272fb77e2ff049c944e44164018289be5306a124311c30340572eaf04
-  data.tar.gz: 436bb8487ba91671e6ab319775460c2b13f34d0873812edf3d0e429f8c6dba5707da5ed599033153fc86cd3bb276f04c227f8e4a029756b67c9b7989e6153484
+  metadata.gz: 6caf7c992dcccd533da3cbcf8ed1e98ee44538faffbdf43c55e1ecc1af899497c70100c62e1ba5bbe9331fba6c78d2a65a571c860f4035b99dc63f44d94cb682
+  data.tar.gz: 88e7f1557e01332a6d5dbd69301b0fcfb30548a80333d835476994a9b9ae92a5fdb8559bfa268d242ad11eaad266b432947277d52b185e40dcc66f166ee01854

data/CHANGELOG.md

@@ -1,21 +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?
-    - bundler itself
-    - use changelog files from installed gems where present
-
 ## Unreleased
 
+## 1.0.1
+
+- Added `--format markdown` to `gemstar diff` command. 
+
+## 1.0
+
+- 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.

data/README.md

@@ -22,6 +22,19 @@ gem "gemstar", group: :development
 
 ## Usage
 
+### 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.
@@ -47,6 +60,12 @@ To examine a specific Gemfile.lock, pass it like this:
 gemstar diff --lockfile=~/MyProject/Gemfile.lock
 ```
 
+To write markdown instead of html:
+
+```shell
+gemstar diff --format markdown
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at [https://github.com/FDj/gemstar](https://github.com/FDj/gemstar).

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
-                      if s.nil? || s.empty?
-                        s = parse_github_release_sections
-                      end
+    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(cache_only: cache_only)
+        end
+
+        pp @@candidates_found if Gemstar.debug? && !cache_only
 
-                      pp @@candidates_found if Gemstar.debug?
+        s
+      end
 
-                      s
-                    end
+      @sections = result unless cache_only
+      result
     end
 
     def extract_relevant_sections(old_version, new_version)
@@ -52,26 +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)"
       #    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?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\s*\)/]
+      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"
       #    Require a dot in the numeric token to avoid capturing dates like 2025-11-21.
-      return $1 if heading[/^\s*(?:#+|=+)?\s*(?:Version\s+)?\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?/i]
+      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
 
@@ -94,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!
@@ -103,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?
@@ -127,18 +145,18 @@ module Gemstar
     end
 
     VERSION_PATTERNS = [
-      /^\s*(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d[\w.\-]+)\s*\)/, # prefer this
-      /^\s*(?:#+|=+)\s*\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/,
-      /^\s*(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?(?:\s*[-(].*)?/i,
-      /^\s*(?:#+|=+)\s*(?:Version\s+)?\[?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)\]?(?:\s*[-(].*)?/i,
-      /^\s*(?:Version\s+)?v?(\d+\.\d+(?:\.\d+)?[A-Za-z0-9.\-]*)(?:\s*[-(].*)?/i
+      /^\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/"))
@@ -194,24 +212,37 @@ 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
 
@@ -271,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

data/lib/gemstar/cli.rb

@@ -13,12 +13,25 @@ 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 :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
     def diff
       Gemstar::Commands::Diff.new(options).run
     end
 
+    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 :project, type: :string, repeatable: true, desc: "Project directories or Gemfile paths"
+    method_option :reload, type: :boolean, default: false, desc: "Restart automatically when files change"
+    def server
+      Gemstar::Commands::Server.new(options).run
+    end
+
+    desc "cache SUBCOMMAND ...ARGS", "Manage gemstar caches"
+    subcommand "cache", Gemstar::CacheCLI
+
     # desc "pick", "Interactively cherry-pick and upgrade gems"
     # option :gem, type: :string, desc: "Gem name to cherry-pick"
     # def pick

data/lib/gemstar/commands/cache.rb

@@ -0,0 +1,12 @@
+require_relative "command"
+
+module Gemstar
+  module Commands
+    class Cache < Command
+      def flush
+        removed_entries = Gemstar::Cache.flush!
+        puts "Flushed #{removed_entries} cache entr#{removed_entries == 1 ? 'y' : 'ies'} from #{Gemstar::Cache::CACHE_DIR}"
+      end
+    end
+  end
+end

data/lib/gemstar/commands/diff.rb

@@ -2,7 +2,7 @@
 
 require_relative "command"
 require "concurrent-ruby"
-require "tempfile"
+require "tmpdir"
 
 module Gemstar
   module Commands
@@ -15,6 +15,7 @@ module Gemstar
       attr_reader :git_repo
       attr_reader :lockfile_full_path
       attr_reader :output_file
+      attr_reader :output_format
 
       def initialize(options)
         super
@@ -24,7 +25,8 @@ module Gemstar
         @from = options[:from] || "HEAD"
         @to = options[:to]
         @lockfile = options[:lockfile] || "Gemfile.lock"
-        @output_file = options[:output_file] || "gem_update_changelog.html"
+        @output_format = normalize_output_format(options[:format] || options[:output_format])
+        @output_file = options[:output_file] || default_output_file
 
         @git_repo = Gemstar::GitRepo.new(File.dirname(@lockfile))
       end
@@ -44,9 +46,9 @@ module Gemstar
 
         collect_updates(new_lockfile: new, old_lockfile: old)
 
-        html = Outputs::HTML.new.render_diff(self)
-        File.write(output_file, html)
-        puts "✅ gem_update_changelog.html created."
+        rendered_output = output_renderer.render_diff(self)
+        File.write(output_file, rendered_output)
+        puts "✅ Changelog report created: #{File.expand_path(output_file)}"
 
         if failed.any?
           puts "\n⚠️ The following gems failed to process:"
@@ -56,6 +58,27 @@ module Gemstar
 
       private
 
+      def normalize_output_format(value)
+        format = value.to_s.strip.downcase
+        return :markdown if %w[md markdown].include?(format)
+
+        :html
+      end
+
+      def default_output_file
+        extension = output_format == :markdown ? "md" : "html"
+        File.join(Dir.tmpdir, "gem_update_changelog.#{extension}")
+      end
+
+      def output_renderer
+        @output_renderer ||= case output_format
+        when :markdown
+          Outputs::Markdown.new
+        else
+          Outputs::HTML.new
+        end
+      end
+
       def build_entry(gem_name:, old_version:, new_version:)
         metadata = Gemstar::RubyGemsMetadata.new(gem_name)
         repo_url = metadata.repo_uri