rails_lens 0.0.0 → 0.2.2

data/lib/rails_lens/file_insertion_helper.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Helper class to handle file insertion logic, particularly for inserting content
+  # after frozen_string_literal comments while maintaining proper formatting
+  class FileInsertionHelper
+    FROZEN_STRING_LITERAL_REGEX = /^# frozen_string_literal: true$/
+
+    class << self
+      # Insert content at a specific class definition location
+      #
+      # @param file_path [String] Path to the file
+      # @param class_name [String] Name of the class to find
+      # @param annotation [String] The annotation to insert
+      # @return [Boolean] Whether insertion was successful
+      def insert_at_class_definition(file_path, _class_name, annotation)
+        return false unless File.exist?(file_path)
+
+        content = File.read(file_path)
+
+        # First remove any existing annotations
+        content = Schema::Annotation.remove(content) if Schema::Annotation.extract(content)
+
+        modified_content = insert_after_frozen_string_literal(content, annotation)
+        File.write(file_path, modified_content)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Insert content at a specific line number
+      #
+      # @param file_path [String] Path to the file
+      # @param line_number [Integer] Line number where class is defined
+      # @param annotation [String] The annotation to insert
+      # @return [Boolean] Whether insertion was successful
+      def insert_at_line(file_path, line_number, annotation)
+        content = File.read(file_path)
+
+        # First remove any existing annotations
+        content = Schema::Annotation.remove(content) if Schema::Annotation.extract(content)
+
+        lines = content.split("\n", -1) # Preserve trailing newlines
+
+        # Find correct insertion point considering frozen_string_literal
+        insert_index = find_insertion_point_for_line(lines, line_number)
+
+        lines.insert(insert_index, annotation)
+
+        # Preserve original line ending
+        result = lines.join("\n")
+        result += "\n" if content.end_with?("\n") && !result.end_with?("\n")
+
+        File.write(file_path, result)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Insert content after frozen_string_literal comment with proper spacing
+      #
+      # @param content [String] The original file content
+      # @param insertion_content [String] The content to insert
+      # @return [String] The modified content
+      def insert_after_frozen_string_literal(content, insertion_content)
+        # First check if frozen_string_literal exists
+        unless content.match?(/^# frozen_string_literal: true/)
+          # If no frozen_string_literal, insert at the beginning with newline
+          return "#{insertion_content}\n#{content}"
+        end
+
+        lines = content.split("\n", -1) # Preserve empty lines
+        insert_index = find_frozen_string_literal_index(lines)
+
+        return content unless insert_index
+
+        # Ensure proper spacing after frozen_string_literal
+        insert_index = ensure_blank_line_after_frozen_literal(lines, insert_index)
+
+        # Insert the new content
+        lines.insert(insert_index, insertion_content)
+
+        # Preserve original line ending
+        result = lines.join("\n")
+        result += "\n" if content.end_with?("\n") && !result.end_with?("\n")
+
+        result
+      end
+
+      # Remove content that was inserted after frozen_string_literal
+      #
+      # @param content [String] The file content
+      # @param marker_start [String] Start marker to identify content to remove
+      # @param marker_end [String] End marker to identify content to remove
+      # @return [String] The content with insertion removed
+      def remove_after_frozen_string_literal(content, marker_start, marker_end)
+        # Use regex to remove the marked content
+        pattern = /^.*#{Regexp.escape(marker_start)}.*$\n(.*\n)*?^.*#{Regexp.escape(marker_end)}.*$\n/
+        content.gsub(pattern, '')
+      end
+
+      private
+
+      # Find the correct insertion point for a line, considering frozen_string_literal
+      #
+      # @param lines [Array<String>] Array of file lines
+      # @param line_number [Integer] Target line number (1-based)
+      # @return [Integer] Index where annotation should be inserted
+      def find_insertion_point_for_line(lines, line_number)
+        # Convert 1-based line number to 0-based index
+        target_index = line_number - 1
+
+        # Ensure target_index is within bounds
+        target_index = 0 if target_index.negative?
+        target_index = lines.length if target_index > lines.length
+
+        # Insert before the class definition line
+        insert_index = target_index
+
+        # If previous line is a comment (but not frozen_string_literal), insert before it
+        while insert_index.positive? &&
+              lines[insert_index - 1].strip.start_with?('#') &&
+              !lines[insert_index - 1].match?(FROZEN_STRING_LITERAL_REGEX)
+          insert_index -= 1
+        end
+
+        # Ensure we have a blank line before the annotation if needed
+        if insert_index.positive? && !lines[insert_index - 1].strip.empty?
+          lines.insert(insert_index, '')
+          insert_index += 1
+        end
+
+        insert_index
+      end
+
+      # Find the index of the frozen_string_literal line
+      #
+      # @param lines [Array<String>] Array of file lines
+      # @return [Integer, nil] Index after the frozen_string_literal line
+      def find_frozen_string_literal_index(lines)
+        lines.each_with_index do |line, index|
+          return index + 1 if line.match?(FROZEN_STRING_LITERAL_REGEX)
+        end
+        nil
+      end
+
+      # Ensure there's a blank line after frozen_string_literal
+      #
+      # @param lines [Array<String>] Array of file lines
+      # @param insert_index [Integer] Index where we want to insert
+      # @return [Integer] Updated insert index
+      def ensure_blank_line_after_frozen_literal(lines, insert_index)
+        if insert_index < lines.length && !lines[insert_index].strip.empty?
+          # No blank line exists, add one
+          lines.insert(insert_index, '')
+        elsif insert_index >= lines.length
+          # At end of file, add blank line
+          lines.insert(insert_index, '')
+        else
+          # There's already a blank line, move past it
+        end
+        insert_index += 1
+
+        insert_index
+      end
+    end
+  end
+end

data/lib/rails_lens/mailer/annotator.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Mailer
+    # Handles adding mailer annotations to mailer files
+    class Annotator
+      def initialize(dry_run: false)
+        @dry_run = dry_run
+        @mailers = RailsLens::Mailer::Extractor.call
+        @changed_files = []
+      end
+
+      # Annotate all mailer files with mailer information
+      #
+      # @param pattern [String] Glob pattern for mailer files
+      # @param exclusion [String] Glob pattern for files to exclude
+      # @return [Array<String>] List of changed files
+      def annotate_all(pattern: '**/*_mailer.rb', exclusion: 'vendor/**/*_mailer.rb')
+        # Simply annotate all mailer files we found via their source locations
+        source_paths_map.each do |source_path, methods|
+          # Skip vendor files or files matching exclusion pattern
+          next if exclusion && source_path.include?('vendor/')
+
+          annotate_file(path: source_path, methods: methods) if File.exist?(source_path)
+        end
+
+        @changed_files
+      end
+
+      # Remove mailer annotations from all mailer files
+      #
+      # @param pattern [String] Glob pattern for mailer files
+      # @param exclusion [String] Glob pattern for files to exclude
+      # @return [Array<String>] List of changed files
+      def remove_all(pattern: '**/*_mailer.rb', exclusion: 'vendor/**/*_mailer.rb')
+        # Remove annotations from all mailer files we found via their source locations
+        source_paths_map.each_key do |source_path|
+          # Skip vendor files or files matching exclusion pattern
+          next if exclusion && source_path.include?('vendor/')
+
+          remove_annotations_from_file(source_path) if File.exist?(source_path)
+        end
+
+        @changed_files
+      end
+
+      private
+
+      # Map source paths to their respective mailer methods
+      #
+      # @return [Hash] Source paths mapped to their methods
+      def source_paths_map
+        map = {}
+
+        @mailers.each_value do |methods|
+          methods.each do |method_name, method_info|
+            source_path = method_info[:source_path]
+            next unless source_path
+
+            map[source_path] ||= {}
+            map[source_path][method_name] = method_info
+          end
+        end
+
+        map
+      end
+
+      # Annotate a single mailer file
+      #
+      # @param path [String] Path to mailer file
+      # @param methods [Hash] Method data for the mailer
+      # @return [void]
+      def annotate_file(path:, methods:)
+        # First, remove any existing annotations
+        remove_annotations_from_file(path)
+
+        # Use our precise parser to find all mailer classes
+        parser_result = RailsLens::Parsers::PrismParser.parse_file(path)
+        mailer_classes = parser_result.classes.select { |cls| cls.name.end_with?('Mailer') }
+
+        # Collect all annotations for this file first (to handle multiple classes properly)
+        annotations_to_insert = []
+
+        # Annotate each mailer class individually
+        mailer_classes.each do |mailer_class|
+          # Find methods for this specific mailer class from the original @mailers data
+          class_methods = {}
+
+          # Look through all mailer classes to find methods for this specific class
+          @mailers.each do |mailer_class_name, mailer_methods|
+            next unless mailer_class_name == mailer_class.name || mailer_class_name == mailer_class.full_name
+
+            # Filter methods that are in this specific file
+            file_methods = mailer_methods.select do |_method_name, method_info|
+              method_info[:source_path] == path
+            end
+            class_methods.merge!(file_methods)
+          end
+
+          next if class_methods.empty?
+
+          # Get class-level information from first method
+          first_method = class_methods.values.first
+          next unless first_method
+
+          # Build class annotation
+          annotation_lines = []
+          annotation_lines << '# <rails-lens:mailers:begin>'
+
+          # Add delivery method
+          annotation_lines << "# DELIVERY_METHOD: #{first_method[:delivery_method]}" if first_method[:delivery_method]
+
+          # Add locales
+          annotation_lines << "# LOCALES: #{first_method[:locales].join(', ')}" if first_method[:locales]&.any?
+
+          # Add defaults
+          if first_method[:defaults]&.any?
+            defaults_strings = first_method[:defaults].map { |k, v| "#{k}: #{v}" }
+            annotation_lines << "# DEFAULTS: #{defaults_strings.join(', ')}"
+          end
+
+          annotation_lines << '# <rails-lens:mailers:end>'
+          annotation_block = annotation_lines.join("\n")
+
+          # Store annotation for batch processing
+          annotations_to_insert << {
+            class_name: mailer_class.name,
+            line_number: mailer_class.line_number,
+            annotation: annotation_block
+          }
+        end
+
+        # Insert all annotations in reverse line order (bottom to top) to preserve line numbers
+        annotations_to_insert.sort_by { |ann| -ann[:line_number] }.each do |annotation_info|
+          success = RailsLens::FileInsertionHelper.insert_at_class_definition(
+            path,
+            annotation_info[:class_name],
+            annotation_info[:annotation]
+          )
+
+          warn "Could not annotate #{annotation_info[:class_name]} in #{path}" unless success
+        end
+
+        # Add file to changed files list if any annotations were inserted
+        return unless annotations_to_insert.any?
+
+        @changed_files << path
+      end
+
+      # Remove annotations from a single file
+      #
+      # @param path [String] Path to mailer file
+      # @return [void]
+      def remove_annotations_from_file(path)
+        content = File.read(path)
+        original_content = content.dup
+
+        # Remove rails-lens mailer annotations
+        content.gsub!(/^.*<rails-lens:mailers:begin>.*$\n/, '')
+        content.gsub!(/^.*<rails-lens:mailers:end>.*$\n/, '')
+        content.gsub!(/^\s*#\s*== Mailer Information.*$\n/, '')
+        content.gsub!(/^\s*#\s*Templates:.*$\n/, '')
+        content.gsub!(/^\s*#\s*Formats:.*$\n/, '')
+        content.gsub!(/^\s*#\s*FORMATS:.*$\n/, '')
+        content.gsub!(/^\s*#\s*Delivery Method:.*$\n/, '')
+        content.gsub!(/^\s*#\s*DELIVERY_METHOD:.*$\n/, '')
+        content.gsub!(/^\s*#\s*Parameters:.*$\n/, '')
+        content.gsub!(/^\s*#\s*Locales:.*$\n/, '')
+        content.gsub!(/^\s*#\s*LOCALES:.*$\n/, '')
+        content.gsub!(/^\s*#\s*Defaults:.*$\n/, '')
+        content.gsub!(/^\s*#\s*DEFAULTS:.*$\n/, '')
+
+        return unless content != original_content
+
+        write_content_to_file(path: path, content: content)
+      end
+
+      # Extract formats from template filenames
+      #
+      # @param templates [Array<String>] Template filenames
+      # @return [Array<String>] Extracted formats
+      def extract_formats_from_templates(templates)
+        formats = []
+
+        templates.each do |template|
+          # Extract format from filename like "method_name.html.erb" or "method_name.text.erb"
+          parts = template.split('.')
+          if parts.length >= 2
+            format = parts[-2] # Get the format part (html, text, etc.)
+            formats << format unless formats.include?(format)
+          end
+        end
+
+        formats.sort
+      end
+
+      # Write content to file
+      #
+      # @param path [String] File path
+      # @param content [String] File content
+      # @return [void]
+      def write_content_to_file(path:, content:)
+        return if @dry_run
+
+        File.write(path, content)
+        @changed_files << path
+      end
+
+      # Check if a mailer file exists and contains mailer classes
+      #
+      # @param path [String] File path
+      # @return [Boolean] Whether file exists and contains mailer classes
+      def mailer_file_exists?(path)
+        return false unless File.exist?(path)
+
+        begin
+          parser_result = RailsLens::Parsers::PrismParser.parse_file(path)
+          parser_result.classes.any? { |cls| cls.name.end_with?('Mailer') }
+        rescue RailsLens::ParseError, Errno::ENOENT, IOError
+          # Fallback to filename-based detection
+          File.basename(path).end_with?('_mailer.rb')
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/mailer/extractor.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Mailer
+    # Handles extracting mailer information from Rails application
+    class Extractor
+      class << self
+        # Extract all mailer information from Rails application
+        #
+        # @return [Hash] Mailer information organized by mailer class and method
+        def call
+          # Check if ActionMailer is available
+          return {} unless defined?(ActionMailer::Base)
+
+          mailers = {}
+
+          find_mailer_classes.each do |mailer_class|
+            mailer_info = extract_mailer_info(mailer_class)
+            next if mailer_info.empty?
+
+            mailers[mailer_class.name] = mailer_info
+          end
+
+          mailers
+        end
+
+        private
+
+        # Find all mailer classes in the application
+        #
+        # @return [Array<Class>] Array of mailer classes
+        def find_mailer_classes
+          return [] unless defined?(ActionMailer::Base)
+
+          # Find all classes that inherit from ActionMailer::Base
+          # No need to load files - they should already be loaded
+          mailer_classes = []
+
+          ObjectSpace.each_object(Class) do |klass|
+            mailer_classes << klass if klass < ActionMailer::Base && klass != ActionMailer::Base
+          end
+
+          mailer_classes
+        end
+
+        # Extract information for a single mailer class
+        #
+        # @param mailer_class [Class] Mailer class to analyze
+        # @return [Hash] Mailer information
+        def extract_mailer_info(mailer_class)
+          mailer_info = {}
+
+          # Get mailer methods (exclude inherited ActionMailer methods)
+          mailer_methods = mailer_class.instance_methods(false)
+
+          mailer_methods.each do |method_name|
+            method_info = extract_method_info(mailer_class, method_name)
+            next if method_info.empty?
+
+            mailer_info[method_name.to_s] = method_info
+          end
+
+          mailer_info
+        end
+
+        # Extract information for a single mailer method
+        #
+        # @param mailer_class [Class] Mailer class
+        # @param method_name [Symbol] Method name
+        # @return [Hash] Method information
+        def extract_method_info(mailer_class, method_name)
+          method_info = {}
+
+          # Get method source location
+          method_obj = mailer_class.instance_method(method_name)
+          source_location = method_obj.source_location
+          return {} unless source_location
+
+          method_info[:source_path] = source_location[0]
+          method_info[:line_number] = source_location[1]
+          method_info[:class_name] = mailer_class.name
+
+          # Extract templates
+          method_info[:templates] = find_templates(mailer_class, method_name)
+
+          # Extract delivery method
+          method_info[:delivery_method] = extract_delivery_method(mailer_class)
+
+          # Extract method parameters
+          method_info[:parameters] = extract_method_parameters(method_obj)
+
+          # Extract locales (from template files)
+          method_info[:locales] = extract_locales(mailer_class, method_name)
+
+          # Extract default values
+          method_info[:defaults] = extract_defaults(mailer_class)
+
+          method_info
+        end
+
+        # Find template files for a mailer method
+        #
+        # @param mailer_class [Class] Mailer class
+        # @param method_name [Symbol] Method name
+        # @return [Array<String>] Template file names
+        def find_templates(mailer_class, method_name)
+          templates = []
+          mailer_name = mailer_class.name.underscore
+
+          # Look for templates in app/views/mailer_name/
+          template_dir = Rails.root.join("app/views/#{mailer_name}")
+          return templates unless File.directory?(template_dir)
+
+          Dir.glob(template_dir.join("#{method_name}.*")).each do |template_path|
+            templates << File.basename(template_path)
+          end
+
+          templates.sort
+        end
+
+        # Extract delivery method configuration
+        #
+        # @param mailer_class [Class] Mailer class
+        # @return [String] Delivery method name
+        def extract_delivery_method(mailer_class)
+          delivery_method = mailer_class.delivery_method
+          delivery_method ? delivery_method.to_s : 'smtp'
+        end
+
+        # Extract method parameters
+        #
+        # @param method_obj [Method] Method object
+        # @return [Array<Hash>] Parameter information
+        def extract_method_parameters(method_obj)
+          parameters = []
+
+          method_obj.parameters.each do |param_type, param_name|
+            param_info = {
+              name: param_name.to_s,
+              type: param_type.to_s
+            }
+
+            parameters << param_info
+          end
+
+          parameters
+        end
+
+        # Extract available locales for a mailer method
+        #
+        # @param mailer_class [Class] Mailer class
+        # @param method_name [Symbol] Method name
+        # @return [Array<String>] Available locales
+        def extract_locales(mailer_class, method_name)
+          locales = []
+          mailer_name = mailer_class.name.underscore
+
+          # Look for locale-specific templates
+          template_dir = Rails.root.join("app/views/#{mailer_name}")
+          return locales unless File.directory?(template_dir)
+
+          Dir.glob(template_dir.join("#{method_name}.*.erb")).each do |template_path|
+            basename = File.basename(template_path, '.erb')
+            parts = basename.split('.')
+
+            # Extract locale from filename like "method_name.en.html.erb"
+            if parts.length > 2
+              locale = parts[1]
+              locales << locale unless locales.include?(locale)
+            end
+          end
+
+          locales.empty? ? ['en'] : locales.sort
+        end
+
+        # Extract default mailer settings
+        #
+        # @param mailer_class [Class] Mailer class
+        # @return [Hash] Default settings
+        def extract_defaults(mailer_class)
+          defaults = {}
+
+          # Extract default from
+          if mailer_class.respond_to?(:default) && mailer_class.default[:from]
+            defaults[:from] = mailer_class.default[:from]
+          end
+
+          # Extract default reply_to
+          if mailer_class.respond_to?(:default) && mailer_class.default[:reply_to]
+            defaults[:reply_to] = mailer_class.default[:reply_to]
+          end
+
+          # Extract layout
+          defaults[:layout] = mailer_class._layout if mailer_class.respond_to?(:_layout) && mailer_class._layout
+
+          defaults
+        end
+      end
+    end
+  end
+end