gem_maintainer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54bd80a6adcda9d4ea287bf7b9d0390d60d0fbad24189c08a58b607ca9043dbe
+  data.tar.gz: 7ce8d01f55319c5f5e49a05db27a181d9729d752717a8a4a84ea0e8cd9f55474
+SHA512:
+  metadata.gz: 9dbaebd2459dfcc6dbc7ccdcd7a6984ccaa763369daaf949050bc467fbe96404a1aa35e5ff94e75ec9829cb6284bb82cd6d530d5478b790f70e7a23549d40259
+  data.tar.gz: 79a8b2c2b068eea85142016516d5a139b0cfaca888bcb8712d112880d35a6afb0eaa6445bde3462e18e2e0f58c4afb76339884344c85beb700aa962f007815da

data/README.md

@@ -0,0 +1,109 @@
+# gem_maintainer
+
+A tool for keeping your Ruby project's gems up to date, one at a time.
+
+This gem is designed around following a weekly updates process to ensure a gemfile is kept largely up to date and does not fall behind. When updating weekly it's assumed that a lot of gem upgrades wouldn't need any changes, and so they can be batched together quickly. The most time consuming part of this process is finding and checking changelogs, which this gem speeds up greatly.
+
+`gem_maintainer` walks you through each available upgrade interactively. You can review the changelog link for each gem, decide whether to approve or skip it, and at the end it updates everything you approved in one go.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "gem_maintainer"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Usage
+
+Run from within your project directory:
+
+```bash
+gem_maintain
+```
+
+You'll be walked through each outdated gem one by one. For each one you'll see the current and new version, the bump type (patch, minor, or major), and a link to the changelog. You can then choose to:
+
+- **approve** — queue it for updating
+- **skip** — leave it at the current version
+- **quit** — save your progress and exit
+
+Once you've worked through the list, all approved gems are updated together with a single `bundle update`. Afterward, a summary is printed showing each updated gem with its version bump and changelog link, which skipped gems were left alone, and any gems that Bundler attempted to update but whose version didn't change (e.g. due to Gemfile constraints).
+
+The intention here is that any gem requiring changes could be skipped, worked on and committed separately. But any gems with no changes can be upgraded all at once in a single commit.
+
+### Filtering by version bump type
+
+To only see patch-level upgrades (e.g. `1.2.3` → `1.2.4`):
+
+```bash
+gem_maintain --patch
+```
+
+To only see minor-level upgrades (e.g. `1.2.3` → `1.3.0`):
+
+```bash
+gem_maintain --minor
+```
+
+To only see major-level upgrades (e.g. `1.2.3` → `2.0.0`):
+
+```bash
+gem_maintain --major
+```
+
+### Inline changelogs
+
+To fetch and render relevant changelog content directly in the terminal for each gem:
+
+```bash
+gem_maintain --changelog
+```
+
+This shows the changelog entries relevant to the upgrade alongside the changelog URL, so you can review what changed without leaving the terminal.
+
+### Resuming a session
+
+If you quit part way through, your progress is saved automatically. Pick up where you left off with:
+
+```bash
+gem_maintain --resume
+```
+
+### Ignoring gems
+
+To permanently skip certain gems (e.g. ones you never want to update), create a `.gem_maintainer.yml` file in your project root:
+
+```yaml
+ignore:
+  - rubocop
+  - bundler-audit
+```
+
+Gems in this list will be excluded from the outdated check entirely and never appear in the interactive session.
+
+## Development
+
+Clone the repo and install dependencies:
+
+```bash
+git clone git@github.com:WillRogers727/gem_maintainer.git
+cd gem_maintainer
+bundle install
+```
+
+To build and install the gem locally for testing, use the provided build script:
+
+```bash
+bin/build
+```
+
+This builds the gem, installs it, and cleans up the `.gem` file in one step.
+
+To release a new version, update the version number in `lib/gem_maintainer/version.rb`, then run `bin/build`.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/bin/gem_maintain

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/gem_maintainer"
+
+GemMaintainer::CLI.new(ARGV).run

data/lib/gem_maintainer/bundle_updater.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module GemMaintainer
+  # Runs `bundle update` for the approved set of gems.
+  class BundleUpdater
+    def initialize(approved_gems)
+      @gems = approved_gems
+    end
+
+    # Returns an array of gem names that Bundler attempted to update but whose
+    # version stayed the same.
+    def run
+      names = @gems.map { |g| g[:name] }.join(" ")
+      puts "Running: bundle update #{names}"
+      puts
+
+      unchanged = []
+
+      Open3.popen2e("bundle update #{names}") do |_stdin, stdout_err, wait_thr|
+        stdout_err.each_line do |line|
+          print line
+          match = line.match(/Bundler attempted to update (\S+) but its version stayed the same/)
+          unchanged << match[1] if match
+        end
+        wait_thr.value
+      end
+
+      unchanged
+    end
+  end
+end

data/lib/gem_maintainer/changelog_fetcher.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module GemMaintainer
+  # Fetches the changelog URL for a gem.
+  # Strategy (mirrors bin/gem-changelog logic):
+  #   1. changelog_uri from RubyGems metadata
+  #   2. source_code_uri — search GitHub for a changelog file
+  #   3. homepage_uri    — search GitHub for a changelog file
+  #   4. Locally installed gem directory
+  class ChangelogFetcher
+    RUBYGEMS_API = "https://rubygems.org/api/v1/gems/%s.json"
+    CHANGELOG_FILES = %w[CHANGELOG.md CHANGELOG.txt CHANGELOG CHANGES.md CHANGES History.md].freeze
+    GITHUB_BRANCHES = %w[main master].freeze
+
+    def fetch(gem_name)
+      metadata = rubygems_metadata(gem_name)
+      return nil unless metadata
+
+      changelog_uri  = metadata["changelog_uri"]
+      source_code_uri = metadata["source_code_uri"]
+      homepage_uri   = metadata["homepage_uri"]
+
+      # 1. Explicit changelog_uri
+      if changelog_uri && !changelog_uri.empty?
+        return changelog_uri if url_exists?(changelog_uri)
+      end
+
+      # 2. source_code_uri → GitHub search
+      if source_code_uri && source_code_uri.include?("github.com")
+        url = find_github_changelog(source_code_uri)
+        return url if url
+      end
+
+      # 3. homepage_uri → GitHub search
+      if homepage_uri && homepage_uri.include?("github.com")
+        url = find_github_changelog(homepage_uri)
+        return url if url
+      end
+
+      # 4. Locally installed gem
+      local = find_local_changelog(gem_name)
+      return local if local
+
+      # Fallback: RubyGems page
+      "https://rubygems.org/gems/#{gem_name}"
+    end
+
+    private
+
+    def rubygems_metadata(gem_name)
+      uri = URI(RUBYGEMS_API % gem_name)
+      response = Net::HTTP.get_response(uri)
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    rescue StandardError
+      nil
+    end
+
+    def find_github_changelog(url)
+      repo = url.match(%r{github\.com/([^/?#]+/[^/?#]+)})&.captures&.first
+      return nil unless repo
+
+      repo = repo.delete_suffix(".git")
+
+      GITHUB_BRANCHES.each do |branch|
+        CHANGELOG_FILES.each do |file|
+          candidate = "https://github.com/#{repo}/blob/#{branch}/#{file}"
+          raw = "https://raw.githubusercontent.com/#{repo}/#{branch}/#{file}"
+          return candidate if url_exists?(raw)
+        end
+      end
+
+      nil
+    end
+
+    def find_local_changelog(gem_name)
+      gem_dir = Gem::Specification.find_by_name(gem_name)&.gem_dir
+      return nil unless gem_dir && Dir.exist?(gem_dir)
+
+      CHANGELOG_FILES.each do |file|
+        path = File.join(gem_dir, file)
+        return "file://#{path}" if File.exist?(path)
+      end
+
+      nil
+    rescue Gem::MissingSpecError
+      nil
+    end
+
+    def url_exists?(url)
+      uri = URI(url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 5) do |http|
+        http.head(uri.request_uri)
+      end
+      response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/gem_maintainer/changelog_renderer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module GemMaintainer
+  # Fetches a changelog file and extracts the section for a given version,
+  # then renders it to the terminal.
+  class ChangelogRenderer
+    # Number of lines to show before truncating
+    MAX_LINES = 30
+
+    def render(version, url, pastel)
+      return unless url
+
+      content = if url.start_with?("file://")
+        fetch_local(url)
+      elsif url.start_with?("https://github.com")
+        fetch_raw(url)
+      end
+
+      return unless content
+
+      section = extract_section(content, version)
+      return unless section
+
+      print_section(section, pastel)
+    end
+
+    private
+
+    def fetch_raw(github_url)
+      raw_url = to_raw_url(github_url)
+      return nil unless raw_url
+
+      uri = URI(raw_url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5) do |http|
+        http.get(uri.request_uri)
+      end
+
+      response.is_a?(Net::HTTPSuccess) ? response.body : nil
+    rescue StandardError
+      nil
+    end
+
+    def to_raw_url(github_url)
+      # https://github.com/user/repo/blob/main/CHANGELOG.md
+      # → https://raw.githubusercontent.com/user/repo/main/CHANGELOG.md
+      github_url
+        .sub("https://github.com", "https://raw.githubusercontent.com")
+        .sub("/blob/", "/")
+    end
+
+    def fetch_local(file_url)
+      path = file_url.sub("file://", "")
+      File.exist?(path) ? File.read(path) : nil
+    rescue StandardError
+      nil
+    end
+
+    def extract_section(content, version)
+      lines = content.lines
+      # Match plain version, v-prefixed, bracketed, and with trailing date
+      # e.g. 1.2.3 / v1.2.3 / [1.2.3] / [1.2.3] - 2024-01-01
+      escaped = Regexp.escape(version)
+      version_pattern = /v?#{escaped}|\[#{escaped}\]/
+
+      # Find the line index of the heading that contains the target version
+      start_idx = lines.index { |line| heading?(line) && line.match?(version_pattern) }
+      return nil unless start_idx
+
+      heading_level = heading_level_of(lines[start_idx])
+
+      # Collect lines until the next heading of the same or higher level
+      section = []
+      lines[(start_idx + 1)..].each do |line|
+        break if heading?(line) && heading_level_of(line) <= heading_level
+
+        section << line
+      end
+
+      section.empty? ? nil : section
+    end
+
+    def print_section(lines, pastel)
+      truncated = lines.length > MAX_LINES
+      display = truncated ? lines.first(MAX_LINES) : lines
+
+      puts
+      display.each { |line| print "    #{line}" }
+      puts pastel.dim("    ... (truncated, see full changelog link above)") if truncated
+      puts
+    end
+
+    def heading?(line)
+      line.match?(/\A#{Regexp.escape("#")}+\s/)
+    end
+
+    def heading_level_of(line)
+      line.match(/\A(#+)/)[1].length
+    end
+  end
+end

data/lib/gem_maintainer/cli.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module GemMaintainer
+  class CLI
+    def initialize(argv)
+      @argv = argv
+      @options = {}
+    end
+
+    def run
+      parse_options!
+
+      session = Session.load_or_new(@options)
+
+      if session.resuming?
+        puts pastel.cyan("Resuming session (#{session.remaining.size} gems remaining)...")
+      else
+        puts pastel.cyan("Resolving outdated gems...")
+        candidates = OutdatedResolver.new.resolve
+        candidates = SemverFilter.new(candidates).filter(@options[:level])
+
+        if candidates.empty?
+          puts pastel.green("No outdated gems found for the selected filter.")
+          return
+        end
+
+        session.start(candidates)
+      end
+
+      Prompt.new(session, pastel, inline_changelog: @options[:inline_changelog]).run
+
+      if session.approved.any?
+        puts
+        unchanged = BundleUpdater.new(session.approved).run
+        session.record_unchanged(unchanged)
+        puts
+        Summary.new(session).print
+        session.clear
+      else
+        puts pastel.yellow("No gems approved. Nothing to update.")
+      end
+    end
+
+    private
+
+    def parse_options!
+      OptionParser.new do |opts|
+        opts.banner = "Usage: gem_maintain [options]"
+
+        opts.on("--patch", "Review patch upgrades only") do
+          @options[:level] = :patch
+        end
+
+        opts.on("--minor", "Review minor upgrades only") do
+          @options[:level] = :minor
+        end
+
+        opts.on("--major", "Review major upgrades only") do
+          @options[:level] = :major
+        end
+
+        opts.on("--changelog", "Render relevant changelog information inline for each gem") do
+          @options[:inline_changelog] = true
+        end
+
+        opts.on("--resume", "Resume a saved session") do
+          @options[:resume] = true
+        end
+
+        opts.on("-h", "--help", "Show this help") do
+          puts opts
+          exit
+        end
+      end.parse!(@argv)
+
+      @options[:level] ||= :all
+    end
+
+    def pastel
+      @pastel ||= Pastel.new
+    end
+  end
+end

data/lib/gem_maintainer/outdated_resolver.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "open3"
+require "yaml"
+
+module GemMaintainer
+  # Runs `bundle outdated` and parses the output into a list of gem candidates.
+  # Each candidate is a hash: { name:, current:, latest: }
+  class OutdatedResolver
+    OUTDATED_LINE = /\A\s*\*\s+(\S+)\s+\(newest\s+([\d.]+).*?installed\s+([\d.]+)/
+
+    def resolve
+      stdout, _stderr, _status = Open3.capture3("bundle outdated --parseable")
+      parse(stdout)
+    end
+
+    private
+
+    def parse(output)
+      candidates = []
+
+      output.each_line do |line|
+        # parseable format: gemname (newest X.Y.Z, installed A.B.C, ...)
+        match = line.match(/\A(\S+)\s+\(newest\s+([\d.]+).*?installed\s+([\d.]+)/)
+        next unless match
+        next if ignore_list.include?(match[1])
+
+        candidates << {
+          name: match[1],
+          latest: match[2],
+          current: match[3]
+        }
+      end
+
+      candidates
+    end
+
+    def ignore_list
+      config_path = File.join(Dir.pwd, ".gem_maintainer.yml")
+      return [] unless File.exist?(config_path)
+
+      config = YAML.load_file(config_path)
+      Array(config&.dig("ignore"))
+    end
+  end
+end

data/lib/gem_maintainer/prompt.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+module GemMaintainer
+  # Drives the interactive per-gem loop.
+  class Prompt
+    DIVIDER = ("━" * 50).freeze
+
+    def initialize(session, pastel, inline_changelog: false)
+      @session          = session
+      @pastel           = pastel
+      @inline_changelog = inline_changelog
+      @tty              = TTY::Prompt.new(interrupt: :exit)
+      @fetcher          = ChangelogFetcher.new
+      @renderer         = ChangelogRenderer.new
+    end
+
+    def run
+      gems = @session.remaining
+      total = @session.candidates.size
+      offset = total - gems.size
+
+      gems.each_with_index do |gem, idx|
+        display_gem(gem, offset + idx + 1, total)
+
+        choice = @tty.select("", choices, cycle: true, per_page: 3, show_help: :never)
+
+        case choice
+        when :approve
+          @session.approve(gem)
+          puts @pastel.green("  Queued for upgrade.")
+        when :skip
+          @session.skip(gem)
+          puts @pastel.yellow("  Skipped.")
+        when :quit
+          puts @pastel.cyan("\nSession saved. Run with --resume to continue.")
+          break
+        end
+
+        puts
+      end
+    end
+
+    private
+
+    def display_gem(gem, position, total)
+      bump = SemverFilter.new(nil).bump_type(gem[:current], gem[:latest])
+      bump_label = bump_colour(bump)
+
+      puts
+      puts @pastel.bold(DIVIDER)
+      puts "  #{@pastel.bold("(#{position}/#{total})")} " \
+           "#{@pastel.bold.cyan(gem[:name])}  " \
+           "#{@pastel.dim(gem[:current])} → #{@pastel.green(gem[:latest])}  #{bump_label}"
+      puts @pastel.bold(DIVIDER)
+
+      changelog = fetch_changelog(gem[:name])
+      if changelog
+        puts "  #{@pastel.dim("Changelog:")} #{changelog}"
+      else
+        puts "  #{@pastel.dim("Changelog: not found")}"
+      end
+
+      if @inline_changelog && changelog
+        @renderer.render(gem[:latest], changelog, @pastel)
+      else
+        puts
+      end
+    end
+
+    def fetch_changelog(gem_name)
+      cached = @session.changelog_for(gem_name)
+      return cached if cached
+
+      print @pastel.dim("  Fetching changelog...")
+      url = @fetcher.fetch(gem_name)
+      print "\r#{" " * 30}\r"
+      @session.store_changelog(gem_name, url) if url
+      url
+    end
+
+    def choices
+      [
+        { name: "approve", value: :approve },
+        { name: "skip",    value: :skip },
+        { name: "quit (save & exit)", value: :quit }
+      ]
+    end
+
+    def bump_colour(bump)
+      case bump
+      when :patch then @pastel.green("[patch]")
+      when :minor then @pastel.yellow("[minor]")
+      when :major then @pastel.red("[major]")
+      end
+    end
+  end
+end

data/lib/gem_maintainer/semver_filter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GemMaintainer
+  # Filters gem candidates by semver bump type.
+  # level: :patch  → only patch bumps (x.y.Z)
+  #        :minor  → only minor bumps (x.Y.z)
+  #        :all    → everything including major
+  class SemverFilter
+    def initialize(candidates)
+      @candidates = candidates
+    end
+
+    BUMP_RANK = { patch: 0, minor: 1, major: 2 }.freeze
+
+    def filter(level)
+      return @candidates if level == :all
+
+      @candidates.select do |gem|
+        bump_type(gem[:current], gem[:latest]) == level
+      end
+    end
+
+    # Returns :patch, :minor, or :major
+    def self.bump_type(current, latest)
+      new(nil).bump_type(current, latest)
+    end
+
+    def bump_type(current, latest)
+      cur = version_parts(current)
+      lat = version_parts(latest)
+
+      if lat[0] != cur[0]
+        :major
+      elsif lat[1] != cur[1]
+        :minor
+      else
+        :patch
+      end
+    end
+
+    private
+
+    def version_parts(version)
+      version.to_s.split(".").map(&:to_i)
+    end
+  end
+end

data/lib/gem_maintainer/session.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "json"
+
+module GemMaintainer
+  # Persists session state to ~/.gem_maintainer_session.json so a run can be
+  # resumed if interrupted.
+  class Session
+    SESSION_FILE = File.join(Dir.home, ".gem_maintainer_session.json")
+
+    attr_reader :candidates, :approved, :skipped, :unchanged, :options
+
+    def self.load_or_new(options)
+      if options[:resume] && File.exist?(SESSION_FILE)
+        from_file(options)
+      else
+        new(options)
+      end
+    end
+
+    def self.from_file(options)
+      data = JSON.parse(File.read(SESSION_FILE), symbolize_names: true)
+      session = new(options)
+      session.restore(data)
+      session
+    end
+
+    def initialize(options)
+      @options = options
+      @candidates = []
+      @approved = []
+      @skipped = []
+      @unchanged = []
+      @changelogs = {}
+      @resuming = false
+    end
+
+    def start(candidates)
+      @candidates = candidates
+      save
+    end
+
+    def restore(data)
+      @candidates = data[:candidates].map { |c| c.transform_keys(&:to_sym) }
+      @approved   = data[:approved].map  { |c| c.transform_keys(&:to_sym) }
+      @skipped    = data[:skipped].map   { |c| c.transform_keys(&:to_sym) }
+      @changelogs = (data[:changelogs] || {}).transform_keys(&:to_s)
+      @resuming = true
+    end
+
+    def resuming?
+      @resuming
+    end
+
+    # Gems not yet actioned
+    def remaining
+      actioned_names = (@approved + @skipped).map { |g| g[:name] }
+      @candidates.reject { |g| actioned_names.include?(g[:name]) }
+    end
+
+    def approve(gem)
+      @approved << gem
+      save
+    end
+
+    def skip(gem)
+      @skipped << gem
+      save
+    end
+
+    def changelog_for(gem_name)
+      @changelogs[gem_name]
+    end
+
+    def record_unchanged(names)
+      @unchanged = names
+    end
+
+    def store_changelog(gem_name, url)
+      @changelogs[gem_name] = url
+      save
+    end
+
+    def clear
+      File.delete(SESSION_FILE) if File.exist?(SESSION_FILE)
+    end
+
+    private
+
+    def save
+      File.write(SESSION_FILE, JSON.pretty_generate({
+        candidates: @candidates,
+        approved: @approved,
+        skipped: @skipped,
+        changelogs: @changelogs
+      }))
+    end
+  end
+end

data/lib/gem_maintainer/summary.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GemMaintainer
+  # Prints a commit-message-ready summary after the batch update.
+  class Summary
+    def initialize(session)
+      @session = session
+    end
+
+    def print
+      puts "Gem updates:\n\n"
+
+      @session.approved.each do |gem|
+        next if @session.unchanged.include?(gem[:name])
+
+        bump = SemverFilter.new(nil).bump_type(gem[:current], gem[:latest])
+        changelog = @session.changelog_for(gem[:name])
+
+        puts "* #{gem[:name]} #{gem[:current]} → #{gem[:latest]} [#{bump}]"
+        puts "  #{changelog}" if changelog
+        puts
+      end
+
+      if @session.skipped.any?
+        skipped_names = @session.skipped.map { |g| g[:name] }.join(", ")
+        puts "Skipped: #{skipped_names}"
+      end
+
+      if @session.unchanged.any?
+        puts "Didn't update: #{@session.unchanged.join(", ")}"
+      end
+    end
+  end
+end

data/lib/gem_maintainer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GemMaintainer
+  VERSION = "0.1.0"
+end

data/lib/gem_maintainer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "gem_maintainer/version"
+require_relative "gem_maintainer/cli"
+require_relative "gem_maintainer/outdated_resolver"
+require_relative "gem_maintainer/semver_filter"
+require_relative "gem_maintainer/changelog_fetcher"
+require_relative "gem_maintainer/changelog_renderer"
+require_relative "gem_maintainer/session"
+require_relative "gem_maintainer/prompt"
+require_relative "gem_maintainer/bundle_updater"
+require_relative "gem_maintainer/summary"
+
+module GemMaintainer
+  class Error < StandardError; end
+end

data/sig/gem_maintainer.rbs

@@ -0,0 +1,4 @@
+module GemMaintainer
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: gem_maintainer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Will Rogers
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Walk through outdated gems one by one, view changelog links, approve
+  or skip, then batch update at the end.
+email:
+- whmrogers@googlemail.com
+executables:
+- gem_maintain
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/gem_maintain
+- lib/gem_maintainer.rb
+- lib/gem_maintainer/bundle_updater.rb
+- lib/gem_maintainer/changelog_fetcher.rb
+- lib/gem_maintainer/changelog_renderer.rb
+- lib/gem_maintainer/cli.rb
+- lib/gem_maintainer/outdated_resolver.rb
+- lib/gem_maintainer/prompt.rb
+- lib/gem_maintainer/semver_filter.rb
+- lib/gem_maintainer/session.rb
+- lib/gem_maintainer/summary.rb
+- lib/gem_maintainer/version.rb
+- sig/gem_maintainer.rbs
+homepage: https://github.com/WillRogers727/gem_maintainer
+licenses: []
+metadata:
+  homepage_uri: https://github.com/WillRogers727/gem_maintainer
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Interactive gem upgrade tool with changelog links and session persistence
+test_files: []