gemstar 1.0.4 → 1.1.1

data/lib/gemstar/importmap_file.rb

@@ -0,0 +1,193 @@
+require "json"
+
+module Gemstar
+  class ImportmapFile
+    Pin = Struct.new(:name, :target, :source, keyword_init: true)
+
+    IMPORTMAP_PACKAGE_METADATA_PATH = File.expand_path("data/importmap_package_metadata.json", __dir__)
+
+    def self.package_metadata
+      @package_metadata ||= begin
+        JSON.parse(File.read(IMPORTMAP_PACKAGE_METADATA_PATH)).transform_values do |attributes|
+          attributes.each_with_object({}) do |(key, value), metadata|
+            metadata[key.to_sym] = value
+          end
+        end
+      rescue Errno::ENOENT, JSON::ParserError
+        {}
+      end
+    end
+
+    def initialize(path: nil, content: nil, vendor_reader: nil)
+      @path = path
+      @vendor_reader = vendor_reader
+      @pins = parse_content(content || File.read(path))
+    end
+
+    attr_reader :pins
+
+    def specs
+      pins.transform_values(&:target)
+    end
+
+    def source_for(name)
+      pins[name]&.source
+    end
+
+    private
+
+    def parse_content(content)
+      content.each_line.with_object({}) do |line, pins|
+        next unless line =~ /^\s*pin\s+["']([^"']+)["'](.*)$/
+
+        name = Regexp.last_match(1)
+        rest = Regexp.last_match(2).to_s
+        target = rest[/\bto:\s*["']([^"']+)["']/, 1] || name
+        inline_version = rest[/#\s*@([^\s]+)/, 1]
+
+        pins[name] = Pin.new(
+          name: name,
+          target: target,
+          source: build_source_for(name, target, inline_version: inline_version)
+        )
+      end
+    end
+
+    def build_source_for(name, target, inline_version: nil)
+      {
+        type: :importmap,
+        remote: target
+      }
+        .merge(default_package_metadata_for(name, inline_version: inline_version))
+        .merge(vendored_package_metadata_for(target))
+        .merge(cdn_package_metadata_for(target))
+        .merge(repo_source_for(name, target))
+    end
+
+    def default_package_metadata_for(name, inline_version: nil)
+      return {} unless package_like_pin_name?(name)
+
+      metadata = { package_name: name, registry_url: "https://www.npmjs.com/package/#{name}" }
+      unless inline_version.to_s.empty?
+        key = exact_package_version?(inline_version) ? :package_version : :package_requirement
+        metadata[key] = inline_version
+      end
+      metadata
+    end
+
+    def vendored_package_metadata_for(target)
+      return {} unless local_javascript_target?(target)
+
+      first_line = vendored_file_first_line(target)
+      return {} if first_line.empty?
+
+      if first_line =~ %r{\A//\s+((?:@[^/]+/)?[^@\s]+(?:/[^@\s]+)?)@([^\s]+)\s+downloaded from\s+(https?://\S+)}
+        package_name = Regexp.last_match(1)
+        package_version = Regexp.last_match(2)
+        remote = Regexp.last_match(3)
+        remote_metadata = cdn_package_metadata_for(remote)
+        package_name = remote_metadata[:package_name] || package_name
+        package_version = remote_metadata[:package_version] || package_version
+        {
+          package_name: package_name,
+          package_version: package_version,
+          registry_url: "https://www.npmjs.com/package/#{package_name}",
+          remote: remote
+        }
+      else
+        {}
+      end
+    rescue EOFError
+      {}
+    end
+
+    def vendored_file_first_line(target)
+      if @vendor_reader
+        content = @vendor_reader.call(target.to_s)
+        return content.to_s.lines.first.to_s if content
+      end
+
+      return "" unless @path
+
+      vendor_path = File.expand_path(File.join(File.dirname(@path), "..", "vendor", "javascript", target.to_s))
+      return "" unless File.file?(vendor_path)
+
+      File.open(vendor_path, &:readline).to_s
+    rescue EOFError
+      ""
+    end
+
+    def cdn_package_metadata_for(target)
+      value = target.to_s
+      return {} if value.empty?
+
+      package_name, package_version =
+        case value
+        when %r{\Ahttps://esm\.sh/((?:@[^/]+/)?[^@/?]+)@([^/?]+)}
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        when %r{\Ahttps://ga\.jspm\.io/npm:((?:@[^/]+/)?[^@/]+)@([^/]+)/}
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        when %r{\Ahttps://cdn\.jsdelivr\.net/npm/((?:@[^/]+/)?[^@/]+)@([^/]+)/}
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        when %r{\Ahttps://unpkg\.com/((?:@[^/]+/)?[^@/?]+)@([^/?]+)}
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        else
+          [nil, nil]
+        end
+
+      return {} unless package_name
+
+      version_metadata = exact_package_version?(package_version) ? { package_version: package_version } : { package_requirement: package_version }
+
+      version_metadata.merge(
+        package_name: package_name,
+        registry_url: "https://www.npmjs.com/package/#{package_name}"
+      )
+    end
+
+    def repo_source_for(name, target)
+      package_metadata = self.class.package_metadata[name]
+      repo_url = github_repo_url_for(target) || package_metadata&.dig(:repo_url)
+      metadata = {}
+      metadata[:repo_url] = repo_url if repo_url
+      metadata[:provider_gem] = package_metadata[:provider_gem] if package_metadata&.dig(:provider_gem)
+      metadata
+    end
+
+    def github_repo_url_for(target)
+      value = target.to_s
+      return nil if value.empty?
+
+      case value
+      when %r{\Ahttps://raw\.githubusercontent\.com/([^/]+/[^/]+)/}
+        "https://github.com/#{Regexp.last_match(1)}"
+      when %r{\Ahttps://github\.com/([^/]+/[^/]+)}
+        "https://github.com/#{Regexp.last_match(1)}"
+      else
+        nil
+      end
+    end
+
+    def package_like_pin_name?(name)
+      value = name.to_s
+      return false if value.empty?
+      return false if value.start_with?("controllers/")
+      return false if value.include?("_controller")
+      return false if value.start_with?("./", "../")
+
+      value.start_with?("@") || value.match?(/\A[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)*\z/i)
+    end
+
+    def exact_package_version?(version)
+      version.to_s.match?(/\Av?\d+(?:\.\d+)*(?:[-.][A-Za-z0-9]+)*\z/)
+    end
+
+    def local_javascript_target?(target)
+      value = target.to_s
+      return false if value.empty?
+      return false if value.match?(%r{\A[a-z]+://}i)
+
+      value.end_with?(".js", ".mjs")
+    end
+  end
+end

data/lib/gemstar/npm_metadata.rb

@@ -0,0 +1,159 @@
+require "open-uri"
+require "uri"
+require "json"
+
+module Gemstar
+  class NpmMetadata
+    def initialize(package_name)
+      @gem_name = package_name
+    end
+
+    attr_reader :gem_name
+
+    def cache_key
+      "npm-#{gem_name}"
+    end
+
+    def meta(cache_only: false, force_refresh: false)
+      return @meta if !cache_only && defined?(@meta)
+
+      json = if cache_only
+        Cache.peek(cache_key)
+      else
+        url = "https://registry.npmjs.org/#{URI.encode_www_form_component(gem_name)}"
+        Cache.fetch(cache_key, force: force_refresh) do
+          URI.open(url, read_timeout: 8).read
+        end
+      end
+
+      parsed = begin
+        JSON.parse(json) if json
+      rescue
+        nil
+      end
+
+      normalized = normalize_meta(parsed)
+      @meta = normalized unless cache_only
+      normalized
+    end
+
+    def repo_uri(cache_only: false, force_refresh: false)
+      resolved_meta = meta(cache_only: cache_only, force_refresh: force_refresh)
+      return nil unless resolved_meta
+
+      return @repo_uri if !cache_only && defined?(@repo_uri)
+
+      repo = begin
+        uri = resolved_meta["source_code_uri"]
+        uri ||= resolved_meta["homepage_uri"] if resolved_meta["homepage_uri"].to_s.include?("github.com")
+        uri ||= ""
+
+        uri = uri.sub(/\Agit\+/, "")
+        uri = uri.sub("git://", "https://")
+        uri = uri.sub("http://", "https://")
+        uri = uri.gsub(/\.git$/, "")
+
+        if uri.include?("github.com")
+          uri = uri[%r{\Ahttps?://github\.com/[^/]+/[^/]+}] || uri
+        end
+
+        uri
+      end
+
+      @repo_uri = repo unless cache_only
+      repo
+    end
+
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false)
+      requested_versions = Array(versions).compact
+      changelog = Gemstar::ChangeLog.new(self)
+      if requested_versions.empty?
+        changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
+      else
+        changelog.sections_for_versions(requested_versions, cache_only: cache_only, force_refresh: force_refresh)
+      end
+    end
+
+    def warm_cache(versions: nil)
+      meta
+      repo_uri
+      changelog_sections(versions: versions)
+    end
+
+    def discover_github_tag_sections?
+      true
+    end
+
+    def github_tag_candidates(version)
+      raw = version.to_s
+      candidates = [raw, (raw.start_with?("v") ? raw : "v#{raw}")]
+
+      package_name = gem_name.to_s
+      unless package_name.empty?
+        candidates << "#{package_name}@#{raw}"
+        candidates << "#{package_name}@v#{raw}" unless raw.start_with?("v")
+
+        short_name = package_name.split("/").last
+        if short_name && short_name != package_name
+          candidates << "#{short_name}@#{raw}"
+          candidates << "#{short_name}@v#{raw}" unless raw.start_with?("v")
+        end
+      end
+
+      candidates.uniq
+    end
+
+    def github_tag_matches?(tag_name)
+      decoded = URI.decode_www_form_component(tag_name.to_s.split("?").first.to_s)
+      package_name = gem_name.to_s
+      return true if package_name.empty?
+
+      if decoded.include?("@")
+        prefix = decoded.sub(/@v?\d[\w.\-]*\z/i, "")
+        return true if prefix == package_name
+
+        short_name = package_name.split("/").last
+        return true if short_name && prefix == short_name
+
+        return false
+      end
+
+      true
+    end
+
+    private
+
+    def normalize_meta(parsed)
+      return nil unless parsed.is_a?(Hash)
+
+      latest_version = parsed.dig("dist-tags", "latest").to_s
+      version_meta = parsed.dig("versions", latest_version)
+      source_code_uri = repository_url(version_meta || parsed)
+      homepage_uri = homepage_url(version_meta || parsed)
+
+      {
+        "name" => parsed["name"],
+        "version" => latest_version.empty? ? nil : latest_version,
+        "info" => (version_meta || parsed)["description"],
+        "homepage_uri" => homepage_uri,
+        "source_code_uri" => source_code_uri,
+        "project_uri" => "https://www.npmjs.com/package/#{parsed["name"]}",
+        "documentation_uri" => homepage_uri
+      }
+    end
+
+    def repository_url(meta)
+      repository = meta["repository"]
+      case repository
+      when Hash
+        repository["url"]
+      when String
+        repository
+      end
+    end
+
+    def homepage_url(meta)
+      meta["homepage"]
+    end
+  end
+end

data/lib/gemstar/outputs/html.rb

@@ -2,6 +2,7 @@
 
 require_relative "basic"
 require "pathname"
+require "cgi"
 require "kramdown"
 begin
   require "kramdown-parser-gfm"
@@ -14,7 +15,7 @@ module Gemstar
     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") ? "🐙" : "💎"
+          icon = icon_for(info)
           tooltip = info[:description] ? "title=\"#{info[:description].gsub('"', "&quot;")}\"" : ""
           link = "<a href=\"#{info[:homepage_url]}\" #{tooltip} target=\"_blank\">#{gem_name}</a>"
           html = if info[:sections]
@@ -38,14 +39,14 @@ module Gemstar
 
           <<~HTML
             <section>
-              <h2>#{icon} #{link}: #{info[:old] || "new"} → #{info[:new]}</h2>
+              <h2>#{icon} #{link}: #{version_label(info)}</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
+        project_name = diff_command.project_name
 
         <<~HTML
           <!DOCTYPE html>
@@ -63,13 +64,61 @@ module Gemstar
             </style>
           </head>
           <body>
-            <h1>#{project_name}: Gem Updates</h1>
+            <h1>#{project_name}: Package 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>
+            #{range_details(diff_command)}
             #{body}
+            #{considered_commits(diff_command)}
           </body>
           </html>
         HTML
       end
+
+      private
+
+      def icon_for(info)
+        return "📦" if info[:package_scope] == "js"
+        return "🐙" if info[:homepage_url]&.include?("github.com")
+
+        "💎"
+      end
+
+      def version_label(info)
+        info[:version_label] || "#{info[:old] || "new"} → #{info[:new]}"
+      end
+
+      def range_details(diff_command)
+        return "" unless diff_command.since
+
+        cutoff = diff_command.format_commit(diff_command.since_cutoff_commit, fallback_revision: diff_command.from)
+        <<~HTML
+          <section>
+            <h2>Diff Range</h2>
+            <p>Since cutoff <code>#{h(diff_command.since)}</code> resolved to #{h(cutoff)}.</p>
+          </section>
+        HTML
+      end
+
+      def considered_commits(diff_command)
+        commits = Array(diff_command.considered_commits)
+        items = commits.map do |commit|
+          %(<li><code>#{h(commit[:short_sha] || commit[:id])}</code> #{h(commit[:authored_at])} #{h(commit[:subject])}</li>)
+        end.join("\n")
+        items = "<li>No commits found in this range.</li>" if items.empty?
+
+        <<~HTML
+          <section>
+            <h2>Commits Considered</h2>
+            <ul>
+              #{items}
+            </ul>
+          </section>
+        HTML
+      end
+
+      def h(value)
+        CGI.escapeHTML(value.to_s)
+      end
     end
   end
 end

data/lib/gemstar/outputs/markdown.rb

@@ -9,17 +9,21 @@ module Gemstar
   module Outputs
     class Markdown < Basic
       def render_diff(diff_command)
-        project_name = Pathname.getwd.basename.to_s
+        project_name = diff_command.project_name
         body = diff_command.updates.sort.map do |gem_name, info|
           render_entry(gem_name, info)
         end.join("\n\n---\n\n")
 
         <<~MARKDOWN
-          # #{project_name}: Gem Updates
+          # #{project_name}: Package Updates
 
           _Showing changes from #{diff_command.from} to #{diff_command.to || "now"}, generated on #{Time.now.strftime("%Y-%m-%d %H:%M:%S %z")}._
 
+          #{range_details(diff_command)}
+
           #{body}
+
+          #{considered_commits(diff_command)}
         MARKDOWN
       end
 
@@ -35,7 +39,7 @@ module Gemstar
         parts = []
         parts << title
         parts << ""
-        parts << "*#{info[:old] || "new"} → #{info[:new]}*"
+        parts << "*#{info[:version_label] || "#{info[:old] || "new"} → #{info[:new]}"}*"
         parts << ""
         parts << info[:description].to_s unless info[:description].to_s.empty?
         parts << "" unless info[:description].to_s.empty?
@@ -53,6 +57,28 @@ module Gemstar
         parts.join("\n").strip
       end
 
+      def range_details(diff_command)
+        return "" unless diff_command.since
+
+        cutoff = diff_command.format_commit(diff_command.since_cutoff_commit, fallback_revision: diff_command.from)
+        "## Diff Range\n\nSince cutoff `#{diff_command.since}` resolved to #{cutoff}."
+      end
+
+      def considered_commits(diff_command)
+        commits = Array(diff_command.considered_commits)
+        lines = ["## Commits Considered", ""]
+
+        if commits.empty?
+          lines << "No commits found in this range."
+        else
+          lines.concat(commits.map do |commit|
+            "- `#{commit[:short_sha] || commit[:id]}` #{commit[:authored_at]} #{commit[:subject]}"
+          end)
+        end
+
+        lines.join("\n")
+      end
+
       def link_lines(info)
         lines = []
         lines << "[Compare changes](#{info[:compare_url]})" if info[:compare_url]

data/lib/gemstar/package_lock_file.rb

@@ -0,0 +1,101 @@
+require "json"
+
+module Gemstar
+  class PackageLockFile
+    def initialize(path: nil, content: nil)
+      @path = path
+      parsed = parse_content(content || File.read(path))
+      @specs = parsed[:specs]
+      @spec_sources = parsed[:spec_sources]
+    end
+
+    attr_reader :specs
+    attr_reader :spec_sources
+
+    def source_for(name)
+      spec_sources[name]
+    end
+
+    private
+
+    def parse_content(content)
+      parsed = JSON.parse(content)
+      specs = {}
+      spec_sources = {}
+
+      if parsed["packages"].is_a?(Hash)
+        parse_packages_map(parsed["packages"], specs, spec_sources)
+      elsif parsed["dependencies"].is_a?(Hash)
+        parse_dependencies_hash(parsed["dependencies"], specs, spec_sources)
+      end
+
+      {
+        specs: specs,
+        spec_sources: spec_sources
+      }
+    end
+
+    def parse_packages_map(packages, specs, spec_sources)
+      packages.each do |path, package|
+        next if path.to_s.empty?
+
+        name = package["name"] || package_name_from_path(path)
+        version = package["version"]
+        next if name.to_s.empty? || version.to_s.empty?
+
+        specs[name] = version
+        spec_sources[name] = {
+          type: :npm,
+          remote: package["resolved"],
+          integrity: package["integrity"],
+          registry_url: "https://www.npmjs.com/package/#{name}"
+        }.compact
+      end
+    end
+
+    def parse_dependencies_hash(dependencies, specs, spec_sources)
+      dependencies.each do |name, package|
+        version = package["version"]
+        next if name.to_s.empty? || version.to_s.empty?
+
+        specs[name] = version
+        spec_sources[name] = {
+          type: :npm,
+          remote: package["resolved"],
+          integrity: package["integrity"],
+          registry_url: "https://www.npmjs.com/package/#{name}"
+        }.compact
+
+        child_dependencies = package["dependencies"]
+        parse_dependencies_hash(child_dependencies, specs, spec_sources) if child_dependencies.is_a?(Hash)
+      end
+    end
+
+    def package_name_from_path(path)
+      value = path.to_s
+      return nil if value.empty?
+
+      segments = value.split("/").reject(&:empty?)
+      package_segments = []
+      index = 0
+      while index < segments.length
+        if segments[index] == "node_modules"
+          index += 1
+          next
+        end
+
+        if segments[index].start_with?("@") && segments[index + 1]
+          package_segments = [segments[index], segments[index + 1]]
+          index += 2
+        else
+          package_segments = [segments[index]]
+          index += 1
+        end
+      end
+
+      return nil if package_segments.empty?
+
+      package_segments.join("/")
+    end
+  end
+end