woods 2.0.1 → 2.1.0

data/lib/woods/extractors/action_cable_extractor.rb

@@ -56,6 +56,8 @@ module Woods
       # @param klass [Class] A channel subclass
       # @return [ExtractedUnit, nil]
       def extract_channel(klass)
+        return nil unless app_channel?(klass)
+
         name = klass.name
         file_path = source_file_for(klass, name)
         source = read_source(file_path)
@@ -91,9 +93,12 @@ module Woods
       #
       # @return [Array<Class>]
       def channel_descendants
-        ActionCable::Channel::Base.descendants.reject do |klass|
-          klass.name.nil? || klass.name == 'ApplicationCable::Channel'
-        end
+        ActionCable::Channel::Base.descendants.select { |klass| app_channel?(klass) }
+      end
+
+      def app_channel?(klass)
+        action_cable_available? && klass.name && klass.name != 'ApplicationCable::Channel' &&
+          klass < ActionCable::Channel::Base && app_source_file?(source_file_for(klass, klass.name))
       end
 
       # Locate the source file for a channel class.

data/lib/woods/extractors/assigned_value_discovery.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../source_references/value_class'
+
+module Woods
+  module Extractors
+    # Selects the source-owned value class instead of its reopening namespace.
+    class AssignedValueDiscovery
+      CORE_METHODS = Module.instance_method(:instance_methods)
+      CORE_PRIVATE_METHODS = Module.instance_method(:private_instance_methods)
+
+      # @param file_path [String] original Ruby file
+      # @param analysis [Hash] original-source Collector result
+      # @param expected [String, nil] active loader's expected constant identity
+      # @param preserve_modules [Boolean] retain a canonical library module primary
+      # @return [String, nil] verified assigned child, or nil to preserve ordinary discovery
+      def call(file_path, analysis:, expected: nil, preserve_modules: false)
+        return if analysis['parse_error']
+
+        verifier = SourceReferences::ValueClass.new
+        declarations = analysis.fetch('declarations')
+        candidates = declarations.filter_map { |record| verifier.call(record, file_path: file_path) }
+        return expected if candidates.include?(expected)
+        return if candidates.empty? || owns_primary?(declarations, file_path, expected, preserve_modules)
+
+        candidates.first
+      end
+
+      private
+
+      def owns_primary?(declarations, file_path, expected, preserve_modules)
+        lookup = SourceReferences::RuntimeLookup.new
+        declarations.any? do |record|
+          next false if record['constructor'] || record.fetch('singleton_depth', 0).positive?
+          next false unless canonical_file?(record['owner'], file_path, lookup)
+          next true if record['kind'] == 'class'
+          next false unless preserve_modules
+
+          record['owner'] == expected || callable_module?(record['owner'], file_path, lookup)
+        end
+      end
+
+      def canonical_file?(identifier, file_path, lookup)
+        parts = identifier.split('::')
+        name = parts.pop
+        scope = parts.empty? ? Object : lookup.call("::#{parts.join('::')}", allow_private: true)[:value]
+        return false unless lookup.module_object?(scope)
+
+        location = SourceReferences::ValueClass::SOURCE_LOCATION.bind(scope).call(name, false)
+        location&.first && File.expand_path(location.first) == File.expand_path(file_path)
+      end
+
+      def callable_module?(identifier, path, lookup)
+        value = lookup.call("::#{identifier}", allow_private: true)[:value]
+        return false unless lookup.module_object?(value)
+
+        singleton = SourceReferences::ValueClass::SINGLETON_CLASS.bind(value).call
+        [value, singleton].any? { |scope| own_method_at?(scope, path) }
+      end
+
+      def own_method_at?(scope, path)
+        names = CORE_METHODS.bind(scope).call(false) + CORE_PRIVATE_METHODS.bind(scope).call(false)
+        names.any? do |name|
+          method = SourceReferences::ValueClass::INSTANCE_METHOD.bind(scope).call(name)
+          owner = SourceReferences::ValueClass::METHOD_OWNER.bind(method).call
+          next false unless SourceReferences::RuntimeLookup::CORE_EQUAL.bind(owner).call(scope)
+
+          location = SourceReferences::ValueClass::METHOD_SOURCE.bind(method).call
+          location && File.expand_path(location.first) == File.expand_path(path)
+        end
+      end
+    end
+  end
+end

data/lib/woods/extractors/class_declarations.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'prism'
+require_relative '../source_references/runtime_lookup'
+
+module Woods
+  module Extractors
+    # Structural declaration evidence without loading or evaluating source.
+    module ClassDeclarations
+      class Unresolved < StandardError; end
+
+      module_function
+
+      # @param source [String] original Ruby source
+      # @return [Array<Hash>] class identities, lexical scopes and syntax nodes
+      def read(source)
+        parsed = Prism.parse(source)
+        return [] unless parsed.success?
+
+        Collector.new.call(parsed.value)
+      end
+
+      # @param declaration [Hash] record returned by .read
+      # @return [String, nil] constant-path parent, including Migration[version]
+      def parent_name(declaration)
+        parent = declaration.fetch(:node).superclass
+        parent = parent.receiver if parent.is_a?(Prism::CallNode) && parent.name == :[]
+        constant_name(parent)
+      end
+
+      # @param node [Prism::Node, nil] constant syntax
+      # @return [String, nil] written constant path, preserving leading ::
+      def constant_name(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent ? constant_name(node.parent) : ''
+          "#{parent}::#{node.name}" if parent
+        end
+      end
+
+      # Qualified declaration receivers follow constant lookup; they do not
+      # automatically belong to the innermost syntactic namespace.
+      class Collector
+        def initialize
+          @lookup = SourceReferences::RuntimeLookup.new
+          @namespaces = {}
+        end
+
+        def call(node, nesting = [], result = [])
+          return result unless node
+          return result if node.is_a?(Prism::SingletonClassNode) || node.is_a?(Prism::DefNode)
+
+          if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+            name = ClassDeclarations.constant_name(node.constant_path)
+            return result unless name
+
+            identifier = declaration_identity(name, nesting)
+            @namespaces[identifier] = true
+            if node.is_a?(Prism::ClassNode)
+              result << { identifier: identifier, nesting: nesting, node: node, source: node.location.slice }
+            end
+            call(node.body, [identifier, *nesting], result)
+          else
+            node.compact_child_nodes.each { |child| call(child, nesting, result) }
+          end
+          result
+        end
+
+        private
+
+        def declaration_identity(name, nesting)
+          parts = name.delete_prefix('::').split('::')
+          return [name.start_with?('::') ? nil : nesting.first, parts.first].compact.join('::') if parts.one?
+
+          leaf = parts.pop
+          receiver = if name.start_with?('::')
+                       namespace(parts.shift)
+                     else
+                       lexical_namespace(parts.shift, nesting)
+                     end
+          parts.each { |part| receiver = namespace("#{receiver}::#{part}") }
+          "#{receiver}::#{leaf}"
+        end
+
+        def lexical_namespace(name, nesting)
+          nesting.each do |scope|
+            candidate = "#{scope}::#{name}"
+            return namespace(candidate) if @namespaces[candidate]
+
+            result = @lookup.call("::#{scope}", allow_private: true)
+            unresolved!(candidate) unless result[:status] == :resolved
+            next unless @lookup.reflect(result[:value], :const_defined?, name, false)
+
+            return namespace(candidate)
+          end
+
+          # Only after all lexical constant tables can be checked may inherited
+          # or root constants supply a receiver. An unloaded scope is unknown.
+          result = @lookup.call(name, nesting: nesting, allow_private: true)
+          return result[:target] if result[:status] == :resolved
+          return namespace(name) if result[:status] == :missing && result[:root_lookup]
+
+          unresolved!(name)
+        end
+
+        def namespace(name)
+          result = @lookup.call("::#{name}", allow_private: true)
+          return result[:target] if result[:status] == :resolved
+          return name if @namespaces[name] && result[:status] == :missing
+
+          unresolved!(name)
+        end
+
+        def unresolved!(name)
+          raise Unresolved, "Unresolved qualified declaration namespace: #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/woods/extractors/configuration_extractor.rb

@@ -42,9 +42,7 @@ module Woods
           extract_configuration_file(file)
         end
 
-        profiler = BehavioralProfile.new
-        profile = profiler.extract
-        SourceInputs::ConsumerErrors.record(self) if SourceInputs::ConsumerErrors.failed?(profiler)
+        profile = extract_behavioral_profile
         units << profile if profile
 
         units
@@ -53,6 +51,16 @@ module Woods
         units || []
       end
 
+      # Re-derive the synthetic unit from resolved runtime values, never from
+      # its nominal config/application.rb source path.
+      # @return [ExtractedUnit, nil]
+      def extract_behavioral_profile
+        profiler = BehavioralProfile.new
+        profile = profiler.extract
+        SourceInputs::ConsumerErrors.record(self) if SourceInputs::ConsumerErrors.failed?(profiler)
+        profile
+      end
+
       # Extract a single configuration file
       #
       # @param file_path [String] Path to the configuration file

data/lib/woods/extractors/declaration_ancestry.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'class_declarations'
+require_relative '../source_references/runtime_lookup'
+
+module Woods
+  module Extractors
+    # Runtime qualification belongs to the selected class and its actual source.
+    # An unavailable class may use limited declaration evidence; a foreign one
+    # must never lend its ancestry to a same-named file.
+    class DeclarationAncestry
+      SOURCE_LOCATION = Module.instance_method(:const_source_location)
+
+      # @param source [String] original source, never evaluated
+      # @param identifier [String] selected extraction identity
+      # @param file_path [String] source file owning the unit
+      def initialize(source:, identifier:, file_path:)
+        @lookup = SourceReferences::RuntimeLookup.new
+        @declaration = declaration(source, identifier)
+        result = @lookup.call("::#{identifier}", allow_private: true)
+        @runtime = result[:value] if result[:status] == :resolved
+        @foreign = if @runtime
+                     !owned_class?(identifier, file_path)
+                   else
+                     result[:status] == :unknown && !%w[autoload_pending unloaded_scope].include?(result[:reason])
+                   end
+        @names = ancestry_names(@runtime) if @runtime && !@foreign
+      end
+
+      # @return [Boolean] whether this file can qualify as a delegator
+      def manager?
+        return false if @foreign
+        return @names.include?('Delegator') if @names
+
+        %w[SimpleDelegator Delegator].include?(parent_name&.delete_prefix('::')) || delegate_class? ||
+          @declaration&.fetch(:source)&.match?(/include\s+(?:::)?Delegator\b/) || false
+      end
+
+      # @return [Symbol] supported delegation metadata, without running a factory
+      def delegation_type
+        return :simple_delegator if @names&.include?('SimpleDelegator')
+        return :simple_delegator if !@names && parent_name&.delete_prefix('::') == 'SimpleDelegator'
+        return :delegate_class if delegate_class?
+
+        :unknown
+      end
+
+      # @return [Boolean] whether a loaded class belongs to another file
+      def foreign?
+        !!@foreign
+      end
+
+      # @return [Boolean] conventional ApplicationPolicy ancestry
+      def application_policy?
+        return false if @foreign
+        return @names.drop(1).any? { |name| name.split('::').last == 'ApplicationPolicy' } if @names
+
+        parent_name&.split('::')&.last == 'ApplicationPolicy'
+      end
+
+      private
+
+      def declaration(source, identifier)
+        ClassDeclarations.read(source).find { |record| record[:identifier] == identifier }
+      rescue ClassDeclarations::Unresolved
+        # Missing static evidence must not suppress independently owned runtime
+        # ancestry or change the generic policy extractor's emission policy.
+        nil
+      end
+
+      def parent_name
+        ClassDeclarations.parent_name(@declaration) if @declaration
+      end
+
+      def delegate_class?
+        parent = @declaration&.fetch(:node)&.superclass
+        parent.is_a?(Prism::CallNode) && parent.name == :DelegateClass && parent.receiver.nil?
+      end
+
+      def owned_class?(identifier, path)
+        return false unless @lookup.class_object?(@runtime)
+
+        location = SOURCE_LOCATION.bind(Object).call(identifier, false)
+        location && File.expand_path(location.first) == File.expand_path(path)
+      end
+
+      def ancestry_names(klass)
+        @lookup.reflect(klass, :ancestors).filter_map { |ancestor| @lookup.reflect(ancestor, :name) }
+      end
+    end
+  end
+end

data/lib/woods/extractors/event_extractor.rb

@@ -187,6 +187,14 @@ module Woods
         all_paths = (data[:publishers] + data[:subscribers]).uniq
         combined_source = load_source_files(all_paths)
 
+        # Keep absolute paths for source reads; emitted paths must not make
+        # metadata or annotation hashes depend on the checkout directory.
+        prefix = File.join(Rails.root.to_s, '')
+        data = data.merge(
+          publishers: data[:publishers].map { |path| path.delete_prefix(prefix) },
+          subscribers: data[:subscribers].map { |path| path.delete_prefix(prefix) }
+        )
+
         unit = ExtractedUnit.new(
           type: :event,
           identifier: event_name,