gemstar 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80dede87ff46bc8aefd962ccd46dffcb199357eca04173b9610f85e74c74111a
-  data.tar.gz: dfd221d5ec0cdd3c3511fdd1e7980fb8bc00050afab9d69cdb81c43d1673fee6
+  metadata.gz: e9eeb335df1b34923f36572389fdf30489fd5e3d2b88e72e602d7cff4c9ace2b
+  data.tar.gz: 34c0bf38181ce5f9516967f94acc5ad08ae57230f7d5d6adadacf6d932860125
 SHA512:
-  metadata.gz: 4d160d053c3e60ef38d7b129876159a2d696015857d917f1dceb82afcd3e648d8e5736232535a9d79ef84e11681591019245317f5f15c3d7b24d06292e6c15f7
-  data.tar.gz: bcadfa71fac1e0be9c6777217cba5797e729ead523383a7f049984e47f9b9c24952cb9ae2d7a4eb7f03615cc8f4aeaafa13961cbedcfde9dd94684d601bcb0f2
+  metadata.gz: 23fad51445796f654d61318b33129d9a9f02136162982623aecafa0afa6271e9244bc6f272fb77e2ff049c944e44164018289be5306a124311c30340572eaf04
+  data.tar.gz: 436bb8487ba91671e6ab319775460c2b13f34d0873812edf3d0e429f8c6dba5707da5ed599033153fc86cd3bb276f04c227f8e4a029756b67c9b7989e6153484

data/CHANGELOG.md

@@ -11,9 +11,17 @@
         - actioncable-next uses release tag names?
         - paper_trail not using CHANGELOG.md?
         - playwright-ruby-client uses release tags?
-    - support ```ruby ```
+    - bundler itself
+    - use changelog files from installed gems where present
 
-## 0.1
+## Unreleased
+
+## 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,28 @@ 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 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 +38,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/change_log.rb

@@ -16,15 +16,15 @@ module Gemstar
 
     def sections
       @sections ||= begin
-        s = parse_changelog_sections
-        if s.nil? || s.empty?
-          s = parse_github_release_sections
-        end
+                      s = parse_changelog_sections
+                      if s.nil? || s.empty?
+                        s = parse_github_release_sections
+                      end
 
-        pp @@candidates_found if Gemstar.debug?
+                      pp @@candidates_found if Gemstar.debug?
 
-        s
-      end
+                      s
+                    end
     end
 
     def extract_relevant_sections(old_version, new_version)
@@ -53,11 +53,14 @@ module Gemstar
       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*\)/]
+      #    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*\)/]
       # 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*(?:Version\s+)?\[?v?(\d+\.\d+(?:\.\d+)?[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?(\d+\.\d+(?:\.\d+)?(?:[A-Za-z0-9.\-])*)\b/]
       nil
     end
 
@@ -123,6 +126,13 @@ module Gemstar
       content
     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
+    ]
 
     def parse_changelog_sections
       # If the fetched content looks like a GitHub Releases HTML page, return {}
@@ -136,108 +146,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?
@@ -272,10 +218,10 @@ module Gemstar
       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 = {}
 

data/lib/gemstar/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Gemstar # :nodoc:
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 
   def self.debug?
     return @debug if defined?(@debug)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstar
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Florian Dejako