gemstar 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 80dede87ff46bc8aefd962ccd46dffcb199357eca04173b9610f85e74c74111a
+  data.tar.gz: dfd221d5ec0cdd3c3511fdd1e7980fb8bc00050afab9d69cdb81c43d1673fee6
+SHA512:
+  metadata.gz: 4d160d053c3e60ef38d7b129876159a2d696015857d917f1dceb82afcd3e648d8e5736232535a9d79ef84e11681591019245317f5f15c3d7b24d06292e6c15f7
+  data.tar.gz: bcadfa71fac1e0be9c6777217cba5797e729ead523383a7f049984e47f9b9c24952cb9ae2d7a4eb7f03615cc8f4aeaafa13961cbedcfde9dd94684d601bcb0f2

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# 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 ```
+
+## 0.1
+
+- Initial release
+- Add GEMSTAR_DEBUG_GEM_REGEX to debug specific gems.
+- Refactor to work correctly with more gems.
+- Diff: More flexible changelog parsing.
+- Diff: Fetch raw GitHub changelogs, not html.
+- Diff: Support GitHub releases.
+- Diff: Improved Markup rendering (with code samples)
+- Diff: Try release notes in order of match frequency.

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2025 Florian Dejako
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,58 @@
+[![Gem Version](https://badge.fury.io/rb/gemstar.svg)](https://rubygems.org/gems/gemstar)
+[![Build](https://github.com/FDj/gemstar/workflows/Build/badge.svg)](https://github.com/palkan/gemstar/actions)
+[![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.
+
+## Installation
+
+Until it's released on RubyGems, you can install it from GitHub:
+
+```shell
+# Shell
+gem install specific_install
+gem specific_install -l https://github.com/FDj/gemstar.git
+```
+
+Or adding to your project:
+
+```ruby
+# Gemfile
+group :development do
+  gem "gemstar", github: "FDj/gemstar"
+end
+```
+
+## Usage
+
+### `gemstar diff`
+
+Run this after you've updated your gems.
+
+```shell
+# in your project directory:
+bundle exec gemstar diff
+```
+
+This will generate an html diff report with changelog entries for each gem that was updated:
+
+![Gemstar diff command output](docs/diff.png)
+
+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
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/FDj/gemstar](https://github.com/FDj/gemstar).
+
+## Credits
+
+This gem is generated via [`newgem` template](https://github.com/palkan/newgem) by [@palkan](https://github.com/palkan).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/gemstar

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require_relative "../lib/gemstar"
+
+Gemstar::CLI.start(ARGV)

data/lib/gemstar/cache.rb

@@ -0,0 +1,60 @@
+require "fileutils"
+require "digest"
+
+module Gemstar
+  class Cache
+    MAX_CACHE_AGE = 60 * 60 * 24 * 7 # 1 week
+    CACHE_DIR = ".gem_changelog_cache"
+
+    @@initialized = false
+
+    def self.init
+      return if @@initialized
+
+      FileUtils.mkdir_p(CACHE_DIR)
+      @@initialized = true
+    end
+
+    def self.fetch(key, &block)
+      init
+
+      path = File.join(CACHE_DIR, Digest::SHA256.hexdigest(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
+      end
+
+      begin
+        data = block.call
+        File.write(path, data || "__404__")
+        data
+      rescue
+        File.write(path, "__404__")
+        nil
+      end
+    end
+
+  end
+
+  def edit_gitignore
+    gitignore_path = ".gitignore"
+    ignore_entries = %w[.gem_changelog_cache/ gem_update_changelog.html]
+
+    existing_lines = File.exist?(gitignore_path) ? File.read(gitignore_path).lines.map(&:chomp) : []
+
+    new_lines = ignore_entries.reject { |entry| existing_lines.include?(entry) }
+
+    unless new_lines.empty?
+      File.open(gitignore_path, "a") do |f|
+        f.puts "\n# Cache/output from gem changelog tool" if (existing_lines & ignore_entries).empty?
+        new_lines.each { |entry| f.puts entry }
+      end
+    end
+  end
+
+end

data/lib/gemstar/change_log.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Gemstar
+  class ChangeLog
+    @@candidates_found = Hash.new(0)
+
+    def initialize(metadata)
+      @metadata = metadata
+    end
+
+    attr_reader :metadata
+
+    def content
+      @content ||= fetch_changelog_content
+    end
+
+    def sections
+      @sections ||= begin
+        s = parse_changelog_sections
+        if s.nil? || s.empty?
+          s = parse_github_release_sections
+        end
+
+        pp @@candidates_found if Gemstar.debug?
+
+        s
+      end
+    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")
+      to = Gem::Version.new(new_version.gsub(/-[\w\-]+$/, "")) rescue nil if new_version
+      to ||= Gem::Version.new("9999.9999.9999")
+
+      sections.select do |version, _|
+        v = Gem::Version.new(version.gsub(/-[\w\-]+$/, ""))
+        v > from && v <= to
+      rescue => e
+        false
+      end.sort_by do |k, _|
+        Gem::Version.new(k.gsub(/-[\w\-]+$/, ""))
+      rescue => e
+        Gem::Version.new("0.0.0")
+      end.reverse.to_h
+    end
+
+    private
+
+    # 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)
+      return nil unless line
+      heading = line.to_s
+      # 1) Prefer version inside parentheses after a date: "### 2025-11-07 (2.16.0)"
+      return $1 if heading[/\(\s*v?(\d[\w.\-]+)\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]
+      # 3) Anywhere: first semver-like token with a dot
+      return $1 if heading[/\bv?(\d+\.\d+(?:\.\d+)?(?:[A-Za-z0-9.\-]+)?)\b/]
+      nil
+    end
+
+    def changelog_uri_candidates
+      candidates = []
+
+      if @metadata.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")
+        aws_style = false
+      end
+
+      base = base.chomp("/")
+
+      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
+
+      candidates += paths.product(branches).map do |file, branch|
+        uri = aws_style ? "#{base}/#{file}" : "#{base}/#{branch}/#{file}"
+      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"])]
+
+      candidates.flatten!
+      candidates.uniq!
+      candidates.compact!
+
+      candidates
+    end
+
+    def fetch_changelog_content
+      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
+        end
+
+        # puts "fetch_changelog_content #{candidate}:\n#{content}" if Gemstar.debug?
+
+        if content
+          @@candidates_found[candidate.split("/").last] += 1
+        end
+
+        !content.nil?
+      end
+
+      content
+    end
+
+
+    def parse_changelog_sections
+      # 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
+      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/"))
+        puts "parse_changelog_sections #{@metadata.gem_name}: Detected GitHub Releases HTML; skipping to fallback" 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|
+        # 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)"
+          new_key = extract_version_from_heading(line) || $1
+        end
+
+        if new_key
+          # Flush previous section before starting a new one
+          flush_current.call
+          current_key = new_key
+          current_lines = [line]
+        elsif current_key
+          current_lines << line
+        end
+      end
+
+      # Flush the last captured section
+      flush_current.call
+
+      # 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?
+      end
+
+      if Gemstar.debug?
+        puts "parse_changelog_sections #{@metadata.gem_name}:"
+        pp sections
+      end
+
+      sections
+    end
+
+    def parse_github_release_sections
+      begin
+        require "nokogiri"
+      rescue LoadError
+        return {}
+      end
+
+      return {} unless @metadata&.repo_uri&.include?("github.com")
+
+      url = github_releases_url
+      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
+        end
+      end
+
+      return {} if html.nil? || html.strip.empty?
+
+      doc = begin
+        Nokogiri::HTML5(html)
+      rescue => _
+        Nokogiri::HTML(html)
+      end
+
+      sections = {}
+
+      # Preferred: iterate release sections that have an accessible h2 with the version (sr-only)
+      doc.css('section[aria-labelledby]').each do |sec|
+        heading = sec.at_css('h2.sr-only')
+        next unless heading
+        text = heading.text.to_s.strip
+        next unless text[/v?(\d[\w.\-]+)/i]
+        version = $1
+
+        body = sec.at_css('[data-test-selector="body-content"] .markdown-body') ||
+               sec.at_css('[data-test-selector="body-content"]') ||
+               sec.at_css('.markdown-body')
+        next unless body
+
+        html_chunk = body.inner_html.to_s.strip
+        next if html_chunk.empty?
+
+        lines = ["## #{version}\n", html_chunk]
+        sections[version] = lines
+      end
+
+      # Fallback: look for any body-content blocks across the page and try to infer nearby tag links
+      if sections.empty?
+        doc.css('[data-test-selector="body-content"]').each do |container|
+          body = container.at_css('.markdown-body') || container
+          # find a tag link near this container
+          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 text && text[/v?(\d[\w.\-]+)/i]
+          version = $1
+
+          html_chunk = body.inner_html.to_s.strip
+          next if html_chunk.empty?
+          lines = ["## #{version}\n", html_chunk]
+          sections[version] = lines
+        end
+      end
+
+      if Gemstar.debug?
+        puts "parse_github_release_sections #{@metadata.gem_name}:"
+        pp sections.keys
+      end
+
+      sections
+    end
+
+    def github_releases_url
+      return nil unless @metadata&.repo_uri
+      repo = @metadata.repo_uri.chomp("/")
+      return nil if repo.empty?
+      "#{repo}/releases"
+    end
+  end
+end

data/lib/gemstar/cli.rb

@@ -0,0 +1,50 @@
+# lib/gemstar/cli.rb
+require "thor"
+
+module Gemstar
+  class CLI < Thor
+    package_name "gemstar"
+
+    map "-D" => "diff"
+
+    class_option :verbose, type: :boolean, default: false, desc: "Enable verbose output"
+    class_option :lockfile, type: :string, default: "Gemfile.lock", desc: "Lockfile path"
+
+    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 :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 "pick", "Interactively cherry-pick and upgrade gems"
+    # option :gem, type: :string, desc: "Gem name to cherry-pick"
+    # def pick
+    #   Gemstar::Commands::Pick.new(options).run
+    # end
+    #
+    # desc "audit", "Run security and vulnerability checks"
+    # def audit
+    #   Gemstar::Commands::Audit.new.run
+    # end
+    #
+    # desc "diff", "Show lockfile diff or GitHub comparison"
+    # option :from, type: :string
+    # option :to, type: :string
+    # def diff
+    #   Gemstar::Commands::Diff.new(options).run
+    # end
+
+    # desc "init", "Setup gem hygiene for a project"
+    # def init
+    #   Gemstar::Commands::Init.new.run
+    # end
+
+    def self.exit_on_failure?
+      true
+    end
+  end
+
+end

data/lib/gemstar/commands/command.rb

@@ -0,0 +1,13 @@
+module Gemstar
+  module Commands
+    class Command
+      def initialize(options)
+        @options = options
+      end
+
+      def run
+        pp @options
+      end
+    end
+  end
+end

data/lib/gemstar/commands/diff.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "command"
+require "concurrent-ruby"
+require "tempfile"
+
+module Gemstar
+  module Commands
+    class Diff < Command
+      attr_reader :updates
+      attr_reader :failed
+      attr_reader :from
+      attr_reader :to
+      attr_reader :lockfile
+      attr_reader :git_repo
+      attr_reader :lockfile_full_path
+      attr_reader :output_file
+
+      def initialize(options)
+        super
+
+        @debug_gem_regex = Regexp.new(options[:debug_gem_regex] || ENV["GEMSTAR_DEBUG_GEM_REGEX"] || ".*")
+
+        @from = options[:from] || "HEAD"
+        @to = options[:to]
+        @lockfile = options[:lockfile] || "Gemfile.lock"
+        @output_file = options[:output_file] || "gem_update_changelog.html"
+
+        @git_repo = Gemstar::GitRepo.new(File.dirname(@lockfile))
+      end
+
+      def run
+        # logic to diff from/to, find updated gems, fetch changelogs
+
+        #+++ edit_gitignore?
+
+        @lockfile_full_path = git_repo.get_full_path(File.basename(lockfile))
+        puts "Lockfile path: #{lockfile_full_path}"
+
+        old = LockFile.new(content: git_repo.show_blob_at(@from, lockfile_full_path))
+        new = @to ?
+                LockFile.new(content: git_repo.show_blob_at(@to, lockfile_full_path)) :
+                LockFile.new(path: lockfile)
+
+        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."
+
+        if failed.any?
+          puts "\n⚠️ The following gems failed to process:"
+          failed.each { |gem, msg| puts "  - #{gem}: #{msg}" }
+        end
+      end
+
+      private
+
+      def build_entry(gem_name:, old_version:, new_version:)
+        metadata = Gemstar::RubyGemsMetadata.new(gem_name)
+        repo_url = metadata.repo_uri
+        changelog = Gemstar::ChangeLog.new(metadata)
+        sections = changelog.extract_relevant_sections(old_version, new_version)
+
+        compare_url = if repo_url && old_version
+          tag_from_v = "v#{old_version}"
+          tag_to_v = "v#{new_version}"
+          tag_from_raw = old_version
+          tag_to_raw = new_version
+
+          url_v = "#{repo_url}/compare/#{tag_from_v}...#{tag_to_v}"
+          url_raw = "#{repo_url}/compare/#{tag_from_raw}...#{tag_to_raw}"
+
+          begin
+            URI.open(url_v, read_timeout: 4) # TODO use a real HTTP client
+            url_v
+          rescue
+            url_raw
+          end
+        end
+
+        homepage_url = metadata.meta["homepage_uri"] || metadata.meta["source_code_uri"] || "https://rubygems.org/gems/#{gem_name}"
+        description = metadata.meta["info"]
+
+        entry = {
+          old: old_version,
+          new: new_version,
+          homepage_url: homepage_url,
+          description: description
+        }
+        entry[:sections] = sections unless sections.nil? || sections.empty?
+        entry[:compare_url] = compare_url if compare_url
+
+        if entry[:sections].nil? && repo_url && new_version
+          entry[:release_url] = "#{repo_url}/releases/tag/#{new_version}"
+        end
+        entry[:release_page] = "#{repo_url}/releases" if repo_url && (!sections || sections.empty?)
+
+        if repo_url && new_version
+          version_list = sections ? sections.keys : []
+          if version_list.empty?
+            version_list = [new_version]
+          end
+
+          entry[:release_urls] = version_list.map do |ver|
+            "#{repo_url}/releases/tag/#{ver}"
+          end
+        end
+
+        entry
+      end
+
+      def collect_updates(new_lockfile:, old_lockfile:)
+        @updates = {}
+        @failed = []
+        mutex = Mutex.new
+        pool = Concurrent::FixedThreadPool.new(10)
+
+        new_lockfile.specs.keys.sort.each do |gem_name|
+          pool.post do
+            next unless @debug_gem_regex.match?(gem_name)
+
+            old_version = old_lockfile.specs[gem_name]
+            new_version = new_lockfile.specs[gem_name]
+            next if old_version == new_version
+
+            puts "#{gem_name} (#{old_version || "new"} → #{new_version})..."
+
+            begin
+              entry = build_entry(gem_name: gem_name, old_version: old_version, new_version: new_version)
+
+              mutex.synchronize { updates[gem_name] = entry }
+            rescue => e
+              mutex.synchronize { failed << [gem_name, e.message] }
+              puts "⚠️ Failed to process #{gem_name}: #{e.message}"
+            end
+          end
+        end
+
+        pool.shutdown
+        pool.wait_for_termination
+
+        @updates = updates
+      end
+    end
+  end
+end

data/lib/gemstar/git_hub.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Gemstar
+  class GitHub
+    def self.github_blob_to_raw(url, ref_is_tag: false)
+      return nil unless url
+
+      uri = URI(url)
+      return url unless uri.host == "github.com"
+
+      owner, repo, blob, *rest = uri.path.split("/")[1..]
+      return url unless blob == "blob"
+
+      ref  = rest.shift
+      path = rest.join("/")
+
+      ref_prefix = ref_is_tag ? "refs/tags/" : ""
+
+      uri.scheme = "https"
+      uri.host   = "raw.githubusercontent.com"
+      uri.path   = "/#{owner}/#{repo}/#{ref_prefix}#{ref}/#{path}"
+      uri.to_s
+    end
+
+  end
+end

data/lib/gemstar/git_repo.rb

@@ -0,0 +1,55 @@
+module Gemstar
+  class GitRepo
+    def initialize(specified_directory)
+      @specified_directory = specified_directory || Dir.pwd
+      @tree_root_directory = find_git_root(File.dirname(@specified_directory))
+    end
+
+    def find_git_root(directory)
+      # return directory if File.directory?(File.join(directory, ".git"))
+      # find_git_root(File.dirname(directory))
+
+      run_git_command(%W[rev-parse --show-toplevel])
+    end
+
+    def git_client
+      "git"
+    end
+
+    def run_git_command(command, in_directory: @specified_directory, strip: true)
+      git_command = [git_client]
+      git_command += ["-C", in_directory] if in_directory
+      git_command += command
+
+      puts %[run_git_command (joined): #{git_command.join(" ")}] if Gemstar.debug?
+
+      output = IO.popen(git_command, err: [:child, :out],
+        &:read)
+      strip ? output.strip : output
+    end
+
+    def resolve_commit(revish, default_branch: "HEAD")
+      # If it looks like a pure date (or you want to support "date only"),
+      # map it to "latest commit before date on default_branch".
+      if revish =~ /\d{4}-\d{2}-\d{2}/ || revish =~ /\d{1,2}:\d{2}/i
+        sha = run_git_command(["rev-list", "-1", "--before", revish, default_branch])
+        raise "No commit before #{revish} on #{default_branch}" if sha.empty?
+        return sha
+      end
+
+      # Otherwise let Git parse whatever the user typed.
+      sha = run_git_command(%W[rev-parse --verify #{revish}^{commit}])
+      raise "Unknown revision: #{revish}" if sha.empty?
+      sha
+    end
+
+    def show_blob_at(revish, path)
+      commit = resolve_commit(revish)
+      run_git_command(["show", "#{commit}:#{path}"])
+    end
+
+    def get_full_path(path)
+      run_git_command(["ls-files", "--full-name", "--", path])
+    end
+  end
+end

data/lib/gemstar/lock_file.rb

@@ -0,0 +1,30 @@
+module Gemstar
+  class LockFile
+    def initialize(path: nil, content: nil)
+      @path = path
+      @specs = content ? parse_content(content) : parse_lockfile(path)
+    end
+
+    attr_reader :specs
+
+    private
+
+    def parse_lockfile(path)
+      parse_content(File.read(path))
+    end
+
+    def parse_content(content)
+      specs = {}
+      in_specs = false
+      content.each_line do |line|
+        in_specs = true if line.strip == "GEM"
+        next unless in_specs
+        if line =~ /^\s{4}(\S+) \((.+)\)/
+          name, version = $1, $2
+          specs[name] = version
+        end
+      end
+      specs
+    end
+  end
+end

data/lib/gemstar/outputs/basic.rb

@@ -0,0 +1,7 @@
+module Gemstar
+  module Outputs
+    class Basic
+      def render_diff(updates) end
+    end
+  end
+end

data/lib/gemstar/outputs/html.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "basic"
+require "pathname"
+require "kramdown"
+begin
+  require "kramdown-parser-gfm"
+rescue LoadError
+  # Optional dependency: if not available, we'll gracefully fall back to the default parser
+end
+
+module Gemstar
+  module Outputs
+    class HTML < Basic
+      def render_diff(diff_command)
+        body = diff_command.updates.sort.map do |gem_name, info|
+          icon = info[:homepage_url]&.include?("github.com") ? "🐙" : "💎"
+          tooltip = info[:description] ? "title=\"#{info[:description].gsub('"', "&quot;")}\"" : ""
+          link = "<a href=\"#{info[:homepage_url]}\" #{tooltip} target=\"_blank\">#{gem_name}</a>"
+          html = if info[:sections]
+            info[:sections].map do |_version, lines|
+              html_chunk = begin
+                opts = { hard_wrap: false }
+                opts[:input] = "GFM" if defined?(Kramdown::Parser::GFM)
+                Kramdown::Document.new(lines.join, opts).to_html
+              rescue Kramdown::Error
+                Kramdown::Document.new(lines.join, { hard_wrap: false }).to_html
+              end
+              <<~HTML
+                #{html_chunk}
+              HTML
+            end.join("\n")
+          elsif info[:release_urls]
+            "" # the changelog wasn't found, but we have release links — skip the message
+          else
+            "<p><strong>#{gem_name}:</strong> No changelog entries found</p>"
+          end
+
+          <<~HTML
+            <section>
+              <h2>#{icon} #{link}: #{info[:old] || "new"} → #{info[:new]}</h2>
+              #{"<p><a href='#{info[:release_page]}' target='_blank'>View all GitHub release notes</a></p>" if info[:release_page]}
+              #{html}
+            </section>
+          HTML
+        end.join("\n")
+
+        project_name = Pathname.getwd.basename.to_s
+
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <meta charset="UTF-8">
+            <title>#{project_name}: Gem Updates with Changelogs</title>
+            <style>
+              body { font-family: sans-serif; padding: 2em; background: #fdfdfd; }
+              section { margin-bottom: 3em; border-bottom: 1px solid #ccc; padding-bottom: 1em; }
+              h2 { color: #333; }
+              h3 { margin-top: 1em; color: #444; }
+              pre { background: #eee; padding: 1em; overflow-x: auto; }
+              a { color: #0645ad; text-decoration: none; }
+            </style>
+          </head>
+          <body>
+            <h1>#{project_name}: Gem Updates</h1>
+            <p><i>Showing changes from #{diff_command.from} to #{diff_command.to || "now"}, generated on #{Time.now.strftime("%Y-%m-%d %H:%M:%S %z")}.</i></p>
+            #{body}
+          </body>
+          </html>
+        HTML
+      end
+    end
+  end
+end

data/lib/gemstar/railtie.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Gemstar # :nodoc:
+  class Railtie < ::Rails::Railtie # :nodoc:
+  end
+end

data/lib/gemstar/remote_repository.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Gemstar
+  class RemoteRepository
+    def initialize(repository_uri)
+      @repository_uri = repository_uri
+    end
+
+    def find_main_branch
+      # Attempt loading .gitignore (assumed to be present in all repos) from either
+      # main or master branch:
+      %w[main master].each do |branch|
+        Cache.fetch("gitignore-#{branch}") do
+          content = begin
+                      URI.open("#{@repository_uri}/#{branch}/.gitignore", read_timeout: 8)&.read
+                    rescue
+                      nil
+                    end
+          return [branch] unless content.nil?
+        end
+      end
+
+      # No .gitignore found, have to search for changelogs in both branches:
+      %w[main master]
+    end
+
+  end
+end

data/lib/gemstar/ruby_gems_metadata.rb

@@ -0,0 +1,59 @@
+require "open-uri"
+require "uri"
+require "json"
+
+module Gemstar
+  class RubyGemsMetadata
+    def initialize(gem_name)
+      @gem_name = gem_name
+    end
+
+    attr_reader :gem_name
+
+    def meta
+      @meta ||=
+        begin
+          url = "https://rubygems.org/api/v1/gems/#{URI.encode_www_form_component(gem_name)}.json"
+          Cache.fetch("rubygems-#{gem_name}") do
+            URI.open(url).read
+          end.then { |json|
+            begin
+              JSON.parse(json) if json
+            rescue
+              nil
+            end }
+        end
+    end
+
+    def repo_uri
+      return nil unless meta
+
+      @repo_uri ||= begin
+                      uri = meta["source_code_uri"]
+
+                      if uri.nil?
+                        uri = meta["homepage_uri"]
+                        if uri.include?("github.com")
+                          uri = uri[%r{http[s?]://github\.com/[^/]+/[^/]+}]
+                        end
+                      end
+
+                      uri ||= ""
+
+                      uri = uri.sub("http://", "https://")
+
+                      uri = uri.gsub(/\.git$/, "")
+
+                      if uri.include?("github.io")
+                        # Convert e.g. https://socketry.github.io/console/ to https://github.com/socketry/console/
+                        uri = uri.sub(%r{\Ahttps?://([\w-]+)\.github\.io/([^/]+)}) do
+                          "https://github.com/#{$1}/#{$2}"
+                        end
+                      end
+
+                      uri
+                    end
+    end
+
+  end
+end

data/lib/gemstar/utils.rb

@@ -0,0 +1,28 @@
+module Gemstar
+  module Utils
+    def generate_version_range(from_str, to_str)
+      from = Gem::Version.new(from_str.gsub(/-[\w\-]+$/, ''))
+      to = Gem::Version.new(to_str.gsub(/-[\w\-]+$/, ''))
+      result = Set.new
+
+      # Generate known version steps up to 2000 iterations max (safety limit)
+      queue = [from]
+      2000.times do
+        v = queue.pop
+        break if v.nil? || v >= to
+
+        patch = Gem::Version.new("#{v.segments[0]}.#{v.segments[1]}.#{v.segments[2] + 1}")
+        minor = Gem::Version.new("#{v.segments[0]}.#{v.segments[1] + 1}.0")
+        major = Gem::Version.new("#{v.segments[0] + 1}.0.0")
+
+        [patch, minor, major].each do |next_v|
+          next if next_v > to || result&.include?(next_v)
+          result << next_v
+          queue << next_v
+        end
+      end
+
+      result.select { |v| v > from && v <= to }.sort.map(&:to_s)
+    end
+  end
+end

data/lib/gemstar/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Gemstar # :nodoc:
+  VERSION = "0.0.1"
+
+  def self.debug?
+    return @debug if defined?(@debug)
+    @debug = ENV["GEMSTAR_DEBUG"] == "true"
+  end
+end

data/lib/gemstar.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "gemstar/version"
+require "gemstar/railtie" if defined?(Rails::Railtie)
+require "gemstar/cli"
+require "gemstar/commands/command"
+require "gemstar/commands/diff"
+require "gemstar/outputs/basic"
+require "gemstar/outputs/html"
+require "gemstar/cache"
+require "gemstar/change_log"
+require "gemstar/git_hub"
+require "gemstar/lock_file"
+require "gemstar/remote_repository"
+require "gemstar/utils"
+require "gemstar/ruby_gems_metadata"
+require "gemstar/git_repo"

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification
+name: gemstar
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Florian Dejako
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.8
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+description: Gem changelog viewer and more, but starting as a changelog viewer for
+  bundled gems.
+email:
+- fdejako@gmail.com
+executables:
+- gemstar
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/gemstar
+- lib/gemstar.rb
+- lib/gemstar/cache.rb
+- lib/gemstar/change_log.rb
+- lib/gemstar/cli.rb
+- lib/gemstar/commands/command.rb
+- lib/gemstar/commands/diff.rb
+- lib/gemstar/git_hub.rb
+- lib/gemstar/git_repo.rb
+- lib/gemstar/lock_file.rb
+- lib/gemstar/outputs/basic.rb
+- lib/gemstar/outputs/html.rb
+- lib/gemstar/railtie.rb
+- lib/gemstar/remote_repository.rb
+- lib/gemstar/ruby_gems_metadata.rb
+- lib/gemstar/utils.rb
+- lib/gemstar/version.rb
+homepage: https://github.com/FDj/gemstar
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/FDj/gemstar/issues
+  changelog_uri: https://github.com/FDj/gemstar/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/FDj/gemstar
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.0
+specification_version: 4
+summary: Making sense of gems.
+test_files: []