gemstar 1.0.2 → 1.1

data/lib/gemstar/change_log.rb

@@ -1,8 +1,17 @@
 # frozen_string_literal: true
+require "cgi"
+require "json"
 
 module Gemstar
   class ChangeLog
     @@candidates_found = Hash.new(0)
+    DEFAULT_CHANGELOG_PATHS = %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
+    ].freeze
 
     def initialize(metadata)
       @metadata = metadata
@@ -19,23 +28,84 @@ module Gemstar
     end
 
     def sections(cache_only: false, force_refresh: false)
-      return @sections if !cache_only && defined?(@sections)
+      return @sections if !cache_only && defined?(@sections) && !force_refresh
 
-      result = begin
-        s = parse_changelog_sections(cache_only: cache_only, force_refresh: force_refresh)
-        if s.nil? || s.empty?
-          s = parse_github_release_sections(cache_only: cache_only, force_refresh: force_refresh)
+      metadata_key = @metadata.respond_to?(:cache_key) ? @metadata.cache_key : @metadata.gem_name
+      cache_key = "sections-v4-#{metadata_key}"
+      serialized = if cache_only
+        Cache.peek(cache_key)
+      else
+        Cache.fetch(cache_key, force: force_refresh) do
+          JSON.generate(compute_sections(force_refresh: force_refresh))
         end
+      end
 
-        pp @@candidates_found if Gemstar.debug? && !cache_only
-
-        s
+      result = if serialized
+        decode_sections(serialized)
+      elsif cache_only
+        nil
+      else
+        compute_sections(force_refresh: force_refresh)
       end
 
       @sections = result unless cache_only
       result
     end
 
+    def sections_for_versions(versions, cache_only: false, force_refresh: false)
+      requested_versions = normalize_requested_versions(versions)
+      return {} if requested_versions.empty?
+
+      cached_sections = sections(cache_only: true) || {}
+      result = cached_sections.select { |version, _| requested_versions.include?(normalize_version_key(version)) }
+      return result if cache_only
+
+      changelog_sections = parse_changelog_sections(cache_only: false, force_refresh: force_refresh) || {}
+      changelog_sections.each do |version, lines|
+        result[version] ||= lines if requested_versions.include?(normalize_version_key(version))
+      end
+
+      repo_uri = @metadata&.repo_uri(cache_only: false, force_refresh: force_refresh)
+      if repo_uri&.include?("github.com")
+        missing_versions = requested_versions - result.keys.map { |version| normalize_version_key(version) }
+        missing_versions.each do |version|
+          specific_release = parse_specific_github_release_pages(
+            repo_uri,
+            version,
+            cache_only: false,
+            force_refresh: force_refresh
+          )
+          result.merge!(specific_release) if specific_release
+        end
+      end
+
+      result
+    end
+
+    def compute_sections(force_refresh: false)
+      changelog_sections = parse_changelog_sections(cache_only: false, force_refresh: force_refresh) || {}
+      github_sections = parse_github_release_sections(cache_only: false, force_refresh: force_refresh) || {}
+
+      sections = merge_section_sources(changelog_sections, github_sections)
+
+      pp @@candidates_found if Gemstar.debug?
+
+      sections
+    end
+
+    def decode_sections(serialized)
+      JSON.parse(serialized)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def merge_section_sources(changelog_sections, github_sections)
+      return github_sections if changelog_sections.nil? || changelog_sections.empty?
+      return changelog_sections if github_sections.nil? || github_sections.empty?
+
+      github_sections.merge(changelog_sections)
+    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")
@@ -56,6 +126,17 @@ module Gemstar
 
     private
 
+    def normalize_requested_versions(versions)
+      Array(versions).filter_map { |version| normalize_version_key(version) }.uniq
+    end
+
+    def normalize_version_key(version)
+      value = version.to_s.strip
+      return nil if value.empty?
+
+      value.sub(/\Av/i, "")
+    end
+
     # 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)
@@ -80,30 +161,11 @@ module Gemstar
       repo_uri = @metadata.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       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 = 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
-      ]
+      changelog_source = metadata_changelog_source(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
+      return [] unless changelog_source
 
-      remote_repository = RemoteRepository.new(base)
-
-      branches = aws_style ? [""] : remote_repository.find_main_branch(cache_only: cache_only, force_refresh: force_refresh)
-
-      candidates += paths.product(branches).map do |file, branch|
-        uri = aws_style ? "#{base}/#{file}" : "#{base}/#{branch}/#{file}"
+      candidates += changelog_source[:paths].product(changelog_source[:branches]).map do |file, branch|
+        [changelog_source[:base], branch, file].reject { |segment| segment.to_s.empty? }.join("/")
       end
 
       # Add the gem's changelog_uri last as it's usually not the most parsable:
@@ -117,6 +179,19 @@ module Gemstar
       candidates
     end
 
+    def metadata_changelog_source(repo_uri, cache_only:, force_refresh:)
+      if @metadata.respond_to?(:changelog_source)
+        return @metadata.changelog_source(repo_uri: repo_uri, cache_only: cache_only, force_refresh: force_refresh)
+      end
+
+      base = repo_uri.sub("https://github.com", "https://raw.githubusercontent.com").chomp("/")
+      {
+        base: base,
+        paths: DEFAULT_CHANGELOG_PATHS,
+        branches: RemoteRepository.new(base).find_main_branch(cache_only: cache_only, force_refresh: force_refresh)
+      }
+    end
+
     def fetch_changelog_content(cache_only: false, force_refresh: false)
       content = nil
 
@@ -261,6 +336,7 @@ module Gemstar
         heading = sec.at_css('h2.sr-only')
         next unless heading
         text = heading.text.to_s.strip
+        next unless github_tag_matches_metadata?(text)
         next unless text[/v?(\d[\w.\-]+)/i]
         version = $1
 
@@ -284,6 +360,7 @@ module Gemstar
           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 github_tag_matches_metadata?(text)
           next unless text && text[/v?(\d[\w.\-]+)/i]
           version = $1
 
@@ -294,6 +371,29 @@ module Gemstar
         end
       end
 
+      if sections.empty?
+        current_version = @metadata&.meta(cache_only: cache_only, force_refresh: force_refresh)&.dig("version")
+        current_release_sections = parse_specific_github_release_pages(
+          repo_uri,
+          current_version,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        tag_sections = parse_github_tag_sections(
+          repo_uri,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        sections = tag_sections.merge(current_release_sections)
+      elsif discover_github_tag_sections?
+        tag_sections = parse_github_tag_sections(
+          repo_uri,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        sections = tag_sections.merge(sections)
+      end
+
       if Gemstar.debug?
         puts "parse_github_release_sections #{@metadata.gem_name}:"
         pp sections.keys
@@ -308,5 +408,211 @@ module Gemstar
       return nil if repo.empty?
       "#{repo}/releases"
     end
+
+    def github_tags_url(repo_uri = @metadata&.repo_uri)
+      return nil unless repo_uri
+      repo = repo_uri.chomp("/")
+      return nil if repo.empty?
+      "#{repo}/tags"
+    end
+
+    def parse_specific_github_release_pages(repo_uri, version, cache_only:, force_refresh:)
+      return {} unless repo_uri&.include?("github.com")
+      return {} if version.to_s.empty?
+
+      github_release_tag_urls(repo_uri, version).each do |url|
+        html = if cache_only
+          Cache.peek("releases-#{url}")
+        else
+          Cache.fetch("releases-#{url}", force: force_refresh) do
+            begin
+              URI.open(url, read_timeout: 8)&.read
+            rescue => e
+              puts "#{url}: #{e}" if Gemstar.debug?
+              nil
+            end
+          end
+        end
+
+        next if html.nil? || html.strip.empty?
+
+        section = parse_single_github_release_page(html, version)
+        return { version => section } if section
+      end
+
+      {}
+    end
+
+    def parse_github_tag_sections(repo_uri, cache_only:, force_refresh:)
+      return {} unless repo_uri&.include?("github.com")
+
+      url = github_tags_url(repo_uri)
+      return {} unless url
+
+      sections = {}
+      seen_urls = {}
+
+      while url && !seen_urls[url]
+        seen_urls[url] = true
+        html = if cache_only
+          Cache.peek("tags-#{url}")
+        else
+          Cache.fetch("tags-#{url}", force: force_refresh) do
+            begin
+              URI.open(url, read_timeout: 8)&.read
+            rescue => e
+              puts "#{url}: #{e}" if Gemstar.debug?
+              nil
+            end
+          end
+        end
+
+        break if html.nil? || html.strip.empty?
+
+        page_sections, next_url = parse_single_github_tags_page(html, repo_uri)
+        sections.merge!(page_sections) { |_version, existing, _new| existing }
+        url = next_url
+      end
+
+      sections.keys.each do |version|
+        specific_release = parse_specific_github_release_pages(
+          repo_uri,
+          version,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        next if specific_release.nil? || specific_release.empty?
+
+        sections[version] = specific_release[version] if specific_release[version]
+      end
+
+      sections
+    end
+
+    def parse_single_github_tags_page(html, repo_uri)
+      require "nokogiri"
+
+      doc = begin
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
+
+      sections = {}
+      repo_path = URI(repo_uri).path
+      release_prefix = "#{repo_path}/releases/tag/"
+      tree_prefix = "#{repo_path}/tree/"
+
+      doc.css("a[href]").each do |link|
+        href = link["href"].to_s
+        tag_name =
+          if href.start_with?(release_prefix)
+            href.delete_prefix(release_prefix)
+          elsif href.start_with?(tree_prefix)
+            href.delete_prefix(tree_prefix)
+          end
+        next if tag_name.to_s.empty?
+        next unless github_tag_matches_metadata?(tag_name)
+
+        version = normalize_github_tag_version(tag_name)
+        next if version.to_s.empty?
+
+        sections[version] ||= [
+          "## #{version}\n",
+          "<p>No release information available. Check the release page for more information.</p>"
+        ]
+      end
+
+      next_href =
+        doc.at_css('a[rel="next"], a.next_page')&.[]("href") ||
+        doc.css("a[href]").find do |link|
+          href = link["href"].to_s
+          text = link.text.to_s.gsub(/\s+/, " ").strip
+          href.include?("/tags?after=") && text == "Next"
+        end&.[]("href")
+      next_url = if next_href && !next_href.empty?
+        URI.join(repo_uri, next_href).to_s
+      end
+
+      [sections, next_url]
+    rescue LoadError
+      [{}, nil]
+    end
+
+    def parse_single_github_release_page(html, version)
+      require "nokogiri"
+
+      doc = begin
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
+
+      body = doc.at_css('[data-test-selector="body-content"] .markdown-body') ||
+             doc.at_css('[data-test-selector="body-content"]') ||
+             doc.at_css('.markdown-body')
+      if body
+        html_chunk = body.inner_html.to_s.strip
+        return ["## #{version}\n", html_chunk] unless html_chunk.empty?
+      end
+
+      title = doc.at_css("title")&.text.to_s.strip
+      synthetic_title = normalize_github_release_title(title, version)
+      return nil if synthetic_title.nil? || synthetic_title.empty?
+
+      ["## #{version}\n", "<p>#{CGI.escapeHTML(synthetic_title)}</p>"]
+    rescue LoadError
+      nil
+    end
+
+    def github_release_tag_urls(repo_url, version)
+      github_tag_candidates(version).map do |tag|
+        encoded_tag = URI.encode_www_form_component(tag)
+        "#{repo_url}/releases/tag/#{encoded_tag}"
+      end.uniq
+    end
+
+    def github_tag_candidates(version)
+      return @metadata.github_tag_candidates(version) if @metadata.respond_to?(:github_tag_candidates)
+
+      raw = version.to_s
+      [raw, (raw.start_with?("v") ? raw : "v#{raw}")].uniq
+    end
+
+    def normalize_github_tag_version(tag_name)
+      decoded = URI.decode_www_form_component(tag_name.to_s.split("?").first.to_s)
+      match = decoded.match(/\A(?:.+@)?v?(\d[\w.\-]*)\z/i)
+      match && match[1]
+    end
+
+    def github_tag_matches_metadata?(tag_name)
+      return @metadata.github_tag_matches?(tag_name) if @metadata.respond_to?(:github_tag_matches?)
+
+      true
+    end
+
+    def discover_github_tag_sections?
+      @metadata.respond_to?(:discover_github_tag_sections?) && @metadata.discover_github_tag_sections?
+    end
+
+    def prefer_github_releases_first?(cache_only:, force_refresh:)
+      meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
+      repo_uri = @metadata.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
+
+      repo_uri.to_s.include?("github.com") && meta["changelog_uri"].to_s.empty?
+    rescue StandardError
+      false
+    end
+
+    def normalize_github_release_title(title, version)
+      return nil if title.to_s.empty?
+
+      cleaned = title.sub(/\s*·\s*[^·]+\s*·\s*GitHub\z/, "")
+      cleaned = cleaned.sub(/\ARelease\s+/, "")
+      cleaned = cleaned.strip
+      return nil if cleaned.empty? || cleaned == version.to_s
+
+      cleaned
+    end
   end
 end

data/lib/gemstar/cli.rb

@@ -13,6 +13,9 @@ 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 :since, type: :string, desc: "Set --from to the latest commit before this relative time (for example: '3 weeks')"
+    method_option :project, type: :string, desc: "Project directory or supported project file path"
+    method_option :ecosystem, type: :string, desc: "Filter packages by ecosystem (all, gems, js)"
     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
@@ -22,9 +25,10 @@ module Gemstar
 
     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 :port, type: :numeric, desc: "Port (default: 2112; auto-increments when omitted)"
     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"
+    method_option :open, type: :boolean, default: false, desc: "Open the server root in a browser after startup"
     def server
       Gemstar::Commands::Server.new(options).run
     end