gemstar 1.1.1 → 1.3

data/lib/gemstar/project.rb

@@ -1,8 +1,29 @@
 require "time"
+require_relative "cargo_lock_file"
+require_relative "uv_lock_file"
 
 module Gemstar
   class Project
     REVISION_HISTORY_LIMIT = 100
+    SUPPORTED_PROJECT_FILES = [
+      "Gemfile",
+      "Gemfile.lock",
+      "config/importmap.rb",
+      "package.json",
+      "package-lock.json",
+      "uv.lock",
+      "Cargo.toml",
+      "Cargo.lock"
+    ].freeze
+
+    class UnsupportedProjectError < ArgumentError
+      def initialize(directory)
+        super(<<~MESSAGE.chomp)
+          Directory #{File.expand_path(directory)} does not contain a recognized project file.
+          Only #{Project.supported_project_files_sentence} are supported.
+        MESSAGE
+      end
+    end
 
     attr_reader :directory
     attr_reader :gemfile_path
@@ -10,6 +31,9 @@ module Gemstar
     attr_reader :importmap_path
     attr_reader :package_json_path
     attr_reader :package_lock_path
+    attr_reader :uv_lock_path
+    attr_reader :cargo_toml_path
+    attr_reader :cargo_lock_path
     attr_reader :name
 
     def self.from_cli_argument(input)
@@ -20,26 +44,36 @@ module Gemstar
         basename = File.basename(expanded_input)
         directory =
           case basename
-          when "Gemfile", "package.json", "package-lock.json"
+          when "Gemfile", "Gemfile.lock", "package.json", "package-lock.json", "uv.lock", "Cargo.toml", "Cargo.lock"
             File.dirname(expanded_input)
           when "importmap.rb"
-            File.dirname(File.dirname(expanded_input))
-          else
-            nil
+            File.dirname(expanded_input, 2)
           end
       end
 
-      raise ArgumentError, "No supported project files found for #{input}" unless directory
-      raise ArgumentError, "No supported project files found for #{input}" unless supported_project_directory?(directory)
+      unless directory
+        unsupported_directory = File.directory?(expanded_input) ? expanded_input : File.dirname(expanded_input)
+        raise UnsupportedProjectError, unsupported_directory
+      end
+
+      raise UnsupportedProjectError, directory unless supported_project_directory?(directory)
 
       new(directory: directory)
     end
 
     def self.supported_project_directory?(directory)
       File.file?(File.join(directory, "Gemfile")) ||
+        File.file?(File.join(directory, "Gemfile.lock")) ||
         File.file?(File.join(directory, "config", "importmap.rb")) ||
         File.file?(File.join(directory, "package.json")) ||
-        File.file?(File.join(directory, "package-lock.json"))
+        File.file?(File.join(directory, "package-lock.json")) ||
+        File.file?(File.join(directory, "uv.lock")) ||
+        File.file?(File.join(directory, "Cargo.toml")) ||
+        File.file?(File.join(directory, "Cargo.lock"))
+    end
+
+    def self.supported_project_files_sentence
+      "#{SUPPORTED_PROJECT_FILES[0...-1].join(", ")}, and #{SUPPORTED_PROJECT_FILES[-1]}"
     end
 
     def initialize(directory:)
@@ -49,10 +83,15 @@ module Gemstar
       @importmap_path = File.join(@directory, "config", "importmap.rb")
       @package_json_path = File.join(@directory, "package.json")
       @package_lock_path = File.join(@directory, "package-lock.json")
+      @uv_lock_path = File.join(@directory, "uv.lock")
+      @cargo_toml_path = File.join(@directory, "Cargo.toml")
+      @cargo_lock_path = File.join(@directory, "Cargo.lock")
       @name = File.basename(@directory)
       @lockfile_cache = {}
       @importmap_cache = {}
       @package_lock_cache = {}
+      @uv_lock_cache = {}
+      @cargo_lock_cache = {}
       @gem_states_cache = {}
       @gem_added_on_cache = {}
       @history_cache = {}
@@ -104,6 +143,46 @@ module Gemstar
       @current_package_lock ||= Gemstar::PackageLockFile.new(path: package_lock_path)
     end
 
+    def uv_lock?
+      File.file?(uv_lock_path)
+    end
+
+    def current_uv_lock
+      return nil unless uv_lock?
+
+      @current_uv_lock ||= Gemstar::UvLockFile.new(path: uv_lock_path)
+    end
+
+    def cargo_toml?
+      File.file?(cargo_toml_path)
+    end
+
+    def cargo_lock?
+      File.file?(cargo_lock_path)
+    end
+
+    def current_cargo_lock
+      return nil unless cargo_lock?
+
+      @current_cargo_lock ||= Gemstar::CargoLockFile.new(path: cargo_lock_path)
+    end
+
+    def clear_cache!
+      @current_lockfile = nil
+      @current_importmap = nil
+      @current_package_lock = nil
+      @current_uv_lock = nil
+      @current_cargo_lock = nil
+      @lockfile_cache.clear
+      @importmap_cache.clear
+      @package_lock_cache.clear
+      @uv_lock_cache.clear
+      @cargo_lock_cache.clear
+      @gem_states_cache.clear
+      @gem_added_on_cache.clear
+      @history_cache.clear
+    end
+
     def revision_history(limit: REVISION_HISTORY_LIMIT)
       history_for_paths(tracked_git_paths, limit: limit)
     end
@@ -133,7 +212,7 @@ module Gemstar
     end
 
     def revision_options(limit: REVISION_HISTORY_LIMIT)
-      [{ id: "worktree", label: "Worktree", description: "Current Gemfile.lock in the working tree" }] +
+      [{ id: "worktree", label: "Worktree", description: "Current project files in the working tree" }] +
         revision_history(limit: limit).map do |revision|
           {
             id: revision[:id],
@@ -147,6 +226,8 @@ module Gemstar
       scopes = []
       scopes << :gems if gemfile? || lockfile?
       scopes << :js if importmap? || package_lock? || package_json?
+      scopes << :python if uv_lock?
+      scopes << :cargo if cargo_toml? || cargo_lock?
       scopes
     end
 
@@ -163,6 +244,16 @@ module Gemstar
       package_scopes == [:gems] ? "Gems" : "Packages"
     end
 
+    def package_item_label
+      case package_scopes
+      when [:gems] then "gem"
+      when [:js] then "JavaScript package"
+      when [:python] then "Python package"
+      when [:cargo] then "Rust crate"
+      else "package"
+      end
+    end
+
     def lockfile_for_revision(revision_id)
       cache_key = revision_id || "worktree"
       return @lockfile_cache[cache_key] if @lockfile_cache.key?(cache_key)
@@ -208,6 +299,36 @@ module Gemstar
       @package_lock_cache[cache_key] = Gemstar::PackageLockFile.new(content: content)
     end
 
+    def uv_lock_for_revision(revision_id)
+      cache_key = revision_id || "worktree"
+      return @uv_lock_cache[cache_key] if @uv_lock_cache.key?(cache_key)
+      return @uv_lock_cache[cache_key] = current_uv_lock if revision_id.nil? || revision_id == "worktree"
+      return nil unless uv_lock?
+
+      relative_uv_lock_path = git_repo.relative_path(uv_lock_path)
+      return nil if relative_uv_lock_path.nil?
+
+      content = git_repo.try_git_command(["show", "#{revision_id}:#{relative_uv_lock_path}"])
+      return nil if content.nil? || content.empty?
+
+      @uv_lock_cache[cache_key] = Gemstar::UvLockFile.new(content: content)
+    end
+
+    def cargo_lock_for_revision(revision_id)
+      cache_key = revision_id || "worktree"
+      return @cargo_lock_cache[cache_key] if @cargo_lock_cache.key?(cache_key)
+      return @cargo_lock_cache[cache_key] = current_cargo_lock if revision_id.nil? || revision_id == "worktree"
+      return nil unless cargo_lock?
+
+      relative_cargo_lock_path = git_repo.relative_path(cargo_lock_path)
+      return nil if relative_cargo_lock_path.nil?
+
+      content = git_repo.try_git_command(["show", "#{revision_id}:#{relative_cargo_lock_path}"])
+      return nil if content.nil? || content.empty?
+
+      @cargo_lock_cache[cache_key] = Gemstar::CargoLockFile.new(content: content)
+    end
+
     def gem_states(from_revision_id: default_from_revision_id, to_revision_id: "worktree")
       cache_key = [from_revision_id, to_revision_id]
       return @gem_states_cache[cache_key] if @gem_states_cache.key?(cache_key)
@@ -298,11 +419,67 @@ module Gemstar
         }
       end
 
-      @gem_states_cache[cache_key] = (gem_states + js_states + npm_states).sort_by { |gem| [gem[:name], gem[:package_scope], gem[:package_source_file].to_s] }
+      from_uv_lock = uv_lock_for_revision(from_revision_id)
+      to_uv_lock = uv_lock_for_revision(to_revision_id)
+      from_python_specs = from_uv_lock&.specs || {}
+      to_python_specs = to_uv_lock&.specs || {}
+      python_states = (from_python_specs.keys | to_python_specs.keys).map do |package_name|
+        old_version = from_python_specs[package_name]
+        new_version = to_python_specs[package_name]
+        effective_uv_lock = new_version ? to_uv_lock : from_uv_lock
+
+        {
+          name: package_name,
+          package_scope: "python",
+          package_type_label: "Python",
+          package_source_file: :uv_lock,
+          old_version: old_version,
+          new_version: new_version,
+          status: gem_status(old_version, new_version),
+          version_label: version_label(old_version, new_version),
+          platform: nil,
+          source: effective_uv_lock&.source_for(package_name),
+          bundle_origins: [],
+          bundle_origin_labels: []
+        }
+      end
+
+      from_cargo_lock = cargo_lock_for_revision(from_revision_id)
+      to_cargo_lock = cargo_lock_for_revision(to_revision_id)
+      from_cargo_specs = from_cargo_lock&.specs || {}
+      to_cargo_specs = to_cargo_lock&.specs || {}
+      cargo_states = (from_cargo_specs.keys | to_cargo_specs.keys).map do |package_key|
+        old_version = from_cargo_specs[package_key]
+        new_version = to_cargo_specs[package_key]
+        effective_cargo_lock = new_version ? to_cargo_lock : from_cargo_lock
+        source = effective_cargo_lock&.source_for(package_key)
+        package_name = source&.dig(:package_name) || package_key
+        display_name = package_key == package_name ? package_name : "#{package_name} @ #{new_version || old_version}"
+
+        {
+          name: display_name,
+          metadata_package_name: package_name,
+          package_lock_key: package_key,
+          package_scope: "cargo",
+          package_type_label: "Crate",
+          package_source_file: :cargo_lock,
+          old_version: old_version,
+          new_version: new_version,
+          status: gem_status(old_version, new_version),
+          version_label: version_label(old_version, new_version),
+          platform: nil,
+          source: source,
+          bundle_origins: [],
+          bundle_origin_labels: []
+        }
+      end
+
+      @gem_states_cache[cache_key] = (gem_states + js_states + npm_states + python_states + cargo_states).sort_by { |gem| [gem[:name], gem[:package_scope], gem[:package_source_file].to_s] }
     end
 
-    def package_added_on(package_name, package_scope:, revision_id: "worktree", source_file: nil)
-      cache_key = [package_name, package_scope, source_file, revision_id]
+    def package_added_on(package_name, package_scope:, revision_id: "worktree", source_file: nil, package_key: nil)
+      lookup_name = package_key || package_name
+      cache_key = [lookup_name, package_scope, source_file, revision_id]
       return @gem_added_on_cache[cache_key] if @gem_added_on_cache.key?(cache_key)
 
       tracked_file, reader =
@@ -310,22 +487,30 @@ module Gemstar
           [importmap_path, method(:importmap_for_revision)]
         elsif source_file == :package_lock
           [package_lock_path, method(:package_lock_for_revision)]
+        elsif source_file == :uv_lock
+          [uv_lock_path, method(:uv_lock_for_revision)]
+        elsif source_file == :cargo_lock
+          [cargo_lock_path, method(:cargo_lock_for_revision)]
         elsif package_scope == "js"
           [importmap_path, method(:importmap_for_revision)]
+        elsif package_scope == "python"
+          [uv_lock_path, method(:uv_lock_for_revision)]
+        elsif package_scope == "cargo"
+          [cargo_lock_path, method(:cargo_lock_for_revision)]
         else
           [lockfile_path, method(:lockfile_for_revision)]
         end
       return @gem_added_on_cache[cache_key] = nil unless File.file?(tracked_file)
 
       target_snapshot = reader.call(revision_id)
-      return @gem_added_on_cache[cache_key] = nil unless target_snapshot&.specs&.key?(package_name)
+      return @gem_added_on_cache[cache_key] = nil unless target_snapshot&.specs&.key?(lookup_name)
 
       relative_path = git_repo.relative_path(tracked_file)
       return @gem_added_on_cache[cache_key] = nil if relative_path.nil?
 
       first_seen_revision = history_for_paths([relative_path], limit: nil, reverse: true).find do |revision|
         snapshot = reader.call(revision[:id])
-        snapshot&.specs&.key?(package_name)
+        snapshot&.specs&.key?(lookup_name)
       end
 
       return @gem_added_on_cache[cache_key] = worktree_added_on_info(tracked_file) if first_seen_revision.nil? && revision_id == "worktree"
@@ -346,14 +531,20 @@ module Gemstar
       current_specs = current_lockfile&.specs || {}
       current_importmap_specs = current_importmap&.specs || {}
       current_package_lock_specs = current_package_lock&.specs || {}
+      current_uv_lock_specs = current_uv_lock&.specs || {}
+      current_cargo_lock_specs = current_cargo_lock&.specs || {}
 
       revision_history(limit: REVISION_HISTORY_LIMIT).find do |revision|
         revision_lockfile = lockfile_for_revision(revision[:id])
         revision_importmap = importmap_for_revision(revision[:id])
         revision_package_lock = package_lock_for_revision(revision[:id])
+        revision_uv_lock = uv_lock_for_revision(revision[:id])
+        revision_cargo_lock = cargo_lock_for_revision(revision[:id])
         (revision_lockfile && revision_lockfile.specs != current_specs) ||
           (revision_importmap && revision_importmap.specs != current_importmap_specs) ||
-          (revision_package_lock && revision_package_lock.specs != current_package_lock_specs)
+          (revision_package_lock && revision_package_lock.specs != current_package_lock_specs) ||
+          (revision_uv_lock && revision_uv_lock.specs != current_uv_lock_specs) ||
+          (revision_cargo_lock && revision_cargo_lock.specs != current_cargo_lock_specs)
       end&.dig(:id)
     end
 
@@ -384,7 +575,7 @@ module Gemstar
     end
 
     def tracked_git_paths
-      [gemfile_path, lockfile_path, importmap_path, package_json_path, package_lock_path, *importmap_vendor_paths].filter_map do |path|
+      [gemfile_path, lockfile_path, importmap_path, package_json_path, package_lock_path, uv_lock_path, cargo_toml_path, cargo_lock_path, *importmap_vendor_paths].filter_map do |path|
         next unless File.file?(path)
 
         git_repo.relative_path(path)
@@ -531,6 +722,7 @@ module Gemstar
       when :gems then "gems"
       when :js then "js"
       when :python then "python"
+      when :cargo then "cargo"
       else scope.to_s
       end
     end
@@ -540,6 +732,7 @@ module Gemstar
       when :gems then "Gems"
       when :js then "JS"
       when :python then "Python"
+      when :cargo then "Cargo"
       else scope.to_s.capitalize
       end
     end

data/lib/gemstar/pypi_metadata.rb

@@ -0,0 +1,182 @@
+require "json"
+require "open-uri"
+require "time"
+require "uri"
+
+module Gemstar
+  class PyPIMetadata
+    def initialize(package_name)
+      @package_name = package_name
+    end
+
+    attr_reader :package_name
+
+    alias_method :gem_name, :package_name
+
+    def cache_key
+      "pypi-#{package_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://pypi.org/pypi/#{URI.encode_www_form_component(package_name)}/json"
+        Cache.fetch(cache_key, force: force_refresh) do
+          URI.parse(url).open(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)
+
+      uri = resolved_meta["source_code_uri"]
+      uri ||= resolved_meta["homepage_uri"] if resolved_meta["homepage_uri"].to_s.include?("github.com")
+      uri = normalize_repo_uri(uri)
+
+      @repo_uri = uri unless cache_only
+      uri
+    end
+
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: 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, use_github_cli: use_github_cli)
+      end
+    end
+
+    def registry_release_dates(cache_only: false, force_refresh: false)
+      parsed = raw_meta(cache_only: cache_only, force_refresh: force_refresh)
+      Array(parsed&.dig("releases")).each_with_object({}) do |(version, files), dates|
+        uploaded_at = Array(files).filter_map { |file| file["upload_time_iso_8601"] || file["upload_time"] }.min
+        next if version.to_s.empty? || uploaded_at.to_s.empty?
+
+        dates[version] = Time.parse(uploaded_at).utc.strftime("%b %-d, %Y")
+      end
+    rescue JSON::ParserError, ArgumentError
+      {}
+    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}")]
+      candidates << "release_#{raw}"
+      candidates << "release_v#{raw}" unless raw.start_with?("v")
+
+      if raw.match?(/\A\d+\.\d\z/)
+        padded_minor = "#{raw}0"
+        candidates << padded_minor
+        candidates << "v#{padded_minor}"
+        candidates << "release_#{padded_minor}"
+        candidates << "release_v#{padded_minor}"
+      end
+
+      if raw.match?(/\A\d{4}\.\d{1,2}\.\d{1,2}\z/)
+        year, month, day = raw.split(".")
+        dotted_date = [year, month.rjust(2, "0"), day.rjust(2, "0")].join(".")
+        candidates << dotted_date
+        candidates << "v#{dotted_date}"
+        candidates << "release_#{dotted_date}"
+        candidates << "release_v#{dotted_date}"
+      end
+
+      candidates.uniq
+    end
+
+    def github_tag_matches?(_tag_name)
+      true
+    end
+
+    private
+
+    def raw_meta(cache_only: false, force_refresh: false)
+      json = if cache_only
+        Cache.peek(cache_key)
+      else
+        url = "https://pypi.org/pypi/#{URI.encode_www_form_component(package_name)}/json"
+        Cache.fetch(cache_key, force: force_refresh) do
+          URI.parse(url).open(read_timeout: 8).read
+        end
+      end
+
+      JSON.parse(json) if json
+    end
+
+    def normalize_meta(parsed)
+      return nil unless parsed.is_a?(Hash)
+
+      info = parsed["info"] || {}
+      project_urls = info["project_urls"] || {}
+      source_code_uri = project_url(project_urls, "Source", "Source Code", "Code", "Repository", "GitHub")
+      homepage_uri = info["home_page"].to_s.empty? ? nil : info["home_page"]
+      homepage_uri ||= project_url(project_urls, "Homepage", "Home", "homepage")
+      changelog_uri = project_url(project_urls, "Changelog", "Change Log", "Changes", "Release Notes", "Release notes", "History")
+
+      {
+        "name" => info["name"] || package_name,
+        "version" => info["version"],
+        "info" => info["summary"] || info["description"],
+        "homepage_uri" => homepage_uri,
+        "source_code_uri" => source_code_uri,
+        "project_uri" => info["package_url"] || "https://pypi.org/project/#{package_name}/",
+        "documentation_uri" => project_url(project_urls, "Documentation", "Docs", "documentation"),
+        "changelog_uri" => changelog_uri
+      }
+    end
+
+    def project_url(project_urls, *names)
+      normalized_urls = project_urls.transform_keys { |key| key.to_s.downcase.gsub(/[\s_-]+/, "") }
+      names.each do |name|
+        value = normalized_urls[name.to_s.downcase.gsub(/[\s_-]+/, "")]
+        return value unless value.to_s.empty?
+      end
+
+      nil
+    end
+
+    def normalize_repo_uri(uri)
+      value = uri.to_s
+      return "" if value.empty?
+
+      value = value.sub(/\Agit\+/, "")
+      value = value.sub(/\Agit:\/\//, "https://")
+      value = value.sub(/\Ahttp:\/\//, "https://")
+      value = value.gsub(/\.git\z/, "")
+
+      if value.include?("github.com")
+        value = value[%r{\Ahttps?://github\.com/[^/]+/[^/]+}] || value
+      end
+
+      value
+    end
+  end
+end

data/lib/gemstar/ruby_gems_metadata.rb

@@ -88,8 +88,19 @@ module Gemstar
       repo
     end
 
-    def changelog_sections(versions: nil, cache_only: false, force_refresh: false)
-      Gemstar::ChangeLog.new(self).sections(cache_only: cache_only, force_refresh: force_refresh)
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: false)
+      changelog = Gemstar::ChangeLog.new(self)
+      if use_github_cli && Array(versions).compact.any?
+        changelog.sections_for_versions(versions, cache_only: cache_only, force_refresh: force_refresh, use_github_cli: true)
+      else
+        changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
+      end
+    end
+
+    def correct_changelog_version(version, heading:)
+      overrides = package_metadata.dig("changelog", "version_overrides") || {}
+      release_date = heading.to_s[/\b\d{4}-\d{2}-\d{2}\b/]
+      overrides.fetch([version, release_date].compact.join("@"), version)
     end
 
     def registry_release_dates(cache_only: false, force_refresh: false)
@@ -140,7 +151,11 @@ module Gemstar
         override_branches = Array(override["branches"]).compact
         override_branches = [""] if override_branches.empty? && override["raw_base"]
         return {
-          base: expand_metadata_template(override["raw_base"] || github_raw_base(repo_uri)),
+          base: expand_metadata_template(
+            override["raw_base"] || github_raw_base(repo_uri),
+            cache_only: cache_only,
+            force_refresh: force_refresh
+          ),
           paths: override_paths.empty? ? Gemstar::ChangeLog::DEFAULT_CHANGELOG_PATHS : override_paths,
           branches: override_branches.empty? ? RemoteRepository.new(github_raw_base(repo_uri)).find_main_branch(cache_only: cache_only, force_refresh: force_refresh) : override_branches
         }
@@ -166,8 +181,21 @@ module Gemstar
       repo_uri.sub("https://github.com", "https://raw.githubusercontent.com").chomp("/")
     end
 
-    def expand_metadata_template(value)
-      value.to_s.gsub("{gem_name}", gem_name)
+    def expand_metadata_template(value, cache_only: false, force_refresh: false)
+      version = metadata_template_version(cache_only: cache_only, force_refresh: force_refresh)
+      value.to_s.gsub("{gem_name}", gem_name).gsub("{version}", version)
+    end
+
+    def metadata_template_version(cache_only: false, force_refresh: false)
+      version = meta(cache_only: cache_only, force_refresh: force_refresh)&.dig("version").to_s
+      return version unless version.empty?
+
+      override_versions = package_metadata.dig("changelog", "version_overrides")
+      Array(override_versions&.values).compact.map(&:to_s).reject(&:empty?).max_by do |override_version|
+        Gem::Version.new(override_version)
+      rescue ArgumentError
+        Gem::Version.new("0")
+      end.to_s
     end
 
     def format_registry_release_date(datetime)