gem_radar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6a7c235545aa90c12bd62cc2adcc11f3ba3ed212863e4dc3b94240c1311658eb
+  data.tar.gz: e9c2b3cff58d9a03af3af57f8e1db3c3ad8d6d1a5a4da9b09bd1114f05ca065d
+SHA512:
+  metadata.gz: f893e96da321bec629f7c8c05f7533112b612c1f5bdfab3900494a130c1024c69ef3ccfdb1d0a8c8a9df3a2bfd263d97ad30dea65272f2aa77505dafa421bcab
+  data.tar.gz: 412a70978527836e6fc4e2e20beedd010a7485c21d275e7e6ee268ca637b3535fda19c4d0bc5a4db49f3508ad376591b9e09067d2a532560f2ffcd833e2b842e

data/.gitignore

@@ -0,0 +1,4 @@
+*.md
+!README.md
+!CHANGELOG.md
+*.gem

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 (26-08-2026) - Brazil
+
+Initial public release.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Laura Jaime
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# gem_radar
+
+![gem_radar](assets/banner.png)
+
+A gem that audits your Ruby on Rails project's gems and reports their
+compatibility and update status.
+
+For each gem, the report links only to its repository — it does not
+download or embed changelog content.
+
+## Installation
+
+Add it to your project's `Gemfile`:
+
+```ruby
+gem "gem_radar", group: :development
+```
+
+then `bundle install`.
+
+## Usage
+
+Run it from the root of the project (where `Gemfile.lock` lives):
+
+```sh
+bundle exec gem_radar
+```
+
+Options:
+
+```
+--ruby VERSION       Project's Ruby version (default: .ruby-version or Gemfile.lock)
+--rails VERSION      Project's Rails version (default: the one in Gemfile.lock)
+--lockfile PATH      Path to Gemfile.lock (default: ./Gemfile.lock)
+-o, --output PATH    Output file (default: gem_radar.md)
+-h, --help           Shows this help
+--version            Shows the version
+```
+
+Export `GITHUB_TOKEN` (or have `gh` authenticated) to avoid GitHub's
+60 requests/hour limit for unauthenticated API access — used to check
+whether a gem's repository has been archived.
+
+## Report categories
+
+- ❗ **Mandatory update** — the installed version no longer satisfies the
+  project's current Ruby version, or the Rails-component version it depends
+  on (`rails`, `railties`, `activerecord`, …). Not a suggestion: the gem is
+  already out of bounds for your current Ruby/Rails.
+- ✅ **Compatible with Ruby and Rails** — up to date, nothing to do.
+- 🗑️ **Deprecated / archived** — the GitHub repository is archived, or the
+  gem's own description mentions it's deprecated.
+- ⬆️ **Safely updatable** — a newer version exists within the same major
+  version line (for `0.x` gems, the minor is treated as the breaking-change
+  boundary, following common SemVer convention).
+- ⚠️ **Updatable with changes** — updating means a major version bump, or no
+  version compatible with the current Ruby/Rails could be found (so the
+  update would also require upgrading the framework).
+- ❔ **No data** — not found on rubygems.org (private gem, or installed
+  from git/path).
+
+## How it works
+
+- Reads direct dependencies, installed versions and the Ruby version from
+  `Gemfile.lock` (or `.ruby-version` / `--ruby`).
+- Queries the rubygems.org API for each gem's metadata, published versions,
+  and per-version runtime dependencies.
+- Rails compatibility is inferred from a gem's dependency on any Rails
+  component; gems unrelated to Rails are judged on Ruby compatibility only.
+- Queries the GitHub API for the repository's `archived` status.
+
+## Requirements
+
+Ruby standard library only — no runtime dependencies.
+
+## License
+
+MIT

data/exe/gem_radar

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

data/gem_radar.gemspec

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "lib/gem_radar/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "gem_radar"
+  spec.version = GemRadar::VERSION
+  spec.authors = ["Laura Jaime"]
+
+  spec.summary = "Audits your Ruby/Rails project's gems and reports their compatibility and update status."
+  spec.description = "Reads a project's Gemfile.lock and reports, for each direct gem, whether it's " \
+                      "compatible with the project's Ruby/Rails, needs a mandatory update, is " \
+                      "deprecated or archived, or can be upgraded safely vs. with breaking changes."
+  spec.homepage = "https://github.com/laurajaime/gem_radar"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/gem_radar/cli.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+#
+# gem_radar — generates a Markdown report on the health of a Ruby/Rails
+# project's direct gems, grouped into categories:
+#   - mandatory update (the installed version is no longer compatible with
+#     the project's current Ruby/Rails)
+#   - compatible with the project's Ruby and Rails version
+#   - deprecated / archived
+#   - safely updatable (same major version line)
+#   - updatable with changes (major version bump, or requires a newer
+#     Ruby/Rails)
+#   - no data (not found on rubygems.org: private gems, git/path sources…)
+#
+# Each gem links only to its repository (changelog content is not
+# downloaded).
+#
+# Data sources:
+#   - rubygems.org API: metadata, versions and per-version dependencies
+#   - GitHub API: repository "archived" status
+#
+# Export GITHUB_TOKEN (or have `gh` authenticated) to avoid GitHub's
+# 60 requests/hour limit for unauthenticated API access.
+
+require "net/http"
+require "json"
+require "uri"
+require "optparse"
+
+module GemRadar
+  module CLI
+    module_function
+
+    USER_AGENT = "gem_radar/#{VERSION} (https://github.com/laurajaime/gem_radar)"
+
+    RAILS_FAMILY = %w[
+      rails railties actionpack actionview activerecord activesupport
+      activejob activemodel actioncable activestorage actionmailer
+      actionmailbox actiontext
+    ].freeze
+
+    MAX_RAILS_CHECKS = 12
+
+    def run(argv)
+      options = parse_options(argv)
+      lock = parse_lockfile(options[:lockfile])
+      ruby_version = detect_ruby_version(options, lock)
+      rails_version = detect_rails_version(options, lock)
+      project = File.basename(File.expand_path(File.dirname(options[:lockfile]) == "." ? Dir.pwd : File.dirname(options[:lockfile])))
+
+      warn "Project: #{project} · Ruby: #{ruby_version || 'not detected (use --ruby)'} · " \
+           "Rails: #{rails_version || 'not detected (use --rails)'} · #{lock[:dependencies].size} direct gems"
+      warn "Warning: no GITHUB_TOKEN and no authenticated `gh`; GitHub's API is limited to 60 requests/hour." unless github_token
+
+      results = lock[:dependencies].each_with_index.map do |name, i|
+        warn format("  [%d/%d] %s…", i + 1, lock[:dependencies].size, name)
+        process_gem(name, lock[:specs][name], ruby_version, rails_version)
+      end
+
+      File.write(options[:output], build_report(project, ruby_version, rails_version, results, options))
+      by_category = results.group_by { |r| classify(r) }
+      warn "Done: #{options[:output]} (#{results.size} gems · " \
+           "#{by_category[:mandatory]&.size || 0} mandatory update · " \
+           "#{by_category[:updatable_safe]&.size || 0} safely updatable · " \
+           "#{by_category[:updatable_breaking]&.size || 0} updatable with changes · " \
+           "#{by_category[:deprecated]&.size || 0} deprecated)"
+    end
+
+    def parse_options(argv)
+      options = { output: "gem_radar.md", lockfile: "Gemfile.lock" }
+      OptionParser.new do |o|
+        o.banner = "Usage: gem_radar [options]  (run from inside the project directory)"
+        o.on("--ruby VERSION", "Project's Ruby version (default: .ruby-version or Gemfile.lock)") { |v| options[:ruby] = v }
+        o.on("--rails VERSION", "Project's Rails version (default: the one in Gemfile.lock)") { |v| options[:rails] = v }
+        o.on("--lockfile PATH", "Path to Gemfile.lock (default: ./Gemfile.lock)") { |v| options[:lockfile] = v }
+        o.on("-o", "--output PATH", "Output file (default: gem_radar.md)") { |v| options[:output] = v }
+        o.on("-h", "--help", "Shows this help") { puts o; exit }
+        o.on("--version", "Shows the version") { puts "gem_radar #{VERSION} (\"#{CODENAME}\")"; exit }
+      end.parse!(argv)
+      options
+    end
+
+    # --- HTTP -----------------------------------------------------------------
+
+    def http_get(url, headers = {}, limit = 5)
+      return nil if limit.zero?
+      uri = URI(url)
+      req = Net::HTTP::Get.new(uri)
+      req["User-Agent"] = USER_AGENT
+      headers.each { |k, v| req[k] = v }
+      res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                            open_timeout: 10, read_timeout: 30) { |h| h.request(req) }
+      if res.is_a?(Net::HTTPRedirection) && res["location"]
+        http_get(URI.join(url, res["location"]).to_s, headers, limit - 1)
+      else
+        res
+      end
+    rescue StandardError => e
+      warn "    warning: HTTP request failed for #{url}: #{e.class}: #{e.message}"
+      nil
+    end
+
+    def github_token
+      return @github_token if defined?(@github_token)
+      token = ENV["GITHUB_TOKEN"] || ENV["GH_TOKEN"]
+      token ||= begin
+        out = `gh auth token 2>/dev/null`.strip
+        out.empty? ? nil : out
+      rescue StandardError
+        nil
+      end
+      @github_token = token
+    end
+
+    def github_api(path)
+      headers = { "Accept" => "application/vnd.github+json" }
+      headers["Authorization"] = "Bearer #{github_token}" if github_token
+      res = http_get("https://api.github.com#{path}", headers)
+      return nil unless res.is_a?(Net::HTTPSuccess)
+      JSON.parse(res.body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # --- Gemfile.lock -----------------------------------------------------------
+
+    # Returns { dependencies: [names], specs: {name => version}, ruby: "x.y.z" or nil }
+    def parse_lockfile(path)
+      abort "Can't find #{path}. Run this from the project root (or use --lockfile)." unless File.file?(path)
+      deps = []
+      specs = {}
+      ruby = nil
+      section = nil
+      File.read(path).each_line do |line|
+        if line =~ /\A[A-Z][A-Z ]*\s*\z/
+          section = line.strip
+          next
+        end
+        case section
+        when "GEM", "GIT", "PATH"
+          specs[$1] = $2 if line =~ /\A    (\S+) \(([^)\s]+)\)/
+        when "DEPENDENCIES"
+          deps << $1 if line =~ /\A  ([^\s!(]+)/
+        when "RUBY VERSION"
+          ruby = $1 if line =~ /ruby (\d+\.\d+\.\d+)/
+        end
+      end
+      { dependencies: deps.uniq.sort, specs: specs, ruby: ruby }
+    end
+
+    def detect_ruby_version(options, lockfile_data)
+      return options[:ruby] if options[:ruby]
+      if File.file?(".ruby-version")
+        v = File.read(".ruby-version").strip.sub(/\Aruby-/, "")
+        return v unless v.empty?
+      end
+      lockfile_data[:ruby]
+    end
+
+    def detect_rails_version(options, lockfile_data)
+      options[:rails] || lockfile_data[:specs]["rails"]
+    end
+
+    # --- rubygems.org -----------------------------------------------------------
+
+    def rubygems_info(name)
+      res = http_get("https://rubygems.org/api/v1/gems/#{name}.json")
+      return nil unless res.is_a?(Net::HTTPSuccess)
+      JSON.parse(res.body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def rubygems_versions(name)
+      res = http_get("https://rubygems.org/api/v1/versions/#{name}.json")
+      return [] unless res.is_a?(Net::HTTPSuccess)
+      JSON.parse(res.body)
+    rescue JSON::ParserError
+      []
+    end
+
+    def version_runtime_dependencies(name, version)
+      @version_deps_cache ||= {}
+      key = "#{name}@#{version}"
+      return @version_deps_cache[key] if @version_deps_cache.key?(key)
+      res = http_get("https://rubygems.org/api/v2/rubygems/#{name}/versions/#{version}.json")
+      @version_deps_cache[key] =
+        begin
+          res.is_a?(Net::HTTPSuccess) ? (JSON.parse(res.body).dig("dependencies", "runtime") || []) : nil
+        rescue JSON::ParserError
+          nil
+        end
+    end
+
+    def gem_version(str)
+      Gem::Version.new(str.to_s.sub(/\Av/i, "").gsub("-", "."))
+    rescue ArgumentError
+      nil
+    end
+
+    def requirement_satisfied?(requirement_str, version)
+      return true if requirement_str.nil? || requirement_str.to_s.empty?
+      Gem::Requirement.new(*requirement_str.split(",").map(&:strip)).satisfied_by?(version)
+    rescue StandardError
+      true
+    end
+
+    def depends_on_rails_family?(runtime_deps)
+      Array(runtime_deps).any? { |d| RAILS_FAMILY.include?(d["name"]) }
+    end
+
+    def rails_requirement_satisfied?(runtime_deps, rails_version)
+      return true unless rails_version
+      rails_deps = Array(runtime_deps).select { |d| RAILS_FAMILY.include?(d["name"]) }
+      return true if rails_deps.empty?
+      rails_deps.all? { |d| requirement_satisfied?(d["requirements"], rails_version) }
+    end
+
+    # Latest stable version compatible with the project's Ruby and, if the gem
+    # depends on any Rails component, also with the project's Rails version.
+    # Returns nil if none of the latest MAX_RAILS_CHECKS ruby-compatible
+    # versions satisfies the Rails requirement.
+    def latest_compatible(name, versions, ruby_version, rails_version, latest_runtime_deps)
+      ruby = ruby_version && gem_version(ruby_version)
+      rails = rails_version && gem_version(rails_version)
+
+      candidates = versions.reject { |v| v["prerelease"] }
+                           .select { |v| v["platform"].nil? || v["platform"] == "ruby" }
+      candidates = candidates.select do |v|
+        ruby.nil? || requirement_satisfied?(v["ruby_version"], ruby)
+      end
+      candidates = candidates.map { |v| [gem_version(v["number"]), v["number"]] }
+                             .select { |gv, _| gv }
+                             .sort_by { |gv, _| gv }
+                             .reverse
+
+      return candidates.first&.first unless rails && depends_on_rails_family?(latest_runtime_deps)
+
+      candidates.first(MAX_RAILS_CHECKS).each do |gv, number|
+        deps = version_runtime_dependencies(name, number)
+        next if deps.nil?
+        return gv if rails_requirement_satisfied?(deps, rails)
+      end
+      nil
+    end
+
+    # Reasons why the ALREADY INSTALLED version fails to meet the project's
+    # current Ruby/Rails: if any are found, this gem must be updated — it's
+    # not just a recommendation (unlike the "updatable" categories).
+    def mandatory_update_reasons(name, installed, versions, ruby_version, rails_version, latest_runtime_deps)
+      return [] unless installed
+      entry = versions.find { |v| gem_version(v["number"]) == installed }
+      return [] unless entry # installed version not indexed on rubygems.org (yanked, etc.)
+
+      reasons = []
+
+      if ruby_version
+        ruby = gem_version(ruby_version)
+        req = entry["ruby_version"]
+        unless req.nil? || req.to_s.empty? || requirement_satisfied?(req, ruby)
+          reasons << "requires Ruby #{req}, project uses #{ruby_version}"
+        end
+      end
+
+      if rails_version && depends_on_rails_family?(latest_runtime_deps)
+        deps = version_runtime_dependencies(name, entry["number"])
+        if deps
+          rails = gem_version(rails_version)
+          Array(deps).select { |d| RAILS_FAMILY.include?(d["name"]) }.each do |d|
+            unless requirement_satisfied?(d["requirements"], rails)
+              reasons << "#{d['name']} requires #{d['requirements']}, project uses Rails #{rails_version}"
+            end
+          end
+        end
+      end
+
+      reasons
+    end
+
+    # --- Repository / deprecation status -----------------------------------------
+
+    def github_repo(url)
+      return nil unless url && !url.empty?
+      m = url.match(%r{github\.com/([^/]+)/([^/#?]+)})
+      m && "#{m[1]}/#{m[2].sub(/\.git\z/, '')}"
+    end
+
+    def repo_url_for(info)
+      repo = github_repo(info["source_code_uri"]) ||
+             github_repo(info.dig("metadata", "source_code_uri")) ||
+             github_repo(info["homepage_uri"]) ||
+             github_repo(info["changelog_uri"])
+      return ["https://github.com/#{repo}", repo] if repo
+
+      [info["source_code_uri"] || info["homepage_uri"], nil]
+    end
+
+    def deprecated?(info, repo_info)
+      return true if repo_info && repo_info["archived"]
+      text = "#{info['info']} #{info['description']}"
+      !!(text =~ /\bdeprecat/i)
+    end
+
+    # --- Classification -----------------------------------------------------------
+
+    CATEGORY_ORDER = %i[mandatory compatible deprecated updatable_safe updatable_breaking not_found].freeze
+
+    CATEGORY_TITLES = {
+      mandatory: "❗ Mandatory update (installed version is no longer compatible with your Ruby/Rails)",
+      compatible: "✅ Compatible with Ruby and Rails",
+      deprecated: "🗑️ Deprecated / archived",
+      updatable_safe: "⬆️ Safely updatable (same major version line)",
+      updatable_breaking: "⚠️ Updatable with changes (major version bump, or requires a newer Ruby/Rails)",
+      not_found: "❔ No data (not found on rubygems.org)"
+    }.freeze
+
+    # In SemVer, when major is 0 it's the minor that marks breaking changes
+    # (0.MAJOR.MINOR), as is common across the Rails gem ecosystem.
+    def same_compat_line?(installed, candidate)
+      if installed.segments.first.zero? && candidate.segments.first.zero?
+        installed.segments[1] == candidate.segments[1]
+      else
+        installed.segments.first == candidate.segments.first
+      end
+    end
+
+    def classify(r)
+      return :not_found unless r[:found]
+      return :mandatory if r[:mandatory_reasons] && !r[:mandatory_reasons].empty?
+      return :deprecated if r[:deprecated]
+      return :compatible unless r[:installed] && r[:latest]
+
+      if r[:compatible] && r[:compatible] > r[:installed]
+        same_compat_line?(r[:installed], r[:compatible]) ? :updatable_safe : :updatable_breaking
+      elsif r[:latest] > r[:installed] && (r[:compatible].nil? || r[:compatible] <= r[:installed])
+        # A newer version exists, but none was found compatible with the
+        # current Ruby/Rails: updating means upgrading the framework too.
+        :updatable_breaking
+      else
+        :compatible
+      end
+    end
+
+    # --- Report -------------------------------------------------------------------
+
+    def format_gem_line(r)
+      parts = ["**#{r[:name]}**"]
+      parts << "installed `#{r[:installed]}`" if r[:installed]
+      if r[:compatible] && r[:installed] && r[:compatible] > r[:installed]
+        parts << "recommended `#{r[:compatible]}`"
+      end
+      if r[:latest] && (r[:compatible].nil? || r[:latest] > r[:compatible])
+        parts << "latest published `#{r[:latest]}`"
+      end
+      line = "- #{parts.join(' · ')}"
+      line += " — [repository](#{r[:repo_url]})" if r[:repo_url]
+      line += "\n\n  > #{r[:error]}" if r[:error]
+      Array(r[:mandatory_reasons]).each { |reason| line += "\n\n  > #{reason}" }
+      line
+    end
+
+    def build_report(project, ruby_version, rails_version, results, options)
+      grouped = results.group_by { |r| classify(r) }
+
+      lines = []
+      lines << "# Gems in #{project}"
+      lines << ""
+      lines << "Generated: #{Time.now.strftime('%Y-%m-%d %H:%M')} · Ruby: #{ruby_version || 'unknown'} · " \
+               "Rails: #{rails_version || 'unknown'} · #{results.size} direct gems"
+      lines << ""
+      lines << "## Summary"
+      lines << ""
+      lines << "| Category | Gems |"
+      lines << "|---|---|"
+      CATEGORY_ORDER.each do |cat|
+        count = grouped[cat]&.size || 0
+        lines << "| #{CATEGORY_TITLES[cat]} | #{count} |"
+      end
+      lines << ""
+      lines << "---"
+
+      CATEGORY_ORDER.each do |cat|
+        items = grouped[cat]
+        next if items.nil? || items.empty?
+        lines << ""
+        lines << "## #{CATEGORY_TITLES[cat]}"
+        lines << ""
+        items.each { |r| lines << format_gem_line(r) }
+      end
+      lines.join("\n") + "\n"
+    end
+
+    # --- Per-gem processing ------------------------------------------------------
+
+    def process_gem(name, installed_str, ruby_version, rails_version)
+      installed = gem_version(installed_str)
+      info = rubygems_info(name)
+      unless info
+        return { name: name, installed: installed, found: false,
+                 error: "Couldn't find `#{name}` on rubygems.org (private gem, or installed from git/path?)." }
+      end
+
+      latest = gem_version(info["version"])
+      versions = rubygems_versions(name)
+      latest_runtime_deps = info.dig("dependencies", "runtime") || []
+      compatible = latest_compatible(name, versions, ruby_version, rails_version, latest_runtime_deps)
+      mandatory_reasons = mandatory_update_reasons(name, installed, versions, ruby_version, rails_version, latest_runtime_deps)
+
+      url, repo = repo_url_for(info)
+      repo_info = repo && github_api("/repos/#{repo}")
+
+      {
+        name: name,
+        found: true,
+        installed: installed,
+        latest: latest,
+        compatible: compatible,
+        repo_url: url,
+        deprecated: deprecated?(info, repo_info),
+        mandatory_reasons: mandatory_reasons
+      }
+    end
+  end
+end

data/lib/gem_radar/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module GemRadar
+  VERSION = "0.1.0"
+  CODENAME = "Brazil"
+end

data/lib/gem_radar.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "gem_radar/version"
+require_relative "gem_radar/cli"
+
+module GemRadar
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: gem_radar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Laura Jaime
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-26 00:00:00.000000000 Z
+dependencies: []
+description: Reads a project's Gemfile.lock and reports, for each direct gem, whether
+  it's compatible with the project's Ruby/Rails, needs a mandatory update, is deprecated
+  or archived, or can be upgraded safely vs. with breaking changes.
+email:
+executables:
+- gem_radar
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- assets/banner.png
+- exe/gem_radar
+- gem_radar.gemspec
+- lib/gem_radar.rb
+- lib/gem_radar/cli.rb
+- lib/gem_radar/version.rb
+homepage: https://github.com/laurajaime/gem_radar
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/laurajaime/gem_radar/blob/main/CHANGELOG.md
+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.3.7
+signing_key:
+specification_version: 4
+summary: Audits your Ruby/Rails project's gems and reports their compatibility and
+  update status.
+test_files: []