codebase_index 0.3.2 → 0.4.0

data/lib/codebase_index/extractors/validator_extractor.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'shared_utility_methods'
-require_relative 'shared_dependency_scanner'
-
-module CodebaseIndex
-  module Extractors
-    # ValidatorExtractor handles custom validator class extraction.
-    #
-    # Custom validators encapsulate reusable validation logic that applies
-    # across multiple models. They inherit from `ActiveModel::Validator`
-    # or `ActiveModel::EachValidator` and live in `app/validators/`.
-    #
-    # We extract:
-    # - Validator name and namespace
-    # - Base class (Validator vs EachValidator)
-    # - Validation rules (what they check)
-    # - Models they operate on (from source references)
-    # - Dependencies (what models/services they reference)
-    #
-    # @example
-    #   extractor = ValidatorExtractor.new
-    #   units = extractor.extract_all
-    #   email = units.find { |u| u.identifier == "EmailFormatValidator" }
-    #
-    class ValidatorExtractor
-      include SharedUtilityMethods
-      include SharedDependencyScanner
-
-      # Directories to scan for custom validators
-      VALIDATOR_DIRECTORIES = %w[
-        app/validators
-      ].freeze
-
-      def initialize
-        @directories = VALIDATOR_DIRECTORIES.map { |d| Rails.root.join(d) }
-                                            .select(&:directory?)
-      end
-
-      # Extract all custom validators
-      #
-      # @return [Array<ExtractedUnit>] List of validator units
-      def extract_all
-        @directories.flat_map do |dir|
-          Dir[dir.join('**/*.rb')].filter_map do |file|
-            extract_validator_file(file)
-          end
-        end
-      end
-
-      # Extract a single validator file
-      #
-      # @param file_path [String] Path to the validator file
-      # @return [ExtractedUnit, nil] The extracted unit or nil if not a validator
-      def extract_validator_file(file_path)
-        source = File.read(file_path)
-        class_name = extract_class_name(file_path, source, 'validators')
-
-        return nil unless class_name
-        return nil unless validator_file?(source)
-
-        unit = ExtractedUnit.new(
-          type: :validator,
-          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)
-
-        unit
-      rescue StandardError => e
-        Rails.logger.error("Failed to extract validator #{file_path}: #{e.message}")
-        nil
-      end
-
-      private
-
-      # ──────────────────────────────────────────────────────────────────────
-      # Class Discovery
-      # ──────────────────────────────────────────────────────────────────────
-
-      def validator_file?(source)
-        source.match?(/< ActiveModel::Validator/) ||
-          source.match?(/< ActiveModel::EachValidator/) ||
-          source.match?(/def\s+validate_each\b/) ||
-          source.match?(/def\s+validate\(/)
-      end
-
-      # ──────────────────────────────────────────────────────────────────────
-      # Source Annotation
-      # ──────────────────────────────────────────────────────────────────────
-
-      def annotate_source(source, class_name)
-        validator_type = detect_validator_type(source)
-        validated_attrs = extract_validated_attributes(source)
-
-        <<~ANNOTATION
-          # ╔═══════════════════════════════════════════════════════════════════════╗
-          # ║ Validator: #{class_name.ljust(57)}║
-          # ║ Type: #{validator_type.to_s.ljust(62)}║
-          # ║ Attributes: #{validated_attrs.join(', ').ljust(56)}║
-          # ╚═══════════════════════════════════════════════════════════════════════╝
-
-          #{source}
-        ANNOTATION
-      end
-
-      # ──────────────────────────────────────────────────────────────────────
-      # Metadata Extraction
-      # ──────────────────────────────────────────────────────────────────────
-
-      def extract_metadata(source, class_name)
-        {
-          validator_type: detect_validator_type(source),
-          validated_attributes: extract_validated_attributes(source),
-          validation_rules: extract_validation_rules(source),
-          error_messages: extract_error_messages(source),
-          public_methods: extract_public_methods(source),
-          class_methods: extract_class_methods(source),
-          options_used: extract_options(source),
-          inferred_models: infer_models_from_name(class_name),
-          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_validator_type(source)
-        return :each_validator if source.match?(/< ActiveModel::EachValidator/)
-        return :validator if source.match?(/< ActiveModel::Validator/)
-        return :each_validator if source.match?(/def\s+validate_each\b/)
-        return :validator if source.match?(/def\s+validate\(/)
-
-        :unknown
-      end
-
-      def extract_validated_attributes(source)
-        attrs = []
-
-        # EachValidator: the attribute param in validate_each
-        attrs << ::Regexp.last_match(1) if source =~ /def\s+validate_each\s*\(\s*\w+\s*,\s*(\w+)/
-
-        # From error.add calls: record.errors.add(:attribute, ...)
-        source.scan(/errors\.add\s*\(\s*:(\w+)/).flatten.each { |a| attrs << a }
-
-        # From validates_each blocks
-        source.scan(/validates_each\s*\(\s*:(\w+)/).flatten.each { |a| attrs << a }
-
-        attrs.uniq
-      end
-
-      def extract_validation_rules(source)
-        # Conditional checks in validate/validate_each body
-        rules = source.scan(/unless\s+(.+)$/).flatten.map(&:strip)
-        source.scan(/if\s+(.+?)(?:\s*$|\s*then)/).flatten.each { |r| rules << r.strip }
-
-        # Regex validations
-        source.scan(%r{=~\s*(/[^/]+/)}).flatten.each { |r| rules << "matches #{r}" }
-        source.scan(%r{match\?\s*\((/[^/]+/)\)}).flatten.each { |r| rules << "matches #{r}" }
-
-        rules.first(10) # Cap at 10 to avoid noise
-      end
-
-      def extract_error_messages(source)
-        # errors.add(:attr, "message") or errors.add(variable, "message")
-        messages = source.scan(/errors\.add\s*\(\s*:?\w+\s*,\s*["']([^"']+)["']/).flatten
-
-        # errors.add(:attr, :symbol) or errors.add(variable, :symbol)
-        source.scan(/errors\.add\s*\(\s*:?\w+\s*,\s*:(\w+)/).flatten.each { |m| messages << ":#{m}" }
-
-        messages
-      end
-
-      def extract_options(source)
-        # options[:key] access
-        options = source.scan(/options\[:(\w+)\]/).flatten
-
-        options.uniq
-      end
-
-      def infer_models_from_name(class_name)
-        # EmailFormatValidator -> might validate email on many models
-        # No reliable way to infer specific models from name alone
-        # Return the validator's conceptual domain
-        stripped = class_name.split('::').last
-        inferred = stripped.sub(/Validator\z/, '')
-        inferred.empty? ? [] : [inferred]
-      end
-
-      # ──────────────────────────────────────────────────────────────────────
-      # Dependency Extraction
-      # ──────────────────────────────────────────────────────────────────────
-
-      def extract_dependencies(source)
-        deps = []
-        deps.concat(scan_model_dependencies(source, via: :validation))
-        deps.concat(scan_service_dependencies(source))
-
-        # Other validators referenced
-        source.scan(/(\w+Validator)(?:\.|::new)/).flatten.uniq.each do |validator|
-          deps << { type: :validator, target: validator, via: :code_reference }
-        end
-
-        deps.uniq { |d| [d[:type], d[:target]] }
-      end
-    end
-  end
-end

data/lib/codebase_index/extractors/view_component_extractor.rb

@@ -1,311 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'shared_utility_methods'
-require_relative 'shared_dependency_scanner'
-
-module CodebaseIndex
-  module Extractors
-    # ViewComponentExtractor handles ViewComponent extraction.
-    #
-    # ViewComponent components are Ruby classes that encapsulate view logic.
-    # We can extract:
-    # - Slot definitions (renders_one, renders_many)
-    # - Sidecar template paths (.html.erb files next to the .rb file)
-    # - Initialize parameters (the component's API)
-    # - Preview classes (ViewComponent::Preview subclasses)
-    # - Collection support
-    # - Callbacks (before_render, after_render)
-    # - Content areas (legacy API)
-    # - Component dependencies (rendered sub-components, model references)
-    #
-    # @example
-    #   extractor = ViewComponentExtractor.new
-    #   units = extractor.extract_all
-    #   card = units.find { |u| u.identifier == "CardComponent" }
-    #
-    class ViewComponentExtractor
-      include SharedUtilityMethods
-      include SharedDependencyScanner
-
-      def initialize
-        @component_base = find_component_base
-      end
-
-      # Extract all ViewComponent components
-      #
-      # @return [Array<ExtractedUnit>] List of view component units
-      def extract_all
-        return [] unless @component_base
-
-        @component_base.descendants.map do |component|
-          extract_component(component)
-        end.compact
-      end
-
-      # Extract a single ViewComponent component
-      #
-      # @param component [Class] The component class
-      # @return [ExtractedUnit, nil] The extracted unit, or nil on failure
-      def extract_component(component)
-        return nil if component.name.nil?
-        return nil if preview_class?(component)
-
-        unit = ExtractedUnit.new(
-          type: :view_component,
-          identifier: component.name,
-          file_path: source_file_for(component)
-        )
-
-        # Skip components with no resolvable source file (framework/internal)
-        return nil unless unit.file_path
-
-        unit.source_code = read_source(unit.file_path)
-
-        unit.namespace = extract_namespace(component)
-        unit.metadata = extract_metadata(component, unit.source_code)
-        unit.dependencies = extract_dependencies(component, unit.source_code)
-
-        unit
-      rescue StandardError => e
-        Rails.logger.error("Failed to extract view component #{component.name}: #{e.message}")
-        nil
-      end
-
-      private
-
-      # Find the ViewComponent::Base class if the gem is loaded
-      #
-      # @return [Class, nil]
-      def find_component_base
-        return nil unless defined?(ViewComponent::Base)
-
-        ViewComponent::Base
-      end
-
-      # Check if a class is a preview class (not a component itself)
-      #
-      # @param klass [Class]
-      # @return [Boolean]
-      def preview_class?(klass)
-        defined?(ViewComponent::Preview) && klass < ViewComponent::Preview
-      end
-
-      # Locate the source file for a component class.
-      #
-      # Convention paths first, then introspection via {#resolve_source_location}
-      # which filters out vendor/node_modules paths.
-      #
-      # @param component [Class]
-      # @return [String, nil]
-      def source_file_for(component)
-        possible_paths = [
-          Rails.root.join("app/components/#{component.name.underscore}.rb"),
-          Rails.root.join("app/views/components/#{component.name.underscore}.rb")
-        ]
-
-        found = possible_paths.find { |p| File.exist?(p) }
-        return found.to_s if found
-
-        resolve_source_location(component, app_root: Rails.root.to_s, fallback: nil)
-      end
-
-      # @param file_path [String, nil]
-      # @return [String]
-      def read_source(file_path)
-        return '' unless file_path && File.exist?(file_path)
-
-        File.read(file_path)
-      end
-
-      # ──────────────────────────────────────────────────────────────────────
-      # Metadata Extraction
-      # ──────────────────────────────────────────────────────────────────────
-
-      def extract_metadata(component, source)
-        {
-          slots: extract_slots(source),
-          initialize_params: extract_initialize_params(component),
-          public_methods: component.public_instance_methods(false),
-          parent_component: component.superclass.name,
-          sidecar_template: detect_sidecar_template(component),
-          preview_class: detect_preview_class(component),
-          collection_support: detect_collection_support(source),
-          callbacks: extract_callbacks(source),
-          content_areas: extract_content_areas(source),
-          renders_many: extract_renders_many(source),
-          renders_one: extract_renders_one(source),
-          loc: source.lines.count { |l| l.strip.length.positive? && !l.strip.start_with?('#') }
-        }
-      end
-
-      # Extract slot definitions from renders_one / renders_many
-      #
-      # @param source [String]
-      # @return [Array<Hash>]
-      def extract_slots(source)
-        slots = []
-
-        source.scan(/renders_one\s+:(\w+)(?:,\s*(\w+(?:::\w+)*))?/) do |name, klass|
-          slots << { name: name, type: :one, class: klass }
-        end
-
-        source.scan(/renders_many\s+:(\w+)(?:,\s*(\w+(?:::\w+)*))?/) do |name, klass|
-          slots << { name: name, type: :many, class: klass }
-        end
-
-        slots
-      end
-
-      def extract_renders_many(source)
-        source.scan(/renders_many\s+:(\w+)/).flatten
-      end
-
-      def extract_renders_one(source)
-        source.scan(/renders_one\s+:(\w+)/).flatten
-      end
-
-      # Extract initialize parameters to understand the component's data requirements
-      #
-      # @param component [Class]
-      # @return [Array<Hash>]
-      def extract_initialize_params(component)
-        method = component.instance_method(:initialize)
-        params = method.parameters
-
-        params.map do |type, name|
-          param_type = case type
-                       when :req then :required
-                       when :opt then :optional
-                       when :keyreq then :keyword_required
-                       when :key then :keyword_optional
-                       when :rest then :splat
-                       when :keyrest then :double_splat
-                       when :block then :block
-                       else type
-                       end
-          { name: name, type: param_type }
-        end
-      rescue StandardError
-        []
-      end
-
-      # Detect sidecar template file (.html.erb next to the .rb file)
-      #
-      # @param component [Class]
-      # @return [String, nil] Path to sidecar template if found
-      def detect_sidecar_template(component)
-        base_path = Rails.root.join("app/components/#{component.name.underscore}")
-
-        # Check common sidecar template patterns
-        candidates = [
-          "#{base_path}.html.erb",
-          "#{base_path}.html.haml",
-          "#{base_path}.html.slim",
-          "#{base_path}/#{component.name.demodulize.underscore}.html.erb"
-        ]
-
-        candidates.find { |path| File.exist?(path) }
-      rescue StandardError
-        nil
-      end
-
-      # Detect if a preview class exists for this component
-      #
-      # @param component [Class]
-      # @return [String, nil] Preview class name if found
-      def detect_preview_class(component)
-        return nil unless defined?(ViewComponent::Preview)
-
-        preview_name = "#{component.name}Preview"
-        klass = preview_name.safe_constantize
-        klass&.name if klass && klass < ViewComponent::Preview
-      rescue StandardError
-        nil
-      end
-
-      # Detect if the component supports collection rendering
-      #
-      # @param source [String]
-      # @return [Boolean]
-      def detect_collection_support(source)
-        source.match?(/with_collection_parameter/) ||
-          source.match?(/def\s+self\.collection_parameter/)
-      end
-
-      # Extract before_render / after_render callbacks
-      #
-      # @param source [String]
-      # @return [Array<Hash>]
-      def extract_callbacks(source)
-        callbacks = []
-
-        source.scan(/before_render\s+:(\w+)/) do |name|
-          callbacks << { kind: :before_render, method: name[0] }
-        end
-
-        source.scan(/after_render\s+:(\w+)/) do |name|
-          callbacks << { kind: :after_render, method: name[0] }
-        end
-
-        # Also detect inline before_render method override
-        callbacks << { kind: :before_render, method: :inline } if source.match?(/def\s+before_render\b/)
-
-        callbacks
-      end
-
-      # Extract legacy content_areas definitions
-      #
-      # @param source [String]
-      # @return [Array<String>]
-      def extract_content_areas(source)
-        source.scan(/with_content_areas\s+(.+)$/).flatten.flat_map do |area_list|
-          area_list.scan(/:(\w+)/).flatten
-        end
-      end
-
-      # ──────────────────────────────────────────────────────────────────────
-      # Dependency Extraction
-      # ──────────────────────────────────────────────────────────────────────
-
-      def extract_dependencies(component, source)
-        deps = []
-
-        # Other components rendered via render()
-        source.scan(/render\s*\(?\s*(\w+(?:::\w+)*)\.new/).flatten.uniq.each do |comp|
-          next if comp == component.name
-
-          deps << { type: :component, target: comp, via: :render }
-        end
-
-        # Components rendered via slot classes
-        source.scan(/renders_one\s+:\w+,\s*(\w+(?:::\w+)*)/).flatten.uniq.each do |comp|
-          deps << { type: :component, target: comp, via: :slot }
-        end
-
-        source.scan(/renders_many\s+:\w+,\s*(\w+(?:::\w+)*)/).flatten.uniq.each do |comp|
-          deps << { type: :component, target: comp, via: :slot }
-        end
-
-        # Model references
-        deps.concat(scan_model_dependencies(source, via: :data_dependency))
-
-        # Helper modules
-        source.scan(/include\s+(\w+Helper)/).flatten.uniq.each do |helper|
-          deps << { type: :helper, target: helper, via: :include }
-        end
-
-        # Stimulus controllers (from data-controller attributes in templates/source)
-        source.scan(/data[_-]controller[=:]\s*["']([^"']+)["']/).flatten.uniq.each do |controller|
-          deps << { type: :stimulus_controller, target: controller, via: :html_attribute }
-        end
-
-        # URL helpers
-        source.scan(/(\w+)_(?:path|url)/).flatten.uniq.each do |route|
-          deps << { type: :route, target: route, via: :url_helper }
-        end
-
-        deps.uniq { |d| [d[:type], d[:target]] }
-      end
-    end
-  end
-end