rfmt 1.7.0 → 2.0.0.beta1

data/lib/rfmt/prism_bridge.rb

@@ -1,529 +0,0 @@
-# frozen_string_literal: true
-
-require 'prism'
-require 'json'
-require_relative 'prism_node_extractor'
-
-module Rfmt
-  # PrismBridge provides the Ruby-side integration with the Prism parser
-  # It parses Ruby source code and converts the AST to a JSON format
-  # that can be consumed by the Rust formatter
-  class PrismBridge
-    extend PrismNodeExtractor
-
-    class ParseError < StandardError; end
-
-    # Parse Ruby source code and return serialized AST
-    # @param source [String] Ruby source code to parse
-    # @return [String] JSON-serialized AST with comments
-    # @raise [ParseError] if parsing fails
-    def self.parse(source)
-      result = Prism.parse(source)
-
-      handle_parse_errors(result) if result.failure?
-
-      serialize_ast_with_comments(result)
-    end
-
-    # Parse Ruby source code from a file
-    # @param file_path [String] Path to Ruby file
-    # @return [String] JSON-serialized AST
-    # @raise [ParseError] if parsing fails
-    # @raise [Errno::ENOENT] if file doesn't exist
-    def self.parse_file(file_path)
-      source = File.read(file_path)
-      parse(source)
-    rescue Errno::ENOENT
-      raise ParseError, "File not found: #{file_path}"
-    end
-
-    # Handle parsing errors from Prism
-    def self.handle_parse_errors(result)
-      errors = result.errors.map do |error|
-        {
-          line: error.location.start_line,
-          column: error.location.start_column,
-          message: error.message
-        }
-      end
-
-      error_messages = errors.map do |err|
-        "#{err[:line]}:#{err[:column]}: #{err[:message]}"
-      end.join("\n")
-
-      raise ParseError, "Parse errors:\n#{error_messages}"
-    end
-
-    # Serialize the Prism AST to JSON
-    def self.serialize_ast(node)
-      JSON.generate(convert_node(node), max_nesting: false)
-    end
-
-    # Serialize the Prism AST with comments to JSON
-    def self.serialize_ast_with_comments(result)
-      comments = result.comments.map do |comment|
-        loc = comment.location
-        end_line = loc.end_line
-        # Prism's `=begin ... =end` (EmbDocComment) location ends at
-        # `<=end_line>:0`, i.e. the column-0 start of the line AFTER the
-        # `=end` terminator. Reporting that larger end_line makes the
-        # comment appear to overlap with the next statement, so the
-        # comment gets misattributed to a deeper node (e.g. the first
-        # expression inside the next method body) and ends up emitted in
-        # the wrong place. Snap it back to the terminator line.
-        end_line = loc.end_line - 1 if loc.end_column.zero? && loc.end_line > loc.start_line
-
-        {
-          comment_type: comment.class.name.split('::').last.downcase.gsub('comment', ''),
-          location: {
-            start_line: loc.start_line,
-            start_column: loc.start_column,
-            end_line: end_line,
-            end_column: loc.end_column,
-            start_offset: loc.start_offset,
-            end_offset: loc.end_offset
-          },
-          text: loc.slice,
-          position: 'leading' # Default position, will be refined by Rust
-        }
-      end
-
-      JSON.generate({
-                      ast: convert_node(result.value),
-                      comments: comments
-                    }, max_nesting: false)
-    end
-
-    # Convert a Prism node to our internal representation
-    def self.convert_node(node)
-      return nil if node.nil?
-
-      {
-        node_type: node_type_name(node),
-        location: extract_location(node),
-        children: extract_children(node),
-        metadata: extract_metadata(node),
-        comments: extract_comments(node),
-        formatting: extract_formatting(node)
-      }
-    end
-
-    # Get the node type name from Prism node
-    def self.node_type_name(node)
-      # Prism node class names are like "Prism::ProgramNode"
-      # We want just "program_node" in snake_case
-      node.class.name.split('::').last.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
-    end
-
-    # Extract location information from node
-    def self.extract_location(node)
-      loc = node.location
-
-      # For heredoc nodes, the location only covers the opening tag (<<~CSV)
-      # We need to find the maximum end_offset including closing_loc
-      end_offset = loc.end_offset
-      end_line = loc.end_line
-      end_column = loc.end_column
-
-      # Check this node's closing_loc
-      if node.respond_to?(:closing_loc) && node.closing_loc
-        closing = node.closing_loc
-        if closing.end_offset > end_offset
-          end_offset = closing.end_offset
-          end_line = heredoc_terminator_line(closing)
-          end_column = closing.end_column
-        end
-      end
-
-      # Recursively check all descendant nodes for heredoc closing_loc
-      # Issue #74: handled direct children (e.g., LocalVariableWriteNode -> StringNode)
-      # Issue #86: handles deeper nesting (e.g., CallNode -> ArgumentsNode -> StringNode)
-      max_closing = find_max_closing_loc_recursive(node)
-      if max_closing && max_closing[:end_offset] > end_offset
-        end_offset = max_closing[:end_offset]
-        end_line = max_closing[:end_line]
-        end_column = max_closing[:end_column]
-      end
-
-      {
-        start_line: loc.start_line,
-        start_column: loc.start_column,
-        end_line: end_line,
-        end_column: end_column,
-        start_offset: loc.start_offset,
-        end_offset: end_offset
-      }
-    end
-
-    # Prism reports a heredoc's `closing_loc` as `<terminator_line>:0..(terminator_line+1):0`,
-    # i.e. its `end_line` is the LINE AFTER the terminator. Using that as the
-    # node's `end_line` makes blank-line preservation fail: a real blank line
-    # right after the terminator looks identical (diff == 1) to two adjacent
-    # statements with no separator. Use the terminator's own line instead.
-    def self.heredoc_terminator_line(closing_loc)
-      if closing_loc.end_column.zero? && closing_loc.end_line > closing_loc.start_line
-        closing_loc.start_line
-      else
-        closing_loc.end_line
-      end
-    end
-
-    # Recursively find the maximum closing_loc among all descendant nodes
-    # Returns nil if no closing_loc found, otherwise { end_offset:, end_line:, end_column: }
-    def self.find_max_closing_loc_recursive(node, depth: 0)
-      return nil if depth > 10
-
-      max_closing = nil
-
-      node.child_nodes.compact.each do |child|
-        if child.respond_to?(:closing_loc) && child.closing_loc
-          closing = child.closing_loc
-          if max_closing.nil? || closing.end_offset > max_closing[:end_offset]
-            max_closing = {
-              end_offset: closing.end_offset,
-              end_line: heredoc_terminator_line(closing),
-              end_column: closing.end_column
-            }
-          end
-        end
-
-        child_max = find_max_closing_loc_recursive(child, depth: depth + 1)
-        max_closing = child_max if child_max && (max_closing.nil? || child_max[:end_offset] > max_closing[:end_offset])
-      end
-
-      max_closing
-    end
-
-    # Extract child nodes
-    def self.extract_children(node)
-      children = []
-
-      begin
-        # Different node types have different child accessors
-        children = case node
-                   when Prism::ProgramNode
-                     node.statements ? node.statements.body : []
-                   when Prism::StatementsNode
-                     node.body || []
-                   when Prism::ClassNode
-                     [
-                       node.constant_path,
-                       node.superclass,
-                       node.body
-                     ].compact
-                   when Prism::ModuleNode
-                     [
-                       node.constant_path,
-                       node.body
-                     ].compact
-                   when Prism::DefNode
-                     params = if node.parameters
-                                node.parameters.child_nodes.compact
-                              else
-                                []
-                              end
-                     params + [node.body].compact
-                   when Prism::CallNode
-                     result = []
-                     result << node.receiver if node.receiver
-                     result.concat(node.arguments.child_nodes.compact) if node.arguments
-                     result << node.block if node.block
-                     result
-                   when Prism::IfNode, Prism::UnlessNode
-                     [
-                       node.predicate,
-                       node.statements,
-                       node.consequent
-                     ].compact
-                   when Prism::ElseNode
-                     [node.statements].compact
-                   when Prism::ArrayNode
-                     node.elements || []
-                   when Prism::HashNode
-                     node.elements || []
-                   when Prism::BlockNode
-                     params = if node.parameters
-                                node.parameters.child_nodes.compact
-                              else
-                                []
-                              end
-                     params + [node.body].compact
-                   when Prism::BeginNode
-                     [
-                       node.statements,
-                       node.rescue_clause,
-                       node.else_clause,
-                       node.ensure_clause
-                     ].compact
-                   when Prism::EnsureNode
-                     [node.statements].compact
-                   when Prism::LambdaNode
-                     params = if node.parameters
-                                node.parameters.child_nodes.compact
-                              else
-                                []
-                              end
-                     params + [node.body].compact
-                   when Prism::RescueNode
-                     result = []
-                     result.concat(node.exceptions) if node.exceptions
-                     result << node.reference if node.reference
-                     result << node.statements if node.statements
-                     result << node.subsequent if node.subsequent
-                     result
-                   when Prism::SymbolNode, Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode
-                     []
-                   when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode
-                     [node.value].compact
-                   when Prism::ReturnNode
-                     node.arguments ? node.arguments.child_nodes.compact : []
-                   when Prism::OrNode
-                     [node.left, node.right].compact
-                   when Prism::AssocNode
-                     [node.key, node.value].compact
-                   when Prism::KeywordHashNode
-                     node.elements || []
-                   when Prism::InterpolatedStringNode
-                     node.parts || []
-                   when Prism::EmbeddedStatementsNode
-                     [node.statements].compact
-                   when Prism::CaseNode
-                     [node.predicate, *node.conditions, node.else_clause].compact
-                   when Prism::WhenNode
-                     [*node.conditions, node.statements].compact
-                   when Prism::WhileNode, Prism::UntilNode
-                     [node.predicate, node.statements].compact
-                   when Prism::ForNode
-                     [node.index, node.collection, node.statements].compact
-                   when Prism::BreakNode, Prism::NextNode
-                     node.arguments ? node.arguments.child_nodes.compact : []
-                   when Prism::RedoNode, Prism::RetryNode
-                     []
-                   when Prism::YieldNode
-                     node.arguments ? node.arguments.child_nodes.compact : []
-                   when Prism::SuperNode
-                     result = []
-                     result.concat(node.arguments.child_nodes.compact) if node.arguments
-                     result << node.block if node.block
-                     result
-                   when Prism::ForwardingSuperNode
-                     node.block ? [node.block] : []
-                   when Prism::RescueModifierNode
-                     [node.expression, node.rescue_expression].compact
-                   when Prism::RangeNode
-                     [node.left, node.right].compact
-                   when Prism::RegularExpressionNode
-                     []
-                   when Prism::SplatNode
-                     [node.expression].compact
-                   when Prism::AndNode
-                     [node.left, node.right].compact
-                   when Prism::InterpolatedRegularExpressionNode, Prism::InterpolatedSymbolNode,
-                        Prism::InterpolatedXStringNode
-                     node.parts || []
-                   when Prism::XStringNode
-                     []
-                   when Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::SelfNode
-                     []
-                   when Prism::ClassVariableWriteNode, Prism::GlobalVariableWriteNode
-                     [node.value].compact
-                   when Prism::ClassVariableOrWriteNode, Prism::ClassVariableAndWriteNode,
-                        Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableAndWriteNode,
-                        Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
-                        Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
-                        Prism::ConstantOrWriteNode, Prism::ConstantAndWriteNode
-                     [node.value].compact
-                   when Prism::ClassVariableOperatorWriteNode, Prism::GlobalVariableOperatorWriteNode,
-                        Prism::LocalVariableOperatorWriteNode, Prism::InstanceVariableOperatorWriteNode,
-                        Prism::ConstantOperatorWriteNode
-                     [node.value].compact
-                   when Prism::ConstantPathOrWriteNode, Prism::ConstantPathAndWriteNode,
-                        Prism::ConstantPathOperatorWriteNode
-                     [node.target, node.value].compact
-                   when Prism::ConstantPathWriteNode
-                     [node.target, node.value].compact
-                   when Prism::CaseMatchNode
-                     [node.predicate, *node.conditions, node.else_clause].compact
-                   when Prism::InNode
-                     [node.pattern, node.statements].compact
-                   when Prism::MatchPredicateNode, Prism::MatchRequiredNode
-                     [node.value, node.pattern].compact
-                   when Prism::ParenthesesNode
-                     [node.body].compact
-                   when Prism::DefinedNode
-                     [node.value].compact
-                   when Prism::SingletonClassNode
-                     [node.expression, node.body].compact
-                   when Prism::AliasMethodNode
-                     [node.new_name, node.old_name].compact
-                   when Prism::AliasGlobalVariableNode
-                     [node.new_name, node.old_name].compact
-                   when Prism::UndefNode
-                     node.names || []
-                   when Prism::AssocSplatNode
-                     [node.value].compact
-                   when Prism::BlockArgumentNode
-                     [node.expression].compact
-                   when Prism::MultiWriteNode
-                     [*node.lefts, node.rest, *node.rights, node.value].compact
-                   when Prism::MultiTargetNode
-                     [*node.lefts, node.rest, *node.rights].compact
-                   when Prism::SourceFileNode, Prism::SourceLineNode, Prism::SourceEncodingNode
-                     []
-                   when Prism::PreExecutionNode, Prism::PostExecutionNode
-                     [node.statements].compact
-                   # Numeric literals
-                   when Prism::RationalNode, Prism::ImaginaryNode
-                     [node.numeric].compact
-                   # String interpolation
-                   when Prism::EmbeddedVariableNode
-                     [node.variable].compact
-                   # Pattern matching patterns
-                   when Prism::ArrayPatternNode
-                     [*node.requireds, node.rest, *node.posts].compact
-                   when Prism::HashPatternNode
-                     [*node.elements, node.rest].compact
-                   when Prism::FindPatternNode
-                     [node.left, *node.requireds, node.right].compact
-                   when Prism::CapturePatternNode
-                     [node.value, node.target].compact
-                   when Prism::AlternationPatternNode
-                     [node.left, node.right].compact
-                   when Prism::PinnedExpressionNode
-                     [node.expression].compact
-                   when Prism::PinnedVariableNode
-                     [node.variable].compact
-                   # Forwarding and special parameters
-                   when Prism::ForwardingArgumentsNode, Prism::ForwardingParameterNode,
-                        Prism::NoKeywordsParameterNode
-                     []
-                   # References
-                   when Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode
-                     []
-                   # Call/Index compound assignment
-                   when Prism::CallAndWriteNode, Prism::CallOrWriteNode, Prism::CallOperatorWriteNode
-                     [node.receiver, node.value].compact
-                   when Prism::IndexAndWriteNode, Prism::IndexOrWriteNode, Prism::IndexOperatorWriteNode
-                     [node.receiver, node.arguments, node.value].compact
-                   # Match
-                   when Prism::MatchWriteNode
-                     [node.call, *node.targets].compact
-                   when Prism::MatchLastLineNode, Prism::InterpolatedMatchLastLineNode
-                     []
-                   # Other
-                   when Prism::FlipFlopNode
-                     [node.left, node.right].compact
-                   when Prism::ImplicitNode
-                     [node.value].compact
-                   when Prism::ImplicitRestNode
-                     []
-                   else
-                     # For unknown types, try to get child nodes if they exist
-                     []
-                   end
-      rescue StandardError => e
-        # Log warning in debug mode but continue processing
-        warn "Warning: Failed to extract children from #{node.class}: #{e.message}" if $DEBUG
-        children = []
-      end
-
-      children.compact.map { |child| convert_node(child) }
-    end
-
-    # Extract metadata specific to node type
-    def self.extract_metadata(node)
-      metadata = {}
-
-      case node
-      when Prism::ClassNode
-        if (name = extract_class_or_module_name(node))
-          metadata['name'] = name
-        end
-        if (superclass = extract_superclass_name(node))
-          metadata['superclass'] = superclass
-        end
-      when Prism::ModuleNode
-        if (name = extract_class_or_module_name(node))
-          metadata['name'] = name
-        end
-      when Prism::DefNode
-        # Prefer `name_loc.slice` over `name.to_s` so unary operator suffixes
-        # (`def !@`, `def +@`, `def -@`) survive the round-trip. Prism
-        # normalizes `name` to the symbol with the `@` stripped for `!@`,
-        # which would otherwise rewrite `def !@` to `def !` silently.
-        name = if node.respond_to?(:name_loc) && node.name_loc
-                 node.name_loc.slice
-               else
-                 extract_node_name(node)
-               end
-        metadata['name'] = name if name
-        metadata['parameters_count'] = extract_parameter_count(node).to_s
-        # Extract parameters text directly from source
-        if node.parameters
-          metadata['parameters_text'] = node.parameters.location.slice
-          metadata['has_parens'] = (!node.lparen_loc.nil?).to_s
-        end
-        # Check if this is a class method (def self.method_name)
-        if node.respond_to?(:receiver) && node.receiver
-          receiver = node.receiver
-          if receiver.is_a?(Prism::SelfNode)
-            metadata['receiver'] = 'self'
-          elsif receiver.respond_to?(:slice)
-            metadata['receiver'] = receiver.slice
-          end
-        end
-      when Prism::CallNode
-        if (name = extract_node_name(node))
-          metadata['name'] = name
-        end
-        if (message = extract_message_name(node))
-          metadata['message'] = message
-        end
-      when Prism::StringNode
-        if (content = extract_string_content(node))
-          metadata['content'] = content
-        end
-      when Prism::IntegerNode
-        if (value = extract_literal_value(node))
-          metadata['value'] = value
-        end
-      when Prism::FloatNode
-        if (value = extract_literal_value(node))
-          metadata['value'] = value
-        end
-      when Prism::SymbolNode
-        if (value = extract_literal_value(node))
-          metadata['value'] = value
-        end
-      when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode
-        metadata['name'] = node.name.to_s
-      when Prism::IfNode, Prism::UnlessNode
-        # Detect ternary operator: if_keyword_loc is nil for ternary
-        metadata['is_ternary'] = node.if_keyword_loc.nil?.to_s if node.respond_to?(:if_keyword_loc)
-      end
-
-      metadata
-    end
-
-    # Extract comments associated with the node
-    def self.extract_comments(_node)
-      # Prism attaches comments to the parse result, not individual nodes
-      # For Phase 1, we'll return empty array and implement in Phase 2
-      []
-    end
-
-    # Extract formatting information
-    def self.extract_formatting(node)
-      loc = node.location
-      {
-        indent_level: 0, # Will be calculated during formatting
-        needs_blank_line_before: false,
-        needs_blank_line_after: false,
-        preserve_newlines: false,
-        multiline: loc.start_line != loc.end_line,
-        original_formatting: nil # Can store original text if needed
-      }
-    end
-  end
-end

data/lib/rfmt/prism_node_extractor.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Rfmt
-  # PrismNodeExtractor provides safe methods to extract information from Prism nodes
-  # This module encapsulates the logic for accessing Prism node properties,
-  # making the code resilient to Prism API changes
-  module PrismNodeExtractor
-    # Extract the name from a node
-    # @param node [Prism::Node] The node to extract name from
-    # @return [String, nil] The node name or nil if not available
-    def extract_node_name(node)
-      return nil unless node.respond_to?(:name)
-
-      node.name.to_s
-    end
-
-    # Extract full name from class or module node (handles namespaced names like Foo::Bar::Baz)
-    # @param node [Prism::ClassNode, Prism::ModuleNode] The class or module node
-    # @return [String, nil] The full name or nil if not available
-    def extract_class_or_module_name(node)
-      return nil unless node.respond_to?(:constant_path)
-
-      cp = node.constant_path
-      return node.name.to_s if cp.nil?
-
-      case cp
-      when Prism::ConstantReadNode
-        cp.name.to_s
-      when Prism::ConstantPathNode
-        if cp.respond_to?(:full_name)
-          cp.full_name.to_s
-        elsif cp.respond_to?(:slice)
-          cp.slice
-        else
-          cp.location.slice
-        end
-      else
-        node.name.to_s
-      end
-    end
-
-    # Extract superclass name from a class node
-    # @param class_node [Prism::ClassNode] The class node
-    # @return [String, nil] The superclass name or nil if not available
-    def extract_superclass_name(class_node)
-      return nil unless class_node.respond_to?(:superclass)
-
-      sc = class_node.superclass
-      return nil if sc.nil?
-
-      case sc
-      when Prism::ConstantReadNode
-        sc.name.to_s
-      when Prism::ConstantPathNode
-        # Try full_name first, fall back to slice for original source
-        if sc.respond_to?(:full_name)
-          sc.full_name.to_s
-        elsif sc.respond_to?(:slice)
-          sc.slice
-        else
-          sc.location.slice
-        end
-      when Prism::CallNode
-        # Handle cases like ActiveRecord::Migration[8.1]
-        # Use slice to get the original source text
-        sc.slice
-      else
-        # Fallback: try to get original source text
-        if sc.respond_to?(:slice)
-          sc.slice
-        else
-          sc.location.slice
-        end
-      end
-    end
-
-    # Extract parameter count from a method definition node
-    # @param def_node [Prism::DefNode] The method definition node
-    # @return [Integer] The number of parameters (0 if none)
-    def extract_parameter_count(def_node)
-      return 0 unless def_node.respond_to?(:parameters)
-      return 0 if def_node.parameters.nil?
-      return 0 unless def_node.parameters.respond_to?(:child_nodes)
-
-      def_node.parameters.child_nodes.compact.length
-    end
-
-    # Extract message name from a call node
-    # @param call_node [Prism::CallNode] The call node
-    # @return [String, nil] The message name or nil if not available
-    def extract_message_name(call_node)
-      return nil unless call_node.respond_to?(:message)
-
-      call_node.message.to_s
-    end
-
-    # Extract content from a string node
-    # @param string_node [Prism::StringNode] The string node
-    # @return [String, nil] The string content or nil if not available
-    def extract_string_content(string_node)
-      return nil unless string_node.respond_to?(:content)
-
-      string_node.content
-    end
-
-    # Extract value from a literal node (Integer, Float, Symbol)
-    # @param node [Prism::Node] The literal node
-    # @return [String, nil] The value as string or nil if not available
-    def extract_literal_value(node)
-      return nil unless node.respond_to?(:value)
-
-      node.value.to_s
-    end
-  end
-end