keela 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0755e73eaeeb61f9f97ffa109fd8c421316e7725b83ef2502a37c5ba0111858f
-  data.tar.gz: d66e1092dd578f28ae3d727b179b601fcd7068671550f9186e53c76a543d1763
+  metadata.gz: 40ac5a23ccbc726eeea66f99e4a6d9cb109360b987daa26e54c43c6d566c448b
+  data.tar.gz: 5c6b44f161613c7dea1aae79490918ce8233572345863febcf34a9417710bf60
 SHA512:
-  metadata.gz: bf117842ed4d8891671dac92ee34c48b5433f50795f9a90963211c1e650df11b31e72c2d142a6fc489f3dfb040989341764ab6eba4d2ea70432828bd6ed1c1dc
-  data.tar.gz: ac2d7352393d70240f7ad1541f2ff476e5ed7c8def8b13212721a527df4e7c285b2c31519333ebe712aab31e9a186a997420598e7e7662af181353cf9f8b96ca
+  metadata.gz: 69de532e979e8bb052281e2fc58f2c4c6b9039f6a157b88139badff12c4f48abc0df134c817a44f6a6b1dcad131c2fe86c7a667fd51e36d1314184d5444b620d
+  data.tar.gz: fc86b2efb01f42db61d20f2a65d029082802a09c480bc6aeda5a6739f4b13c4ebfbb5d061f98520bb0248d10d15b9f4237bd18b8a5a0925b384553915d5f6ed4

data/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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/lib/keela/scanner.rb

@@ -214,6 +214,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 +239,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/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/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.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keela
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Kerri Miller