woods 1.6.1 → 2.0.0.beta2

data/lib/woods/extractors/policy_extractor.rb

@@ -31,9 +31,6 @@ module Woods
         app/policies
       ].freeze
 
-      # Method name patterns that indicate decision/eligibility logic
-      DECISION_METHOD_PATTERN = /\b(allowed|eligible|valid|permitted|can_\w+|should_\w+|qualifies|meets_\w+|satisfies)\?/
-
       def initialize
         @directories = POLICY_DIRECTORIES.map { |d| Rails.root.join(d) }
                                          .select(&:directory?)
@@ -144,8 +141,12 @@ module Woods
 
         # From initialize params
         if source =~ /def\s+initialize\s*\(([^)]*)\)/
-          params = ::Regexp.last_match(1)
-          params.scan(/(\w+)/).flatten.each do |param|
+          # One parameter per comma. Keyword arguments (`strict: false`),
+          # default values (`user = nil`), and splats name no model, so only
+          # a bare positional identifier survives.
+          ::Regexp.last_match(1).split(',').each do |raw|
+            param = raw.strip[/\A(?:\*\*?|&)?([a-z_]\w*)\s*(?:=|\z)/, 1]
+            next if param.nil? || raw.strip.start_with?('*', '&')
             # Skip generic param names
             next if %w[args options params attributes context].include?(param)
 

data/lib/woods/extractors/poro_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 PoroExtractor
       include SharedUtilityMethods
       include SharedDependencyScanner
+      include SourceNesting
 
       # Glob pattern for all Ruby files in app/models/ (recursive).
       MODELS_GLOB = 'app/models/**/*.rb'
@@ -123,25 +125,22 @@ module Woods
 
       # Infer the primary class name from source or fall back to file path.
       #
-      # For regular class definitions we parse the first `class Foo` line,
-      # joining outer module namespaces when present. For Struct.new / Data.define
-      # patterns we read the constant assignment name. Falls back to the
-      # Rails camelize convention on the relative path.
+      # For regular class definitions the position-aware nesting scan
+      # (SourceNesting) qualifies the first `class` declaration with the
+      # modules actually open at that position — so a helper module nested
+      # inside the class, or a sibling module that closed before the class
+      # opened, no longer pollutes the identifier (#174). For Struct.new /
+      # Data.define patterns we read the constant assignment name. Falls back
+      # to the Rails camelize convention on the relative path.
       #
       # @param file_path [String] Absolute path to the file
       # @param source [String] Ruby source code
       # @return [String, nil] The inferred class name
       def infer_class_name(file_path, source)
-        # Explicit class keyword — combine outer module namespaces + class name
-        class_match = source.match(/^\s*class\s+([\w:]+)/)
-        if class_match
-          base = class_match[1]
-          # If already fully qualified (e.g., Order::Update), use as-is
-          return base if base.include?('::')
-
-          namespaces = source.scan(/^\s*module\s+([\w:]+)/).flatten
-          return namespaces.any? ? "#{namespaces.join('::')}::#{base}" : base
-        end
+        # Explicit class keyword — Zeitwerk-governed naming first (G-1), then
+        # enclosing modules joined by position (#174)
+        qualified = governed_class_name(file_path, source) || qualified_first_class_name(source)
+        return qualified if qualified
 
         # Struct.new / Data.define: ConstantName = Struct.new(...)
         struct_match = source.match(/^(\w[\w:]*)\s*=\s*(?:Struct\.new|Data\.define)/)

data/lib/woods/extractors/pundit_extractor.rb

@@ -83,9 +83,9 @@ module Woods
       # @param source [String]
       # @return [String, nil]
       def extract_class_name(file_path, source)
-        return ::Regexp.last_match(1) if source =~ /^\s*class\s+([\w:]+)/
-
-        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/policies/}, '')
           .sub('.rb', '')

data/lib/woods/extractors/rails_source_extractor.rb

@@ -13,6 +13,25 @@ module Woods
     #
     # Only high-value, frequently-referenced code is indexed to avoid bloat.
     #
+    # Emits TWO unit types — `:rails_source` (framework files) and
+    # `:gem_source` (configured gems) — both written under the `rails_source/`
+    # output directory. `Extractor::TYPE_TO_EXTRACTOR_KEY` maps both back to
+    # this extractor; keep that in sync if a type is ever added here.
+    #
+    # Unit `file_path`s are absolute installed-gem paths and stay
+    # environment-specific by design (#169): they are read from
+    # `Gem::Specification` in the extracting environment, there is no
+    # meaningful Rails.root-relative form for them, and rewriting them to some
+    # portable fiction would break the one thing they are for — opening the
+    # exact source the running app loads. An index read in a different
+    # environment simply cannot resolve them; `woods:validate` warns when
+    # that is the case rather than treating it as corruption.
+    #
+    # Kept current by the `Gemfile.lock` whole-app trigger (incremental runs),
+    # by full extraction when `include_framework_sources` is enabled (the
+    # default), and on demand via `woods:refresh[rails_source]` /
+    # `woods:extract_framework`.
+    #
     # @example
     #   extractor = RailsSourceExtractor.new
     #   units = extractor.extract_all
@@ -36,12 +55,11 @@ module Woods
           'lib/active_record/nested_attributes.rb'
         ],
         'actionpack' => [
+          # callbacks.rb, rendering.rb, redirecting.rb, and params_wrapper.rb
+          # all live under metal/, not directly under action_controller/ —
+          # the metal/ directory entry below already covers them.
           'lib/action_controller/metal',
-          'lib/action_controller/callbacks.rb',
-          'lib/abstract_controller/callbacks.rb',
-          'lib/action_controller/rendering.rb',
-          'lib/action_controller/redirecting.rb',
-          'lib/action_controller/params_wrapper.rb'
+          'lib/abstract_controller/callbacks.rb'
         ],
         'activesupport' => [
           'lib/active_support/callbacks.rb',
@@ -58,8 +76,7 @@ module Woods
         ],
         'actionmailer' => [
           'lib/action_mailer/base.rb',
-          'lib/action_mailer/delivery_methods.rb',
-          'lib/action_mailer/callbacks.rb'
+          'lib/action_mailer/delivery_methods.rb'
         ]
       }.freeze
 

data/lib/woods/extractors/rake_task_extractor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'line_neutralizer'
 require_relative 'shared_utility_methods'
 require_relative 'shared_dependency_scanner'
 
@@ -26,6 +27,20 @@ module Woods
       # Namespaces to exclude from extraction (this gem's own tasks)
       EXCLUDED_NAMESPACES = %w[woods].freeze
 
+      # Matches a line-leading `end` that closes a block, whether it stands
+      # alone or is followed by a method chain (`end.freeze`) or a closing
+      # delimiter (`end)`, `end]`, `end,`). An exact `== 'end'` check misses
+      # those, leaving the namespace/task depth counters out of sync with
+      # blocks that never get popped.
+      END_LINE = /\Aend\b/
+
+      # One task-dependency token: a quoted name (`'assets:precompile'`, whose
+      # namespace segments must survive — EXTB-9) or a plain symbol
+      # (`:environment`). The quoted branch comes first so the `:` inside a
+      # quoted name is consumed with it instead of being read as symbol
+      # syntax and truncated to its last segment.
+      DEPENDENCY_TOKEN = /(?:(['"])([\w:]+)\1|:(\w+))/
+
       def initialize
         @directories = RAKE_DIRECTORIES.map { |d| Rails.root.join(d) }.select(&:directory?)
       end
@@ -34,7 +49,7 @@ module Woods
       #
       # @return [Array<ExtractedUnit>] List of rake task units
       def extract_all
-        find_files_in_directories(@directories, '**/*.rake').flat_map { |file| extract_rake_file(file) }
+        rake_files.flat_map { |file| extract_rake_file(file) }.uniq(&:identifier)
       end
 
       # Extract rake tasks from a single .rake file.
@@ -46,13 +61,16 @@ module Woods
       def extract_rake_file(file_path)
         return [] unless file_path.to_s.end_with?('.rake')
 
-        source = File.read(file_path)
-        tasks = parse_tasks(source)
+        data = rake_file_data(file_path.to_s)
+        return [] unless data
+
+        tasks = data[:tasks]
+        Rails.logger.debug("Woods: no rake tasks parsed from #{file_path}") if tasks.empty?
 
         tasks.filter_map do |task_data|
           next if excluded_namespace?(task_data[:full_name])
 
-          build_unit(task_data, file_path, source)
+          build_unit(task_data, file_path, data[:source], sibling_definitions(task_data[:full_name], file_path))
         end
       rescue StandardError => e
         Rails.logger.error("Failed to extract rake tasks from #{file_path}: #{e.message}")
@@ -61,10 +79,70 @@ module Woods
 
       private
 
+      def rake_files
+        find_files_in_directories(@directories, '**/*.rake').map(&:to_s).sort
+      end
+
+      # One read and one parse per .rake file per extractor instance (audit
+      # P9a). {#extract_rake_file} and {#all_definitions} both need every
+      # file's source and tasks; the sibling index used to re-read and
+      # re-parse all of them on its first access. The bytes cannot change
+      # mid-run, so the first read/parse answers both paths.
+      #
+      # A file that fails to read or parse is memoized as nil: it produced no
+      # definitions and no units before either.
+      #
+      # @param file [String] Absolute path of the .rake file
+      # @return [Hash{Symbol => String, Array<Hash>}, nil] `{ source:, tasks: }`
+      def rake_file_data(file)
+        (@rake_file_data ||= {})[file] ||= begin
+          source = File.read(file)
+          { source: source, tasks: parse_tasks(source) }
+        end
+      rescue StandardError => e
+        Rails.logger.error("Failed to scan rake tasks in #{file}: #{e.message}")
+        nil
+      end
+
+      # Every definition of every task across the rake directories, keyed by
+      # full name (B-126). Rake merges a task reopened in two files into one
+      # task, so the index does the same: one unit whose source carries every
+      # definition. Built lazily once per extractor instance, which the
+      # orchestrator rebuilds per run.
+      #
+      # @return [Hash{String => Array<Hash>}] `{ full_name => [{ file:, task:, source: }] }`
+      def all_definitions
+        @all_definitions ||= rake_files.each_with_object(Hash.new { |h, k| h[k] = [] }) do |file, index|
+          data = rake_file_data(file)
+          next unless data
+
+          data[:tasks].each do |task_data|
+            index[task_data[:full_name]] << { file: file, task: task_data, source: data[:source] }
+          end
+        end
+      end
+
+      # Definitions of +full_name+ in files other than +file_path+.
+      #
+      # @return [Array<Hash>]
+      def sibling_definitions(full_name, file_path)
+        all_definitions[full_name].reject { |definition| definition[:file] == file_path.to_s }
+      end
+
       # Parse task definitions from rake source using a line-by-line state machine.
       #
       # Tracks namespace nesting, desc buffers, and task blocks.
       #
+      # Every structural decision (is this a declaration, does this line open
+      # or close a block) is made against the *neutralized* line — comments,
+      # string bodies, and heredoc bodies blanked by {LineNeutralizer} —
+      # while names and descriptions are still read from the raw line, which
+      # is where their string literals live. Scanning raw source let prose
+      # steer the parser: `# do not touch production` inflated depth with no
+      # matching `end`, so later namespaces inherited a stale prefix, and a
+      # heredoc line reading `end of the road` popped a task's own frame and
+      # truncated its body (EXTB-1).
+      #
       # @param source [String] Rake file source code
       # @return [Array<Hash>] Parsed task data
       def parse_tasks(source)
@@ -76,44 +154,51 @@ module Woods
         pending_desc = nil
         depth = 0
         lines = source.lines
+        scannable = LineNeutralizer.neutralize_lines(source)
 
         lines.each_with_index do |line, index|
           stripped = line.strip
+          code = scannable[index].to_s.strip
+          next if code.empty?
 
           # Track namespace blocks
-          if stripped.match?(/\Anamespace\s+/)
+          if code.match?(/\Anamespace\s+/)
             name = extract_namespace_name(stripped)
             if name
               namespace_stack.push(name)
               namespace_depths.push(depth)
               depth += 1
+            elsif code.include?(' do')
+              # Unparseable namespace name (e.g. dynamic/interpolated) — still
+              # count its block so depth stays in sync with the closing `end`.
+              depth += 1
             end
             next
           end
 
           # Buffer desc for the next task
-          if stripped.match?(/\Adesc\s+/)
+          if code.match?(/\Adesc\s+/)
             pending_desc = extract_desc(stripped)
             next
           end
 
           # Detect task definitions
-          if stripped.match?(/\Atask\s+/)
+          if code.match?(/\Atask\s+/)
             task_data = parse_task_line(stripped, namespace_stack, pending_desc, index + 1)
             if task_data
-              task_data[:block_source] = extract_task_block(lines, index)
+              task_data[:block_source] = extract_task_block(lines, scannable, index)
               tasks << task_data
             end
             pending_desc = nil
-            depth += 1 if stripped.include?(' do')
+            depth += 1 if code.include?(' do')
             next
           end
 
           # Track block openers (non-namespace, non-task)
-          depth += 1 if block_opener?(stripped)
+          depth += 1 if block_opener?(code)
 
           # Track end keywords
-          next unless stripped == 'end'
+          next unless code.match?(END_LINE)
 
           depth -= 1
           # Pop namespace if we've returned to the depth where it was opened
@@ -128,11 +213,17 @@ module Woods
 
       # Extract the namespace name from a namespace declaration line.
       #
+      # Handles both the symbol form (`namespace :foo do`) and the string
+      # form (`namespace 'foo' do` / `namespace "foo" do`).
+      #
       # @param line [String] e.g. "namespace :foo do"
       # @return [String, nil] The namespace name
       def extract_namespace_name(line)
         match = line.match(/\Anamespace\s+:(\w+)/)
-        match ? match[1] : nil
+        return match[1] if match
+
+        match = line.match(/\Anamespace\s+(['"])(\w+)\1/)
+        match ? match[2] : nil
       end
 
       # Extract the description string from a desc line.
@@ -176,6 +267,8 @@ module Woods
       #   task :name => :dep
       #   task :name => [:dep1, :dep2]
       #   task :name, [:arg1, :arg2] => :dep
+      #   task name: :dep
+      #   task name: [:dep1, :dep2]
       #
       # @param line [String] The task line
       # @return [Array(String, Array<String>, Array<String>)] [name, deps, args]
@@ -202,6 +295,15 @@ module Woods
           return [name, deps, []]
         end
 
+        # Ruby 1.9 label form: task name: :dep / task name: [:dep1, :dep2]
+        # Ordered after the args branch so `task :name, [:args] => :dep`
+        # is never misread (the leading colon keeps it out of this regex).
+        if line.match(/\Atask\s+(\w+):\s*(.+?)(?:\s+do|\s*$)/)
+          name = ::Regexp.last_match(1)
+          deps = parse_dependency_list(::Regexp.last_match(2))
+          return [name, deps, []]
+        end
+
         # Simple task: task :name
         return [::Regexp.last_match(1), [], []] if line.match(/\Atask\s+:(\w+)/)
 
@@ -213,46 +315,62 @@ module Woods
       # @param dep_str [String] e.g. ":environment" or "[:dep1, :dep2]"
       # @return [Array<String>]
       def parse_dependency_list(dep_str)
-        dep_str.scan(/:(\w+)/).flatten
+        dep_str.scan(DEPENDENCY_TOKEN).map { |_quote, quoted, symbol| quoted || symbol }
       end
 
       # Extract the task block body (lines between task...do and matching end).
       #
+      # Depth is counted against the neutralized lines so a keyword inside a
+      # comment, string, or heredoc body cannot open or close a block
+      # (EXTB-1); the body itself is collected from the raw lines.
+      #
       # @param lines [Array<String>] All source lines
+      # @param scannable [Array<String>] Neutralized counterparts of +lines+
       # @param task_line_index [Integer] 0-based index of the task line
       # @return [String] The block body source
-      def extract_task_block(lines, task_line_index)
-        task_line = lines[task_line_index]
-        return '' unless task_line&.include?('do')
+      def extract_task_block(lines, scannable, task_line_index)
+        task_line = scannable[task_line_index]
+        # `block_opener?`, not a bare `include?('do')` substring check — a
+        # task named `docs` (`task docs: :environment`) contains the
+        # substring "do" in its own name, which made a blockless task look
+        # like it opened a `do` block and swallowed the following task's
+        # lines as its own body.
+        return '' unless task_line && block_opener?(task_line.strip)
 
         depth = 1
         body_lines = []
 
         ((task_line_index + 1)...lines.size).each do |i|
-          line = lines[i]
-          stripped = line.strip
+          code = scannable[i].to_s.strip
 
-          depth += 1 if block_opener?(stripped)
-          depth -= 1 if stripped == 'end'
+          depth += 1 if block_opener?(code)
+          depth -= 1 if code.match?(END_LINE)
 
           break if depth.zero?
 
-          body_lines << line
+          body_lines << lines[i]
         end
 
         body_lines.join
       end
 
       # Check if a line opens a new block (do...end or def...end).
-      # Note: if/unless only count as block openers when they start the line
-      # (standalone form), not as trailing modifiers (e.g., `return if x`).
+      #
+      # +if+/+unless+ count as block openers in statement position: leading
+      # the line, or directly after an assignment operator (`value = if x`,
+      # `@memo ||= unless y` — the {Woods::Chunking::SemanticChunker}
+      # precedent). Trailing modifiers (`return if x`, `value = 1 if x`)
+      # must not count, and a line whose opener closes on the same line
+      # (`x = if a then b end`) is self-balancing: its trailing `end` never
+      # matches the line-leading {END_LINE}, so counting it would push a
+      # frame nothing pops — the same `end` guard the keyword branch uses.
       #
       # @param stripped [String] Stripped line content
       # @return [Boolean]
       def block_opener?(stripped)
         return true if stripped.match?(/\b(do|def|case|begin|class|module|while|until|for)\b.*(?<!\bend)\s*$/)
 
-        stripped.match?(/\A(if|unless)\b/)
+        stripped.match?(/(?:\A|=\s*)(?:if|unless)\b.*(?<!\bend)\s*$/)
       end
 
       # Check if a task name falls under an excluded namespace.
@@ -269,21 +387,30 @@ module Woods
       # @param file_path [String] Path to the .rake file
       # @param file_source [String] Full file source
       # @return [ExtractedUnit]
-      def build_unit(task_data, file_path, file_source)
+      def build_unit(task_data, file_path, file_source, siblings = [])
+        definitions = ([{ file: file_path.to_s, task: task_data, source: file_source }] + siblings)
+                      .sort_by { |definition| definition[:file] }
+        primary = definitions.first
+
         unit = ExtractedUnit.new(
           type: :rake_task,
           identifier: task_data[:full_name],
-          file_path: file_path
+          file_path: primary[:file]
         )
 
         unit.namespace = task_data[:task_namespace]
-        unit.source_code = build_source_annotation(task_data, file_source)
-        unit.metadata = build_metadata(task_data)
-        unit.dependencies = extract_dependencies(task_data, file_source)
+        unit.source_code = definitions.map { |d| build_source_annotation(d[:task], d[:source]) }.join("\n\n")
+        unit.metadata = build_metadata(primary[:task])
+        unit.metadata[:defined_in] = definitions.map { |d| relative_path(d[:file]) } if definitions.size > 1
+        unit.dependencies = definitions.flat_map { |d| extract_dependencies(d[:task], d[:source]) }.uniq
 
         unit
       end
 
+      def relative_path(file)
+        file.to_s.sub("#{Rails.root}/", '')
+      end
+
       # Build annotated source code for the unit.
       #
       # @param task_data [Hash] Parsed task data
@@ -308,7 +435,8 @@ module Woods
           task_dependencies: task_data[:task_dependencies],
           arguments: task_data[:arguments],
           has_environment_dependency: task_data[:task_dependencies].include?('environment'),
-          source_lines: (task_data[:block_source] || '').lines.size
+          source_lines: (task_data[:block_source] || '').lines.size,
+          line_number: task_data[:line_number]
         }
       end
 

data/lib/woods/extractors/reference_patterns.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Woods
+  module Extractors
+    # Regexes for "this source references that class", shared by every site
+    # that scans Ruby text for service, job/worker, and mailer references.
+    #
+    # Three implementations of "detect an enqueue" used to disagree pairwise —
+    # the scanner missed `*Worker` and `.set(…)`, JobExtractor missed
+    # `*Worker`, CallbackAnalyzer missed `.set(…)` — so which units recorded
+    # an edge to a job depended on which extractor happened to look (EXTA-4).
+    # They all use {JOB_ENQUEUE} now.
+    #
+    # Every pattern is namespace-capable (EXTA-2). Since G-1 a namespaced
+    # unit's identifier is fully qualified (`Billing::ChargeService`), so a
+    # `\w+`-only capture recorded `ChargeService` — an edge target matching no
+    # node, invisible to `dependents`, PageRank, and the incremental blast
+    # radius. The leading `(?:\w+::)*` is greedy but backtracks to the last
+    # segment carrying the suffix, so `Billing::ChargeService::VERSION` still
+    # targets +Billing::ChargeService+.
+    module ReferencePatterns
+      # Async dispatch methods that enqueue a job. `set` is ActiveJob's
+      # delayed-enqueue entry point (`SyncJob.set(wait: 5).perform_later`).
+      ENQUEUE_METHODS = %w[perform_later perform_async perform_in perform_at].freeze
+
+      # `FooService.call` / `FooService::new`, namespace included.
+      SERVICE_REFERENCE = /((?:\w+::)*\w+Service)(?:\.|::)/
+
+      # `FooMailer.welcome`, namespace included.
+      MAILER_REFERENCE = /((?:\w+::)*\w+Mailer)\./
+
+      # `FooJob.perform_later` / `HardWorker.perform_async` /
+      # `SyncJob.set(wait: …).perform_later`, namespace included.
+      JOB_ENQUEUE =
+        /((?:\w+::)*\w+(?:Job|Worker))\.(?:#{ENQUEUE_METHODS.map { |m| Regexp.escape(m) }.join('|')}|set\b)/
+    end
+  end
+end

data/lib/woods/extractors/route_extractor.rb

@@ -31,7 +31,7 @@ module Woods
         return [] unless rails_routes_available?
 
         routes = Rails.application.routes.routes
-        routes.filter_map { |route| extract_route(route) }
+        number_colliding_identifiers(routes.filter_map { |route| extract_route(route) })
       end
 
       private
@@ -59,7 +59,7 @@ module Woods
 
         verb = route_verb(route)
         path = route_path(route)
-        identifier = "#{verb} #{path}"
+        identifier = route_identifier(verb, path, route)
 
         controller_class = "#{controller.camelize}Controller"
 
@@ -80,6 +80,62 @@ module Woods
         nil
       end
 
+      # Identifier for a route: `VERB /path`, qualified by its request
+      # constraints when it has any (B-127). Two routes that share a verb and
+      # path but differ by subdomain, header, or format would otherwise
+      # collapse into one unit, and the second silently vanished from the
+      # index. Path-segment requirements (`id: /\d+/`) do not qualify: they
+      # do not distinguish routes with the same path spec, and folding them
+      # in would rename every `resources` route with an `id` constraint.
+      #
+      # @return [String] e.g. "GET /users" or "GET /users [subdomain=api]"
+      def route_identifier(verb, path, route)
+        base = "#{verb} #{path}"
+        parts = identifier_constraints(path, route)
+        parts.empty? ? base : "#{base} [#{parts.join(', ')}]"
+      end
+
+      # @return [Array<String>] sorted `key=value` pairs for the constraints
+      #   that qualify the identifier, plus `constraint=proc` when the route
+      #   is wrapped by a callable constraint
+      def identifier_constraints(path, route)
+        segment_keys = path.scan(/:(\w+)/).flatten.map(&:to_sym)
+        pairs = route_constraints(route).reject { |key, _| segment_keys.include?(key.to_sym) }
+        requirements = route.respond_to?(:requirements) && route.requirements.is_a?(Hash) ? route.requirements : {}
+        pairs[:format] = requirements[:format] if requirements.key?(:format) && !pairs.key?(:format)
+
+        parts = pairs.sort_by { |key, _| key.to_s }.map { |key, value| "#{key}=#{constraint_value(value)}" }
+        parts << 'constraint=proc' if callable_constraint?(route)
+        parts
+      end
+
+      def constraint_value(value)
+        value.is_a?(Regexp) ? value.source : value.to_s
+      end
+
+      # A `constraints -> (req) { ... }` block wraps the endpoint in
+      # ActionDispatch::Routing::Mapper::Constraints, which exposes the
+      # callables as +constraints+.
+      def callable_constraint?(route)
+        app = route.respond_to?(:app) ? route.app : nil
+        app.respond_to?(:constraints) && app.constraints.is_a?(Array) && app.constraints.any?
+      end
+
+      # Routes still sharing an identifier after constraints are applied
+      # (two callable constraints, say) are numbered in route order:
+      # `GET /users`, `GET /users #2`. Deterministic for a given routes file,
+      # and the second route is indexed instead of dropped.
+      def number_colliding_identifiers(units)
+        seen = Hash.new(0)
+        units.each do |unit|
+          seen[unit.identifier] += 1
+          next if seen[unit.identifier] == 1
+
+          unit.identifier = "#{unit.identifier} ##{seen[unit.identifier]}"
+        end
+        units
+      end
+
       # Extract defaults hash from route, handling different Rails versions.
       #
       # @param route [ActionDispatch::Journey::Route]