keela 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5eafef4540bb30839eb54b9de70e43000be89b8984a5494d9c5b1e37c76b968
-  data.tar.gz: de69c9165352044cdfc64e84a480e4aef098a28d3ecfd285d6d0a2227d417b56
+  metadata.gz: b2532684d9e7c3cca0411cbe55c3d944265236d159c287f8b719a778695872ed
+  data.tar.gz: '08a678fa6105ae093817dba3ce3632f25d173cae617db34aa267bd524b77e2ee'
 SHA512:
-  metadata.gz: 71d6ecd16abc63e8b74db4a09f6d5979e168219b16fa27014c848209e230d9674f9393b4087fa97af1c9bd0af84e7f00eaebabd2375fbc788f1d090377b39685
-  data.tar.gz: 5b590194ecec3ef30621d67c85bcd07a9cd4c7a43374184bd45ac53badab44cd86d83887294624e1e82122a5f85f5d57874b8e46252a92c1d3b3401a3de23be8
+  metadata.gz: 8b0574c28fcec2f29a78463c08d20ccf58401d81b67c60878571fef4c381dc88bd4beca3b802c72edb5b456ec9c8bbf7b1f46b3bd2c6ed68380994ac04267330
+  data.tar.gz: 90e50d394dff39875fad354923381b9490994a9d2a4d3673f4c1a0d6df15be85c21bb54a24fee6a4860553bcea580ac589d4ed57f0e5fa44c8c2e80ba6742765

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# 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).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-07-16
+
+### Added
+
+- Initial release
+- `Scanner` class for detecting unused code
+- Built-in strategies for methods and scopes detection
+- CLI tool with `--report` and `--update-baseline` modes
+- Configurable file extensions and directory patterns
+- Baseline comparison for CI integration
+- Exclusion file support for false positives

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kerri Miller
+
+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,207 @@
+# Keela 🐕
+
+Like the famous CSI dog who found what others missed, Keela sniffs out unused code in your Ruby codebase.
+
+## Why Remove Unused Code?
+
+Dead code isn't harmless — it's actively costly:
+
+- **Cognitive overhead**: Developers read and try to understand code that doesn't matter, slowing down onboarding and feature work
+- **CI minutes**: Tests for unused methods still run, burning compute time on every pipeline
+- **False confidence**: Test coverage metrics include dead code, masking gaps in the code that actually runs
+- **Refactoring friction**: Unused code creates dependencies that make refactoring harder ("wait, is this called somewhere?")
+- **Security surface**: More code means more potential vulnerabilities, even in paths users never hit
+
+Most codebases accumulate dead code gradually — a feature flag that's always on, a method replaced but never deleted, a scope that lost its last caller. Keela helps you find it and clean it up.
+
+## Installation
+
+```bash
+gem install keela
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'keela', group: :development
+```
+
+## Quick Start
+
+```bash
+# First time: generate a baseline of current unused code
+keela --update-baseline
+
+# This creates .keela_baseline.yml in your project root
+
+# From now on, just run:
+keela
+
+# Keela will fail if:
+#   - NEW unused code is detected (someone added dead code)
+#   - Previously unused code was REMOVED (time to update the baseline!)
+```
+
+## How It Works
+
+Keela operates in two modes:
+
+### Baseline Mode (Default)
+
+If a `.keela_baseline.yml` file exists, Keela compares the current scan against it:
+
+| Scenario | Result |
+|----------|--------|
+| No changes from baseline | ✅ Pass (silent, exit 0) |
+| NEW unused code detected | ❌ Fail (shows new items) |
+| Code REMOVED from baseline | ❌ Fail (prompts to update baseline) |
+
+This lets you gradually pay down tech debt while preventing new dead code from sneaking in.
+
+### Report Mode
+
+If no baseline exists (or you use `--report`), Keela shows all unused code:
+
+```bash
+keela --report
+```
+
+## Command Line Options
+
+```bash
+# Scan for all unused code (methods and scopes)
+keela
+
+# Scan for specific types
+keela --type methods
+keela --type scopes
+
+# Force report mode (ignore baseline)
+keela --report
+
+# Update the baseline file
+keela --update-baseline
+
+# Use a custom baseline path
+keela --baseline config/unused_baseline.yml
+
+# Specify excluded items file
+keela --excluded config/keela_excluded.yml
+
+# Custom file extensions
+keela --extensions rb,rake,haml
+
+# Show version
+keela --version
+```
+
+## CI Integration
+
+Keela is designed for CI pipelines. Add it to catch dead code before it merges:
+
+```yaml
+# .gitlab-ci.yml
+unused_code:
+  script:
+    - bundle exec keela
+  rules:
+    - if: $CI_MERGE_REQUEST_IID
+```
+
+```yaml
+# .github/workflows/ci.yml
+- name: Check for unused code
+  run: bundle exec keela
+```
+
+The workflow:
+
+1. **Initial setup**: Run `keela --update-baseline` and commit `.keela_baseline.yml`
+2. **CI runs**: `keela` compares against baseline, fails on new dead code
+3. **After cleanup**: Run `keela --update-baseline` to update the baseline
+
+## Exclusion File
+
+Some code appears unused but is actually called dynamically. Exclude it:
+
+```yaml
+# .keela_excluded.yml
+app/models/user.rb:
+  - legacy_method: "Called via metaprogramming"
+  - callback_method: "Used as ActiveRecord callback"
+app/helpers/application_helper.rb:
+  - helper_method: "Called from views dynamically"
+```
+
+Then run with:
+
+```bash
+keela --excluded .keela_excluded.yml
+```
+
+## Ruby API
+
+```ruby
+require 'keela'
+
+# Configure Keela
+Keela.configure do |config|
+  config.extensions = %w[rb haml erb]
+  config.directory_patterns = %w[
+    app/**/*.%<ext>s
+    lib/**/*.%<ext>s
+  ]
+  config.excluded_path = '.keela_excluded.yml'
+  config.baseline_path = '.keela_baseline.yml'
+end
+
+# Run a scan
+strategy = Keela::Strategies::Methods.new
+scanner = Keela::Scanner.new(strategy: strategy)
+success = scanner.run
+
+# Access results
+scanner.unused_collection  # Hash of file => [unused_names]
+scanner.new_unused         # Items not in baseline
+scanner.removed            # Items in baseline but no longer unused
+```
+
+## Custom Strategies
+
+Detect other patterns by creating your own strategy:
+
+```ruby
+class CallbackStrategy < Keela::Strategy
+  def name
+    "callbacks"
+  end
+
+  def definition_file_pattern
+    %r{app/models}
+  end
+
+  def extract_definition(line)
+    # Match: before_save :do_something
+    line =~ /(?:before|after|around)_\w+\s+:(\w+)/ ? Regexp.last_match(1) : nil
+  end
+
+  def usage_regex(name)
+    /def #{Regexp.quote(name)}\b/
+  end
+
+  def skip_comments?
+    true
+  end
+end
+
+scanner = Keela::Scanner.new(strategy: CallbackStrategy.new)
+scanner.run(force_report: true)
+```
+
+## About the Name
+
+[Keela](https://en.wikipedia.org/wiki/Keela_(dog)) was a famous English Springer Spaniel known as the "CSI dog." She could detect microscopic traces of blood that other methods missed, and worked on many high-profile forensic cases including the Madeleine McCann investigation. Like her namesake, this gem finds the unused code that other tools miss.
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/exe/keela

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "keela"
+
+options = {
+  type: :all,
+  force_report: false,
+  update_baseline: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: keela [options]"
+
+  opts.separator ""
+  opts.separator "Keela sniffs out unused code in your Ruby codebase."
+  opts.separator ""
+  opts.separator "By default, if a baseline file exists, Keela runs in diff mode:"
+  opts.separator "  - Fails if NEW unused code is detected"
+  opts.separator "  - Fails if previously unused code was REMOVED (update baseline)"
+  opts.separator "  - Passes if unchanged from baseline"
+  opts.separator ""
+  opts.separator "If no baseline exists, shows a full report of all unused code."
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("--type TYPE", %i[methods scopes all], "Type to detect: methods, scopes, all (default: all)") do |type|
+    options[:type] = type
+  end
+
+  opts.on("--report", "-r", "Force report mode: show all unused code (ignore baseline)") do
+    options[:force_report] = true
+  end
+
+  opts.on("--update-baseline", "-u", "Update the baseline file with current unused code") do
+    options[:update_baseline] = true
+  end
+
+  opts.on("--excluded PATH", "Path to YAML file of excluded items") do |path|
+    Keela.configuration.excluded_path = path
+  end
+
+  opts.on("--baseline PATH", "Path to YAML baseline file (default: .keela_baseline.yml)") do |path|
+    Keela.configuration.baseline_path = path
+  end
+
+  opts.on("--extensions EXTS", "Comma-separated file extensions to scan (default: rb,haml,erb)") do |exts|
+    Keela.configuration.extensions = exts.split(",").map(&:strip)
+  end
+
+  opts.on("--version", "-v", "Show version") do
+    puts "keela #{Keela::VERSION}"
+    exit
+  end
+
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    exit
+  end
+end.parse!
+
+# Set default baseline path if not specified
+Keela.configuration.baseline_path ||= ".keela_baseline.yml"
+
+strategies = case options[:type]
+             when :all
+               [Keela::Strategies::Methods.new, Keela::Strategies::Scopes.new]
+             when :methods
+               [Keela::Strategies::Methods.new]
+             when :scopes
+               [Keela::Strategies::Scopes.new]
+             end
+
+success = true
+
+strategies.each_with_index do |strategy, index|
+  puts Rainbow("=== Sniffing for unused #{strategy.name} ===").cyan.bright if strategies.size > 1
+
+  scanner = Keela::Scanner.new(strategy: strategy)
+  success &&= scanner.run(force_report: options[:force_report], update_baseline: options[:update_baseline])
+
+  puts if strategies.size > 1 && index < strategies.size - 1
+end
+
+exit(success ? 0 : 1)

data/lib/keela/configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Keela
+  class Configuration
+    # File extensions to scan for code usage
+    attr_accessor :extensions
+
+    # Directory patterns to scan (use %<ext>s as placeholder for extension)
+    attr_accessor :directory_patterns
+
+    # Path to YAML file listing excluded items (won't be flagged as unused)
+    attr_accessor :excluded_path
+
+    # Path to YAML file tracking known unused items (baseline)
+    attr_accessor :baseline_path
+
+    # Optional directory that must exist for scanning to proceed (e.g., "ee" for GitLab)
+    attr_accessor :required_directory
+
+    # Whether to show progress during scanning
+    attr_accessor :show_progress
+
+    def initialize
+      @extensions = %w[rb haml erb].freeze
+      @directory_patterns = %w[
+        app/**/*.%<ext>s
+        lib/**/*.%<ext>s
+        config/**/*.%<ext>s
+      ].freeze
+      @excluded_path = nil
+      @baseline_path = nil
+      @required_directory = nil
+      @show_progress = true
+    end
+  end
+end

data/lib/keela/reporter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "rainbow"
+require "yaml"
+
+module Keela
+  class Reporter
+    attr_reader :strategy_name
+
+    def initialize(strategy_name)
+      @strategy_name = strategy_name
+    end
+
+    def print_full_report(unused_collection, elapsed_time)
+      unused_count = unused_collection.values.flatten.size
+
+      if unused_count > 0
+        puts "\nFound #{unused_count} unused #{strategy_name}:\n\n"
+        puts format_yaml(unused_collection)
+        puts "\n"
+      else
+        puts Rainbow("No unused #{strategy_name} were found.").green.bright
+      end
+
+      puts "Finished in #{elapsed_time.round(2)} seconds."
+    end
+
+    def print_diff_report(new_unused, removed, excluded_path:, baseline_path:)
+      print_new_unused(new_unused, excluded_path) unless new_unused.empty?
+
+      if new_unused.size + removed.size > 0
+        puts Rainbow("~" * 80).white.bright
+        puts "\n"
+      end
+
+      print_removed(removed, baseline_path) unless removed.empty?
+    end
+
+    def format_yaml(collection)
+      indent_yaml_list_items(collection.sort.to_h.to_yaml)
+    end
+
+    private
+
+    def print_new_unused(new_unused, excluded_path)
+      error = <<~MESSAGE
+        We have detected #{new_unused.size} newly unused #{strategy_name}.
+
+        Please remove these #{strategy_name}, or if in use, add to #{excluded_path}.
+      MESSAGE
+
+      puts Rainbow(error).red.bright
+      puts Rainbow(format_yaml(parse_diff(new_unused))).red.bright
+    end
+
+    def print_removed(removed, baseline_path)
+      message = <<~MESSAGE
+        It appears you have removed unused #{strategy_name}. Thank you!
+
+        Please update #{File.basename(baseline_path)} and remove entries for these #{strategy_name}.
+      MESSAGE
+
+      puts Rainbow(message).yellow.bright
+      puts Rainbow(format_yaml(parse_diff(removed))).yellow.bright
+    end
+
+    def parse_diff(diff_to_parse)
+      result = Hash.new { |hash, key| hash[key] = [] }
+
+      diff_to_parse.each do |file_name, name|
+        result[file_name] << name
+      end
+
+      result
+    end
+
+    # Indents YAML list items that are not already indented.
+    # Ruby's to_yaml outputs list items without indentation (e.g., "- item"),
+    # but we want 2-space indentation (e.g., "  - item").
+    def indent_yaml_list_items(yaml_string)
+      yaml_string.gsub(/\n-(\s+\S)/, "\n  -\\1")
+    end
+  end
+end

data/lib/keela/scanner.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "parallel"
+require "yaml"
+
+module Keela
+  class Scanner
+    attr_reader :strategy, :configuration, :source_files, :unused_collection, :new_unused, :removed
+
+    def initialize(strategy:, configuration: Keela.configuration)
+      @strategy = strategy
+      @configuration = configuration
+      @source_files = {}
+      @unused_collection = Hash.new { |hash, key| hash[key] = [] }
+      @new_unused = []
+      @removed = []
+    end
+
+    def run(force_report: false, update_baseline: false)
+      return true unless should_run?
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      load_source_files
+      definitions = find_definitions
+      definitions = filter_excluded(definitions)
+
+      # Determine mode: report if forced, updating baseline, or no baseline exists
+      report_mode = force_report || update_baseline || !baseline_exists?
+
+      find_unused(definitions, show_progress: report_mode)
+
+      if report_mode
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        reporter.print_full_report(unused_collection, elapsed)
+        write_baseline_file if update_baseline
+        return true
+      end
+
+      # Baseline mode: compare against known unused code
+      compare_with_baseline
+      reporter.print_diff_report(
+        new_unused,
+        removed,
+        excluded_path: configuration.excluded_path || "excluded.yml",
+        baseline_path: configuration.baseline_path
+      )
+
+      new_unused.empty? && removed.empty?
+    end
+
+    def file_globs
+      configuration.extensions.flat_map do |ext|
+        configuration.directory_patterns.map { |pattern| format(pattern, ext: ext) }
+      end
+    end
+
+    private
+
+    def baseline_exists?
+      configuration.baseline_path && File.exist?(configuration.baseline_path)
+    end
+
+    def should_run?
+      return true unless configuration.required_directory
+
+      Dir.exist?(configuration.required_directory)
+    end
+
+    def reporter
+      @reporter ||= Reporter.new(strategy.name)
+    end
+
+    def load_source_files
+      Dir.glob(file_globs).each do |filename|
+        @source_files[filename] = File.readlines(filename)
+      end
+    end
+
+    def find_definitions
+      source_files.keys.grep(strategy.definition_file_pattern).flat_map do |filename|
+        source_files[filename].flat_map do |line|
+          next [] if strategy.skip_comments? && line.strip.start_with?("#")
+
+          name = strategy.extract_definition(line)
+          name ? [{ name: name, file: filename }] : []
+        end
+      end
+    end
+
+    def filter_excluded(definitions)
+      return definitions unless configuration.excluded_path
+      return definitions unless File.exist?(configuration.excluded_path)
+
+      excluded = YAML.load_file(configuration.excluded_path, symbolize_names: true) || {}
+
+      definitions.reject do |h|
+        excluded_for_file = excluded[h[:file].to_sym]
+        excluded_for_file&.flat_map(&:keys)&.include?(h[:name].to_sym)
+      end
+    end
+
+    def find_unused(definitions, show_progress: false)
+      source_code = source_files.values.flatten.join
+
+      progress_label = show_progress ? "Checking #{strategy.name}" : nil
+
+      unused = Parallel.flat_map(definitions, progress: progress_label) do |definition|
+        regex = strategy.usage_regex(definition[:name])
+        regex.match?(source_code) ? [] : definition
+      end
+
+      unused.each do |unused_def|
+        @unused_collection[unused_def[:file]] << unused_def[:name]
+      end
+    end
+
+    def compare_with_baseline
+      baseline = YAML.load_file(configuration.baseline_path) || {}
+      baseline_items = baseline.flat_map { |f, names| [f].product(names) }
+
+      current_items = unused_collection.flat_map { |f, names| [f].product(names) }
+
+      @new_unused = current_items - baseline_items
+      @removed = baseline_items - current_items
+    end
+
+    def write_baseline_file
+      return unless configuration.baseline_path
+
+      header = <<~HEADER
+        # The #{strategy.name} listed here have been identified as "unused" by Keela,
+        # and are potential targets for future removal.
+        #
+        # If a #{strategy.name.chomp('s')} listed here is actually in use,
+        # remove it from this file and add it to your excluded file.
+        #
+      HEADER
+
+      yaml_content = if unused_collection.empty?
+                       "#{header}---\n{}\n"
+                     else
+                       sorted_collection = unused_collection.sort.to_h
+                       "#{header}#{reporter.format_yaml(sorted_collection)}"
+                     end
+
+      File.write(configuration.baseline_path, yaml_content)
+      puts Rainbow("Updated #{configuration.baseline_path}").green.bright
+    end
+  end
+end

data/lib/keela/strategies/methods.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Keela
+  module Strategies
+    class Methods < Strategy
+      def name
+        "methods"
+      end
+
+      def definition_file_pattern
+        %r{app/helpers|app/models}
+      end
+
+      def extract_definition(line)
+        return nil unless line =~ /def ([^(;\s]+)/
+
+        Regexp.last_match(1).chomp
+      end
+
+      def usage_regex(name)
+        if name.end_with?("=")
+          # Setter method: match assignment usage
+          /(?<!def )#{Regexp.quote(name.sub(/^self\./, "").chomp("="))}\W=*/
+        else
+          # Regular method: match calls
+          /(?<!def )#{Regexp.quote(name.sub(/^self\./, ""))}\W/
+        end
+      end
+
+      def skip_comments?
+        false
+      end
+    end
+  end
+end

data/lib/keela/strategies/scopes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Keela
+  module Strategies
+    class Scopes < Strategy
+      def name
+        "scopes"
+      end
+
+      def definition_file_pattern
+        %r{app/models}
+      end
+
+      def extract_definition(line)
+        return nil unless line =~ /\bscope\s+:(\w+)/
+
+        Regexp.last_match(1)
+      end
+
+      def usage_regex(name)
+        /(?<!scope :)(?<!def )#{Regexp.quote(name)}\W/
+      end
+
+      def skip_comments?
+        true
+      end
+    end
+  end
+end

data/lib/keela/strategy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Keela
+  # Base class for detection strategies.
+  #
+  # Subclasses define how to find definitions and detect usage for
+  # different types of code (methods, scopes, etc.)
+  #
+  class Strategy
+    # Human-readable name for this strategy (e.g., "methods", "scopes")
+    def name
+      raise NotImplementedError, "#{self.class} must implement #name"
+    end
+
+    # Regex pattern to match files that may contain definitions
+    # (e.g., /app\/models/ for scopes)
+    def definition_file_pattern
+      raise NotImplementedError, "#{self.class} must implement #definition_file_pattern"
+    end
+
+    # Extract a definition name from a line of code, or nil if no definition found
+    def extract_definition(line)
+      raise NotImplementedError, "#{self.class} must implement #extract_definition"
+    end
+
+    # Build a regex to detect usage of the given definition name
+    def usage_regex(name)
+      raise NotImplementedError, "#{self.class} must implement #usage_regex"
+    end
+
+    # Whether to skip lines that start with # (comments)
+    def skip_comments?
+      false
+    end
+  end
+end

data/lib/keela/version.rb

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

data/lib/keela.rb

@@ -1,5 +1,27 @@
 # frozen_string_literal: true
 
+require_relative "keela/version"
+require_relative "keela/configuration"
+require_relative "keela/strategy"
+require_relative "keela/strategies/methods"
+require_relative "keela/strategies/scopes"
+require_relative "keela/reporter"
+require_relative "keela/scanner"
+
 module Keela
-  VERSION = '0.0.2'
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
 end

metadata

@@ -1,26 +1,84 @@
 --- !ruby/object:Gem::Specification
 name: keela
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Kerri Miller
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.20'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
 description: Like the famous CSI dog who found what others missed, Keela detects unused
   methods and scopes in your Ruby codebase.
 email: kerrizor@kerrizor.com
-executables: []
+executables:
+- keela
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/keela
 - lib/keela.rb
+- lib/keela/configuration.rb
+- lib/keela/reporter.rb
+- lib/keela/scanner.rb
+- lib/keela/strategies/methods.rb
+- lib/keela/strategies/scopes.rb
+- lib/keela/strategy.rb
+- lib/keela/version.rb
 homepage: https://github.com/kerrizor/keela
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/kerrizor/keela
+  source_code_uri: https://github.com/kerrizor/keela
+  changelog_uri: https://github.com/kerrizor/keela/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/kerrizor/keela/issues
 rdoc_options: []
 require_paths:
 - lib
@@ -35,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Sniff out unused code in your Ruby codebase
 test_files: []