woods 1.0.0

data/lib/woods/extractors/concern_extractor.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require_relative 'shared_utility_methods'
+require_relative 'shared_dependency_scanner'
+
+module Woods
+  module Extractors
+    # ConcernExtractor handles ActiveSupport::Concern module extraction.
+    #
+    # Concerns are mixins that extend model and controller behavior.
+    # They live in `app/models/concerns/` and `app/controllers/concerns/`,
+    # as well as nested directories like `app/models/gateway/stripe/concerns/`.
+    #
+    # We extract:
+    # - Module name and namespace
+    # - Included/extended hooks and class methods block
+    # - Instance methods and class methods added by the concern
+    # - Dependencies on models and other concerns
+    #
+    # @example
+    #   extractor = ConcernExtractor.new
+    #   units = extractor.extract_all
+    #   searchable = units.find { |u| u.identifier == "Searchable" }
+    #
+    class ConcernExtractor
+      include SharedUtilityMethods
+      include SharedDependencyScanner
+
+      # Canonical concern directories (used as fallback if glob finds nothing).
+      CONCERN_DIRECTORIES = %w[
+        app/models/concerns
+        app/controllers/concerns
+      ].freeze
+
+      def initialize
+        # Discover all concerns/ directories under app/, including deeply nested ones
+        # like app/models/gateway/stripe/webhook/concerns/.
+        @directories = Dir[Rails.root.join('app/**/concerns')].map { |d| Pathname.new(d) }
+                                                              .select(&:directory?)
+        # Fall back to canonical directories if glob finds nothing.
+        return unless @directories.empty?
+
+        @directories = CONCERN_DIRECTORIES.map { |d| Rails.root.join(d) }
+                                          .select(&:directory?)
+      end
+
+      # Extract all concern modules
+      #
+      # @return [Array<ExtractedUnit>] List of concern units
+      def extract_all
+        @directories.flat_map do |dir|
+          Dir[dir.join('**/*.rb')].filter_map do |file|
+            extract_concern_file(file)
+          end
+        end
+      end
+
+      # Extract a single concern file
+      #
+      # @param file_path [String] Path to the concern file
+      # @return [ExtractedUnit, nil] The extracted unit or nil if not a concern
+      def extract_concern_file(file_path)
+        source = File.read(file_path)
+        module_name = extract_module_name(file_path, source)
+
+        return nil unless module_name
+        return nil unless concern_module?(source)
+
+        unit = ExtractedUnit.new(
+          type: :concern,
+          identifier: module_name,
+          file_path: file_path
+        )
+
+        unit.namespace = extract_namespace(module_name)
+        unit.source_code = annotate_source(source, module_name)
+        unit.metadata = extract_metadata(source, file_path)
+        unit.dependencies = extract_dependencies(source)
+
+        unit
+      rescue StandardError => e
+        Rails.logger.error("Failed to extract concern #{file_path}: #{e.message}")
+        nil
+      end
+
+      private
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Module Discovery
+      # ──────────────────────────────────────────────────────────────────────
+
+      # Extract the module name from source or infer from file path.
+      #
+      # @param file_path [String] Path to the concern file
+      # @param source [String] Ruby source code
+      # @return [String, nil] The module name
+      def extract_module_name(file_path, source)
+        # Try to find the outermost module definition
+        modules = source.scan(/^\s*module\s+([\w:]+)/).flatten
+        return modules.last if modules.any?
+
+        # Infer from file path — strip everything up to and including the first concerns/ dir.
+        # Handles canonical (app/models/concerns/) and nested (app/models/foo/concerns/) paths.
+        relative = file_path.sub("#{Rails.root}/", '')
+        relative
+          .sub(%r{^app/.*?/concerns/}, '')
+          .sub('.rb', '')
+          .split('/')
+          .map { |segment| segment.split('_').map(&:capitalize).join }
+          .join('::')
+      end
+
+      # Detect whether source defines an ActiveSupport::Concern or a plain mixin.
+      #
+      # @param source [String] Ruby source code
+      # @return [Boolean]
+      def concern_module?(source)
+        # ActiveSupport::Concern usage or plain module with methods
+        source.match?(/^\s*module\s+/) &&
+          (source.match?(/extend\s+ActiveSupport::Concern/) ||
+           source.match?(/included\s+do/) ||
+           source.match?(/class_methods\s+do/) ||
+           source.match?(/def\s+\w+/))
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Source Annotation
+      # ──────────────────────────────────────────────────────────────────────
+
+      # @param source [String] Ruby source code
+      # @param module_name [String] The concern module name
+      # @return [String] Annotated source
+      def annotate_source(source, module_name)
+        concern_type = detect_concern_type(source)
+        instance_methods = extract_instance_method_names(source)
+
+        <<~ANNOTATION
+          # ╔═══════════════════════════════════════════════════════════════════════╗
+          # ║ Concern: #{module_name.ljust(59)}║
+          # ║ Type: #{concern_type.ljust(62)}║
+          # ║ Methods: #{instance_methods.join(', ').ljust(59)}║
+          # ╚═══════════════════════════════════════════════════════════════════════╝
+
+          #{source}
+        ANNOTATION
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Metadata Extraction
+      # ──────────────────────────────────────────────────────────────────────
+
+      # @param source [String] Ruby source code
+      # @param file_path [String] Path to the concern file
+      # @return [Hash] Concern metadata
+      def extract_metadata(source, file_path)
+        {
+          concern_type: detect_concern_type(source),
+          concern_scope: detect_concern_scope(file_path),
+          uses_active_support: source.match?(/extend\s+ActiveSupport::Concern/),
+          has_included_block: source.match?(/included\s+do/) || false,
+          has_class_methods_block: source.match?(/class_methods\s+do/) || false,
+          included_modules: detect_included_modules(source),
+          instance_methods: extract_instance_method_names(source),
+          class_methods: extract_class_methods(source),
+          public_methods: extract_public_methods(source),
+          callbacks_defined: detect_callbacks(source),
+          scopes_defined: detect_scopes(source),
+          validations_defined: detect_validations(source),
+          loc: source.lines.count { |l| l.strip.length.positive? && !l.strip.start_with?('#') },
+          method_count: source.scan(/def\s+(?:self\.)?\w+/).size
+        }
+      end
+
+      # Detect whether this is a model concern, controller concern, or generic.
+      #
+      # @param source [String] Ruby source code
+      # @return [String] One of "active_support", "plain_mixin"
+      def detect_concern_type(source)
+        if source.match?(/extend\s+ActiveSupport::Concern/)
+          'active_support'
+        else
+          'plain_mixin'
+        end
+      end
+
+      # Detect concern scope from file path (model vs controller).
+      #
+      # @param file_path [String] Path to the concern file
+      # @return [String] One of "model", "controller", "unknown"
+      def detect_concern_scope(file_path)
+        if file_path.include?('app/models/')
+          'model'
+        elsif file_path.include?('app/controllers/')
+          'controller'
+        else
+          'unknown'
+        end
+      end
+
+      # Extract instance method names (not self. methods).
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Instance method names
+      def extract_instance_method_names(source)
+        source.scan(/^\s*def\s+(\w+[?!=]?)/).flatten.reject { |m| m.start_with?('self.') }
+      end
+
+      # Detect other modules included or extended by this concern (for metadata display).
+      #
+      # Returns all module names found in include/extend calls, excluding
+      # ActiveSupport::Concern itself.
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Module names
+      def detect_included_modules(source)
+        source.scan(/(?:include|extend)\s+([\w:]+)/).flatten
+              .reject { |m| m == 'ActiveSupport::Concern' }
+      end
+
+      # Detect modules explicitly included by this concern.
+      #
+      # Scans for bare +include ModuleName+ calls, excluding ActiveSupport::Concern.
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Included module names
+      def detect_includes(source)
+        source.scan(/\binclude\s+([\w:]+)/).flatten
+              .reject { |m| m == 'ActiveSupport::Concern' }
+      end
+
+      # Detect modules explicitly extended by this concern.
+      #
+      # Scans for bare +extend ModuleName+ calls, excluding ActiveSupport::Concern.
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Extended module names
+      def detect_extends(source)
+        source.scan(/\bextend\s+([\w:]+)/).flatten
+              .reject { |m| m == 'ActiveSupport::Concern' }
+      end
+
+      # Detect callback declarations.
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Callback names
+      def detect_callbacks(source)
+        source.scan(/(before_\w+|after_\w+|around_\w+)\s/).flatten.uniq
+      end
+
+      # Detect scope declarations.
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Scope names
+      def detect_scopes(source)
+        source.scan(/scope\s+:(\w+)/).flatten
+      end
+
+      # Detect validation declarations.
+      #
+      # @param source [String] Ruby source code
+      # @return [Array<String>] Validation types
+      def detect_validations(source)
+        source.scan(/(validates?(?:_\w+)?)\s/).flatten.uniq
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Dependency Extraction
+      # ──────────────────────────────────────────────────────────────────────
+
+      # @param source [String] Ruby source code
+      # @return [Array<Hash>] Dependency hashes
+      def extract_dependencies(source)
+        # Concerns included by this concern (add instance-level behavior)
+        deps = detect_includes(source).map do |mod|
+          { type: :concern, target: mod, via: :include }
+        end
+
+        # Concerns extended by this concern (add class-level behavior)
+        detect_extends(source).each do |mod|
+          deps << { type: :concern, target: mod, via: :extend }
+        end
+
+        # Standard dependency scanning
+        deps.concat(scan_model_dependencies(source))
+        deps.concat(scan_service_dependencies(source))
+        deps.concat(scan_job_dependencies(source))
+
+        deps.uniq { |d| [d[:type], d[:target]] }
+      end
+    end
+  end
+end

data/lib/woods/extractors/configuration_extractor.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'shared_utility_methods'
+require_relative 'shared_dependency_scanner'
+require_relative 'behavioral_profile'
+
+module Woods
+  module Extractors
+    # ConfigurationExtractor handles Rails configuration file extraction.
+    #
+    # Scans `config/initializers/` and `config/environments/` for Ruby
+    # configuration files. Each file becomes one ExtractedUnit with metadata
+    # about config type, gem references, and detected settings.
+    #
+    # @example
+    #   extractor = ConfigurationExtractor.new
+    #   units = extractor.extract_all
+    #   devise = units.find { |u| u.identifier == "initializers/devise.rb" }
+    #
+    class ConfigurationExtractor
+      include SharedUtilityMethods
+      include SharedDependencyScanner
+
+      # Directories to scan for configuration files
+      CONFIG_DIRECTORIES = %w[
+        config/initializers
+        config/environments
+      ].freeze
+
+      def initialize
+        @directories = CONFIG_DIRECTORIES.map { |d| Rails.root.join(d) }
+                                         .select(&:directory?)
+      end
+
+      # Extract all configuration files and the behavioral profile.
+      #
+      # @return [Array<ExtractedUnit>] List of configuration units
+      def extract_all
+        units = @directories.flat_map do |dir|
+          Dir[dir.join('**/*.rb')].filter_map do |file|
+            extract_configuration_file(file)
+          end
+        end
+
+        profile = BehavioralProfile.new.extract
+        units << profile if profile
+
+        units
+      rescue StandardError => e
+        Rails.logger.error("BehavioralProfile integration failed: #{e.message}")
+        units || []
+      end
+
+      # Extract a single configuration file
+      #
+      # @param file_path [String] Path to the configuration file
+      # @return [ExtractedUnit, nil] The extracted unit or nil on failure
+      def extract_configuration_file(file_path)
+        source = File.read(file_path)
+        identifier = build_identifier(file_path)
+        config_type = detect_config_type(file_path)
+
+        unit = ExtractedUnit.new(
+          type: :configuration,
+          identifier: identifier,
+          file_path: file_path
+        )
+
+        unit.namespace = config_type
+        unit.source_code = annotate_source(source, identifier, config_type)
+        unit.metadata = extract_metadata(source, config_type)
+        unit.dependencies = extract_dependencies(source)
+
+        unit
+      rescue StandardError => e
+        Rails.logger.error("Failed to extract configuration #{file_path}: #{e.message}")
+        nil
+      end
+
+      private
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Identification
+      # ──────────────────────────────────────────────────────────────────────
+
+      # Build a readable identifier from the file path.
+      #
+      # @param file_path [String]
+      # @return [String] e.g., "initializers/devise.rb" or "environments/production.rb"
+      def build_identifier(file_path)
+        relative = file_path.sub("#{Rails.root}/", '')
+        relative.sub(%r{^config/}, '')
+      end
+
+      # Detect whether this is an initializer or environment config.
+      #
+      # @param file_path [String]
+      # @return [String]
+      def detect_config_type(file_path)
+        if file_path.include?('config/initializers')
+          'initializer'
+        elsif file_path.include?('config/environments')
+          'environment'
+        else
+          'configuration'
+        end
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Source Annotation
+      # ──────────────────────────────────────────────────────────────────────
+
+      # @param source [String]
+      # @param identifier [String]
+      # @param config_type [String]
+      # @return [String]
+      def annotate_source(source, identifier, config_type)
+        gem_refs = detect_gem_references(source)
+
+        <<~ANNOTATION
+          # ╔═══════════════════════════════════════════════════════════════════════╗
+          # ║ Configuration: #{identifier.ljust(53)}║
+          # ║ Type: #{config_type.ljust(62)}║
+          # ║ Gems: #{gem_refs.join(', ').ljust(62)}║
+          # ╚═══════════════════════════════════════════════════════════════════════╝
+
+          #{source}
+        ANNOTATION
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Metadata Extraction
+      # ──────────────────────────────────────────────────────────────────────
+
+      # @param source [String]
+      # @param config_type [String]
+      # @return [Hash]
+      def extract_metadata(source, config_type)
+        {
+          config_type: config_type,
+          gem_references: detect_gem_references(source),
+          config_settings: detect_config_settings(source),
+          rails_config_blocks: detect_rails_config_blocks(source),
+          loc: source.lines.count { |l| l.strip.length.positive? && !l.strip.start_with?('#') },
+          method_count: source.scan(/def\s+(?:self\.)?\w+/).size
+        }
+      end
+
+      # Detect gem/library references in configuration.
+      #
+      # @param source [String]
+      # @return [Array<String>]
+      def detect_gem_references(source)
+        refs = []
+
+        # Gem.configure style: Devise.setup, Sidekiq.configure_server
+        source.scan(/(\w+)\.(setup|configure\w*|config)\b/).each do |match|
+          name = match[0]
+          refs << name unless generic_config_name?(name)
+        end
+
+        # require statements for gems
+        source.scan(/require\s+['"]([^'"]+)['"]/).each do |match|
+          refs << match[0]
+        end
+
+        refs.uniq
+      end
+
+      # Detect configuration settings (key = value patterns).
+      #
+      # @param source [String]
+      # @return [Array<String>]
+      def detect_config_settings(source)
+        # config.something = value
+        settings = source.scan(/config\.(\w+(?:\.\w+)*)\s*=/).map { |match| match[0] }
+
+        # self.something = value (inside configure blocks)
+        settings.concat(source.scan(/(?:self|config)\.(\w+)\s*=/).map { |match| match[0] })
+
+        settings.uniq
+      end
+
+      # Detect Rails.application.configure or similar blocks.
+      #
+      # @param source [String]
+      # @return [Array<String>]
+      def detect_rails_config_blocks(source)
+        source.scan(/(Rails\.application\.configure|Rails\.application\.config\.\w+)/)
+              .map { |match| match[0] }
+              .uniq
+      end
+
+      # Check if a name is too generic to be a gem reference.
+      #
+      # @param name [String]
+      # @return [Boolean]
+      def generic_config_name?(name)
+        %w[Rails ActiveRecord ActiveJob ActionMailer ActionController ActiveStorage ActionCable].include?(name)
+      end
+
+      # ──────────────────────────────────────────────────────────────────────
+      # Dependency Extraction
+      # ──────────────────────────────────────────────────────────────────────
+
+      # @param source [String]
+      # @return [Array<Hash>]
+      def extract_dependencies(source)
+        deps = detect_gem_references(source).map do |gem_ref|
+          { type: :gem, target: gem_ref, via: :configuration }
+        end
+
+        deps.concat(scan_service_dependencies(source))
+
+        deps.uniq { |d| [d[:type], d[:target]] }
+      end
+    end
+  end
+end