prism-merge 1.0.3 → 1.1.0

data/lib/prism/merge/file_analysis.rb

@@ -1,120 +1,86 @@
 # frozen_string_literal: true
 
-require "prism"
-
 module Prism
   module Merge
-    # Comprehensive metadata capture for a Ruby file being merged.
-    # Tracks Prism parse result, line-to-node mapping, comment associations,
-    # structural signatures, and sequential anchor lines for merge alignment.
+    # Simplified file analysis using Prism's native comment attachment.
+    # This version leverages parse_result.attach_comments! to automatically
+    # attach comments to nodes, eliminating the need for manual comment tracking
+    # and the CommentNode class.
+    #
+    # Key improvements over V1:
+    # - Uses Prism's native node.location.leading_comments and trailing_comments
+    # - No manual comment tracking or CommentNode class
+    # - Simpler freeze block extraction via comment scanning
+    # - Better performance (one attach_comments! call vs multiple iterations)
+    # - Enhanced freeze block validation (detects partial nodes and non-class/module contexts)
     class FileAnalysis
-      # Regex pattern for freeze block start marker.
-      # Matches comments like: # kettle-dev:freeze
-      # Case-insensitive to allow variations like FREEZE or Freeze
-      FREEZE_START = /#\s*kettle-dev:freeze/i
-
-      # Regex pattern for freeze block end marker.
-      # Matches comments like: # kettle-dev:unfreeze
-      # Case-insensitive to allow variations like UNFREEZE or Unfreeze
-      FREEZE_END = /#\s*kettle-dev:unfreeze/i
-
-      # Combined regex pattern for matching complete freeze blocks.
-      # Captures content between freeze/unfreeze markers (inclusive).
-      # Used to identify sections that should always be preserved from destination.
+      # Default freeze token for identifying freeze blocks
+      DEFAULT_FREEZE_TOKEN = "prism-merge"
+
+      # @return [Prism::ParseResult] The parse result from Prism
+      attr_reader :parse_result
+
+      # @return [String] Source code content
+      attr_reader :source
+
+      # @return [Array<String>] Lines of source code
+      attr_reader :lines
+
+      # @return [String] Token used to mark freeze blocks
+      attr_reader :freeze_token
+
+      # @return [Proc, nil] Custom signature generator
+      attr_reader :signature_generator
+
+      # Initialize file analysis with Prism's native comment handling
       #
-      # @example Freeze block in Ruby code
-      #   # kettle-dev:freeze
-      #   CUSTOM_CONFIG = { key: "secret" }
-      #   # kettle-dev:unfreeze
-      FREEZE_BLOCK = Regexp.new("(#{FREEZE_START.source}).*?(#{FREEZE_END.source})", Regexp::IGNORECASE | Regexp::MULTILINE)
-
-      attr_reader :content, :parse_result, :lines, :statements, :freeze_blocks
-
-      # @param content [String] Ruby source code to analyze
-      # @param signature_generator [Proc, nil] Optional proc to generate node signatures
-      def initialize(content, signature_generator: nil)
-        @content = content
-        @lines = content.lines
-        @parse_result = Prism.parse(content)
-        @statements = extract_statements
-        @freeze_blocks = extract_freeze_blocks
+      # @param source [String] Ruby source code to analyze
+      # @param freeze_token [String] Token for freeze block markers (default: "prism-merge")
+      # @param signature_generator [Proc, nil] Custom signature generator
+      def initialize(source, freeze_token: DEFAULT_FREEZE_TOKEN, signature_generator: nil)
+        @source = source
+        @lines = source.lines
+        @freeze_token = freeze_token
         @signature_generator = signature_generator
-        @line_to_node_map = nil
-        @node_to_line_map = nil
-        @comment_map = nil
-      end
+        @parse_result = Prism.parse(source)
 
-      # Check if parsing was successful
-      # @return [Boolean]
-      def valid?
-        @parse_result.success?
-      end
+        # Use Prism's native comment attachment
+        # On JRuby, the Comments class may not be loaded yet, so we need to require it
+        attach_comments_safely!
 
-      # Get all top-level statement nodes
-      # @return [Array<Prism::Node>]
-      def extract_statements
-        return [] unless valid?
-        body = @parse_result.value.statements
-        return [] unless body
+        # Extract and validate structure
+        @statements = extract_and_integrate_all_nodes
 
-        if body.is_a?(Prism::StatementsNode)
-          body.body.compact
-        else
-          [body].compact
-        end
+        DebugLogger.debug("FileAnalysis initialized", {
+          signature_generator: signature_generator ? "custom" : "default",
+          statements_count: @statements.size,
+          freeze_blocks: freeze_blocks.size,
+        }) if defined?(DebugLogger)
       end
 
-      # Extract freeze block information
-      # @return [Array<Hash>] Array of freeze block metadata
-      def extract_freeze_blocks
-        return [] unless content.match?(FREEZE_START)
-
-        blocks = []
-        content.to_enum(:scan, FREEZE_BLOCK).each do
-          match = Regexp.last_match
-          next unless match
-
-          start_idx = match.begin(0)
-          end_idx = match.end(0)
-          segment = match[0]
-          start_line = content[0...start_idx].count("\n") + 1
-          end_line = content[0...end_idx].count("\n") + 1
-
-          blocks << {
-            range: start_idx...end_idx,
-            line_range: start_line..end_line,
-            text: segment,
-            start_marker: segment&.lines&.first&.strip,
-          }
-        end
-
-        blocks
+      # Check if parse was successful
+      # @return [Boolean]
+      def valid?
+        @parse_result.success?
       end
 
-      # Build mapping from line numbers to AST nodes
-      # @return [Hash<Integer, Array<Prism::Node>>] Line number => nodes on that line
-      def line_to_node_map
-        @line_to_node_map ||= build_line_to_node_map
-      end
+      # Get all statements (code nodes outside freeze blocks + FreezeNodes)
+      # @return [Array<Prism::Node, FreezeNode>]
+      attr_reader :statements
 
-      # Build mapping from nodes to line ranges
-      # @return [Hash<Prism::Node, Range>] Node => line range
-      def node_to_line_map
-        @node_to_line_map ||= build_node_to_line_map
+      # Get freeze blocks
+      # @return [Array<FreezeNode>]
+      def freeze_blocks
+        @statements.select { |node| node.is_a?(FreezeNode) }
       end
 
       # Get nodes with their associated comments and metadata
+      # Comments are now accessed via Prism's native node.location API
       # @return [Array<Hash>] Array of node info hashes
       def nodes_with_comments
         @nodes_with_comments ||= extract_nodes_with_comments
       end
 
-      # Get comment map by line number
-      # @return [Hash<Integer, Array<Prism::Comment>>] Line number => comments
-      def comment_map
-        @comment_map ||= build_comment_map
-      end
-
       # Get structural signature for a statement at given index
       # @param index [Integer] Statement index
       # @return [Array, nil] Signature array
@@ -127,25 +93,33 @@ module Prism
       # @param node [Prism::Node] Node to generate signature for
       # @return [Array, nil] Signature array
       def generate_signature(node)
-        if @signature_generator
+        result = if @signature_generator
           @signature_generator.call(node)
         else
-          default_signature(node)
+          compute_node_signature(node)
         end
+
+        DebugLogger.debug("Generated signature", {
+          node_type: node.class.name.split("::").last,
+          signature: result,
+          generator: @signature_generator ? "custom" : "default",
+        }) if defined?(DebugLogger) && result
+
+        result
       end
 
       # Check if a line is within a freeze block
       # @param line_num [Integer] 1-based line number
       # @return [Boolean]
       def in_freeze_block?(line_num)
-        freeze_blocks.any? { |block| block[:line_range].cover?(line_num) }
+        freeze_blocks.any? { |freeze_node| freeze_node.location.cover?(line_num) }
       end
 
       # Get the freeze block containing the given line, if any
       # @param line_num [Integer] 1-based line number
-      # @return [Hash, nil] Freeze block metadata or nil
+      # @return [FreezeNode, nil] Freeze block node or nil
       def freeze_block_at(line_num)
-        freeze_blocks.find { |block| block[:line_range].cover?(line_num) }
+        freeze_blocks.find { |freeze_node| freeze_node.location.cover?(line_num) }
       end
 
       # Get normalized line content (stripped)
@@ -166,131 +140,228 @@ module Prism
 
       private
 
-      def build_line_to_node_map
-        map = Hash.new { |h, k| h[k] = [] }
-        return map unless valid?
-
-        statements.each do |node|
-          start_line = node.location.start_line
-          end_line = node.location.end_line
-          (start_line..end_line).each do |line_num|
-            map[line_num] << node
-          end
+      # Safely attach comments to nodes, handling JRuby compatibility issues
+      # On JRuby, the Prism::ParseResult::Comments class may not be autoloaded,
+      # so we need to explicitly require it
+      def attach_comments_safely!
+        @parse_result.attach_comments!
+      rescue NameError => e
+        if e.message.include?("Comments")
+          # On JRuby, the Comments class needs to be explicitly required
+          require "prism/parse_result/comments"
+          @parse_result.attach_comments!
+        else
+          raise
         end
-
-        map
       end
 
-      def build_node_to_line_map
-        map = {}
-        return map unless valid?
+      # Extract all nodes: freeze blocks + statements outside freeze blocks
+      # @return [Array<Prism::Node, FreezeNode>]
+      def extract_and_integrate_all_nodes
+        return [] unless valid?
 
-        statements.each do |node|
-          map[node] = node.location.start_line..node.location.end_line
+        body = @parse_result.value.statements
+        base_statements = if body.nil?
+          []
+        elsif body.is_a?(Prism::StatementsNode)
+          body.body.compact
+        else
+          [body].compact
         end
 
-        map
-      end
+        # Extract freeze blocks by scanning comments for markers
+        freeze_nodes = extract_freeze_nodes(base_statements)
 
-      def extract_nodes_with_comments
-        return [] unless valid?
+        # Filter out statements inside freeze blocks
+        statements_outside_freeze = filter_statements_outside_freeze(base_statements, freeze_nodes)
 
-        statements.map.with_index do |stmt, idx|
-          prev_stmt = (idx > 0) ? statements[idx - 1] : nil
-          body_node = @parse_result.value.statements
-
-          {
-            node: stmt,
-            index: idx,
-            leading_comments: find_leading_comments(stmt, prev_stmt, body_node),
-            inline_comments: inline_comments_for_node(stmt),
-            signature: generate_signature(stmt),
-            line_range: stmt.location.start_line..stmt.location.end_line,
-          }
+        # Combine and sort by line number
+        all_nodes = (statements_outside_freeze + freeze_nodes).sort_by do |node|
+          node.location.start_line
         end
+
+        all_nodes
       end
 
-      def find_leading_comments(current_stmt, prev_stmt, body_node)
-        start_line = prev_stmt ? prev_stmt.location.end_line : 0
-        end_line = current_stmt.location.start_line
+      # Extract freeze blocks by scanning for freeze/unfreeze markers in comments
+      # @param statements [Array<Prism::Node>] Base AST statements
+      # @return [Array<FreezeNode>] Freeze block nodes
+      def extract_freeze_nodes(statements)
+        # Skip freeze node extraction if no freeze token is configured
+        return [] unless @freeze_token
+
+        freeze_blocks = []
+        freeze_start_line = nil
+        freeze_start_pattern = /#\s*#{Regexp.escape(@freeze_token)}:freeze/i
+        freeze_end_pattern = /#\s*#{Regexp.escape(@freeze_token)}:unfreeze/i
 
-        # Find all comments in the range
-        candidates = @parse_result.comments.select do |comment|
-          comment.location.start_line > start_line &&
-            comment.location.start_line < end_line
+        # Scan all comments for freeze markers
+        @parse_result.comments.each do |comment|
+          line = comment.slice
+          line_num = comment.location.start_line
+
+          if line.match?(freeze_start_pattern)
+            if freeze_start_line
+              # Nested freeze blocks not allowed
+              raise FreezeNode::InvalidStructureError,
+                "Nested freeze block at line #{line_num} (previous freeze at line #{freeze_start_line})"
+            end
+            freeze_start_line = line_num
+          elsif line.match?(freeze_end_pattern)
+            unless freeze_start_line
+              raise FreezeNode::InvalidStructureError,
+                "Unfreeze marker at line #{line_num} without matching freeze marker"
+            end
+
+            # Find statements enclosed by this freeze block
+            enclosed_statements = statements.select do |stmt|
+              stmt.location.start_line > freeze_start_line &&
+                stmt.location.end_line < line_num
+            end
+
+            # Find all statements that overlap with this freeze block (for validation)
+            overlapping_statements = statements.select do |stmt|
+              stmt_start = stmt.location.start_line
+              stmt_end = stmt.location.end_line
+              # Overlaps if: starts before end AND ends after start
+              stmt_start <= line_num && stmt_end >= freeze_start_line
+            end
+
+            # Create freeze node (validation happens in initialize)
+            freeze_node = FreezeNode.new(
+              start_line: freeze_start_line,
+              end_line: line_num,
+              analysis: self,
+              nodes: enclosed_statements,
+              overlapping_nodes: overlapping_statements,
+            )
+
+            freeze_blocks << freeze_node
+            freeze_start_line = nil
+          end
         end
 
-        # Only include comments that are immediately adjacent to the statement
-        # (no blank lines between the comment and the statement)
-        adjacent_comments = []
-        expected_line = end_line - 1
+        # Handle unclosed freeze blocks
+        # If freeze block is unclosed AND at root level, it extends to end of file
+        # If freeze block is unclosed AND inside a nested node, it's an error
+        if freeze_start_line
+          # Check if any statement starts before freeze_start_line and ends after it
+          # This means the freeze is inside a nested structure (class, module, method, etc.)
+          nested_context = statements.any? do |stmt|
+            stmt.location.start_line < freeze_start_line &&
+              stmt.location.end_line > freeze_start_line
+          end
 
-        candidates.reverse_each do |comment|
-          comment_line = comment.location.start_line
+          if nested_context
+            raise FreezeNode::InvalidStructureError,
+              "Unclosed freeze block starting at line #{freeze_start_line} inside a nested structure. " \
+                "Freeze blocks inside classes/methods/modules must have matching unfreeze markers."
+          end
 
-          # Only include if this comment is immediately adjacent (no gaps)
-          if comment_line == expected_line
-            adjacent_comments.unshift(comment)
-            expected_line = comment_line - 1
-          else
-            # Gap found (blank line or code), stop looking
-            break
+          # Root-level unclosed freeze: extends to end of file
+          last_line = @lines.length
+          enclosed_statements = statements.select do |stmt|
+            stmt.location.start_line > freeze_start_line &&
+              stmt.location.end_line <= last_line
           end
+
+          freeze_node = FreezeNode.new(
+            start_line: freeze_start_line,
+            end_line: last_line,
+            analysis: self,
+            nodes: enclosed_statements,
+          )
+
+          freeze_blocks << freeze_node
         end
 
-        adjacent_comments
+        freeze_blocks
       end
 
-      def inline_comments_for_node(stmt)
-        @parse_result.comments.select do |comment|
-          # Check if comment is on the same line as the start of the statement
-          # and appears after the statement text begins
-          comment.location.start_line == stmt.location.start_line &&
-            comment.location.start_offset > stmt.location.start_offset
+      # Filter out statements that are inside freeze blocks
+      # @param statements [Array<Prism::Node>] Base statements
+      # @param freeze_nodes [Array<FreezeNode>] Freeze block nodes
+      # @return [Array<Prism::Node>] Statements outside freeze blocks
+      def filter_statements_outside_freeze(statements, freeze_nodes)
+        statements.reject do |stmt|
+          freeze_nodes.any? do |freeze_node|
+            stmt.location.start_line >= freeze_node.start_line &&
+              stmt.location.end_line <= freeze_node.end_line
+          end
         end
       end
 
-      def build_comment_map
-        map = Hash.new { |h, k| h[k] = [] }
-        return map unless valid?
+      # Extract nodes with their comments and metadata
+      # Uses Prism's native comment attachment via node.location
+      # @return [Array<Hash>]
+      def extract_nodes_with_comments
+        return [] unless valid?
 
-        @parse_result.comments.each do |comment|
-          line = comment.location.start_line
-          map[line] << comment
+        statements.map.with_index do |stmt, idx|
+          # FreezeNode doesn't have Prism location with comments
+          # It's a wrapper with custom Location struct
+          if stmt.is_a?(FreezeNode)
+            {
+              node: stmt,
+              index: idx,
+              leading_comments: [],
+              inline_comments: [],
+              signature: generate_signature(stmt),
+              line_range: stmt.location.start_line..stmt.location.end_line,
+            }
+          else
+            {
+              node: stmt,
+              index: idx,
+              leading_comments: stmt.location.leading_comments,    # Prism native!
+              inline_comments: stmt.location.trailing_comments,    # Prism native!
+              signature: generate_signature(stmt),
+              line_range: stmt.location.start_line..stmt.location.end_line,
+            }
+          end
         end
-
-        map
       end
 
-      # Default signature generation
-      def default_signature(node)
-        return [:nil] unless node
+      # Generate default signature for a node
+      # @param node [Prism::Node] Node to generate signature for
+      # @return [Array] Signature array [type, name, params, ...]
+      def compute_node_signature(node)
+        # IMPORTANT: Do NOT call node.signature - Prism nodes have their own signature method
+        # that returns [node_type_symbol, source_text] which is not what we want for matching.
+        # We need our own signature format: [:type_symbol, identifier, params]
 
-        # For conditional nodes, signature should be based on the condition only,
-        # not the body, so conditionals with same condition but different bodies
-        # are recognized as matching
         case node
+        when Prism::DefNode
+          # Extract parameter names from ParametersNode
+          params = if node.parameters
+            param_names = []
+            param_names.concat(node.parameters.requireds.map(&:name)) if node.parameters.requireds
+            param_names.concat(node.parameters.optionals.map(&:name)) if node.parameters.optionals
+            param_names << node.parameters.rest.name if node.parameters.rest
+            param_names.concat(node.parameters.posts.map(&:name)) if node.parameters.posts
+            param_names.concat(node.parameters.keywords.map(&:name)) if node.parameters.keywords
+            param_names << node.parameters.keyword_rest.name if node.parameters.keyword_rest
+            param_names << node.parameters.block.name if node.parameters.block
+            param_names
+          else
+            []
+          end
+          [:def, node.name, params]
+        when Prism::ClassNode
+          [:class, node.constant_path.slice]
+        when Prism::ModuleNode
+          [:module, node.constant_path.slice]
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          [:const, node.name || node.target.slice]
         when Prism::IfNode, Prism::UnlessNode
-          condition_slice = node.predicate&.slice || ""
-          [node.class.name.split("::").last.to_sym, condition_slice]
-        when Prism::ConstantWriteNode, Prism::GlobalVariableWriteNode,
-             Prism::InstanceVariableWriteNode, Prism::ClassVariableWriteNode,
-             Prism::LocalVariableWriteNode
-          # For variable/constant assignments, signature based on name only,
-          # not the value, so assignments with same name but different values
-          # are recognized as matching
-          name = node.respond_to?(:name) ? node.name.to_s : node.slice.split("=").first.strip
-          [node.class.name.split("::").last.to_sym, name]
-        when Prism::CallNode
-          # For method calls with blocks, signature based on method name and arguments only,
-          # not the block body, so calls with same name/args but different blocks
-          # are recognized as matching
-          method_name = node.name.to_s
-          # Extract just the arguments (not the block)
-          arg_signature = node.arguments&.arguments&.map { |arg| arg.slice }&.join(", ") || ""
-          [node.class.name.split("::").last.to_sym, method_name, arg_signature]
+          # Conditionals match by their condition expression
+          condition_source = node.predicate.slice
+          [node.is_a?(Prism::IfNode) ? :if : :unless, condition_source]
+        when FreezeNode
+          # FreezeNode has its own signature method with normalized content
+          node.signature
         else
-          [node.class.name.split("::").last.to_sym, node.slice]
+          [:other, node.class.name, node.location.start_line]
         end
       end
     end