woods 1.6.1 → 2.0.0.beta2

data/lib/woods/extractors/action_cable_extractor.rb

@@ -34,12 +34,17 @@ module Woods
       #
       # @return [Array<ExtractedUnit>] List of channel units
       def extract_all
-        return [] unless action_cable_available?
+        discoverable_classes.filter_map { |klass| extract_channel(klass) }
+      end
 
-        channels = channel_descendants
-        return [] if channels.empty?
+      # The channel classes this extractor would extract from the running app.
+      # Shared with the incremental path's class reconciliation (#164).
+      #
+      # @return [Array<Class>]
+      def discoverable_classes
+        return [] unless action_cable_available?
 
-        channels.filter_map { |klass| extract_channel(klass) }
+        channel_descendants
       end
 
       # Extract a single channel class into an ExtractedUnit.

data/lib/woods/extractors/ast_source_extraction.rb

@@ -35,12 +35,30 @@ module Woods
         file, _line = source_location
         return nil unless File.exist?(file)
 
-        source = File.read(file)
-        Ast::MethodExtractor.new.extract_method_source(source, action.to_s)
+        action_sources_for(file)[action.to_s]
       rescue StandardError => e
         Rails.logger.debug("Could not extract action source for #{klass}##{action}: #{e.message}")
         nil
       end
+
+      # Every instance-method source in one file, keyed by method name — read
+      # and parsed once per file per extractor instance (audit P1).
+      #
+      # {#build_action_chunks} in the including extractors calls
+      # {#extract_action_source} once per action, so a 30-action controller
+      # previously read and re-parsed its own source 30 times. The parse
+      # result is a pure function of the file's bytes, so answering every
+      # action from one parse is byte-identical to parsing per action.
+      #
+      # A file whose source fails to parse stays uncached (the `||=` never
+      # assigns), so each action retries it and rescues exactly as before.
+      #
+      # @param file [String] Absolute path of the defining file
+      # @return [Hash{String => String, nil}] method name => source text
+      def action_sources_for(file)
+        (@action_sources ||= {})[file] ||=
+          Ast::MethodExtractor.new.extract_method_sources(File.read(file))
+      end
     end
   end
 end

data/lib/woods/extractors/caching_extractor.rb

@@ -159,7 +159,12 @@ module Woods
 
       # Extract individual cache call entries from source.
       #
-      # Each entry has :type, :key_pattern, and :ttl.
+      # Each entry has :type, :key_pattern, and :ttl, parsed from that
+      # occurrence's own argument text (the remainder of its line) — not
+      # from the whole file. Matching against the whole source gave every
+      # entry the first call's key and the first `expires_in:` in the file
+      # (#201); a call without its own `expires_in:` gets a nil ttl rather
+      # than inheriting a neighbor's.
       #
       # @param source [String] Source code
       # @return [Array<Hash>] Cache call descriptors
@@ -167,36 +172,65 @@ module Woods
         calls = []
 
         CACHE_PATTERNS.each do |type, pattern|
-          source.scan(pattern) do
-            key = extract_key_pattern(source, type)
-            ttl = extract_ttl(source)
-            calls << { type: type, key_pattern: key, ttl: ttl }
+          each_occurrence(source, pattern) do |offset|
+            call_text = call_argument_text(source, offset)
+            calls << {
+              type: type,
+              key_pattern: extract_key_pattern(call_text, type),
+              ttl: extract_ttl(call_text)
+            }
           end
         end
 
         calls
       end
 
+      # Yield the start offset of every non-overlapping occurrence of a pattern.
+      #
+      # @param source [String] Source code
+      # @param pattern [Regexp] Pattern to scan for
+      # @yieldparam offset [Integer] Character offset where the occurrence begins
+      # @return [void]
+      def each_occurrence(source, pattern)
+        offset = 0
+        while (match = source.match(pattern, offset))
+          yield match.begin(0)
+          offset = [match.end(0), match.begin(0) + 1].max
+        end
+      end
+
+      # The argument text belonging to one cache call occurrence: the
+      # remainder of the line the call starts on. Bounding the slice to the
+      # line keeps key/TTL parsing from reading a neighboring call's options.
+      #
+      # @param source [String] Source code
+      # @param offset [Integer] Character offset where the occurrence begins
+      # @return [String] The call's own argument text
+      def call_argument_text(source, offset)
+        line_end = source.index("\n", offset) || source.length
+        source[offset...line_end]
+      end
+
       # Extract the key pattern for a Rails.cache call.
       #
       # Returns a simplified string representation of the first argument.
       #
-      # @param source [String] Source code
+      # @param call_text [String] The call's own argument text
       # @param type [Symbol] The cache call type
       # @return [String, nil] The key pattern or nil
-      def extract_key_pattern(source, type)
+      def extract_key_pattern(call_text, type)
         return nil unless %i[fetch read write delete exist].include?(type)
 
-        match = source.match(KEY_PATTERN)
+        match = call_text.match(KEY_PATTERN)
         match ? match[1].strip[0, 60] : nil
       end
 
-      # Extract TTL value from expires_in option.
+      # Extract TTL value from the call's own expires_in option.
       #
-      # @param source [String] Source code
+      # @param call_text [String] The call's own argument text
       # @return [String, nil] The TTL expression or nil
-      def extract_ttl(source)
-        match = source.match(TTL_PATTERN)
+      def extract_ttl(call_text)
+        match = call_text.match(TTL_PATTERN)
         match ? match[1].strip : nil
       end
 

data/lib/woods/extractors/callback_analyzer.rb

@@ -3,6 +3,8 @@
 require 'set'
 require_relative '../ast/parser'
 require_relative '../flow_analysis/operation_extractor'
+require_relative 'line_neutralizer'
+require_relative 'reference_patterns'
 
 module Woods
   module Extractors
@@ -32,7 +34,15 @@ module Woods
       MULTI_COLUMN_WRITERS = %w[update_columns assign_attributes].freeze
 
       # Async enqueue methods that indicate a job is being dispatched.
-      ASYNC_METHODS = %w[perform_later perform_async perform_in perform_at].freeze
+      ASYNC_METHODS = ReferencePatterns::ENQUEUE_METHODS
+
+      # Assignment to a column through +self+: plain, conditional (`||=`,
+      # `&&=`), or arithmetic (`+=`, `-=`, `*=`, `/=`). `self.token ||=
+      # SecureRandom.uuid` in a before_create is arguably the most common
+      # callback body in Rails and reported no write at all (EXTA-6). The
+      # lookahead rejects `==` (comparison) and `=~` (regex match), the
+      # latter having been read as a write.
+      SELF_ASSIGNMENT_PATTERN = %r{self\.(\w+)\s*(?:\|\||&&|[+\-*/])?=(?!=|~)}
 
       # Pre-compiled regex patterns (avoid dynamic regex construction in hot loops)
       SINGLE_COLUMN_WRITER_PATTERNS = SINGLE_COLUMN_WRITERS.to_h do |w|
@@ -43,7 +53,7 @@ module Woods
         [w, /\b#{Regexp.escape(w)}\s*\(([^)]+)\)/m]
       end.freeze
 
-      ASYNC_PATTERN = /(\w+(?:Job|Worker))\.(?:#{ASYNC_METHODS.map { |m| Regexp.escape(m) }.join('|')})/
+      ASYNC_PATTERN = ReferencePatterns::JOB_ENQUEUE
 
       DB_READ_PATTERNS = DB_READ_METHODS.to_h do |m|
         [m, /\.#{Regexp.escape(m)}\b/]
@@ -74,7 +84,7 @@ module Woods
 
         return callback_hash.merge(side_effects: empty_side_effects) if method_node.nil?
 
-        method_source = method_source_from_node(method_node)
+        method_source = scannable_source(method_source_from_node(method_node))
         return callback_hash.merge(side_effects: empty_side_effects) if method_source.nil?
 
         callback_hash.merge(
@@ -130,6 +140,24 @@ module Woods
         lines[start_idx..end_idx].join
       end
 
+      # Neutralize a method body before the regex scans run over it.
+      #
+      # The body is located by AST but scanned by regex, so
+      # `logger.info "self.status = pending"` and a commented-out
+      # `# self.status = 'x'` both reported a column write (EXTA-8).
+      # {LineNeutralizer} blanks comment and string-literal bodies, which is
+      # exactly the text a side-effect scan must not believe; identifiers,
+      # call chains, and symbols — everything the patterns actually match —
+      # survive untouched.
+      #
+      # @param method_source [String, nil]
+      # @return [String, nil]
+      def scannable_source(method_source)
+        return nil if method_source.nil?
+
+        LineNeutralizer.neutralize_lines(method_source).join
+      end
+
       # Check if a filter string looks like a valid Ruby method name.
       # Rejects proc/lambda string representations and other non-method filters.
       #
@@ -150,8 +178,8 @@ module Woods
       def detect_columns_written(method_source)
         columns = Set.new
 
-        # Pattern: self.col = value (direct assignment, not ==)
-        method_source.scan(/self\.(\w+)\s*=(?!=)/).flatten.each do |col|
+        # Pattern: self.col = value (plain, ||=, &&=, +=, … — never == or =~)
+        method_source.scan(SELF_ASSIGNMENT_PATTERN).flatten.each do |col|
           columns << col if @column_names.include?(col)
         end
 
@@ -186,22 +214,24 @@ module Woods
 
       # Detect service objects called by the callback method.
       #
-      # Matches classes ending in Service followed by a method call.
+      # Matches classes ending in Service followed by a method call,
+      # namespace included (EXTA-2).
       #
       # @param method_source [String]
       # @return [Array<String>]
       def detect_services_called(method_source)
-        method_source.scan(/(\w+Service)(?:\.|::)/).flatten.uniq.sort
+        method_source.scan(ReferencePatterns::SERVICE_REFERENCE).flatten.uniq.sort
       end
 
       # Detect mailers triggered by the callback method.
       #
-      # Matches classes ending in Mailer followed by a method call.
+      # Matches classes ending in Mailer followed by a method call,
+      # namespace included (EXTA-2).
       #
       # @param method_source [String]
       # @return [Array<String>]
       def detect_mailers_triggered(method_source)
-        method_source.scan(/(\w+Mailer)\./).flatten.uniq.sort
+        method_source.scan(ReferencePatterns::MAILER_REFERENCE).flatten.uniq.sort
       end
 
       # Detect database read operations in the callback method.

data/lib/woods/extractors/component_discovery.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Woods
+  module Extractors
+    # Finds component classes the eager load never reached.
+    #
+    # Both component extractors discover their units through
+    # `component_base.descendants`, which only knows the classes something has
+    # already loaded. Rails leaves `app/views` out of both `autoload_paths` and
+    # `eager_load_paths`, so an app that keeps components beside their
+    # templates and opts the subtree into autoloading gets classes that exist
+    # on disk, resolve by name, and are absent from `descendants` for the whole
+    # extraction (B-184).
+    #
+    # This walks the configured component directories and asks the autoloader
+    # for each file's constant before `descendants` is read. Zeitwerk does the
+    # loading, so a file that does not define the constant its path implies is
+    # skipped rather than guessed at, and nothing is loaded twice.
+    module ComponentDiscovery
+      # Directories scanned when `Woods.configuration.component_paths` is unset.
+      # Relative to `Rails.root`, deepest first is not required: the autoload
+      # root a file resolves against is chosen per file, longest match first.
+      DEFAULT_COMPONENT_PATHS = %w[
+        app/components
+        app/views/components
+        app/views
+      ].freeze
+
+      # Ask the autoloader for every component file's constant.
+      #
+      # Call before reading `descendants`. Cheap when the app has no component
+      # directories: each miss is one `File.directory?`.
+      #
+      # @return [void]
+      def load_component_files
+        unresolved = 0
+        component_directories.each do |directory|
+          Dir.glob(File.join(directory, '**', '*.rb')).each do |path|
+            unresolved += 1 unless constantize_component_file(path)
+          end
+        end
+        return if unresolved.zero?
+
+        # The one misconfiguration this cannot fix for the caller: a component
+        # directory no Rails autoload path owns. Loading those files by hand
+        # would define constants Zeitwerk does not manage, so they are skipped,
+        # and skipping silently looks identical to having no components.
+        Rails.logger.debug do
+          "[Woods] #{unresolved} component file(s) resolved to no constant; " \
+            'their directory is not on an autoload path.'
+        end
+      end
+
+      # @return [Array<String>] absolute directories to walk, nested entries
+      #   collapsed into their ancestor so no file is handed over twice
+      def component_directories
+        present = component_paths
+                  .map { |relative| File.join(Rails.root.to_s, relative) }
+                  .uniq
+                  .select { |directory| File.directory?(directory) }
+
+        present.reject do |directory|
+          present.any? { |other| other != directory && directory.start_with?("#{other}#{File::SEPARATOR}") }
+        end
+      end
+
+      # Nil means "the defaults". An explicitly empty list means "walk
+      # nothing", which is how an app opts out of the walk entirely.
+      #
+      # @return [Array<String>] directories to scan, relative to Rails.root
+      def component_paths
+        configured = Woods.configuration&.component_paths
+        configured.nil? ? DEFAULT_COMPONENT_PATHS : Array(configured)
+      end
+
+      private
+
+      # @param path [String] absolute path to a Ruby file
+      # @return [Boolean] false when the path implies no constant Zeitwerk owns
+      def constantize_component_file(path)
+        name = component_constant_name(path)
+        return false unless name
+
+        name.safe_constantize
+        true
+      rescue StandardError, ScriptError => e
+        # A component that cannot load must not abort the extraction; a
+        # SyntaxError in one file would otherwise take the whole run with it.
+        Rails.logger.warn("[Woods] Could not load component file #{path}: #{e.message}")
+        true
+      end
+
+      # The constant a file's path implies, under the autoload root that owns
+      # it. Nil when no autoload root does, because then the file's name says
+      # nothing about its constant and loading it by hand would define
+      # constants Zeitwerk does not manage.
+      #
+      # @param path [String]
+      # @return [String, nil]
+      def component_constant_name(path)
+        root = autoload_roots.find { |candidate| path.start_with?("#{candidate}#{File::SEPARATOR}") }
+        return nil unless root
+
+        path.delete_prefix("#{root}#{File::SEPARATOR}").delete_suffix('.rb').camelize
+      end
+
+      # Every directory Zeitwerk resolves constants against, longest first so a
+      # file under `app/views/components` resolves against that root rather
+      # than against `app/views` when an app registers both.
+      #
+      # @return [Array<String>]
+      def autoload_roots
+        @autoload_roots ||= begin
+          config = Rails.application&.config
+          roots = %i[autoload_paths eager_load_paths autoload_once_paths].flat_map do |key|
+            config.respond_to?(key) ? Array(config.public_send(key)).map(&:to_s) : []
+          end
+          roots.uniq.sort_by { |path| -path.length }
+        end
+      end
+    end
+  end
+end

data/lib/woods/extractors/concern_extractor.rb

@@ -2,6 +2,7 @@
 
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
+require_relative 'source_nesting'
 
 module Woods
   module Extractors
@@ -25,6 +26,7 @@ module Woods
     class ConcernExtractor
       include SharedUtilityMethods
       include SharedDependencyScanner
+      include SourceNesting
 
       # Canonical concern directories (used as fallback if glob finds nothing).
       CONCERN_DIRECTORIES = %w[
@@ -89,13 +91,25 @@ module Woods
 
       # Extract the module name from source or infer from file path.
       #
+      # Zeitwerk-governed naming first (G-1): a file under a managed autoload
+      # path is named for the constant its path spells, which is what lets a
+      # concern under a mid-path `concerns/` segment (`app/models/outer/
+      # concerns/leaf.rb`, a real namespace, not an autoload root) survive a
+      # one-line class declared above it — the outer-module scan below stops
+      # at the first non-module line and would name the wrapper.
+      #
+      # Otherwise the position-aware scan names the concern by its outer
+      # module chain — `module Gateway; module Stripe; module Refundable`
+      # yields +Gateway::Stripe::Refundable+ — and never by an inner mixin
+      # module: `module Trackable; module ClassMethods` yields +Trackable+,
+      # where the old innermost-declaration scan yielded +ClassMethods+ (#174).
+      #
       # @param file_path [String] Path to the concern file
       # @param source [String] Ruby source code
       # @return [String, nil] The module name
       def extract_module_name(file_path, source)
-        # Try to find the outermost module definition
-        modules = source.scan(/^\s*module\s+([\w:]+)/).flatten
-        return modules.last if modules.any?
+        qualified = governed_class_name(file_path, source) || qualified_outer_module_name(source)
+        return qualified if qualified
 
         # Infer from file path — strip everything up to and including the first concerns/ dir.
         # Handles canonical (app/models/concerns/) and nested (app/models/foo/concerns/) paths.