woods 1.0.0

data/lib/woods/extractors/validator_extractor.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative 'shared_utility_methods'
+require_relative 'shared_dependency_scanner'
+
+module Woods
+  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/woods/extractors/view_component_extractor.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require_relative 'shared_utility_methods'
+require_relative 'shared_dependency_scanner'
+
+module Woods
+  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