keela 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0755e73eaeeb61f9f97ffa109fd8c421316e7725b83ef2502a37c5ba0111858f
-  data.tar.gz: d66e1092dd578f28ae3d727b179b601fcd7068671550f9186e53c76a543d1763
+  metadata.gz: b149f85c049e9f0a669ccdef6c9f70f4bcd627d9bec77a543303fae76592cfde
+  data.tar.gz: 3ddae5519560492fbd7fc223065047f787f08bf9c8e99da35efdcbfec0e8e1c7
 SHA512:
-  metadata.gz: bf117842ed4d8891671dac92ee34c48b5433f50795f9a90963211c1e650df11b31e72c2d142a6fc489f3dfb040989341764ab6eba4d2ea70432828bd6ed1c1dc
-  data.tar.gz: ac2d7352393d70240f7ad1541f2ff476e5ed7c8def8b13212721a527df4e7c285b2c31519333ebe712aab31e9a186a997420598e7e7662af181353cf9f8b96ca
+  metadata.gz: c02762a44f0cab25a0c3711001bcc1891cd016c489318b55c837b4a6be87973551c7f073a29b3ef97691fadf5e6d5c2b040b873f3b2a37a0f1c58bdcf6fc78d7
+  data.tar.gz: 529a21fb0e9e8c1e603f48b6f3565a6b8f85c81a939a7120301476c444ce0478d2aac842eaa2f4689afc80803847f6f1f577e8010842f3517c8a4b20fa6fc8d6

data/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-30
+
+### Added
+
+- **Stale exclusions are now reported during a normal run, not just under `--test-exclusions`.** An entry in the excluded YAML whose definition no longer exists (removed, renamed, or its file deleted) was previously only caught by the separate `--test-exclusions` command, so the exclusions file silently rotted. A normal run now flags these inline, elevated to the same behavior as newly unused findings: in baseline mode it fails the run (exit 1), and structured output (`--format json|toon`) carries a `stale_exclusions` section and a `stale_total` summary count. Detection is scoped to the current strategy's section; legacy flat-format entries are skipped to avoid cross-strategy false positives ([#103](https://github.com/kerrizor/keela/issues/103))
+- **New `--normalize-exclusions` flag rewrites the exclusions file in sorted, normalized order.** An explicit write mode (modeled on `--update-baseline`) that deep-sorts the excluded YAML: strategy keys, then file keys within each strategy, then the `name: reason` entries by name. It is reorder-only and non-destructive, it never prunes stale entries, and it preserves every reason verbatim (reasons containing colons stay quoted). Both the strategy-aware and legacy flat formats are handled, output is idempotent, and the file is rewritten with a fixed header (freeform comments are not preserved) ([#93](https://github.com/kerrizor/keela/issues/93))
+
+### Changed
+
+- Relaxed the `parallel` dependency from `~> 1.20` to `>= 1.20, < 3`, so keela no longer forces a downgrade in projects already on parallel 2.x, while still supporting 1.x ([#101](https://github.com/kerrizor/keela/pull/101))
+
+### Fixed
+
+- **`has_scope :name` is no longer swallowed as a false positive by the `scopes` strategy.** The usage regex excluded any line ending in `scope :` to skip the `scope :name` definition, but `has_scope :name` (common in Rails controllers and ActiveAdmin) also ends in `scope :`, so real usages were rejected and the scope was wrongly reported unused. The lookbehind now requires a whitespace character before `scope`, so an indented definition is still excluded while `has_scope` (preceded by `_`) counts as usage ([#100](https://github.com/kerrizor/keela/issues/100))
+- **A method named only in a comment is no longer counted as used.** Usage detection matched its regex against the whole source, comments included, so a method whose name appeared in a comment was treated as called and genuinely dead code was never flagged. Whole-line Ruby comments (`.rb`, `.rake`, `.builder`) are now dropped from the usage corpus before matching. HAML is left alone (a leading `#` there is an element id), and `#{}` interpolation and trailing comments are kept, since telling a real `#` from one inside a string or regexp needs a tokenizer ([#104](https://github.com/kerrizor/keela/pull/104))
+- Run every selected strategy in baseline mode even when an earlier strategy fails, so text and structured reports include all unused code findings ([#102](https://github.com/kerrizor/keela/pull/102)).
+- **Lazy i18n lookups (`t(".key")`) in mailers, controllers, and `.text.` mailer templates are no longer reported as false-positive unused keys.** The `i18n_keys` strategy only expanded lazy lookups inside `.html.` view templates, so a lazy key used in a mailer/controller Ruby method or a `.text.erb` template was flagged unused. The view-path matcher now also covers `.text.` templates, and a pragmatic line scan of `app/mailers` and `app/controllers` (plus `ee/` variants) resolves each lazy `t(".x")` against its enclosing class and method scope, keeping `_mailer` for mailers and dropping `_controller` for controllers ([#73](https://github.com/kerrizor/keela/issues/73))
+- **Multi-line `delegate` declarations now detect every delegated method, not just the one on the first line.** The `delegations` strategy parsed files line by line, so a `delegate` wrapped across several lines only matched the methods on the opening line; the continuation lines did not match `delegate` and the opening line had no `to:` for target/prefix detection. The strategy now joins each `delegate` statement, across continuation lines while a line ends in a comma (after a trailing comment is stripped), into one logical statement before extracting, so target, `prefix:`, and every method resolve correctly. Single-line delegates and comment skipping are preserved ([#52](https://github.com/kerrizor/keela/issues/52))
+
+## [0.5.1] - 2026-10-06
+
+### Changed
+
+- **The `partials` strategy is dramatically faster on large codebases, up to ~27× less CPU.** It now collects every rendered partial in a single pass over the source instead of re-scanning the whole codebase once per partial. Measured against a large reference Rails monolith, partials went from the slowest strategy to effectively free, and no longer meaningfully slows a combined `--type all,partials` run. The report is unchanged ([#96](https://github.com/kerrizor/keela/pull/96))
+
 ## [0.5.0] - 2026-09-21
 
 ### Added

data/README.md

@@ -63,6 +63,7 @@ If a `.keela_baseline.yml` file exists, Keela compares the current scan against
 | 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) |
+| STALE exclusion (its definition is gone) | ❌ Fail (shows stale entries to remove) |
 
 This lets you gradually pay down tech debt while preventing new dead code from sneaking in.
 
@@ -178,6 +179,9 @@ keela --source-location
 # Validate exclusion file entries (find stale exclusions)
 keela --test-exclusions
 
+# Rewrite the exclusion file in sorted, normalized order
+keela --normalize-exclusions
+
 # Show version
 keela --version
 ```
@@ -193,8 +197,8 @@ Keela detects several types of unused code:
 | **constants** | Unused constants | `UNUSED_CONSTANT = 'value'` |
 | **delegations** | Unused delegate declarations | `delegate :unused, to: :target` |
 | **attributes** | Unused attr_* declarations | `attr_accessor :unused_attr` |
-| **i18n_keys** | Unused translation keys | `en.users.unused_key` in locale YAML |
-| **partials** | Unused Rails view partials | `app/views/users/_unused.html.erb` |
+| **i18n_keys** _(beta)_ | Unused translation keys | `en.users.unused_key` in locale YAML |
+| **partials** _(beta)_ | Unused Rails view partials | `app/views/users/_unused.html.erb` |
 
 Run all strategies (default) or target specific ones with `--type`.
 
@@ -508,6 +512,18 @@ Or configure in `keela.yml`:
 excluded_path: ".keela/excluded.yml"
 ```
 
+### Normalizing the Exclusion File
+
+As the exclusion file grows, entries tend to land in whatever order they were added, which makes diffs noisy. Rewrite it in a sorted, canonical order with:
+
+```bash
+keela --normalize-exclusions
+```
+
+This sorts the strategy sections, the files within each section, and the entries within each file, then rewrites the file with a fixed header. It is reorder-only: no entry is removed, and every `name: reason` pair is preserved (use `--test-exclusions` to find stale entries). Running it twice produces identical output.
+
+Freeform comments are not preserved: the rewrite regenerates a fixed header, so any hand-written comments in the file are dropped.
+
 ## Ruby API
 
 ```ruby

data/exe/keela

@@ -94,6 +94,10 @@ OptionParser.new do |opts|
     options[:test_exclusions] = true
   end
 
+  opts.on("--normalize-exclusions", "Rewrite the exclusions file in sorted, normalized order") do
+    options[:normalize_exclusions] = true
+  end
+
   opts.on("-h", "--help", "Show this help") do
     puts opts
     exit
@@ -135,6 +139,21 @@ if options[:test_exclusions]
   exit(success ? 0 : 1)
 end
 
+# Handle --normalize-exclusions mode
+if options[:normalize_exclusions]
+  excluded_path = Keela.configuration.excluded_path ||
+                  Keela::Scanner::DEFAULT_EXCLUDED_PATHS.find { |p| File.exist?(p) }
+
+  unless excluded_path
+    warn "Error: No exclusion file found. Specify with --excluded PATH"
+    exit 1
+  end
+
+  normalizer = Keela::ExclusionNormalizer.new(excluded_path)
+  success = normalizer.normalize
+  exit(success ? 0 : 1)
+end
+
 STRATEGY_MAP = {
   methods: Keela::Strategies::Methods,
   scopes: Keela::Strategies::Scopes,
@@ -210,6 +229,7 @@ end
 
 success = true
 results = {}
+stale_exclusions = {}
 
 structured_output = Keela::Formatters.structured_format?(options[:format])
 silent_output = structured_output || options[:quiet]
@@ -220,14 +240,16 @@ strategies.each_with_index do |strategy, index|
   end
 
   scanner = Keela::Scanner.new(strategy: strategy, baseline: baseline, source_files: source_files)
-  success &&= scanner.run(
+  strategy_success = scanner.run(
     force_report: options[:force_report],
     update_baseline: options[:update_baseline],
     silent: silent_output
   )
+  success &&= strategy_success
 
   # Collect results for structured output formats
   results[strategy.name] = scanner.unused_collection.transform_values(&:to_a)
+  stale_exclusions[strategy.name] = scanner.stale_exclusions.transform_values(&:to_a)
 
   unless silent_output
     puts if strategies.size > 1 && index < strategies.size - 1
@@ -243,7 +265,7 @@ end
 # Output structured format if requested
 if structured_output
   formatter_class = Keela::Formatters.for(options[:format])
-  formatter = formatter_class.new(results: results, strategies: strategies)
+  formatter = formatter_class.new(results: results, strategies: strategies, stale_exclusions: stale_exclusions)
   puts formatter.format
 end
 

data/lib/keela/exclusion_normalizer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "rainbow"
+
+module Keela
+  # Rewrites an exclusion file in sorted, normalized order.
+  #
+  # Reorder-only and non-destructive: it never prunes stale entries, it only
+  # deep-sorts the existing data and re-dumps it with a fixed header. Freeform
+  # YAML comments are not preserved (Psych drops them on load).
+  #
+  class ExclusionNormalizer
+    STRATEGY_MAP = {
+      methods: Strategies::Methods,
+      scopes: Strategies::Scopes,
+      constants: Strategies::Constants,
+      delegations: Strategies::Delegations,
+      attributes: Strategies::Attributes,
+      i18n_keys: Strategies::I18nKeys
+    }.freeze
+
+    attr_reader :excluded_path
+
+    def initialize(excluded_path)
+      @excluded_path = excluded_path
+    end
+
+    def normalize
+      unless File.exist?(excluded_path)
+        puts Rainbow("Exclusion file not found: #{excluded_path}").red
+        return false
+      end
+
+      data = YAML.load_file(excluded_path, symbolize_names: true) || {}
+
+      sorted = strategy_aware_format?(data) ? deep_sort_strategy_aware(data) : deep_sort_flat(data)
+
+      File.write(excluded_path, serialize(sorted))
+      puts Rainbow("Normalized #{excluded_path}").green.bright
+      true
+    end
+
+    private
+
+    def strategy_aware_format?(data)
+      data.keys.any? { |k| STRATEGY_MAP.key?(k) }
+    end
+
+    def deep_sort_strategy_aware(data)
+      data.sort_by { |key, _| key.to_s }.to_h do |strategy_name, files|
+        [strategy_name.to_s, sort_files(files || {})]
+      end
+    end
+
+    def deep_sort_flat(data)
+      sort_files(data)
+    end
+
+    def sort_files(files)
+      files.sort_by { |key, _| key.to_s }.to_h do |file_path, entries|
+        [file_path.to_s, sort_entries(entries || [])]
+      end
+    end
+
+    # Sorts the name:reason entry array by name, converting the symbolized
+    # key back to a string so the dumped YAML uses string keys.
+    #
+    def sort_entries(entries)
+      entries
+        .map { |entry| { entry.keys.first.to_s => entry.values.first } }
+        .sort_by { |entry| entry.keys.first }
+    end
+
+    def serialize(data)
+      if data.empty? || data.values.all? { |v| v.respond_to?(:empty?) && v.empty? }
+        "#{header}---\n{}\n"
+      else
+        "#{header}#{format_yaml(data)}"
+      end
+    end
+
+    def header
+      <<~HEADER
+        # Excluded items that Keela should not flag as unused.
+        # These are known to be in use (e.g. called via metaprogramming).
+        #
+        # This file is normalized by `keela --normalize-exclusions`.
+        # Freeform comments are not preserved when it is rewritten.
+        #
+      HEADER
+    end
+
+    def format_yaml(hash)
+      indent_yaml_list_items(hash.to_yaml)
+    end
+
+    # Indents YAML list items that are not already indented, matching the
+    # style Baseline uses for its output.
+    #
+    def indent_yaml_list_items(yaml_string)
+      yaml_string.gsub(/\n-(\s+\S)/, "\n  -\\1")
+    end
+  end
+end

data/lib/keela/formatters/base.rb

@@ -3,11 +3,12 @@
 module Keela
   module Formatters
     class Base
-      attr_reader :results, :strategies
+      attr_reader :results, :strategies, :stale_exclusions
 
-      def initialize(results:, strategies:)
+      def initialize(results:, strategies:, stale_exclusions: {})
         @results = results
         @strategies = strategies
+        @stale_exclusions = stale_exclusions
       end
 
       def format
@@ -28,6 +29,14 @@ module Keela
       def non_empty_results
         results.reject { |_, v| v.empty? }
       end
+
+      def non_empty_stale_exclusions
+        stale_exclusions.reject { |_, v| v.empty? }
+      end
+
+      def stale_total
+        stale_exclusions.values.flat_map(&:values).flatten.size
+      end
     end
   end
 end

data/lib/keela/formatters/json.rb

@@ -9,9 +9,11 @@ module Keela
         output = {
           strategies: strategies.map(&:name),
           unused: non_empty_results,
+          stale_exclusions: non_empty_stale_exclusions,
           summary: {
             total: total_count,
-            by_strategy: by_strategy_counts
+            by_strategy: by_strategy_counts,
+            stale_total: stale_total
           }
         }
 

data/lib/keela/formatters/toon.rb

@@ -9,9 +9,11 @@ module Keela
         output = {
           "strategies" => strategies.map(&:name),
           "unused" => non_empty_results.transform_keys(&:to_s),
+          "stale_exclusions" => non_empty_stale_exclusions.transform_keys(&:to_s),
           "summary" => {
             "total" => total_count,
-            "by_strategy" => by_strategy_counts.transform_keys(&:to_s)
+            "by_strategy" => by_strategy_counts.transform_keys(&:to_s),
+            "stale_total" => stale_total
           }
         }
 

data/lib/keela/reporter.rb

@@ -36,6 +36,20 @@ module Keela
       print_removed(removed, baseline_path) unless removed.empty?
     end
 
+    def print_stale_exclusions(stale, excluded_path)
+      return if stale.empty?
+
+      count = stale.values.flatten.size
+      message = <<~MESSAGE
+        We have detected #{count} stale #{strategy_name} exclusion(s).
+
+        Their definitions no longer exist; remove them from #{excluded_path}.
+      MESSAGE
+
+      puts Rainbow(message).red.bright
+      puts Rainbow(format_yaml(stale)).red.bright
+    end
+
     def format_report(collection, source_locations = {})
       if source_locations.empty?
         format_yaml(collection)

data/lib/keela/scanner.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "parallel"
+require "set"
 require "yaml"
 
 module Keela
   class Scanner
-    attr_reader :strategy, :configuration, :baseline, :source_files, :unused_collection, :source_locations, :new_unused, :removed
+    attr_reader :strategy, :configuration, :baseline, :source_files, :unused_collection, :source_locations, :new_unused, :removed, :stale_exclusions
 
     DEFAULT_EXCLUDED_PATHS = [".keela/excluded.yml", "keela_excluded.yml"].freeze
     DEFAULT_BASELINE_PATHS = [".keela/baseline.yml", "keela_baseline.yml"].freeze
@@ -51,6 +52,7 @@ module Keela
       @source_locations = {}  # { "file:name" => line_number }
       @new_unused = []
       @removed = []
+      @stale_exclusions = Hash.new { |hash, key| hash[key] = [] }
     end
 
     def run(force_report: false, update_baseline: false, silent: false)
@@ -71,7 +73,10 @@ module Keela
 
       if report_mode
         elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-        reporter.print_full_report(unused_collection, elapsed, source_locations: source_locations) unless silent
+        unless silent
+          reporter.print_full_report(unused_collection, elapsed, source_locations: source_locations)
+          reporter.print_stale_exclusions(stale_exclusions, resolve_excluded_path) unless stale_exclusions.empty?
+        end
         if update_baseline
           baseline.set(strategy.name, unused_collection)
           # Note: caller is responsible for calling baseline.save after all strategies run
@@ -91,7 +96,9 @@ module Keela
         )
       end
 
-      new_unused.empty? && removed.empty?
+      reporter.print_stale_exclusions(stale_exclusions, resolve_excluded_path) unless silent || stale_exclusions.empty?
+
+      new_unused.empty? && removed.empty? && stale_exclusions.empty?
     end
 
     def file_globs
@@ -181,18 +188,37 @@ module Keela
       # Support both formats:
       # 1. Strategy-aware (new): { methods: { "file.rb": [{ name: "reason" }] } }
       # 2. Flat (legacy): { "file.rb": [{ name: "reason" }] }
-      excluded = if all_excluded.key?(strategy.name.to_sym)
+      strategy_aware = all_excluded.key?(strategy.name.to_sym)
+      excluded = if strategy_aware
                    all_excluded[strategy.name.to_sym] || {}
                  else
                    all_excluded # Legacy flat format
                  end
 
+      # Stale detection is only safe for the current strategy's section. A legacy
+      # flat entry may belong to another strategy, and keela runs one strategy per
+      # Scanner, so flagging it here would be a false positive. Skip flat format.
+      #
+      detect_stale_exclusions(excluded, definitions) if strategy_aware
+
       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 detect_stale_exclusions(excluded, definitions)
+      present = definitions.map { |h| [h[:file].to_sym, h[:name].to_sym] }.to_set
+
+      excluded.each do |file, entries|
+        Array(entries).flat_map(&:keys).each do |name|
+          next if present.include?([file, name])
+
+          @stale_exclusions[file.to_s] << name.to_s
+        end
+      end
+    end
+
     def resolve_excluded_path
       return configuration.excluded_path if configuration.excluded_path && File.exist?(configuration.excluded_path)
 
@@ -214,6 +240,17 @@ module Keela
       # (e.g., I18n lazy lookup)
       additional_used = strategy.additional_used_names(source_files)
 
+      # A strategy whose #additional_used_names enumerates every used name in one
+      # pass (e.g. partials) decides purely by Set membership. Skip building the
+      # derived source views and the per-definition #used? scan entirely: that
+      # per-definition scan is O(N x whole-codebase) and is the hot path we are
+      # avoiding here.
+      #
+      if strategy.detects_all_usage?
+        unused = definitions.reject { |definition| additional_used.include?(definition[:name]) }
+        return record_unused(unused)
+      end
+
       # Build the source views the strategy needs here, in the parent, so that
       # the workers Parallel forks below inherit them instead of each building
       # its own copy of a string the size of the whole codebase.
@@ -228,10 +265,16 @@ module Keela
         strategy.used?(definition[:name], source) ? [] : definition
       end
 
-      # A single logical definition can be extracted from multiple lines
-      # (e.g. the same method delegated twice, or a constant declared and
-      # referenced), so guard against listing the same name twice per file.
-      #
+      record_unused(unused)
+    end
+
+    # Collect the unused definitions into @unused_collection / @source_locations.
+    #
+    # A single logical definition can be extracted from multiple lines (e.g. the
+    # same method delegated twice, or a constant declared and referenced), so
+    # guard against listing the same name twice per file.
+    #
+    def record_unused(unused)
       unused.each do |unused_def|
         names = @unused_collection[unused_def[:file]]
         next if names.include?(unused_def[:name])

data/lib/keela/source.rb

@@ -14,6 +14,11 @@ module Keela
     # control characters the range ends in.
     ASCII_RANGE = [0x00, 0x7F].map { |code_point| code_point.chr(Encoding::UTF_8) }.join("-").freeze
 
+    # Extensions whose "#" begins a line comment. HAML is excluded on purpose:
+    # there "#id" is an element id, not a comment.
+    #
+    RUBY_EXTENSIONS = %w[.rb .rake .builder].freeze
+
     attr_reader :text
 
     def initialize(text)
@@ -29,8 +34,23 @@ module Keela
     # no single file (issue #83). Empty files contribute nothing.
     #
     def self.from_source_files(source_files)
-      new(source_files.values.map { |lines| terminate(lines.join) }.join)
+      new(source_files.map { |filename, lines| terminate(strip_comments(filename, lines).join) }.join)
+    end
+
+    # Drop whole-line Ruby comments from the usage corpus.
+    #
+    # A method name mentioned in a comment is not a call, but the usage regex
+    # matches it anyway and would hide genuinely dead code. Only whole-line
+    # comments are dropped: telling a real "#" from one inside a string, a
+    # regexp, or "#{" interpolation needs a tokenizer, not worth it for the
+    # trailing-comment case.
+    #
+    def self.strip_comments(filename, lines)
+      return lines unless RUBY_EXTENSIONS.include?(File.extname(filename))
+
+      lines.reject { |line| line.match?(/\A\s*#(?!\{)/) }
     end
+    private_class_method :strip_comments
 
     def self.terminate(text)
       return text if text.empty? || text.end_with?("\n")

data/lib/keela/strategies/delegations.rb

@@ -48,6 +48,62 @@ module Keela
         methods.length == 1 ? methods.first : methods
       end
 
+      # Own extraction for delegation files so multi-line delegate statements
+      # are detected in full. The scanner's default line-by-line path sees only
+      # the first line of a wrapped delegate, missing every continuation method.
+      # We join each statement into one logical line, then reuse
+      # #extract_definition on the result so target/prefix detection is unchanged.
+      #
+      # Because returning non-nil makes the scanner skip its default path, this
+      # must also replicate that path's comment-skipping and its line-gating on
+      # configuration.source_location.
+      #
+      def extract_definitions_from_file(filepath, lines)
+        track_lines = Keela.configuration.source_location
+        definitions = []
+        index = 0
+
+        while index < lines.length
+          line = lines[index]
+
+          if skip_comments? && line.strip.start_with?("#")
+            index += 1
+            next
+          end
+
+          unless line =~ /^\s*delegate\s+/
+            index += 1
+            next
+          end
+
+          start_index = index
+          statement = strip_comment(line)
+
+          # A delegate statement continues onto the next line while the current
+          # line, ignoring a trailing comment and trailing whitespace, ends in a
+          # comma. It stops at the first line that does not (the options line).
+          # Strip inline comments as we join so #extract_definition sees the same
+          # clean text the scanner's default (comment-skipping) path would.
+          #
+          while continuation?(lines[index])
+            index += 1
+            break if index >= lines.length
+
+            statement += strip_comment(lines[index])
+          end
+
+          index += 1
+
+          Array(extract_definition(statement)).compact.each do |name|
+            definition = { name: name, file: filepath }
+            definition[:line] = start_index + 1 if track_lines
+            definitions << definition
+          end
+        end
+
+        definitions
+      end
+
       def usage_regex(name)
         # Match usage of the delegated method, but not the delegate declaration
         # Uses negative lookbehind to avoid matching:
@@ -85,6 +141,25 @@ module Keela
 
       private
 
+      # Whether +line+ hands off to a continuation line: true when it ends in a
+      # comma after a trailing comment and whitespace are stripped. A `#` inside
+      # a delegate statement can only start a comment, since method symbols
+      # cannot contain one, so dropping from the first `#` is safe here.
+      #
+      def continuation?(line)
+        return false unless line
+
+        strip_comment(line).rstrip.end_with?(",")
+      end
+
+      # Drop a trailing line comment, preserving the newline. A `#` inside a
+      # delegate statement can only start a comment, since method symbols cannot
+      # contain one, so dropping from the first `#` is safe here.
+      #
+      def strip_comment(line)
+        line.sub(/#[^\n]*/, "")
+      end
+
       def folded_usage_regex(name)
         /(?<!:)(?<!delegate\s)(?<![a-z_])#{Regexp.quote(name.downcase(:fold))}(?!\w)/
       end

data/lib/keela/strategies/i18n_keys.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "set"
 
 module Keela
   module Strategies
@@ -21,9 +22,17 @@ module Keela
     # Lazy lookup is supported: t('.title') in app/views/users/show.html.erb
     # resolves to 'users.show.title'.
     #
+    # Lazy lookup in mailer/controller Ruby methods is also supported, e.g.
+    # t('.greeting') in UserMailer#welcome resolves to 'user_mailer.welcome.greeting',
+    # and t('.notice') in UsersController#create resolves to 'users.create.notice'.
+    #
     class I18nKeys < Strategy
       PLURAL_SUFFIXES = %w[zero one two few many other].freeze
-      VIEW_PATH_REGEX = %r{(?:ee/)?app/views/(.+)\.html\.(?:erb|haml|slim)$}.freeze
+      VIEW_PATH_REGEX = %r{(?:ee/)?app/views/(.+)\.(?:html|text)\.(?:erb|haml|slim)$}.freeze
+      RUBY_SCOPE_PATH_REGEX = %r{(?:ee/)?app/(?:mailers|controllers)/.+\.rb$}.freeze
+      CLASS_DEF_REGEX = /^\s*class\s+([A-Z][\w:]*)/.freeze
+      MODULE_DEF_REGEX = /^\s*module\s+([A-Z][\w:]*)/.freeze
+      METHOD_DEF_REGEX = /^\s*def\s+(?:self\.)?([a-z_][\w]*[?!=]?)/.freeze
       LAZY_LOOKUP_REGEX = /(?:I18n\.)?t\s*\(\s*['"](\.[^'"]+)['"]/
       def name
         "i18n_keys"
@@ -95,6 +104,7 @@ module Keela
       # "app/views/users/show.html.erb" -> "users.show"
       # "app/views/users/_form.html.erb" -> "users.form"
       # "ee/app/views/users/show.html.erb" -> "users.show"
+      # "app/views/user_mailer/welcome.text.erb" -> "user_mailer.welcome"
       def view_path_to_prefix(path)
         return nil unless path =~ VIEW_PATH_REGEX
 
@@ -115,22 +125,21 @@ module Keela
         content.scan(LAZY_LOOKUP_REGEX).flatten
       end
 
-      # Build a set of expanded lazy lookup keys from view files
-      # Called by the scanner to detect usage via lazy lookup
+      # Build a set of expanded lazy lookup keys from view files,
+      # mailers, and controllers. Called by the scanner to detect
+      # usage via lazy lookup.
       def additional_used_names(source_files)
         expanded = Set.new
 
         source_files.each do |filepath, lines|
-          prefix = view_path_to_prefix(filepath)
-          next unless prefix
-
-          content = lines.join("\n")
-          lazy_keys = extract_lazy_keys(content)
-
-          lazy_keys.each do |lazy_key|
-            # .title -> users.show.title
-            full_key = "#{prefix}#{lazy_key}"
-            expanded << full_key
+          if (prefix = view_path_to_prefix(filepath))
+            content = lines.join("\n")
+            extract_lazy_keys(content).each do |lazy_key|
+              # .title -> users.show.title
+              expanded << "#{prefix}#{lazy_key}"
+            end
+          elsif filepath =~ RUBY_SCOPE_PATH_REGEX
+            expand_ruby_lazy_keys(lines).each { |key| expanded << key }
           end
         end
 
@@ -139,6 +148,70 @@ module Keela
 
       private
 
+      # Scan a mailer/controller Ruby file line by line, tracking the current
+      # class scope and method, and expand each lazy t('.x') to its full key.
+      #
+      # This is a pragmatic line scan (no AST) matching keela's regex style.
+      # It tracks the last-seen `def` as the enclosing method and does NOT
+      # attempt precise `end` matching. A lazy call that appears after a method
+      # body but before the next `def` is still attributed to the last method.
+      # This over-association can only mark an EXTRA key as used, never cause a
+      # false "unused" flag, so it is a safe conservative tradeoff. A lazy call
+      # seen before any `def` has no enclosing method and is skipped.
+      #
+      def expand_ruby_lazy_keys(lines)
+        keys = []
+        namespace = []
+        class_scope = nil
+        current_method = nil
+
+        lines.each do |line|
+          if (m = line.match(MODULE_DEF_REGEX))
+            namespace << m[1]
+          elsif (m = line.match(CLASS_DEF_REGEX))
+            class_scope = ruby_class_scope(namespace, m[1])
+            current_method = nil
+          elsif (m = line.match(METHOD_DEF_REGEX))
+            current_method = m[1]
+          end
+
+          next unless class_scope && current_method
+
+          line.scan(LAZY_LOOKUP_REGEX).flatten.each do |lazy_key|
+            # .greeting -> user_mailer.welcome.greeting
+            keys << "#{class_scope}.#{current_method}#{lazy_key}"
+          end
+        end
+
+        keys
+      end
+
+      # Derive the i18n scope for a class in a mailer/controller file.
+      # Combines any enclosing `module` nesting with the class name (which may
+      # itself be compact, e.g. `Admin::UserMailer`), underscores the full path,
+      # converts "/" to ".", and drops a trailing "_controller" for controllers
+      # while keeping "_mailer" for mailers.
+      #
+      #   [], "PaymentOrderMailer"        -> "payment_order_mailer"
+      #   ["Admin"], "UserMailer"         -> "admin.user_mailer"
+      #   [], "Admin::UserMailer"         -> "admin.user_mailer"
+      #   [], "UsersController"           -> "users"
+      #   ["Admin"], "UsersController"    -> "admin.users"
+      #
+      def ruby_class_scope(namespace, class_name)
+        full_path = (namespace + class_name.split("::")).map { |part| underscore(part) }.join("/")
+        full_path = full_path.delete_suffix("_controller") if full_path.end_with?("_controller")
+        full_path.tr("/", ".")
+      end
+
+      # Convert a CamelCase constant segment to snake_case.
+      # "PaymentOrderMailer" -> "payment_order_mailer"
+      def underscore(word)
+        word.gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+      end
+
       # Returns the parent key if this is a pluralization key, nil otherwise
       # "items.count.one" -> "items.count"
       # "users.show.title" -> nil

data/lib/keela/strategies/partials.rb

@@ -55,6 +55,13 @@ module Keela
       #
       CONTROLLER_REGEX = %r{(?:ee/)?app/controllers/(.+)_controller\.rb$}.freeze
 
+      # A view directly under app/views/ with no intermediate directory, e.g.
+      # app/views/index.html.erb. Its caller directory is the root (""), so a
+      # bareword render "foo" from here resolves to the root-level partial "foo".
+      # VIEW_DIR_REGEX requires an intermediate dir and so never matches these.
+      #
+      ROOT_VIEW_REGEX = %r{(?:ee/)?app/views/[^/]+\.html\.(?:erb|haml|slim)$}.freeze
+
       # The render family we recognize: render, plus render_to_string and
       # render_to_body, which render partials the same way (Rails/GitLab use both
       # off-request, e.g. in mailers and background jobs). An optional opening
@@ -123,6 +130,14 @@ module Keela
         true
       end
 
+      # #additional_used_names collects every rendered partial name in a single
+      # pass, so the scanner decides by Set membership and skips the per-definition
+      # #used? scan. See the note on #additional_used_names.
+      #
+      def detects_all_usage?
+        true
+      end
+
       # Build the comment-stripped view once in the parent so workers inherit it
       # copy-on-write instead of each rebuilding a codebase-sized string.
       #
@@ -136,12 +151,41 @@ module Keela
       # demand if #prepare was not run for this source (defensive: #used? can be
       # called directly in tests, or on a different source than #prepare saw).
       #
+      # Retained as the Strategy contract and for direct callers (tests), but the
+      # scanner no longer drives detection through it: #additional_used_names now
+      # collects every used name in a single pass over the corpus, so the scanner
+      # decides via that Set instead of calling #used? per definition. See the
+      # note on #additional_used_names.
+      #
       def used?(name, source)
         usage_regex(name).match?(stripped_text_for(source))
       end
 
-      # Resolve bareword renders against the calling file's directory so that a
-      # short render marks the fully-qualified partial used.
+      # The set of partial names used anywhere in +source_files+, collected in a
+      # SINGLE pass over the corpus.
+      #
+      # This is the whole-run detection path for partials. The scanner checks a
+      # definition against this Set and never calls #used? for a name that is in
+      # it, so extracting every used name here (not just the bareword/positional
+      # ones) turns detection from O(N_partials x codebase) per-definition regex
+      # scans into O(codebase + N_partials): we scan each file once, collect the
+      # rendered names, then membership-test each definition. This is the fix for
+      # the partials strategy being CPU-bound on large codebases.
+      #
+      # Three render forms are collected, each the single-pass twin of a branch
+      # that used to be matched per-definition:
+      #
+      #   1. Explicit slashed paths (the #usage_regex cases): render "users/form",
+      #      render partial:/layout: "users/form", render_to_string/_to_body, and
+      #      configured render_helpers. Captured verbatim as the logical name.
+      #   2. Positional-underscore paths: render "shared/notes/_note" names the
+      #      file directly -> "shared/notes/note" (strip the basename's leading _).
+      #   3. Barewords resolved against the caller's directory: render "form" in
+      #      app/views/users/* or users_controller.rb -> "users/form".
+      #
+      # All three share the comment-stripped content and the same left word-anchor
+      # and render-method rules as #usage_regex, so the collected strings are
+      # exactly what the per-name regex would have matched.
       #
       def additional_used_names(source_files)
         used = Set.new
@@ -149,6 +193,14 @@ module Keela
         source_files.each do |filepath, lines|
           content = strip_erb_comments(lines.join("\n"))
 
+          # Explicit slashed paths: the single-pass twin of #usage_regex. A
+          # basename leading _ is stripped so "users/_form" and "users/form"
+          # agree with the positional-underscore form and with definition names.
+          #
+          content.scan(explicit_path_regex).each do |(path)|
+            used << path.sub(%r{(^|/)_([^/]+)$}, '\1\2')
+          end
+
           # Positional-underscore paths are absolute logical names, so they are
           # resolved regardless of the caller's directory. "shared/notes/_note"
           # -> "shared/notes/note" (strip the leading _ of the basename only).
@@ -161,7 +213,10 @@ module Keela
           next unless dir
 
           content.scan(BAREWORD_RENDER_REGEX).each do |(bareword)|
-            used << "#{dir}/#{bareword}"
+            # dir is "" for a root-level view, so join without a separator to
+            # resolve render "foo" -> "foo" rather than "/foo".
+            #
+            used << (dir.empty? ? bareword : "#{dir}/#{bareword}")
           end
         end
 
@@ -193,17 +248,34 @@ module Keela
         text.gsub(/<%\s*-?\s*#.*?-?\s*%>/) { |match| " " * match.length }
       end
 
-      # The directory a bareword render resolves against: the view's own dir, or
-      # the controller-derived dir. Returns nil for files that render nothing
-      # resolvable this way.
+      # The directory a bareword render resolves against: the view's own dir, the
+      # controller-derived dir, or "" for a root-level view (render "foo" from
+      # app/views/index.html.erb resolves to the root partial "foo"). Returns nil
+      # for files that render nothing resolvable this way.
       #
       def caller_directory(filepath)
         return Regexp.last_match(1) if filepath =~ VIEW_DIR_REGEX
         return Regexp.last_match(1) if filepath =~ CONTROLLER_REGEX
+        return "" if filepath =~ ROOT_VIEW_REGEX
 
         nil
       end
 
+      # The single-pass twin of #usage_regex: instead of matching one known name,
+      # CAPTURE the rendered path so one scan collects every explicitly-rendered
+      # partial. Same left word-anchor, same optional partial:/layout: keyword,
+      # same #render_method_pattern (so configured render_helpers are honored),
+      # as #usage_regex.
+      #
+      # The captured path must contain at least one slash: barewords (no slash)
+      # are resolved relative to the caller by #additional_used_names via
+      # BAREWORD_RENDER_REGEX, exactly as #usage_regex only ever matched slashed
+      # logical names. Requiring a slash here keeps the two paths disjoint.
+      #
+      def explicit_path_regex
+        %r{(?<!\w)#{render_method_pattern}(?:(?:partial|layout):\s*)?["']([^"'/]+(?:/[^"'/]+)+)["']}
+      end
+
       # A positional string whose basename starts with _ names a partial file
       # directly: render_to_string("shared/notes/_note") uses shared/notes/note.
       # There is no partial:/layout: keyword here, so it is handled separately

data/lib/keela/strategies/scopes.rb

@@ -18,7 +18,11 @@ module Keela
       end
 
       def usage_regex(name)
-        /(?<!scope :)(?<!def )#{Regexp.quote(name)}\W/
+        # Whitespace-anchoring the lookbehind distinguishes a `scope :name`
+        # definition (preceded by indentation whitespace) from `has_scope :name`
+        # usage (preceded by `_`), which must count as a real usage.
+        #
+        /(?<!\sscope :)(?<!def )#{Regexp.quote(name)}\W/
       end
 
       def skip_comments?

data/lib/keela/strategy.rb

@@ -83,6 +83,20 @@ module Keela
       Set.new
     end
 
+    # Whether #additional_used_names already collects EVERY used name in a single
+    # pass, making the per-definition #used? scan redundant.
+    #
+    # Defaults to false: the scanner checks #additional_used_names first and then
+    # falls back to #used? per definition. A strategy that returns true here is
+    # declaring its #additional_used_names is complete, so the scanner skips the
+    # per-definition scan entirely. This turns O(N_definitions x codebase) regex
+    # scanning into a single O(codebase) pass plus Set membership tests, for
+    # strategies whose usage can be enumerated in one sweep (e.g. partials).
+    #
+    def detects_all_usage?
+      false
+    end
+
     private
 
     def configured_pattern

data/lib/keela/version.rb

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

data/lib/keela.rb

@@ -16,6 +16,7 @@ require_relative "keela/reporter"
 require_relative "keela/baseline"
 require_relative "keela/scanner"
 require_relative "keela/exclusion_validator"
+require_relative "keela/exclusion_normalizer"
 require_relative "keela/formatters"
 
 module Keela

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keela
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Kerri Miller
@@ -13,16 +13,22 @@ dependencies:
   name: parallel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.20'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.20'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +87,7 @@ files:
 - lib/keela/baseline.rb
 - lib/keela/config_file.rb
 - lib/keela/configuration.rb
+- lib/keela/exclusion_normalizer.rb
 - lib/keela/exclusion_validator.rb
 - lib/keela/formatters.rb
 - lib/keela/formatters/base.rb