codebase_index 0.1.0

data/lib/codebase_index/extractors/manager_extractor.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative 'shared_utility_methods'
+require_relative 'shared_dependency_scanner'
+
+module CodebaseIndex
+  module Extractors
+    # ManagerExtractor handles SimpleDelegator subclass extraction.
+    #
+    # Manager/delegator objects wrap a model and provide a richer interface
+    # for specific contexts (e.g., OrderManager wrapping Order with
+    # checkout-specific methods). They live in `app/managers/`.
+    #
+    # We extract:
+    # - Wrapped model (via SimpleDelegator superclass or initializer)
+    # - Public methods (the manager's added interface)
+    # - Delegation chain (what gets delegated vs overridden)
+    # - Dependencies (what models/services they reference)
+    #
+    # @example
+    #   extractor = ManagerExtractor.new
+    #   units = extractor.extract_all
+    #   order_mgr = units.find { |u| u.identifier == "OrderManager" }
+    #
+    class ManagerExtractor
+      include SharedUtilityMethods
+      include SharedDependencyScanner
+
+      # Directories to scan for manager/delegator objects
+      MANAGER_DIRECTORIES = %w[
+        app/managers
+      ].freeze
+
+      def initialize
+        @directories = MANAGER_DIRECTORIES.map { |d| Rails.root.join(d) }
+                                          .select(&:directory?)
+      end
+
+      # Extract all manager/delegator objects
+      #
+      # @return [Array<ExtractedUnit>] List of manager units
+      def extract_all
+        @directories.flat_map do |dir|
+          Dir[dir.join('**/*.rb')].filter_map do |file|
+            extract_manager_file(file)
+          end
+        end
+      end
+
+      # Extract a single manager file
+      #
+      # @param file_path [String] Path to the manager file
+      # @return [ExtractedUnit, nil] The extracted unit or nil if not a manager
+      def extract_manager_file(file_path)
+        source = File.read(file_path)
+        class_name = extract_class_name(file_path, source)
+
+        return nil unless class_name
+        return nil unless manager_file?(source)
+
+        unit = ExtractedUnit.new(
+          type: :manager,
+          identifier: class_name,
+          file_path: file_path
+        )
+
+        unit.namespace = extract_namespace(class_name)
+        unit.source_code = annotate_source(source, class_name)
+        unit.metadata = extract_metadata(source, class_name)
+        unit.dependencies = extract_dependencies(source, class_name)
+
+        unit
+      rescue StandardError => e
+        Rails.logger.error("Failed to extract manager #{file_path}: #{e.message}")
+        nil
+      end
+
+      private
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Class Discovery
+      # ──────────────────────────────────────────────────────────────────────
+
+      def extract_class_name(file_path, source)
+        return ::Regexp.last_match(1) if source =~ /^\s*class\s+([\w:]+)/
+
+        file_path
+          .sub("#{Rails.root}/", '')
+          .sub(%r{^app/managers/}, '')
+          .sub('.rb', '')
+          .camelize
+      end
+
+      def manager_file?(source)
+        source.match?(/< SimpleDelegator/) ||
+          source.match?(/< DelegateClass\(/) ||
+          source.match?(/include Delegator/)
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Source Annotation
+      # ──────────────────────────────────────────────────────────────────────
+
+      def annotate_source(source, class_name)
+        wrapped = detect_wrapped_model(source, class_name)
+
+        <<~ANNOTATION
+          # ╔═══════════════════════════════════════════════════════════════════════╗
+          # ║ Manager: #{class_name.ljust(60)}║
+          # ║ Wraps: #{(wrapped || 'unknown').ljust(61)}║
+          # ╚═══════════════════════════════════════════════════════════════════════╝
+
+          #{source}
+        ANNOTATION
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Metadata Extraction
+      # ──────────────────────────────────────────────────────────────────────
+
+      def extract_metadata(source, class_name)
+        {
+          wrapped_model: detect_wrapped_model(source, class_name),
+          delegation_type: detect_delegation_type(source),
+          public_methods: extract_public_methods(source),
+          class_methods: extract_class_methods(source),
+          initialize_params: extract_initialize_params(source),
+          delegated_methods: extract_delegated_methods(source),
+          overridden_methods: extract_overridden_methods(source),
+          custom_errors: extract_custom_errors(source),
+          loc: source.lines.count { |l| l.strip.length.positive? && !l.strip.start_with?('#') },
+          method_count: source.scan(/def\s+(?:self\.)?\w+/).size
+        }
+      end
+
+      def detect_wrapped_model(source, class_name)
+        # DelegateClass(ModelName) pattern
+        return ::Regexp.last_match(1) if source =~ /< DelegateClass\((\w+)\)/
+
+        # super(model) in initialize
+        return ::Regexp.last_match(1).capitalize if source =~ /super\((\w+)\)/
+
+        # @model = model; super(model) — look for param name
+        if source =~ /def\s+initialize\s*\((\w+)/
+          param = ::Regexp.last_match(1)
+          return param.capitalize unless %w[args options params attributes].include?(param)
+        end
+
+        # Infer from class name: OrderManager -> Order
+        stripped = class_name.split('::').last
+        inferred = stripped.sub(/Manager\z/, '')
+        # Return nil if no suffix was removed (not a FooManager pattern)
+        return nil if inferred == stripped || inferred.empty?
+
+        inferred
+      end
+
+      def detect_delegation_type(source)
+        return :delegate_class if source.match?(/< DelegateClass\(/)
+        return :simple_delegator if source.match?(/< SimpleDelegator/)
+
+        :unknown
+      end
+
+      def extract_delegated_methods(source)
+        methods = []
+
+        # delegate :foo, :bar, to: :something
+        source.scan(/delegate\s+(.+?)(?:,\s*to:)/) do |match|
+          match[0].scan(/:(\w+)/).flatten.each { |m| methods << m }
+        end
+
+        methods
+      end
+
+      def extract_overridden_methods(source)
+        # Methods that call super — these override delegated behavior
+        source.scan(/def\s+(\w+[?!=]?).*?\n.*?super/m).flatten
+      end
+
+      def extract_custom_errors(source)
+        source.scan(/class\s+(\w+(?:Error|Exception))\s*</).flatten
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Dependency Extraction
+      # ──────────────────────────────────────────────────────────────────────
+
+      def extract_dependencies(source, class_name)
+        deps = []
+
+        # Wrapped model dependency (specific :via)
+        wrapped = detect_wrapped_model(source, class_name)
+        deps << { type: :model, target: wrapped, via: :delegation } if wrapped
+
+        deps.concat(scan_common_dependencies(source))
+
+        deps.uniq { |d| [d[:type], d[:target]] }
+      end
+    end
+  end
+end

data/lib/codebase_index/extractors/middleware_extractor.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module CodebaseIndex
+  module Extractors
+    # MiddlewareExtractor handles Rack middleware stack extraction via runtime introspection.
+    #
+    # Reads the middleware stack from `Rails.application.middleware` and produces
+    # a single ExtractedUnit representing the full ordered stack. Each middleware
+    # entry includes the class name, arguments, and insertion point.
+    #
+    # @example
+    #   extractor = MiddlewareExtractor.new
+    #   units = extractor.extract_all
+    #   stack = units.find { |u| u.identifier == "MiddlewareStack" }
+    #
+    class MiddlewareExtractor
+      def initialize
+        # No directories to scan — this is runtime introspection
+      end
+
+      # Extract the middleware stack as a single ExtractedUnit
+      #
+      # @return [Array<ExtractedUnit>] Array containing one unit for the stack
+      def extract_all
+        return [] unless middleware_available?
+
+        stack = Rails.application.middleware
+        entries = extract_middleware_entries(stack)
+
+        return [] if entries.empty?
+
+        unit = ExtractedUnit.new(
+          type: :middleware,
+          identifier: 'MiddlewareStack',
+          file_path: nil
+        )
+
+        unit.namespace = nil
+        unit.source_code = build_stack_source(entries)
+        unit.metadata = build_stack_metadata(entries)
+        unit.dependencies = []
+
+        [unit]
+      rescue StandardError => e
+        Rails.logger.error("Failed to extract middleware stack: #{e.message}")
+        []
+      end
+
+      private
+
+      # Check if Rails middleware stack is available.
+      #
+      # @return [Boolean]
+      def middleware_available?
+        defined?(Rails) &&
+          Rails.respond_to?(:application) &&
+          Rails.application.respond_to?(:middleware)
+      end
+
+      # Extract individual middleware entries from the stack.
+      #
+      # @param stack [ActionDispatch::MiddlewareStack] The middleware stack
+      # @return [Array<Hash>] List of middleware entry hashes
+      def extract_middleware_entries(stack)
+        entries = []
+        position = 0
+
+        stack.each do |middleware|
+          entry = extract_single_middleware(middleware, position)
+          entries << entry if entry
+          position += 1
+        end
+
+        entries
+      end
+
+      # Extract info from a single middleware entry.
+      #
+      # @param middleware [ActionDispatch::MiddlewareStack::Middleware] A middleware entry
+      # @param position [Integer] Position in the stack
+      # @return [Hash, nil]
+      def extract_single_middleware(middleware, position)
+        name = if middleware.respond_to?(:name)
+                 middleware.name
+               elsif middleware.respond_to?(:klass)
+                 middleware.klass.to_s
+               else
+                 middleware.to_s
+               end
+
+        args = if middleware.respond_to?(:args)
+                 middleware.args.map(&:to_s)
+               else
+                 []
+               end
+
+        { name: name, args: args, position: position }
+      rescue StandardError
+        nil
+      end
+
+      # Build a human-readable source representation of the middleware stack.
+      #
+      # @param entries [Array<Hash>] Middleware entries
+      # @return [String]
+      def build_stack_source(entries)
+        lines = []
+        lines << '# Rack Middleware Stack'
+        lines << "# #{entries.size} middleware(s)"
+        lines << '#'
+
+        entries.each do |entry|
+          args_str = entry[:args].any? ? " (#{entry[:args].join(', ')})" : ''
+          lines << "# [#{entry[:position]}] #{entry[:name]}#{args_str}"
+        end
+
+        lines.join("\n")
+      end
+
+      # Build metadata hash for the middleware stack.
+      #
+      # @param entries [Array<Hash>] Middleware entries
+      # @return [Hash]
+      def build_stack_metadata(entries)
+        {
+          middleware_count: entries.size,
+          middleware_list: entries.map { |e| e[:name] },
+          middleware_details: entries
+        }
+      end
+    end
+  end
+end