gemstar 1.0.4 → 1.1.1

data/lib/gemstar/change_log.rb

@@ -1,9 +1,19 @@
 # frozen_string_literal: true
 require "cgi"
+require "date"
+require "json"
+require "time"
 
 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
@@ -20,28 +30,122 @@ 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
-        changelog_sections = parse_changelog_sections(cache_only: cache_only, force_refresh: force_refresh) || {}
-        github_sections = 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-v5-#{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
 
-        s = merge_section_sources(changelog_sections, github_sections)
+      result = if serialized
+        decode_sections(serialized)
+      elsif cache_only
+        nil
+      else
+        compute_sections(force_refresh: force_refresh)
+      end
 
-        pp @@candidates_found if Gemstar.debug? && !cache_only
+      @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?
 
-        s
+      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
 
-      @sections = result unless cache_only
       result
     end
 
+    def release_dates(versions: nil, cache_only: false, force_refresh: false)
+      requested_versions = normalize_requested_versions(versions)
+      metadata_key = @metadata.respond_to?(:cache_key) ? @metadata.cache_key : @metadata.gem_name
+      cache_key = "release-dates-v2-#{metadata_key}"
+      serialized = if cache_only
+        Cache.peek(cache_key)
+      else
+        Cache.fetch(cache_key, force: force_refresh) do
+          JSON.generate(compute_release_dates(force_refresh: force_refresh))
+        end
+      end
+
+      dates = if serialized
+        decode_sections(serialized) || {}
+      elsif cache_only
+        {}
+      else
+        compute_release_dates(force_refresh: force_refresh)
+      end
+
+      return dates if requested_versions.empty?
+
+      dates.select { |version, _date| requested_versions.include?(normalize_version_key(version)) }
+    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 compute_release_dates(force_refresh: false)
+      registry_dates = if @metadata.respond_to?(:registry_release_dates)
+        @metadata.registry_release_dates(cache_only: false, force_refresh: force_refresh)
+      else
+        {}
+      end
+      return registry_dates unless registry_dates.nil? || registry_dates.empty?
+
+      changelog_dates = parse_changelog_release_dates(cache_only: false, force_refresh: force_refresh)
+      return changelog_dates unless changelog_dates.nil? || changelog_dates.empty?
+
+      repo_uri = @metadata&.repo_uri(cache_only: false, force_refresh: force_refresh)
+      return {} unless repo_uri&.include?("github.com")
+
+      parse_github_tag_dates(repo_uri, cache_only: false, force_refresh: force_refresh)
+    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)
+      changelog_sections
     end
 
     def extract_relevant_sections(old_version, new_version)
@@ -64,6 +168,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)
@@ -82,40 +197,30 @@ module Gemstar
       nil
     end
 
+    def extract_release_date_from_heading(line)
+      return nil unless line
+
+      raw_date = line.to_s[/\b(\d{4}-\d{2}-\d{2})\b/, 1]
+      format_release_date(raw_date)
+    end
+
     def changelog_uri_candidates(cache_only: false, force_refresh: false)
       candidates = []
 
       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
-      ]
-
-      remote_repository = RemoteRepository.new(base)
+      meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
+      candidates += changelog_uri_markdown_candidates(meta["changelog_uri"]) if meta
 
-      branches = aws_style ? [""] : remote_repository.find_main_branch(cache_only: cache_only, force_refresh: force_refresh)
+      changelog_source = metadata_changelog_source(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
+      return [] unless changelog_source
 
-      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:
-      meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
       candidates += [Gemstar::GitHub::github_blob_to_raw(meta["changelog_uri"])] if meta
 
       candidates.flatten!
@@ -125,6 +230,43 @@ module Gemstar
       candidates
     end
 
+    def changelog_uri_markdown_candidates(changelog_uri)
+      raw_uri = Gemstar::GitHub::github_blob_to_raw(changelog_uri)
+      return [] if raw_uri.to_s.empty?
+
+      candidates = []
+      candidates << raw_uri if raw_uri.match?(/\.(?:md|markdown|rdoc|txt)\z/i)
+
+      begin
+        uri = URI(raw_uri)
+        path = uri.path.to_s
+        if path.end_with?("/")
+          uri.path = "#{path.chomp("/")}.md"
+          candidates << uri.to_s
+        elsif File.extname(path).empty?
+          uri.path = "#{path}.md"
+          candidates << uri.to_s
+        end
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      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
 
@@ -220,6 +362,21 @@ module Gemstar
       sections
     end
 
+    def parse_changelog_release_dates(cache_only: false, force_refresh: false)
+      c = content(cache_only: cache_only, force_refresh: force_refresh)
+      return {} if c.nil? || c.strip.empty?
+      return {} if c.include?("<html") || c.include?("<!DOCTYPE html")
+
+      c.lines.each_with_object({}) do |line, dates|
+        line = line.gsub(/^=+/) { |m| "#" * m.length }
+        next unless VERSION_PATTERNS.any? { |re| line.match?(re) }
+
+        version = extract_version_from_heading(line)
+        date = extract_release_date_from_heading(line)
+        dates[version] ||= date if version && date
+      end
+    end
+
     def parse_github_release_sections(cache_only: false, force_refresh: false)
       begin
         require "nokogiri"
@@ -269,6 +426,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
 
@@ -292,6 +450,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
 
@@ -316,6 +475,13 @@ module Gemstar
           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?
@@ -413,6 +579,40 @@ module Gemstar
       sections
     end
 
+    def parse_github_tag_dates(repo_uri, cache_only:, force_refresh:)
+      return {} unless repo_uri&.include?("github.com")
+
+      url = github_tags_url(repo_uri)
+      return {} unless url
+
+      dates = {}
+      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_dates, next_url = parse_single_github_tag_dates_page(html, repo_uri)
+        dates.merge!(page_dates) { |_version, existing, _new| existing }
+        url = next_url
+      end
+
+      dates
+    end
+
     def parse_single_github_tags_page(html, repo_uri)
       require "nokogiri"
 
@@ -436,6 +636,7 @@ module Gemstar
             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?
@@ -462,6 +663,75 @@ module Gemstar
       [{}, nil]
     end
 
+    def parse_single_github_tag_dates_page(html, repo_uri)
+      require "nokogiri"
+
+      doc = begin
+              Nokogiri::HTML5(html)
+            rescue => _
+              Nokogiri::HTML(html)
+            end
+
+      dates = {}
+      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?
+
+        datetime = github_tag_datetime_for(link)
+        next if datetime.to_s.empty?
+
+        dates[version] ||= format_release_date(datetime)
+      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
+
+      [dates.compact, next_url]
+    rescue LoadError
+      [{}, nil]
+    end
+
+    def github_tag_datetime_for(link)
+      container = link.at_xpath('ancestor::*[self::li or self::div][.//relative-time or .//time-ago][1]')
+      time_node = container&.at_css("relative-time[datetime], time-ago[datetime]") ||
+                  link.xpath('following::relative-time[@datetime] | following::time-ago[@datetime]').first
+      time_node&.[]("datetime")
+    end
+
+    def format_release_date(datetime)
+      if datetime.to_s.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        date = Date.strptime(datetime.to_s, "%Y-%m-%d")
+        return date.strftime("%b #{date.day}, %Y")
+      end
+
+      time = Time.parse(datetime.to_s).utc
+      time.strftime("%b #{time.day}, %Y")
+    rescue ArgumentError
+      nil
+    end
+
     def parse_single_github_release_page(html, version)
       require "nokogiri"
 
@@ -490,21 +760,34 @@ module Gemstar
 
     def github_release_tag_urls(repo_url, version)
       github_tag_candidates(version).map do |tag|
-        "#{repo_url}/releases/tag/#{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(/\Av?(\d[\w.\-]*)\z/i)
+      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)

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