rfmt 1.3.0-arm64-darwin

data/lib/rfmt/prism_bridge.rb

@@ -0,0 +1,390 @@
+# 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))
+    end
+
+    # Serialize the Prism AST with comments to JSON
+    def self.serialize_ast_with_comments(result)
+      comments = result.comments.map do |comment|
+        {
+          comment_type: comment.class.name.split('::').last.downcase.gsub('comment', ''),
+          location: {
+            start_line: comment.location.start_line,
+            start_column: comment.location.start_column,
+            end_line: comment.location.end_line,
+            end_column: comment.location.end_column,
+            start_offset: comment.location.start_offset,
+            end_offset: comment.location.end_offset
+          },
+          text: comment.location.slice,
+          position: 'leading' # Default position, will be refined by Rust
+        }
+      end
+
+      JSON.generate({
+                      ast: convert_node(result.value),
+                      comments: comments
+                    })
+    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
+      {
+        start_line: loc.start_line,
+        start_column: loc.start_column,
+        end_line: loc.end_line,
+        end_column: loc.end_column,
+        start_offset: loc.start_offset,
+        end_offset: loc.end_offset
+      }
+    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.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::NotNode
+                     [node.expression].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
+                   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
+        if (name = extract_node_name(node))
+          metadata['name'] = name
+        end
+        metadata['parameters_count'] = extract_parameter_count(node).to_s
+        # 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::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

@@ -0,0 +1,115 @@
+# 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

data/lib/rfmt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rfmt
+  VERSION = '1.3.0'
+end

data/lib/rfmt.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative 'rfmt/version'
+require_relative 'rfmt/rfmt'
+require_relative 'rfmt/prism_bridge'
+
+module Rfmt
+  class Error < StandardError; end
+  # Errors from Rust side
+  class RfmtError < Error; end
+  # AST validation errors
+  class ValidationError < RfmtError; end
+
+  # Format Ruby source code
+  # @param source [String] Ruby source code to format
+  # @return [String] Formatted Ruby code
+  def self.format(source)
+    # Step 1: Parse with Prism (Ruby side)
+    prism_json = PrismBridge.parse(source)
+
+    # Step 2: Format in Rust
+    # Pass both source and AST to enable source extraction fallback
+    format_code(source, prism_json)
+  rescue PrismBridge::ParseError => e
+    # Re-raise with more context
+    raise Error, "Failed to parse Ruby code: #{e.message}"
+  rescue RfmtError
+    # Rust side errors are re-raised as-is to preserve error details
+    raise
+  rescue StandardError => e
+    raise Error, "Unexpected error during formatting: #{e.class}: #{e.message}"
+  end
+
+  # Format a Ruby file
+  # @param path [String] Path to Ruby file
+  # @return [String] Formatted Ruby code
+  def self.format_file(path)
+    source = File.read(path)
+    format(source)
+  rescue Errno::ENOENT
+    raise Error, "File not found: #{path}"
+  end
+
+  # Get version information
+  # @return [String] Version string including Ruby and Rust versions
+  def self.version_info
+    "Ruby: #{VERSION}, Rust: #{rust_version}"
+  end
+
+  # Parse Ruby code to AST (for debugging)
+  # @param source [String] Ruby source code
+  # @return [String] AST representation
+  def self.parse(source)
+    prism_json = PrismBridge.parse(source)
+    parse_to_json(prism_json)
+  end
+
+  # Configuration management
+  module Config
+    # Default configuration template
+    DEFAULT_CONFIG = <<~YAML
+      # rfmt Configuration File
+      # This file controls how rfmt formats your Ruby code.
+      # See https://github.com/fs0414/rfmt for full documentation.
+
+      version: "1.0"
+
+      # Formatting options
+      formatting:
+        # Maximum line length before wrapping (40-500)
+        line_length: 100
+
+        # Number of spaces or tabs per indentation level (1-8)
+        indent_width: 2
+
+        # Use "spaces" or "tabs" for indentation
+        indent_style: "spaces"
+
+        # Quote style for strings: "double", "single", or "consistent"
+        quote_style: "double"
+
+      # Files to include in formatting (glob patterns)
+      include:
+        - "**/*.rb"
+        - "**/*.rake"
+        - "**/Rakefile"
+        - "**/Gemfile"
+
+      # Files to exclude from formatting (glob patterns)
+      exclude:
+        - "vendor/**/*"
+        - "tmp/**/*"
+        - "node_modules/**/*"
+        - "db/schema.rb"
+    YAML
+
+    # Generate a default configuration file
+    # @param path [String] Path where to create the config file (default: .rfmt.yml)
+    # @param force [Boolean] Overwrite existing file if true
+    # @return [Boolean] true if file was created, false if already exists
+    def self.init(path = '.rfmt.yml', force: false)
+      if File.exist?(path) && !force
+        warn "Configuration file already exists: #{path}"
+        warn 'Use force: true to overwrite'
+        return false
+      end
+
+      File.write(path, DEFAULT_CONFIG)
+      puts "Created rfmt configuration file: #{path}"
+      true
+    end
+
+    # Find configuration file in current or parent directories
+    # @return [String, nil] Path to config file or nil if not found
+    def self.find
+      current_dir = Dir.pwd
+
+      loop do
+        ['.rfmt.yml', '.rfmt.yaml', 'rfmt.yml', 'rfmt.yaml'].each do |filename|
+          config_path = File.join(current_dir, filename)
+          return config_path if File.exist?(config_path)
+        end
+
+        parent = File.dirname(current_dir)
+        break if parent == current_dir # Reached root
+
+        current_dir = parent
+      end
+
+      # Check user home directory
+      home_dir = begin
+        Dir.home
+      rescue StandardError
+        nil
+      end
+      if home_dir
+        ['.rfmt.yml', '.rfmt.yaml', 'rfmt.yml', 'rfmt.yaml'].each do |filename|
+          config_path = File.join(home_dir, filename)
+          return config_path if File.exist?(config_path)
+        end
+      end
+
+      nil
+    end
+
+    # Check if configuration file exists
+    # @return [Boolean] true if config file exists
+    def self.exists?
+      !find.nil?
+    end
+
+    # Load and validate configuration file
+    # @param path [String, nil] Path to config file (default: auto-detect)
+    # @return [Hash] Loaded configuration
+    def self.load(path = nil)
+      require 'yaml'
+
+      config_path = path || find
+
+      unless config_path
+        warn 'No configuration file found, using defaults'
+        return {}
+      end
+
+      YAML.load_file(config_path)
+    rescue Errno::ENOENT
+      raise Error, "Configuration file not found: #{config_path}"
+    rescue Psych::SyntaxError => e
+      raise Error, "Invalid YAML in configuration file: #{e.message}"
+    end
+  end
+end

data/lib/ruby_lsp/rfmt/addon.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'ruby_lsp/addon'
+require_relative 'formatter_runner'
+
+module RubyLsp
+  module Rfmt
+    class Addon < ::RubyLsp::Addon
+      def name
+        'rfmt'
+      end
+
+      def activate(global_state, _message_queue)
+        global_state.register_formatter('rfmt', FormatterRunner.new)
+      end
+
+      def deactivate; end
+    end
+  end
+end