gem-why 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 427248f88372106860306d895e33b9323628582c6bee05b5b83fed9ce5c1b416
+  data.tar.gz: 4e6fec4a6b52226de621ea6d3486e79780c68e3a6e2ba4bcc6e6e843c9bcd0de
+SHA512:
+  metadata.gz: 8c61e858acfd0fa46812f0eb8548e4710137b07fd9d551ad2dc7a75fe456655bb6c45817a2799e8770d2a4fcc1e59f1bb026ed9ebaa814a090411611d67929cd
+  data.tar.gz: bfc45293182646801fc2d3ab7ea7b5f4b464c21c844fd3a7f18743b716e4b4d76b6b0e9e885e036c00774940da1ef6b285b124e10243c4dab296791e4094ec90

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.0.1] - 2025-10-01
+
+### Added
+
+- Initial release of `gem-why` plugin
+- `gem why GEMNAME` command to show which installed gems depend on a specific gem
+- Display gem names, versions, and version requirements for dependencies
+- Alphabetically sorted output for easy scanning
+- Clear messaging when no dependencies are found
+- **Deep dependency tracking** - traverse the full dependency tree to find transitive dependencies (DEFAULT)
+- **Tree visualization** with `--tree` option - display dependencies as a visual tree with proper indentation
+- `--direct` option to show only direct dependencies (for quick lookups)
+- Comprehensive test suite with 16 test cases
+- RuboCop compliance with default settings
+- Complete documentation in README
+
+[0.0.1]: https://github.com/vitaly/gem-why/releases/tag/v0.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Vitaly Slobodin
+
+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,162 @@
+# gem-why
+
+A RubyGems plugin that shows which installed gems depend on a specific gem. Similar to `yarn why` or `npm why`.
+
+## Quick Start
+
+```bash
+# Install the plugin
+gem install gem-why
+
+# Find all dependency chains to rake (default - shows transitive dependencies)
+gem why rake
+
+# Show only direct dependencies
+gem why rake --direct
+
+# Visualize dependencies as a tree
+gem why rake --tree
+```
+
+## Why Deep by Default?
+
+Unlike most dependency tools that show only direct dependencies by default, `gem why` defaults to **deep dependency analysis** because:
+
+- **Most real-world scenarios** involve transitive dependencies - you typically want to know "why is this gem even installed?" not just "what directly depends on it?"
+- **Debugging is easier** when you see the full chain immediately - you can trace exactly how a problematic gem entered your dependency tree
+- **Mirrors `yarn why`** behavior - the inspiration for this tool also defaults to showing full dependency chains
+- **Direct lookups are still fast** - use `--direct` when you specifically need just immediate dependents
+
+## Installation
+
+Install the gem by executing:
+
+```bash
+gem install gem-why
+```
+
+The plugin will automatically be available as a `gem` command after installation.
+
+## Feature Comparison
+
+| Mode | Command | Shows | Best For |
+|------|---------|-------|----------|
+| **Deep** (default) | `gem why GEMNAME` | Full dependency chains with paths | Understanding transitive dependencies |
+| **Direct** | `gem why GEMNAME --direct` | Only direct dependencies | Quick lookup of immediate dependents |
+| **Tree** | `gem why GEMNAME --tree` | Visual tree structure | Complex dependency visualization |
+
+## Usage
+
+To see which gems depend on a specific gem:
+
+```bash
+gem why GEMNAME [options]
+```
+
+### Examples
+
+#### Default Behavior - Deep Dependencies
+
+Show all dependency chains leading to a gem (including transitive dependencies):
+
+```bash
+$ gem why concurrent-ruby
+Dependency chains leading to concurrent-ruby:
+
+  rails => activesupport => concurrent-ruby
+    └─ rails (8.0.3) requires activesupport = 8.0.3
+      └─ activesupport (8.0.3) requires concurrent-ruby ~> 1.0, >= 1.3.1
+
+  actionpack => activesupport => concurrent-ruby
+    └─ actionpack (8.0.3) requires activesupport = 8.0.3
+      └─ activesupport (8.0.3) requires concurrent-ruby ~> 1.0, >= 1.3.1
+
+Total: 10 root gem(s) depend on concurrent-ruby
+Found 25 dependency chain(s)
+
+Tip: Use --direct for direct dependencies only or --tree for a visual tree
+```
+
+#### Direct Dependencies Only
+
+Check which gems directly depend on `rake`:
+
+```bash
+$ gem why rake --direct
+Gems that depend on rake:
+
+  ast (2.4.3) requires rake ~> 13.2
+  minitest (5.16.0) requires rake >= 0
+  rubocop (1.21.0) requires rake >= 0
+  ...
+
+Total: 15 gem(s)
+```
+
+#### Tree Visualization
+
+Display dependencies as a visual tree:
+
+```bash
+$ gem why concurrent-ruby --tree
+Dependency tree for concurrent-ruby:
+
+rails (8.0.3)
+├── activesupport = 8.0.3
+│   └── activesupport (8.0.3) requires concurrent-ruby ~> 1.0, >= 1.3.1
+│       └── concurrent-ruby ✓
+
+actionpack (8.0.3)
+├── activesupport = 8.0.3
+│   └── activesupport (8.0.3) requires concurrent-ruby ~> 1.0, >= 1.3.1
+│       └── concurrent-ruby ✓
+
+Total: 10 root gem(s) depend on concurrent-ruby
+```
+
+If no gems depend on the specified gem:
+
+```bash
+$ gem why nonexistent-gem
+No gems depend on nonexistent-gem
+```
+
+### Options
+
+| Option | Short | Description |
+|--------|-------|-------------|
+| (none) | | Show full dependency chains (default) |
+| `--direct` | `-d` | Show only direct dependencies |
+| `--tree` | `-t` | Display as a visual tree |
+| `--help` | `-h` | Show help message |
+| `--verbose` | `-V` | Verbose output |
+
+## How It Works
+
+### Default Mode (Deep Dependencies)
+
+1. Builds a complete dependency graph of all installed gems
+2. Finds all paths (dependency chains) leading to the target gem
+3. Shows transitive dependencies (A depends on B, B depends on target)
+4. Groups results by root gems
+5. Displays the full chain: `root => intermediate => target`
+
+### Direct Mode (`--direct`)
+
+1. Scans all installed gems on your system
+2. Checks both runtime and development dependencies
+3. Finds which gems **directly** depend on the specified gem
+4. Displays results with gem names, versions, and requirements
+5. Results are sorted alphabetically for easy reading
+
+### Tree Mode (`--tree`)
+
+1. Performs deep dependency analysis
+2. Builds a hierarchical tree structure
+3. Visualizes dependencies using tree characters (├──, └──, │)
+4. Shows the complete dependency path from root to target
+5. Makes it easy to understand complex dependency relationships
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/gem_why/analyzer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module GemWhy
+  # Analyzes gem dependencies to find dependents and dependency chains
+  class Analyzer
+    # Finds all gems that directly depend on the target gem
+    # @param target_gem_name [String] the gem to find dependents for
+    # @return [Array<Array(String, String)>] array of [gem_name, requirement] pairs
+    def find_direct_dependents(target_gem_name)
+      dependents = []
+      normalized_target = target_gem_name.downcase
+
+      Gem::Specification.each do |spec|
+        spec.dependencies.each do |dep|
+          dependents << [spec.name, dep.requirement.to_s] if dep.name.downcase == normalized_target
+        end
+      end
+
+      dependents.sort_by(&:first)
+    end
+
+    # Finds all dependency chains leading to the target gem
+    # @param target_gem_name [String] the gem to find chains for
+    # @return [Array<Array<Hash>>] array of dependency chains
+    def find_dependency_chains(target_gem_name)
+      chains = []
+      normalized_target = target_gem_name.downcase
+
+      Gem::Specification.each do |spec|
+        paths = find_paths_to_target(spec.name, normalized_target, [])
+        chains.concat(paths)
+      end
+
+      chains.uniq.sort_by { |chain| chain.first[:name] }
+    end
+
+    private
+
+    # Recursively finds all paths from current gem to target gem
+    # @param current_gem [String] the current gem being explored
+    # @param target_gem [String] the gem we're searching for
+    # @param path [Array<Hash>] the current dependency path
+    # @param visited [Set<String>] set of already visited gems (prevents cycles)
+    # @return [Array<Array<Hash>>] array of paths to the target
+    def find_paths_to_target(current_gem, target_gem, path, visited = Set.new)
+      return [] if visited.include?(current_gem)
+
+      visited = visited.dup
+      visited.add(current_gem)
+      spec = load_gem_spec(current_gem)
+      return [] unless spec
+
+      collect_dependency_paths(spec, target_gem, path, visited)
+    end
+
+    def collect_dependency_paths(spec, target_gem, path, visited)
+      paths = []
+
+      spec.dependencies.each do |dep|
+        new_node = build_dependency_node(spec, dep)
+        paths.concat(process_dependency(dep, target_gem, path, new_node, visited))
+      end
+
+      paths
+    end
+
+    def process_dependency(dep, target_gem, path, new_node, visited)
+      if dep.name.downcase == target_gem.downcase
+        [path + [new_node]]
+      else
+        find_paths_to_target(dep.name, target_gem, path + [new_node], visited)
+      end
+    end
+
+    def load_gem_spec(gem_name)
+      Gem::Specification.find_by_name(gem_name)
+    rescue Gem::MissingSpecError
+      nil
+    end
+
+    def build_dependency_node(spec, dep)
+      name = spec.name
+      version = spec.version.to_s
+      dependency = dep.name
+      requirement = dep.requirement.to_s
+      { name:, version:, dependency:, requirement: }
+    end
+  end
+end

data/lib/gem_why/formatters/base_formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rainbow"
+
+module GemWhy
+  module Formatters
+    # Base formatter with colorization support
+    class BaseFormatter
+      attr_reader :command
+
+      def initialize(command)
+        @command = command
+      end
+
+      private
+
+      # Determines if output should be colorized
+      # @return [Boolean] true if colors should be used
+      def colorize?
+        !command.options[:no_color] && $stdout.tty?
+      end
+
+      # Colorizes text if appropriate
+      # @param text [String] the text to colorize
+      # @param color [Symbol] the color to apply
+      # @return [String] the colorized or original text
+      def colorize(text, color)
+        colorize? ? Rainbow(text).color(color) : text
+      end
+
+      # Delegates to command's say method
+      def say(message)
+        command.say(message)
+      end
+    end
+  end
+end

data/lib/gem_why/formatters/deep_formatter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module GemWhy
+  module Formatters
+    # Formats deep dependency chains output
+    class DeepFormatter < BaseFormatter
+      # Formats and displays deep dependency chains
+      # @param gem_name [String] the target gem name
+      # @param chains [Array<Array<Hash>>] the dependency chains
+      # @return [void]
+      def format(gem_name, chains)
+        return say "No gems depend on #{colorize(gem_name, :yellow)}" if chains.empty?
+
+        say "Dependency chains leading to #{colorize(gem_name, :cyan)}:\n\n"
+        print_dependency_chains(chains, gem_name)
+        print_deep_summary(chains, gem_name)
+      end
+
+      private
+
+      def print_dependency_chains(chains, gem_name)
+        chains_by_root = chains.group_by { |chain| chain.first[:name] }
+
+        chains_by_root.each_value do |root_chains|
+          root_chains.each do |chain|
+            display_chain(chain, gem_name)
+            say ""
+          end
+        end
+      end
+
+      def print_deep_summary(chains, gem_name)
+        chains_by_root = chains.group_by { |chain| chain.first[:name] }
+        root_gems = chains_by_root.keys
+
+        say "#{colorize("Total:", :green)} #{root_gems.size} root gem(s) depend on #{gem_name}"
+        say "Found #{chains.size} dependency chain(s)"
+        say "\n#{colorize("Tip:", :yellow)} Use --direct for direct dependencies only or --tree for a visual tree"
+      end
+
+      def display_chain(chain, gem_name)
+        path_str = chain.map { |node| colorize(node[:name], :blue) }.join(" #{colorize("=>", :white)} ")
+        path_str += " #{colorize("=>", :white)} #{colorize(gem_name, :cyan)}"
+        say "  #{path_str}"
+
+        chain.each_with_index do |node, idx|
+          display_chain_node(node, idx)
+        end
+      end
+
+      def display_chain_node(node, idx)
+        indent = "    " * (idx + 1)
+        requirement = "#{node[:dependency]} #{node[:requirement]}"
+        say "#{indent}└─ #{node[:name]} (#{node[:version]}) requires #{requirement}"
+      end
+    end
+  end
+end

data/lib/gem_why/formatters/direct_formatter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module GemWhy
+  module Formatters
+    # Formats direct dependencies output
+    class DirectFormatter < BaseFormatter
+      # Formats and displays direct dependencies
+      # @param gem_name [String] the target gem name
+      # @param dependents [Array<Array(String, String)>] the dependent gems
+      # @return [void]
+      def format(gem_name, dependents)
+        return say "No gems depend on #{colorize(gem_name, :yellow)}" if dependents.empty?
+
+        say "Gems that depend on #{colorize(gem_name, :cyan)}:\n\n"
+        print_direct_dependents(dependents, gem_name)
+        say "\n#{colorize("Total:", :green)} #{dependents.size} gem(s)"
+      end
+
+      private
+
+      def print_direct_dependents(dependents, gem_name)
+        dependents.each do |dependent_name, requirement|
+          spec = Gem::Specification.find_by_name(dependent_name)
+          say "  #{colorize(dependent_name, :blue)} (#{spec.version}) requires #{gem_name} #{requirement}"
+        end
+      end
+    end
+  end
+end

data/lib/gem_why/formatters/tree_formatter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "base_formatter"
+
+module GemWhy
+  module Formatters
+    # Formats tree visualization output
+    class TreeFormatter < BaseFormatter
+      attr_reader :tree_builder
+
+      def initialize(command, tree_builder)
+        super(command)
+        @tree_builder = tree_builder
+      end
+
+      # Formats and displays dependency tree
+      # @param gem_name [String] the target gem name
+      # @param chains [Array<Array<Hash>>] the dependency chains
+      # @return [void]
+      def format(gem_name, chains)
+        return say "No gems depend on #{colorize(gem_name, :yellow)}" if chains.empty?
+
+        say "Dependency tree for #{colorize(gem_name, :cyan)}:\n\n"
+        print_dependency_tree(chains, gem_name)
+        print_tree_summary(chains, gem_name)
+      end
+
+      private
+
+      def print_dependency_tree(chains, gem_name)
+        chains_by_root = chains.group_by { |chain| chain.first[:name] }
+
+        chains_by_root.each do |root_name, root_chains|
+          print_root_tree(root_name, root_chains, gem_name)
+        end
+      end
+
+      def print_root_tree(root_name, root_chains, gem_name)
+        root_spec = Gem::Specification.find_by_name(root_name)
+        say "#{colorize(root_name, :blue)} (#{root_spec.version})"
+
+        tree = tree_builder.build_tree_structure(root_chains)
+        display_tree_node(tree, "", gem_name)
+
+        say ""
+      end
+
+      def print_tree_summary(chains, gem_name)
+        chains_by_root = chains.group_by { |chain| chain.first[:name] }
+        root_gems = chains_by_root.keys
+        say "#{colorize("Total:", :green)} #{root_gems.size} root gem(s) depend on #{gem_name}"
+      end
+
+      def display_tree_node(tree, prefix, target_gem, depth = 0)
+        return if tree.empty?
+
+        tree.each_with_index do |(key, value), index|
+          is_last = index == tree.size - 1
+          display_node_line(key, value, prefix, is_last, depth)
+          display_children_or_target(value, prefix, is_last, target_gem, depth)
+        end
+      end
+
+      def display_node_line(key, value, prefix, is_last, depth)
+        connector = is_last ? "└──" : "├──"
+        line = build_node_line(key, value, depth)
+        say "#{prefix}#{connector} #{line}"
+      end
+
+      def build_node_line(key, value, depth)
+        if depth.zero?
+          "#{value[:dependency]} #{value[:requirement]}"
+        else
+          "#{key} requires #{value[:dependency]} #{value[:requirement]}"
+        end
+      end
+
+      def display_children_or_target(value, prefix, is_last, target_gem, depth)
+        new_prefix = prefix + (is_last ? "    " : "│   ")
+
+        if value[:children].empty?
+          say "#{new_prefix}└── #{colorize(target_gem, :cyan)} #{colorize("✓", :green)}"
+        else
+          display_tree_node(value[:children], new_prefix, target_gem, depth + 1)
+        end
+      end
+    end
+  end
+end

data/lib/gem_why/json_outputter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "json"
+
+module GemWhy
+  # Handles JSON output for all display modes
+  class JSONOutputter
+    attr_reader :command, :tree_builder
+
+    def initialize(command, tree_builder)
+      @command = command
+      @tree_builder = tree_builder
+    end
+
+    # Outputs direct dependencies as JSON
+    # @param gem_name [String] the target gem name
+    # @param dependents [Array<Array(String, String)>] the dependent gems
+    # @return [void]
+    def output_direct(gem_name, dependents)
+      target = gem_name
+      mode = "direct"
+      total = dependents.size
+      dependents_data = dependents.map do |name, requirement|
+        spec = Gem::Specification.find_by_name(name)
+        version = spec.version.to_s
+        { name:, version:, requirement: }
+      end
+      output = { target:, mode:, dependents: dependents_data, total: }
+      say JSON.pretty_generate(output)
+    end
+
+    # Outputs deep dependency chains as JSON
+    # @param gem_name [String] the target gem name
+    # @param chains [Array<Array<Hash>>] the dependency chains
+    # @return [void]
+    def output_deep(gem_name, chains)
+      chains_by_root = chains.group_by { |chain| chain.first[:name] }
+      target = gem_name
+      mode = "deep"
+      chains_data = chains.map { |chain| chain.map { |node| node.slice(:name, :version, :dependency, :requirement) } }
+      root_gems = chains_by_root.keys.size
+      total_chains = chains.size
+      output = { target:, mode:, chains: chains_data, root_gems:, total_chains: }
+      say JSON.pretty_generate(output)
+    end
+
+    # Outputs dependency tree as JSON
+    # @param gem_name [String] the target gem name
+    # @param chains [Array<Array<Hash>>] the dependency chains
+    # @return [void]
+    def output_tree(gem_name, chains)
+      chains_by_root = chains.group_by { |chain| chain.first[:name] }
+      target = gem_name
+      mode = "tree"
+      roots = build_json_roots(chains_by_root)
+      total_roots = chains_by_root.keys.size
+      output = { target:, mode:, roots:, total_roots: }
+      say JSON.pretty_generate(output)
+    end
+
+    private
+
+    def build_json_roots(chains_by_root)
+      chains_by_root.map do |root_name, root_chains|
+        root_spec = Gem::Specification.find_by_name(root_name)
+        name = root_name
+        version = root_spec.version.to_s
+        tree = tree_builder.build_tree_structure(root_chains)
+        { name:, version:, tree: }
+      end
+    end
+
+    def say(message)
+      command.say(message)
+    end
+  end
+end

data/lib/gem_why/tree_builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GemWhy
+  # Builds tree structures from dependency chains
+  class TreeBuilder
+    # Builds a tree structure from dependency chains
+    # @param chains [Array<Array<Hash>>] the dependency chains
+    # @return [Hash] hierarchical tree structure
+    def build_tree_structure(chains)
+      tree = {}
+
+      chains.each do |chain|
+        add_chain_to_tree(tree, chain)
+      end
+
+      tree
+    end
+
+    private
+
+    def add_chain_to_tree(tree, chain)
+      current_level = tree
+
+      chain.each do |node|
+        key = "#{node[:name]} (#{node[:version]})"
+        current_level[key] ||= create_tree_node(node)
+        current_level = current_level[key][:children]
+      end
+    end
+
+    def create_tree_node(node)
+      dependency = node[:dependency]
+      requirement = node[:requirement]
+      children = {}
+      { dependency:, requirement:, children: }
+    end
+  end
+end

data/lib/gem_why/version.rb

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

data/lib/rubygems/commands/why_command.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "rubygems/command"
+require_relative "../../gem_why/version"
+require_relative "../../gem_why/analyzer"
+require_relative "../../gem_why/tree_builder"
+require_relative "../../gem_why/json_outputter"
+require_relative "../../gem_why/formatters/direct_formatter"
+require_relative "../../gem_why/formatters/deep_formatter"
+require_relative "../../gem_why/formatters/tree_formatter"
+
+module Gem
+  module Commands
+    # Command to show which gems depend on a specific gem
+    #
+    # This command helps identify dependency relationships by showing:
+    # - Direct dependencies (--direct): immediate dependents only
+    # - Deep dependencies (default): full dependency chains
+    # - Tree visualization (--tree): hierarchical view
+    #
+    # @example Show all dependency chains
+    #   gem why concurrent-ruby
+    #
+    # @example Show only direct dependencies
+    #   gem why rake --direct
+    #
+    # @example Show tree visualization
+    #   gem why concurrent-ruby --tree
+    #
+    # @example Output as JSON
+    #   gem why rake --json
+    class WhyCommand < Gem::Command
+      # Initializes the why command with options
+      def initialize
+        super("why", "Show which gems depend on a specific gem")
+        setup_options
+        initialize_dependencies
+      end
+
+      # @return [String] long description of the command
+      def description
+        "Show which installed gems depend on a specific gem, including dependency chains"
+      end
+
+      # @return [String] usage string for the command
+      def usage
+        "#{program_name} GEMNAME [options]"
+      end
+
+      # Executes the command with the provided arguments
+      # @return [void]
+      def execute
+        gem_name = validate_gem_name
+        route_to_display_mode(gem_name)
+      end
+
+      private
+
+      attr_reader :analyzer, :tree_builder, :json_outputter, :direct_formatter, :deep_formatter, :tree_formatter
+
+      def setup_options
+        setup_tree_option
+        setup_direct_option
+        setup_version_option
+        setup_no_color_option
+        setup_json_option
+      end
+
+      def setup_tree_option
+        add_option("-t", "--tree", "Display dependencies as a tree") do |value, options|
+          options[:tree] = value
+        end
+      end
+
+      def setup_direct_option
+        add_option("-d", "--direct", "Show only direct dependencies") do |value, options|
+          options[:direct] = value
+        end
+      end
+
+      def setup_version_option
+        add_option("-v", "--version", "Show gem-why version") do |_value, _options|
+          say "gem-why version #{GemWhy::VERSION}"
+          terminate_interaction
+        end
+      end
+
+      def setup_no_color_option
+        add_option("--no-color", "Disable colored output") do |_value, options|
+          options[:no_color] = true
+        end
+      end
+
+      def setup_json_option
+        add_option("--json", "Output in JSON format") do |_value, options|
+          options[:json] = true
+        end
+      end
+
+      def initialize_dependencies
+        @analyzer = GemWhy::Analyzer.new
+        @tree_builder = GemWhy::TreeBuilder.new
+        @json_outputter = GemWhy::JSONOutputter.new(self, tree_builder)
+        @direct_formatter = GemWhy::Formatters::DirectFormatter.new(self)
+        @deep_formatter = GemWhy::Formatters::DeepFormatter.new(self)
+        @tree_formatter = GemWhy::Formatters::TreeFormatter.new(self, tree_builder)
+      end
+
+      # Validates and normalizes the gem name argument
+      # @return [String] the normalized gem name
+      # @raise [Gem::CommandLineError] if no gem name provided
+      def validate_gem_name
+        gem_name = get_one_optional_argument || raise(
+          Gem::CommandLineError,
+          "Please specify a gem name (e.g. gem why rake)"
+        )
+        gem_name.downcase
+      end
+
+      # Routes execution to the appropriate display mode
+      # @param gem_name [String] the target gem name
+      # @return [void]
+      def route_to_display_mode(gem_name)
+        if options[:direct]
+          show_direct_dependencies(gem_name)
+        elsif options[:tree]
+          show_tree_visualization(gem_name)
+        else
+          show_deep_dependencies(gem_name)
+        end
+      end
+
+      # Shows direct dependencies only
+      # @param gem_name [String] the target gem name
+      # @return [void]
+      def show_direct_dependencies(gem_name)
+        dependents = analyzer.find_direct_dependents(gem_name)
+
+        if options[:json]
+          json_outputter.output_direct(gem_name, dependents)
+        else
+          direct_formatter.format(gem_name, dependents)
+        end
+      end
+
+      # Shows deep dependencies (full chains)
+      # @param gem_name [String] the target gem name
+      # @return [void]
+      def show_deep_dependencies(gem_name)
+        chains = analyzer.find_dependency_chains(gem_name)
+
+        if options[:json]
+          json_outputter.output_deep(gem_name, chains)
+        else
+          deep_formatter.format(gem_name, chains)
+        end
+      end
+
+      # Shows tree visualization
+      # @param gem_name [String] the target gem name
+      # @return [void]
+      def show_tree_visualization(gem_name)
+        chains = analyzer.find_dependency_chains(gem_name)
+
+        if options[:json]
+          json_outputter.output_tree(gem_name, chains)
+        else
+          tree_formatter.format(gem_name, chains)
+        end
+      end
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "rubygems/command_manager"
+
+Gem::CommandManager.instance.register_command :why

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: gem-why
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Vitaly Slobodin
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: A RubyGems plugin that shows which gems depend on a specific gem, including
+  full dependency chains and tree visualization.
+email:
+- vitaliy.slobodin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/gem_why/analyzer.rb
+- lib/gem_why/formatters/base_formatter.rb
+- lib/gem_why/formatters/deep_formatter.rb
+- lib/gem_why/formatters/direct_formatter.rb
+- lib/gem_why/formatters/tree_formatter.rb
+- lib/gem_why/json_outputter.rb
+- lib/gem_why/tree_builder.rb
+- lib/gem_why/version.rb
+- lib/rubygems/commands/why_command.rb
+- lib/rubygems_plugin.rb
+homepage: https://github.com/vitallium/gem-why
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/vitallium/gem-why
+  source_code_uri: https://github.com/vitallium/gem-why
+  changelog_uri: https://github.com/vitallium/gem-why/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A RubyGems plugin to show which gems depend on a specific gem
+test_files: []