gemstar 0.0.2 → 1.0

data/lib/gemstar/config.rb

@@ -0,0 +1,15 @@
+require "fileutils"
+
+module Gemstar
+  module Config
+    module_function
+
+    def home_directory
+      File.expand_path("~/.config/gemstar")
+    end
+
+    def ensure_home_directory!
+      FileUtils.mkdir_p(home_directory)
+    end
+  end
+end

data/lib/gemstar/git_repo.rb

@@ -1,25 +1,36 @@
+require "open3"
+require "pathname"
+
 module Gemstar
   class GitRepo
+    attr_reader :tree_root_directory
+
     def initialize(specified_directory)
       @specified_directory = specified_directory || Dir.pwd
-      @tree_root_directory = find_git_root(File.dirname(@specified_directory))
+      search_directory = if File.directory?(@specified_directory)
+        @specified_directory
+      else
+        File.dirname(@specified_directory)
+      end
+      @tree_root_directory = find_git_root(search_directory)
     end
 
     def find_git_root(directory)
-      # return directory if File.directory?(File.join(directory, ".git"))
-      # find_git_root(File.dirname(directory))
-
-      run_git_command(%W[rev-parse --show-toplevel])
+      try_git_command(%W[rev-parse --show-toplevel], in_directory: directory)
     end
 
     def git_client
       "git"
     end
 
-    def run_git_command(command, in_directory: @specified_directory, strip: true)
+    def build_git_command(command, in_directory: @specified_directory)
       git_command = [git_client]
       git_command += ["-C", in_directory] if in_directory
-      git_command += command
+      git_command + command
+    end
+
+    def run_git_command(command, in_directory: @specified_directory, strip: true)
+      git_command = build_git_command(command, in_directory:)
 
       puts %[run_git_command (joined): #{git_command.join(" ")}] if Gemstar.debug?
 
@@ -28,6 +39,17 @@ module Gemstar
       strip ? output.strip : output
     end
 
+    def try_git_command(command, in_directory: @specified_directory, strip: true)
+      git_command = build_git_command(command, in_directory:)
+
+      puts %[try_git_command (joined): #{git_command.join(" ")}] if Gemstar.debug?
+
+      output, status = Open3.capture2e(*git_command)
+      return nil unless status.success?
+
+      strip ? output.strip : output
+    end
+
     def resolve_commit(revish, default_branch: "HEAD")
       # If it looks like a pure date (or you want to support "date only"),
       # map it to "latest commit before date on default_branch".
@@ -51,5 +73,50 @@ module Gemstar
     def get_full_path(path)
       run_git_command(["ls-files", "--full-name", "--", path])
     end
+
+    def relative_path(path)
+      return nil if tree_root_directory.nil? || tree_root_directory.empty?
+
+      Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(tree_root_directory)).to_s
+    rescue ArgumentError
+      nil
+    end
+
+    def origin_repo_url
+      remote = try_git_command(["remote", "get-url", "origin"])
+      return nil if remote.nil? || remote.empty?
+
+      normalize_remote_url(remote)
+    end
+
+    def log_for_paths(paths, limit: 20, reverse: false)
+      return "" if tree_root_directory.nil? || tree_root_directory.empty? || paths.empty?
+
+      format = "%H%x1f%h%x1f%aI%x1f%s"
+      command = ["log"]
+      command += ["-n", limit.to_s] if limit
+      command << "--reverse" if reverse
+      command += ["--pretty=format:#{format}", "--", *paths]
+
+      run_git_command(command, in_directory: tree_root_directory)
+    end
+
+    private
+
+    def normalize_remote_url(remote)
+      normalized = remote.strip.sub(%r{\.git\z}, "")
+
+      if normalized.start_with?("git@github.com:")
+        path = normalized.delete_prefix("git@github.com:")
+        return "https://github.com/#{path}"
+      end
+
+      if normalized.start_with?("ssh://git@github.com/")
+        path = normalized.delete_prefix("ssh://git@github.com/")
+        return "https://github.com/#{path}"
+      end
+
+      normalized.sub(%r{\Ahttp://}, "https://")
+    end
   end
 end

data/lib/gemstar/lock_file.rb

@@ -2,29 +2,107 @@ module Gemstar
   class LockFile
     def initialize(path: nil, content: nil)
       @path = path
-      @specs = content ? parse_content(content) : parse_lockfile(path)
+      parsed = content ? parse_content(content) : parse_lockfile(path)
+      @specs = parsed[:specs]
+      @dependency_graph = parsed[:dependency_graph]
+      @direct_dependencies = parsed[:direct_dependencies]
     end
 
     attr_reader :specs
+    attr_reader :dependency_graph
+    attr_reader :direct_dependencies
+
+    def origins_for(gem_name)
+      return [{ type: :direct, path: [gem_name] }] if direct_dependencies.include?(gem_name)
+
+      direct_dependencies.filter_map do |root_dependency|
+        path = shortest_path_from(root_dependency, gem_name)
+        next if path.nil?
+
+        { type: :transitive, path: path }
+      end
+    end
 
     private
 
+    def shortest_path_from(root_dependency, target_gem)
+      queue = [[root_dependency, [root_dependency]]]
+      visited = {}
+
+      until queue.empty?
+        current_name, path = queue.shift
+        next if visited[current_name]
+
+        visited[current_name] = true
+
+        Array(dependency_graph[current_name]).each do |dependency_name|
+          next_path = path + [dependency_name]
+          return next_path if dependency_name == target_gem
+
+          queue << [dependency_name, next_path]
+        end
+      end
+
+      nil
+    end
+
     def parse_lockfile(path)
       parse_content(File.read(path))
     end
 
     def parse_content(content)
       specs = {}
-      in_specs = false
+      dependency_graph = Hash.new { |hash, key| hash[key] = [] }
+      direct_dependencies = []
+      current_section = nil
+      current_spec = nil
+
       content.each_line do |line|
-        in_specs = true if line.strip == "GEM"
-        next unless in_specs
-        if line =~ /^\s{4}(\S+) \((.+)\)/
-          name, version = $1, $2
-          specs[name] = version
+        stripped = line.strip
+
+        if stripped.match?(/\A[A-Z][A-Z0-9 ]*\z/)
+          current_section = nil
+          current_spec = nil
+        end
+
+        if stripped == "GEM"
+          current_section = :gem
+          current_spec = nil
+          next
+        end
+
+        if stripped == "DEPENDENCIES"
+          current_section = :dependencies
+          current_spec = nil
+          next
+        end
+
+        if stripped.empty?
+          current_spec = nil if current_section == :dependencies
+          next
+        end
+
+        case current_section
+        when :gem
+          if line =~ /^\s{4}(\S+) \((.+)\)/
+            name, version = Regexp.last_match(1), Regexp.last_match(2)
+            specs[name] = version
+            current_spec = name
+          elsif current_spec && line =~ /^\s{6}([^\s(]+)/
+            dependency_graph[current_spec] << Regexp.last_match(1)
+          end
+        when :dependencies
+          if line =~ /^\s{2}([^\s!(]+)/
+            direct_dependencies << Regexp.last_match(1)
+          end
         end
       end
-      specs
+
+      {
+        specs: specs,
+        dependency_graph: dependency_graph.transform_values(&:uniq),
+        direct_dependencies: direct_dependencies.uniq
+      }
     end
   end
 end

data/lib/gemstar/project.rb

@@ -0,0 +1,245 @@
+require "time"
+
+module Gemstar
+  class Project
+    attr_reader :directory
+    attr_reader :gemfile_path
+    attr_reader :lockfile_path
+    attr_reader :name
+
+    def self.from_cli_argument(input)
+      expanded_input = File.expand_path(input)
+      gemfile_path = if File.directory?(expanded_input)
+        File.join(expanded_input, "Gemfile")
+      else
+        expanded_input
+      end
+
+      raise ArgumentError, "No Gemfile found for #{input}" unless File.file?(gemfile_path)
+      raise ArgumentError, "#{gemfile_path} is not a Gemfile" unless File.basename(gemfile_path) == "Gemfile"
+
+      new(gemfile_path)
+    end
+
+    def initialize(gemfile_path)
+      @gemfile_path = File.expand_path(gemfile_path)
+      @directory = File.dirname(@gemfile_path)
+      @lockfile_path = File.join(@directory, "Gemfile.lock")
+      @name = File.basename(@directory)
+    end
+
+    def git_repo
+      @git_repo ||= Gemstar::GitRepo.new(directory)
+    end
+
+    def git_root
+      git_repo.tree_root_directory
+    end
+
+    def lockfile?
+      File.file?(lockfile_path)
+    end
+
+    def current_lockfile
+      return nil unless lockfile?
+
+      @current_lockfile ||= Gemstar::LockFile.new(path: lockfile_path)
+    end
+
+    def revision_history(limit: 20)
+      history_for_paths(tracked_git_paths, limit: limit)
+    end
+
+    def lockfile_revision_history(limit: 20)
+      return [] unless lockfile?
+
+      relative_path = git_repo.relative_path(lockfile_path)
+      return [] if relative_path.nil?
+
+      history_for_paths([relative_path], limit: limit)
+    end
+
+    def gemfile_revision_history(limit: 20)
+      relative_path = git_repo.relative_path(gemfile_path)
+      return [] if relative_path.nil?
+
+      history_for_paths([relative_path], limit: limit)
+    end
+
+    def default_from_revision_id
+      default_changed_lockfile_revision_id ||
+        gemfile_revision_history(limit: 1).first&.dig(:id) ||
+        "worktree"
+    end
+
+    def revision_options(limit: 20)
+      [{ id: "worktree", label: "Worktree", description: "Current Gemfile.lock in the working tree" }] +
+        revision_history(limit: limit).map do |revision|
+          {
+            id: revision[:id],
+            label: revision[:short_sha],
+            description: "#{revision[:subject]} (#{revision[:authored_at].strftime("%Y-%m-%d %H:%M")})"
+          }
+        end
+    end
+
+    def lockfile_for_revision(revision_id)
+      return current_lockfile if revision_id.nil? || revision_id == "worktree"
+      return nil unless lockfile?
+
+      relative_lockfile_path = git_repo.relative_path(lockfile_path)
+      return nil if relative_lockfile_path.nil?
+
+      content = git_repo.try_git_command(["show", "#{revision_id}:#{relative_lockfile_path}"])
+      return nil if content.nil? || content.empty?
+
+      Gemstar::LockFile.new(content: content)
+    end
+
+    def gem_states(from_revision_id: default_from_revision_id, to_revision_id: "worktree")
+      from_lockfile = lockfile_for_revision(from_revision_id)
+      to_lockfile = lockfile_for_revision(to_revision_id)
+      from_specs = from_lockfile&.specs || {}
+      to_specs = to_lockfile&.specs || {}
+
+      (from_specs.keys | to_specs.keys).map do |gem_name|
+        old_version = from_specs[gem_name]
+        new_version = to_specs[gem_name]
+        bundle_origins = to_lockfile&.origins_for(gem_name) || []
+
+        {
+          name: gem_name,
+          old_version: old_version,
+          new_version: new_version,
+          status: gem_status(old_version, new_version),
+          version_label: version_label(old_version, new_version),
+          bundle_origins: bundle_origins,
+          bundle_origin_labels: bundle_origin_labels(bundle_origins)
+        }
+      end.sort_by { |gem| gem[:name] }
+    end
+
+    def gem_added_on(gem_name, revision_id: "worktree")
+      return nil unless lockfile?
+
+      target_lockfile = lockfile_for_revision(revision_id)
+      return nil unless target_lockfile&.specs&.key?(gem_name)
+
+      relative_path = git_repo.relative_path(lockfile_path)
+      return nil if relative_path.nil?
+
+      first_seen_revision = history_for_paths([relative_path], limit: nil, reverse: true).find do |revision|
+        lockfile = lockfile_for_revision(revision[:id])
+        lockfile&.specs&.key?(gem_name)
+      end
+
+      return worktree_added_on_info if first_seen_revision.nil? && revision_id == "worktree"
+      return nil unless first_seen_revision
+
+      {
+        project_name: name,
+        date: first_seen_revision[:authored_at].strftime("%Y-%m-%d"),
+        revision: first_seen_revision[:short_sha],
+        revision_url: revision_url(first_seen_revision[:id]),
+        worktree: false
+      }
+    end
+
+    private
+
+    def default_changed_lockfile_revision_id
+      return nil unless lockfile?
+
+      current_specs = current_lockfile&.specs || {}
+
+      lockfile_revision_history(limit: 20).find do |revision|
+        revision_lockfile = lockfile_for_revision(revision[:id])
+        revision_lockfile && revision_lockfile.specs != current_specs
+      end&.dig(:id)
+    end
+
+    def history_for_paths(paths, limit: 20, reverse: false)
+      return [] if git_root.nil? || git_root.empty?
+      return [] if paths.empty?
+
+      output = git_repo.log_for_paths(paths, limit: limit, reverse: reverse)
+      return [] if output.nil? || output.empty?
+
+      output.lines.filter_map do |line|
+        full_sha, short_sha, authored_at, subject = line.strip.split("\u001f", 4)
+        next if full_sha.nil?
+
+        {
+          id: full_sha,
+          full_sha: full_sha,
+          short_sha: short_sha,
+          authored_at: Time.iso8601(authored_at),
+          subject: subject
+        }
+      end
+    rescue ArgumentError
+      []
+    end
+
+    def tracked_git_paths
+      [gemfile_path, lockfile_path].filter_map do |path|
+        next unless File.file?(path)
+
+        git_repo.relative_path(path)
+      end.uniq
+    end
+
+    def gem_status(old_version, new_version)
+      return :added if old_version.nil? && !new_version.nil?
+      return :removed if !old_version.nil? && new_version.nil?
+      return :unchanged if old_version == new_version
+
+      comparison = compare_versions(new_version, old_version)
+      return :upgrade if comparison.positive?
+      return :downgrade if comparison.negative?
+
+      :changed
+    end
+
+    def version_label(old_version, new_version)
+      return "new → #{new_version}" if old_version.nil? && !new_version.nil?
+      return "#{old_version} → removed" if !old_version.nil? && new_version.nil?
+      return new_version.to_s if old_version == new_version
+
+      "#{old_version} → #{new_version}"
+    end
+
+    def compare_versions(left, right)
+      Gem::Version.new(left.to_s.gsub(/-[\w\-]+$/, "")) <=> Gem::Version.new(right.to_s.gsub(/-[\w\-]+$/, ""))
+    rescue ArgumentError
+      left.to_s <=> right.to_s
+    end
+
+    def bundle_origin_labels(origins)
+      Array(origins).map do |origin|
+        next "Gemfile" if origin[:type] == :direct
+
+        ["Gemfile", *origin[:path]].join(" → ")
+      end.compact.uniq
+    end
+
+    def worktree_added_on_info
+      return nil unless File.file?(lockfile_path)
+
+      {
+        project_name: name,
+        date: File.mtime(lockfile_path).strftime("%Y-%m-%d"),
+        revision: "Worktree",
+        revision_url: nil,
+        worktree: true
+      }
+    end
+
+    def revision_url(full_sha)
+      repo_url = git_repo.origin_repo_url
+      return nil unless repo_url&.include?("github.com")
+
+      "#{repo_url}/commit/#{full_sha}"
+    end
+  end
+end

data/lib/gemstar/request_logger.rb

@@ -0,0 +1,31 @@
+module Gemstar
+  class RequestLogger
+    def initialize(app, io: $stderr)
+      @app = app
+      @io = io
+    end
+
+    def call(env)
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      status, headers, body = @app.call(env)
+      log_request(env, status, started_at)
+      [status, headers, body]
+    rescue StandardError => e
+      log_request(env, 500, started_at, error: e)
+      raise
+    end
+
+    private
+
+    def log_request(env, status, started_at, error: nil)
+      duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(1)
+      path = env["PATH_INFO"].to_s
+      query = env["QUERY_STRING"].to_s
+      full_path = query.empty? ? path : "#{path}?#{query}"
+      method = env["REQUEST_METHOD"].to_s
+      suffix = error ? " #{error.class}: #{error.message}" : ""
+
+      @io.puts "[gemstar] #{method} #{full_path} -> #{status} in #{duration_ms}ms#{suffix}"
+    end
+  end
+end

data/lib/gemstar/ruby_gems_metadata.rb

@@ -10,49 +10,65 @@ module Gemstar
 
     attr_reader :gem_name
 
-    def meta
-      @meta ||=
-        begin
-          url = "https://rubygems.org/api/v1/gems/#{URI.encode_www_form_component(gem_name)}.json"
-          Cache.fetch("rubygems-#{gem_name}") do
-            URI.open(url).read
-          end.then { |json|
-            begin
-              JSON.parse(json) if json
-            rescue
-              nil
-            end }
+    def meta(cache_only: false)
+      return @meta if !cache_only && defined?(@meta)
+
+      json = if cache_only
+        Cache.peek("rubygems-#{gem_name}")
+      else
+        url = "https://rubygems.org/api/v1/gems/#{URI.encode_www_form_component(gem_name)}.json"
+        Cache.fetch("rubygems-#{gem_name}") do
+          URI.open(url).read
         end
+      end
+
+      parsed = begin
+        JSON.parse(json) if json
+      rescue
+        nil
+      end
+
+      @meta = parsed unless cache_only
+      parsed
     end
 
-    def repo_uri
-      return nil unless meta
+    def repo_uri(cache_only: false)
+      resolved_meta = meta(cache_only: cache_only)
+      return nil unless resolved_meta
+
+      return @repo_uri if !cache_only && defined?(@repo_uri)
+
+      repo = begin
+               uri = resolved_meta["source_code_uri"]
+
+               if uri.nil?
+                 uri = resolved_meta["homepage_uri"]
+                 if uri.include?("github.com")
+                   uri = uri[%r{http[s?]://github\.com/[^/]+/[^/]+}]
+                 end
+               end
 
-      @repo_uri ||= begin
-                      uri = meta["source_code_uri"]
+               uri ||= ""
 
-                      if uri.nil?
-                        uri = meta["homepage_uri"]
-                        if uri.include?("github.com")
-                          uri = uri[%r{http[s?]://github\.com/[^/]+/[^/]+}]
-                        end
-                      end
+               uri = uri.sub("http://", "https://")
 
-                      uri ||= ""
+               uri = uri.gsub(/\.git$/, "")
 
-                      uri = uri.sub("http://", "https://")
+               if uri.include?("github.io")
+                 uri = uri.sub(%r{\Ahttps?://([\w-]+)\.github\.io/([^/]+)}) do
+                   "https://github.com/#{$1}/#{$2}"
+                 end
+               end
 
-                      uri = uri.gsub(/\.git$/, "")
+               if uri.include?("github.com")
+                 uri = uri[%r{\Ahttps?://github\.com/[^/]+/[^/]+}] || uri
+               end
 
-                      if uri.include?("github.io")
-                        # Convert e.g. https://socketry.github.io/console/ to https://github.com/socketry/console/
-                        uri = uri.sub(%r{\Ahttps?://([\w-]+)\.github\.io/([^/]+)}) do
-                          "https://github.com/#{$1}/#{$2}"
-                        end
-                      end
+               uri
+             end
 
-                      uri
-                    end
+      @repo_uri = repo unless cache_only
+      repo
     end
 
   end

data/lib/gemstar/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Gemstar # :nodoc:
-  VERSION = "0.0.2"
+  VERSION = "1.0"
 
   def self.debug?
     return @debug if defined?(@debug)