woods 1.6.1 → 2.0.0.beta2

data/lib/woods/extractors/scheduled_job_extractor.rb

@@ -41,6 +41,11 @@ module Woods
       # Environment keys to unwrap when nested in YAML
       ENVIRONMENT_KEYS = %w[production development test staging].freeze
 
+      # A quoted Whenever command argument in either style. The body runs to
+      # the *matching* delimiter, so the inner quotes of `command "echo 'hi'"`
+      # stay part of the command.
+      QUOTED_ARGUMENT = /(['"])((?:(?!\1).)+)\1/
+
       def initialize
         @schedule_files = SCHEDULE_FILES.each_with_object({}) do |(relative_path, format), hash|
           full_path = Rails.root.join(relative_path)
@@ -63,10 +68,9 @@ module Woods
       # this returns an Array because each schedule file contains multiple entries.
       #
       # @param file_path [String] Path to the schedule file
-      # @param format [Symbol, nil] One of :solid_queue, :sidekiq_cron, :whenever (inferred from filename if nil)
+      # @param format [Symbol] One of :solid_queue, :sidekiq_cron, :whenever
       # @return [Array<ExtractedUnit>] List of scheduled job units
-      def extract_scheduled_job_file(file_path, format = nil)
-        format ||= infer_format(file_path)
+      def extract_scheduled_job_file(file_path, format)
         case format
         when :solid_queue, :sidekiq_cron
           extract_yaml_schedule(file_path, format)
@@ -93,7 +97,12 @@ module Woods
       # @return [Array<ExtractedUnit>]
       def extract_yaml_schedule(file_path, format)
         source = File.read(file_path)
-        data = YAML.safe_load(source, permitted_classes: [Symbol])
+        # aliases: true — schedule files commonly share defaults via anchors
+        # (`<<: *defaults`); without it Psych 4+ raises AliasesNotEnabled and
+        # the whole file is silently dropped (#203). Alias expansion only
+        # re-references the scalar/hash types already permitted, so it adds
+        # no deserialization risk.
+        data = YAML.safe_load(source, permitted_classes: [Symbol], aliases: true)
 
         return [] unless data.is_a?(Hash) && data.any?
 
@@ -109,17 +118,28 @@ module Woods
 
       # Detect and unwrap environment-nested YAML.
       #
-      # If the top-level keys are environment names (production, development, etc.),
-      # unwrap to the first environment's entries.
+      # If the top-level keys are environment names (production, development,
+      # etc.), unwrap to the section for the environment being extracted,
+      # falling back to the first section when the current environment has no
+      # entry. Taking `values.first` unconditionally meant a file listing
+      # `development:` before `production:` indexed the development schedule
+      # and dropped production entirely (EXTB-19).
       #
       # @param data [Hash] Parsed YAML data
       # @return [Hash] Unwrapped entries
       def unwrap_environment_nesting(data)
-        if data.keys.all? { |k| ENVIRONMENT_KEYS.include?(k.to_s) }
-          data.values.first || {}
-        else
-          data
-        end
+        return data unless data.keys.all? { |k| ENVIRONMENT_KEYS.include?(k.to_s) }
+
+        data[current_environment] || data.values.first || {}
+      end
+
+      # The environment name the extraction is running under, as a String.
+      #
+      # @return [String, nil]
+      def current_environment
+        Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
+      rescue StandardError
+        nil
       end
 
       # Build an ExtractedUnit from a YAML schedule entry.
@@ -188,12 +208,20 @@ module Woods
 
       # Parse `every ... do ... end` blocks from Whenever DSL.
       #
+      # The terminator is line-anchored (`^\s*end\s*$`), not the bare
+      # substring `end` — that substring also occurs inside identifiers
+      # (CalendarSyncJob, WeekendDigest), truncating the body so command
+      # detection failed (#204). A nested `do ... end` inside an `every`
+      # block still terminates the body at the nested block's own `end`
+      # line; commands appearing before the nested block are detected,
+      # anything after it is not.
+      #
       # @param source [String] Ruby source code
       # @return [Array<Hash>] Parsed block data
       def parse_whenever_blocks(source)
         blocks = []
-        # Match: every <frequency>[, options] do ... end
-        source.scan(/every\s+(.+?)\s+do\s*\n(.*?)end/m) do |frequency_str, body|
+        # Match: every <frequency>[, options] do ... end (end on its own line)
+        source.scan(/every\s+(.+?)\s+do\s*\n(.*?)^\s*end\s*$/m) do |frequency_str, body|
           # Clean up the frequency — strip trailing options like ", at: '...'"
           frequency = frequency_str.strip.sub(/,\s*at:.*\z/, '').strip
 
@@ -214,16 +242,20 @@ module Woods
 
       # Detect the command type inside a Whenever block body.
       #
+      # Both quote styles are accepted (EXTB-12): double-quote-only regexes
+      # left `runner 'CleanupJob.perform_later'` — the frozen-string-literal
+      # idiom — as command_type :unknown with no job class and no `:job` edge.
+      #
       # @param body [String] Block body content
       # @return [Array<Symbol, String>] Command type and body
       def detect_whenever_command(body)
         case body
-        when /runner\s+"([^"]+)"/
-          [:runner, ::Regexp.last_match(1)]
-        when /rake\s+"([^"]+)"/
-          [:rake, ::Regexp.last_match(1)]
-        when /command\s+"([^"]+)"/
-          [:command, ::Regexp.last_match(1)]
+        when /runner\s+#{QUOTED_ARGUMENT}/o
+          [:runner, ::Regexp.last_match(2)]
+        when /rake\s+#{QUOTED_ARGUMENT}/o
+          [:rake, ::Regexp.last_match(2)]
+        when /command\s+#{QUOTED_ARGUMENT}/o
+          [:command, ::Regexp.last_match(2)]
         else
           [:unknown, body.strip]
         end
@@ -276,22 +308,6 @@ module Woods
         unit
       end
 
-      # ──────────────────────────────────────────────────────────────────────
-      # Format Detection
-      # ──────────────────────────────────────────────────────────────────────
-
-      # Infer the schedule format from the file path.
-      #
-      # @param file_path [String] Path to the schedule file
-      # @return [Symbol] One of :solid_queue, :sidekiq_cron, :whenever
-      def infer_format(file_path)
-        basename = File.basename(file_path)
-        SCHEDULE_FILES.each do |relative, fmt|
-          return fmt if basename == File.basename(relative)
-        end
-        :unknown
-      end
-
       # ──────────────────────────────────────────────────────────────────────
       # Shared helpers
       # ──────────────────────────────────────────────────────────────────────

data/lib/woods/extractors/serializer_extractor.rb

@@ -145,10 +145,9 @@ module Woods
       # ──────────────────────────────────────────────────────────────────────
 
       def extract_class_name(file_path, source)
-        return ::Regexp.last_match(1) if source =~ /^\s*class\s+([\w:]+)/
-
-        # Fall back to convention
-        file_path
+        # Zeitwerk-governed naming (G-1), then position-aware (#174), then
+        # convention.
+        governed_class_name(file_path, source) || qualified_first_class_name(source) || file_path
           .sub("#{Rails.root}/", '')
           .sub(%r{^app/(serializers|blueprinters|decorators)/}, '')
           .sub('.rb', '')

data/lib/woods/extractors/service_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 ServiceExtractor
       include SharedUtilityMethods
       include SharedDependencyScanner
+      include SourceNesting
 
       # Directories to scan for service objects
       SERVICE_DIRECTORIES = %w[
@@ -55,7 +57,15 @@ module Woods
       # @return [ExtractedUnit, nil] The extracted unit or nil if not a service
       def extract_service_file(file_path)
         source = File.read(file_path)
-        class_name = extract_class_name(file_path, source, '(?:services|interactors|operations|commands|use_cases)')
+        # Zeitwerk-governed naming first (G-1): a file under a managed
+        # autoload path is named for the constant its path spells, so
+        # `module Domain; class Container; class Parser` names the file's
+        # Parser, not the wrapper. Position-aware nesting scan (#174) and the
+        # path-based convention remain the fallbacks for unmanaged or
+        # unconventional files.
+        class_name = governed_class_name(file_path, source) ||
+                     qualified_first_class_name(source) ||
+                     extract_class_name(file_path, source, '(?:services|interactors|operations|commands|use_cases)')
 
         return nil unless class_name
         return nil if skip_file?(source)

data/lib/woods/extractors/shared_dependency_scanner.rb

@@ -2,6 +2,8 @@
 
 require 'set'
 require_relative '../model_name_cache'
+require_relative 'line_neutralizer'
+require_relative 'reference_patterns'
 require_relative 'route_helper_resolver'
 
 module Woods
@@ -80,8 +82,8 @@ module Woods
       #
       # A naive `gsub(/#.*/, '')` truncates lines like
       # `redirect "/posts#comments"; Post.touch` at the in-string `#`,
-      # silently dropping the `Post` reference. This scanner walks each line
-      # tracking quote state so only a genuine (unquoted) `#` starts a
+      # silently dropping the `Post` reference. {LineNeutralizer} walks each
+      # line tracking quote state so only a genuine (unquoted) `#` starts a
       # comment. Escapes (`\"`, `\'`) inside literals are honored. Heredocs,
       # `%`-literals, and character literals whose char is a quote (`?'`,
       # `?"`) are not modeled — these are rare in the constant-bearing code
@@ -92,7 +94,7 @@ module Woods
       # @param source [String] Ruby source code
       # @return [String] source with unquoted `#` comments removed
       def strip_ruby_line_comments(source)
-        source.each_line.map { |line| strip_line_comment(line) }.join
+        LineNeutralizer.strip_comments(source)
       end
 
       # Strip a trailing `#` comment from a single line, ignoring `#` inside
@@ -101,30 +103,7 @@ module Woods
       # @param line [String]
       # @return [String]
       def strip_line_comment(line)
-        in_single = false
-        in_double = false
-        i = 0
-        len = line.length
-        while i < len
-          ch = line[i]
-          if (in_single || in_double) && ch == '\\'
-            i += 2 # skip escaped char inside a literal
-            next
-          elsif in_single
-            in_single = false if ch == "'"
-          elsif in_double
-            in_double = false if ch == '"'
-          elsif ch == "'"
-            in_single = true
-          elsif ch == '"'
-            in_double = true
-          elsif ch == '#'
-            trailing = line[i..].end_with?("\n") ? "\n" : ''
-            return line[0...i] + trailing
-          end
-          i += 1
-        end
-        line
+        LineNeutralizer.strip_line_comment(line)
       end
 
       # Extract string-literal arguments passed to `.constantize` or
@@ -154,22 +133,27 @@ module Woods
 
       # Scan for service object references (e.g., FooService.call, FooService::new).
       #
+      # Targets keep their namespace ({ReferencePatterns::SERVICE_REFERENCE}):
+      # `Billing::ChargeService.call` records the fully-qualified name the
+      # service's own unit is identified by.
+      #
       # @param source [String] Ruby source code to scan
       # @param via [Symbol] Relationship label (default: :code_reference)
       # @return [Array<Hash>] Dependency hashes
       def scan_service_dependencies(source, via: :code_reference)
-        source.scan(/(\w+Service)(?:\.|::)/).flatten.uniq.map do |service|
+        source.scan(ReferencePatterns::SERVICE_REFERENCE).flatten.uniq.map do |service|
           { type: :service, target: service, via: via }
         end
       end
 
-      # Scan for background job references (e.g., FooJob.perform_later).
+      # Scan for background job references (e.g., FooJob.perform_later,
+      # HardWorker.perform_async, SyncJob.set(wait: 5).perform_later).
       #
       # @param source [String] Ruby source code to scan
       # @param via [Symbol] Relationship label (default: :code_reference)
       # @return [Array<Hash>] Dependency hashes
       def scan_job_dependencies(source, via: :code_reference)
-        source.scan(/(\w+Job)\.perform/).flatten.uniq.map do |job|
+        source.scan(ReferencePatterns::JOB_ENQUEUE).flatten.uniq.map do |job|
           { type: :job, target: job, via: via }
         end
       end
@@ -180,7 +164,7 @@ module Woods
       # @param via [Symbol] Relationship label (default: :code_reference)
       # @return [Array<Hash>] Dependency hashes
       def scan_mailer_dependencies(source, via: :code_reference)
-        source.scan(/(\w+Mailer)\./).flatten.uniq.map do |mailer|
+        source.scan(ReferencePatterns::MAILER_REFERENCE).flatten.uniq.map do |mailer|
           { type: :mailer, target: mailer, via: via }
         end
       end
@@ -227,9 +211,15 @@ module Woods
       ROUTE_HELPER_PATTERN = /\b(\w+)_(path|url)\b/
 
       # Match form_with/form_for with a named route helper as the action/url.
-      # Scans only within the form opening tag (up to the first `do`, `%>`, or `end`)
-      # to avoid matching unrelated _path/_url helpers that appear after the form.
-      FORM_ACTION_HELPER = /form_(with|for)\b[^%]*?(\w+)_(path|url)/
+      # Scans only within the form opening tag (up to the first `do`, `%>`, or
+      # `end`) to avoid matching unrelated _path/_url helpers that appear
+      # after the form. The negative lookahead (rather than a `[^%]`
+      # character class) is what actually enforces that boundary: a
+      # `[^%]*?` scan has nothing bounding it in plain-Ruby sources (Phlex,
+      # ViewComponent, mailers) that contain no `%` at all, so a
+      # `form_with` with no route-helper argument ran past its own `do`
+      # block and matched the next unrelated `_path` call in the method.
+      FORM_ACTION_HELPER = /form_(with|for)\b(?:(?!%>|\bdo\b|\bend\b)[\s\S])*?(\w+)_(path|url)/
 
       # Scan source for named route helpers and resolve them to controller targets.
       #

data/lib/woods/extractors/shared_utility_methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'source_nesting'
+
 module Woods
   module Extractors
     # Utility methods shared across multiple extractors.
@@ -20,6 +22,8 @@ module Woods
     #   end
     #
     module SharedUtilityMethods
+      include SourceNesting
+
       # Glob files matching a pattern across a list of directories.
       #
       # Centralizes the `Dir[dir.join('**/*.rb')]` loop duplicated across
@@ -51,22 +55,30 @@ module Woods
       end
 
       # Resolve the source file for a class using reliable introspection,
-      # filtered through {#app_source?} to reject vendor/gem paths.
+      # preferring app-owned locations ({#app_source?}) over vendor/gem paths.
       #
       # Tier order:
       #   1. +const_source_location+ (returns the class definition site)
       #   2. Instance method source locations (first match wins)
       #   3. Class/singleton method source locations (first match wins)
+      #   4. The tier-1 definition site even when it is outside the app, if
+      #      that file exists — a gem-owned class (an engine model such as
+      #      +ActiveStorage::Blob+) has no app location at all, and the
+      #      convention fallback would name a file that does not exist.
+      #      Path normalization leaves such a path absolute, and
+      #      `woods:validate` reports it as gem-owned rather than missing.
       #
       # @param klass [Class, Module] The class to resolve
       # @param app_root [String] Rails.root.to_s
       # @param fallback [String] Path to return when resolution fails
       # @return [String] Resolved source path or fallback
       def resolve_source_location(klass, app_root:, fallback:)
+        definition_site = nil
+
         # Tier 1: const_source_location (most reliable — returns class definition site)
         if Object.respond_to?(:const_source_location) && klass.name
-          loc = Object.const_source_location(klass.name)&.first
-          return loc if app_source?(loc, app_root)
+          definition_site = Object.const_source_location(klass.name)&.first
+          return definition_site if app_source?(definition_site, app_root)
         end
 
         # Tier 2: Instance methods defined directly on this class
@@ -81,6 +93,10 @@ module Woods
           return loc if app_source?(loc, app_root)
         end
 
+        # Tier 4: nothing in the app defines it — the real definition site,
+        # when it exists, beats a synthesized path that does not.
+        return definition_site if definition_site && File.exist?(definition_site)
+
         fallback
       rescue StandardError
         fallback
@@ -94,9 +110,15 @@ module Woods
       #   (e.g., "policies", "validators", "(?:services|interactors|operations|commands|use_cases)")
       # @return [String] The class name
       def extract_class_name(file_path, source, dir_prefix)
-        return ::Regexp.last_match(1) if source =~ /^\s*class\s+([\w:]+)/
-
-        file_path.sub("#{Rails.root}/", '').sub(%r{^app/#{dir_prefix}/}, '').sub('.rb', '').camelize
+        # Zeitwerk-governed naming first (G-1): a file under a managed
+        # autoload path is named for the constant its path spells, so
+        # `module Domain; class Container; class Parser` names the file's
+        # Parser, not the wrapper. Position-aware (SourceNesting, #174):
+        # `module Admin; class Foo` names Admin::Foo, and a helper module
+        # nested inside the class does not leak into the identifier.
+        governed_class_name(file_path, source) ||
+          qualified_first_class_name(source) ||
+          file_path.sub("#{Rails.root}/", '').sub(%r{^app/#{dir_prefix}/}, '').sub('.rb', '').camelize
       end
 
       # Extract the parent class name from a class definition.
@@ -245,6 +267,14 @@ module Woods
           in_private = false if stripped == 'public'
           in_protected = false if stripped == 'public'
 
+          # `private def foo` / `protected def foo` mark one method without
+          # opening a visibility section. Matching only the bare keyword lines
+          # above meant the inline form was invisible, so the `def` that
+          # follows on the same line was collected as public — and a method
+          # reported public can be misclassified downstream as a decision
+          # method. Skip the line without touching section state.
+          next if stripped.match?(/\A(?:private|protected)\s+def\b/)
+
           if !in_private && !in_protected && stripped =~ /def\s+((?:self\.)?\w+[?!=]?)/
             method_name = ::Regexp.last_match(1)
             methods << method_name unless method_name.start_with?('_')