gemstar 1.0.2 → 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/lock_file.rb

@@ -5,26 +5,72 @@ module Gemstar
       parsed = content ? parse_content(content) : parse_lockfile(path)
       @specs = parsed[:specs]
       @dependency_graph = parsed[:dependency_graph]
+      @dependency_requirements = parsed[:dependency_requirements]
       @direct_dependencies = parsed[:direct_dependencies]
+      @direct_dependency_requirements = parsed[:direct_dependency_requirements]
+      @spec_sources = parsed[:spec_sources]
     end
 
     attr_reader :specs
     attr_reader :dependency_graph
+    attr_reader :dependency_requirements
     attr_reader :direct_dependencies
+    attr_reader :direct_dependency_requirements
+    attr_reader :spec_sources
 
     def origins_for(gem_name)
-      return [{ type: :direct, path: [gem_name] }] if direct_dependencies.include?(gem_name)
+      if direct_dependencies.include?(gem_name)
+        return [{
+          type: :direct,
+          path: [gem_name],
+          requirement: direct_dependency_requirements[gem_name]
+        }]
+      end
 
       direct_dependencies.filter_map do |root_dependency|
         path = shortest_path_from(root_dependency, gem_name)
         next if path.nil?
 
-        { type: :transitive, path: path }
+        parent_name = path[-2]
+        {
+          type: :transitive,
+          path: path,
+          requirement: dependency_requirements.dig(parent_name, gem_name)
+        }
       end
     end
 
+    def source_for(gem_name)
+      spec_sources[gem_name]
+    end
+
+    def platform_for(gem_name)
+      version = specs[gem_name].to_s
+      parts = version.split("-")
+      return nil if parts.length < 2
+
+      1.upto(parts.length - 1) do |index|
+        candidate_version = parts[0...index].join("-")
+        candidate_platform = parts[index..].join("-")
+        next unless plausible_platform_suffix?(candidate_platform)
+
+        begin
+          Gem::Version.new(candidate_version)
+          return candidate_platform
+        rescue ArgumentError
+          next
+        end
+      end
+
+      nil
+    end
+
     private
 
+    def plausible_platform_suffix?(suffix)
+      suffix.match?(/darwin|linux|mingw|mswin|musl|java|x86|arm|universal/i)
+    end
+
     def shortest_path_from(root_dependency, target_gem)
       queue = [[root_dependency, [root_dependency]]]
       visited = {}
@@ -53,9 +99,13 @@ module Gemstar
     def parse_content(content)
       specs = {}
       dependency_graph = Hash.new { |hash, key| hash[key] = [] }
+      dependency_requirements = Hash.new { |hash, key| hash[key] = {} }
       direct_dependencies = []
+      direct_dependency_requirements = {}
+      spec_sources = {}
       current_section = nil
       current_spec = nil
+      current_source = nil
 
       content.each_line do |line|
         stripped = line.strip
@@ -68,12 +118,28 @@ module Gemstar
         if stripped == "GEM"
           current_section = :gem
           current_spec = nil
+          current_source = { type: :rubygems }
+          next
+        end
+
+        if stripped == "PATH"
+          current_section = :path
+          current_spec = nil
+          current_source = { type: :path }
+          next
+        end
+
+        if stripped == "GIT"
+          current_section = :git
+          current_spec = nil
+          current_source = { type: :git }
           next
         end
 
         if stripped == "DEPENDENCIES"
           current_section = :dependencies
           current_spec = nil
+          current_source = nil
           next
         end
 
@@ -83,17 +149,30 @@ module Gemstar
         end
 
         case current_section
-        when :gem
-          if line =~ /^\s{4}(\S+) \((.+)\)/
+        when :gem, :path, :git
+          if line =~ /^\s{2}remote:\s+(.+)$/
+            current_source = (current_source || {}).merge(remote: Regexp.last_match(1))
+          elsif line =~ /^\s{2}(revision|branch|tag|ref|glob|submodules):\s+(.+)$/
+            current_source = (current_source || {}).merge(Regexp.last_match(1).to_sym => Regexp.last_match(2))
+          elsif line =~ /^\s{2}path:\s+(.+)$/
+            current_source = (current_source || {}).merge(path: Regexp.last_match(1))
+          elsif line =~ /^\s{4}(\S+) \((.+)\)/
             name, version = Regexp.last_match(1), Regexp.last_match(2)
             specs[name] = version
+            spec_sources[name] = (current_source || {}).dup
             current_spec = name
-          elsif current_spec && line =~ /^\s{6}([^\s(]+)/
-            dependency_graph[current_spec] << Regexp.last_match(1)
+          elsif current_spec && line =~ /^\s{6}([^\s(]+)(?: \(([^)]+)\))?/
+            dependency_name = Regexp.last_match(1)
+            requirement = Regexp.last_match(2)
+            dependency_graph[current_spec] << dependency_name
+            dependency_requirements[current_spec][dependency_name] = requirement if requirement && !requirement.empty?
           end
         when :dependencies
-          if line =~ /^\s{2}([^\s!(]+)/
-            direct_dependencies << Regexp.last_match(1)
+          if line =~ /^\s{2}([^\s!(]+)(?: \(([^)]+)\))?/
+            dependency_name = Regexp.last_match(1)
+            requirement = Regexp.last_match(2)
+            direct_dependencies << dependency_name
+            direct_dependency_requirements[dependency_name] = requirement if requirement && !requirement.empty?
           end
         end
       end
@@ -101,7 +180,10 @@ module Gemstar
       {
         specs: specs,
         dependency_graph: dependency_graph.transform_values(&:uniq),
-        direct_dependencies: direct_dependencies.uniq
+        dependency_requirements: dependency_requirements,
+        direct_dependencies: direct_dependencies.uniq,
+        direct_dependency_requirements: direct_dependency_requirements,
+        spec_sources: spec_sources
       }
     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]