rfmt 1.6.3 → 2.0.0.beta1

data/lib/rfmt/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'thor'
 
 # Check for verbose flag before loading rfmt to set debug mode early
@@ -44,11 +45,15 @@ module Rfmt
 
   # Command Line Interface for rfmt
   class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
     # Constants
     PROGRESS_THRESHOLD = 20  # Show progress for file counts >= this
     PROGRESS_INTERVAL = 10   # Update progress every N files
 
-    class_option :config, type: :string, desc: 'Path to configuration file'
+    class_option :config, type: :string, desc: 'Path to configuration file (formatting options and file selection)'
     class_option :verbose, type: :boolean, desc: 'Verbose output'
 
     default_command :format
@@ -120,11 +125,11 @@ module Rfmt
       say "Rust extension: #{Rfmt.rust_version}"
     end
 
-    desc 'config', 'Show current configuration'
+    desc 'config', 'Show the effective configuration the formatter will use'
     def config_cmd
-      config = load_config
-      require 'json'
-      say JSON.pretty_generate(config.config)
+      say Rfmt.resolved_config(config_path: options[:config])
+    rescue Rfmt::Error => e
+      raise Thor::Error, e.message
     end
 
     desc 'cache SUBCOMMAND', 'Manage cache'
@@ -183,12 +188,24 @@ module Rfmt
 
     def load_config
       if options[:config]
+        validate_explicit_config!(options[:config])
         Configuration.new(file: options[:config])
       else
         Configuration.discover
       end
     end
 
+    # Fail fast once instead of repeating the same load error per file
+    def validate_explicit_config!(path)
+      raise Thor::Error, "Configuration file not found: #{path}" unless File.exist?(path)
+
+      begin
+        Rfmt.resolved_config(config_path: path)
+      rescue Rfmt::Error => e
+        raise Thor::Error, e.message
+      end
+    end
+
     def initialize_cache_if_enabled
       return nil unless options[:cache]
 
@@ -255,7 +272,7 @@ module Rfmt
       start_time = Time.now
       source = File.read(file)
 
-      formatted = Rfmt.format(source)
+      formatted = Rfmt.format(source, config_path: options[:config])
       changed = source != formatted
 
       {
@@ -325,11 +342,24 @@ module Rfmt
     end
 
     def write_formatted_file(result, cache)
-      File.write(result[:file], result[:formatted])
+      atomic_write(result[:file], result[:formatted])
       say "✓ Formatted #{result[:file]}", :green unless options[:quiet]
       cache&.mark_formatted(result[:file])
     end
 
+    # Temp file must live in the same directory: rename across filesystems is not atomic.
+    def atomic_write(path, content)
+      # rename would replace a symlink itself; write to its target instead
+      path = File.realpath(path) if File.symlink?(path)
+      tmp_path = "#{path}.rfmt-#{Process.pid}.tmp"
+      mode = File.stat(path).mode
+      File.write(tmp_path, content)
+      File.chmod(mode, tmp_path)
+      File.rename(tmp_path, path)
+    ensure
+      FileUtils.rm_f(tmp_path)
+    end
+
     def display_summary(stats, total_files)
       @last_stats = stats # Store for verbose details
       unchanged_count = total_files - stats[:changed] - stats[:errors]

data/lib/rfmt/configuration.rb

@@ -3,17 +3,13 @@
 require 'yaml'
 
 module Rfmt
-  # Configuration management for rfmt
+  # File selection and cache concerns only: formatter settings (indent_width
+  # etc.) live in the Rust Config, reached via Rfmt.format(config_path:).
   class Configuration
     class ConfigError < StandardError; end
 
     DEFAULT_CONFIG = {
       'version' => '1.0',
-      'formatting' => {
-        'line_length' => 100,
-        'indent_width' => 2,
-        'indent_style' => 'spaces'
-      },
       'include' => ['**/*.rb'],
       'exclude' => ['vendor/**/*', 'tmp/**/*', 'node_modules/**/*']
     }.freeze
@@ -43,11 +39,6 @@ module Rfmt
       (included_files - excluded_files).select { |f| File.file?(f) }
     end
 
-    # Get formatting configuration
-    def formatting_config
-      @config['formatting']
-    end
-
     private
 
     def load_configuration(options)
@@ -64,18 +55,9 @@ module Rfmt
       options.delete('file')
       config = deep_merge(config, options) unless options.empty?
 
-      validate_config!(config)
       config
     end
 
-    def validate_config!(config)
-      line_length = config.dig('formatting', 'line_length')
-      raise ConfigError, 'line_length must be positive' if line_length && line_length <= 0
-
-      indent_width = config.dig('formatting', 'indent_width')
-      raise ConfigError, 'indent_width must be positive' if indent_width && indent_width <= 0
-    end
-
     def deep_merge(hash1, hash2)
       hash1.merge(hash2) do |_key, old_val, new_val|
         if old_val.is_a?(Hash) && new_val.is_a?(Hash)

data/lib/rfmt/lsp/document_store.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rfmt
+  module LSP
+    class DocumentStore
+      def initialize
+        @documents = {}
+      end
+
+      def open(uri, text)
+        @documents[uri] = text
+      end
+
+      def change(uri, text)
+        @documents[uri] = text
+      end
+
+      def close(uri)
+        @documents.delete(uri)
+      end
+
+      def source_for(uri)
+        @documents[uri]
+      end
+    end
+  end
+end

data/lib/rfmt/lsp/formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rfmt'
+
+module Rfmt
+  module LSP
+    class Formatter
+      def self.format_edits(source)
+        formatted = source.empty? ? "\n" : Rfmt.format(source)
+        return [] if formatted == source
+
+        [
+          {
+            range: full_document_range(source),
+            newText: formatted
+          }
+        ]
+      rescue Rfmt::Error
+        []
+      end
+
+      def self.full_document_range(source)
+        return { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } } if source.empty?
+
+        lines = source.split("\n", -1)
+
+        {
+          start: { line: 0, character: 0 },
+          end: {
+            line: lines.length - 1,
+            character: lines.last.length
+          }
+        }
+      end
+    end
+  end
+end

data/lib/rfmt/lsp/message_io.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Rfmt
+  module LSP
+    # Reads and writes LSP JSON-RPC messages over an IO pair.
+    class MessageIO
+      HEADER_SEPARATOR = "\r\n\r\n"
+      CONTENT_LENGTH = /\AContent-Length:\s*(\d+)\z/i
+
+      def initialize(input: $stdin, output: $stdout)
+        @input = input
+        @output = output
+      end
+
+      def read_message
+        headers = read_headers
+        return nil if headers.nil?
+
+        content_length = headers.fetch('content-length').to_i
+        JSON.parse(@input.read(content_length))
+      end
+
+      def write_message(payload)
+        body = JSON.generate(payload)
+        @output.write("Content-Length: #{body.bytesize}#{HEADER_SEPARATOR}#{body}")
+        @output.flush if @output.respond_to?(:flush)
+      end
+
+      private
+
+      def read_headers
+        headers = {}
+
+        loop do
+          line = @input.gets
+          return nil if line.nil?
+
+          line = line.chomp
+          line = line.delete_suffix("\r")
+          break if line.empty?
+
+          match = CONTENT_LENGTH.match(line)
+          headers['content-length'] = match[1] if match
+        end
+
+        headers.fetch('content-length')
+        headers
+      rescue KeyError
+        nil
+      end
+    end
+  end
+end

data/lib/rfmt/lsp/server.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'language_server/protocol'
+require 'rfmt/version'
+
+require_relative 'document_store'
+require_relative 'formatter'
+require_relative 'message_io'
+require_relative 'uri'
+require_relative 'workspace'
+
+module Rfmt
+  module LSP
+    class Server
+      TEXT_DOCUMENT_SYNC_FULL = 1
+      METHOD_NOT_FOUND = -32_601
+      INTERNAL_ERROR = -32_603
+
+      def initialize(input: $stdin, output: $stdout)
+        @io = MessageIO.new(input: input, output: output)
+        @documents = DocumentStore.new
+        @workspace = Workspace.new
+        @shutdown_requested = false
+      end
+
+      def run
+        while (message = @io.read_message)
+          return @shutdown_requested ? 0 : 1 if handle_message(message) == :exit
+        end
+
+        0
+      end
+
+      def handle_message(message)
+        method = message['method']
+        id = message['id']
+        params = message['params'] || {}
+
+        dispatch_message(method, id, params)
+      rescue StandardError => e
+        respond_error(id, INTERNAL_ERROR, e.message) if id
+      end
+
+      private
+
+      def dispatch_message(method, id, params)
+        if request_handler?(method)
+          dispatch_request(method, id, params)
+        else
+          dispatch_notification(method, params) || respond_method_not_found(id, method)
+        end
+      end
+
+      def request_handler?(method)
+        %w[initialize textDocument/formatting shutdown].include?(method)
+      end
+
+      def dispatch_request(method, id, params)
+        case method
+        when 'initialize'
+          handle_initialize(id, params)
+        when 'textDocument/formatting'
+          handle_formatting(id, params)
+        when 'shutdown'
+          handle_shutdown(id)
+        end
+      end
+
+      def dispatch_notification(method, params)
+        case method
+        when 'initialized'
+          true
+        when 'textDocument/didOpen'
+          handle_did_open(params)
+          true
+        when 'textDocument/didChange'
+          handle_did_change(params)
+          true
+        when 'textDocument/didClose'
+          handle_did_close(params)
+          true
+        when 'exit'
+          :exit
+        end
+      end
+
+      def respond_method_not_found(id, method)
+        respond_error(id, METHOD_NOT_FOUND, "Method not found: #{method}") if id
+      end
+
+      def handle_initialize(id, params)
+        @workspace.configure(params)
+
+        respond(id, {
+                  capabilities: {
+                    documentFormattingProvider: true,
+                    textDocumentSync: TEXT_DOCUMENT_SYNC_FULL
+                  },
+                  serverInfo: {
+                    name: 'rfmt',
+                    version: Rfmt::VERSION
+                  }
+                })
+      end
+
+      def handle_did_open(params)
+        text_document = params.fetch('textDocument')
+        @documents.open(text_document.fetch('uri'), text_document.fetch('text'))
+      end
+
+      def handle_did_change(params)
+        uri = params.fetch('textDocument').fetch('uri')
+        change = Array(params['contentChanges']).last
+        return unless change&.key?('text')
+
+        @documents.change(uri, change.fetch('text'))
+      end
+
+      def handle_did_close(params)
+        uri = params.fetch('textDocument').fetch('uri')
+        @documents.close(uri)
+      end
+
+      def handle_formatting(id, params)
+        uri = params.fetch('textDocument').fetch('uri')
+        source = @documents.source_for(uri) || read_file_source(uri)
+        edits = if source
+                  @workspace.with_root_for(uri) { Formatter.format_edits(source) }
+                else
+                  []
+                end
+
+        respond(id, edits)
+      end
+
+      def handle_shutdown(id)
+        @shutdown_requested = true
+        respond(id, nil)
+      end
+
+      def read_file_source(uri)
+        path = URI.file_uri_to_path(uri)
+        return nil unless path && File.file?(path)
+
+        File.read(path)
+      end
+
+      def respond(id, result)
+        @io.write_message({
+                            jsonrpc: '2.0',
+                            id: id,
+                            result: result
+                          })
+      end
+
+      def respond_error(id, code, message)
+        @io.write_message({
+                            jsonrpc: '2.0',
+                            id: id,
+                            error: {
+                              code: code,
+                              message: message
+                            }
+                          })
+      end
+    end
+  end
+end

data/lib/rfmt/lsp/uri.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Rfmt
+  module LSP
+    module URI
+      module_function
+
+      def file_uri_to_path(uri)
+        parsed = ::URI.parse(uri)
+        return nil unless parsed.scheme == 'file'
+
+        percent_decode(parsed.path)
+      rescue ::URI::InvalidURIError
+        nil
+      end
+
+      def path_to_file_uri(path)
+        "file://#{percent_encode(File.expand_path(path))}"
+      end
+
+      def percent_decode(value)
+        value.gsub(/%[0-9A-Fa-f]{2}/) { |match| [match[1..].to_i(16)].pack('C') }
+      end
+
+      def percent_encode(value)
+        value.bytes.map do |byte|
+          char = byte.chr
+          char.match?(%r{[A-Za-z0-9._~/-]}) ? char : format('%%%02X', byte)
+        end.join
+      end
+    end
+  end
+end

data/lib/rfmt/lsp/workspace.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+require_relative 'uri'
+
+module Rfmt
+  module LSP
+    class Workspace
+      def initialize
+        @roots = []
+      end
+
+      def configure(params)
+        @roots = workspace_folder_roots(params)
+        root_uri = params['rootUri']
+        @roots << URI.file_uri_to_path(root_uri) if root_uri
+        @roots = @roots.compact.map { |root| File.expand_path(root) }.uniq
+      end
+
+      def root_for(uri)
+        path = URI.file_uri_to_path(uri)
+        return existing_root(@roots.first) unless path
+
+        matching_root = @roots
+                        .select { |root| path_inside?(path, root) }
+                        .max_by(&:length)
+        return existing_root(matching_root) if matching_root
+
+        existing_root(File.dirname(path))
+      end
+
+      def with_root_for(uri, &block)
+        root = root_for(uri)
+        return block.call unless root
+
+        Dir.chdir(root, &block)
+      end
+
+      private
+
+      def workspace_folder_roots(params)
+        Array(params['workspaceFolders']).filter_map do |folder|
+          URI.file_uri_to_path(folder['uri'])
+        end
+      end
+
+      def path_inside?(path, root)
+        relative = Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
+        relative == '.' || !relative.start_with?('..')
+      rescue ArgumentError
+        false
+      end
+
+      def existing_root(root)
+        return nil unless root && File.directory?(root)
+
+        root
+      end
+    end
+  end
+end

data/lib/rfmt/lsp.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'lsp/document_store'
+require_relative 'lsp/formatter'
+require_relative 'lsp/message_io'
+require_relative 'lsp/server'
+require_relative 'lsp/uri'
+require_relative 'lsp/workspace'

data/lib/rfmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rfmt
-  VERSION = '1.6.3'
+  VERSION = '2.0.0.beta1'
 end

data/lib/rfmt.rb

@@ -2,7 +2,6 @@
 
 require_relative 'rfmt/version'
 require_relative 'rfmt/native_extension_loader'
-require_relative 'rfmt/prism_bridge'
 
 # Load native extension with version-aware loader
 Rfmt::NativeExtensionLoader.load_extension
@@ -14,25 +13,43 @@ module Rfmt
   # AST validation errors
   class ValidationError < RfmtError; end
 
+  # Rust reports errors as plain StandardError with a [Rfmt::<kind>] prefix;
+  # these two kinds map onto the public exception classes.
+  NATIVE_PARSE_ERROR_PREFIX = '[Rfmt::ParseError] '
+  NATIVE_VALIDATION_ERROR_PREFIX = '[Rfmt::ValidationError] '
+  NATIVE_CONFIG_ERROR_PREFIX = '[Rfmt::ConfigError] '
+  private_constant :NATIVE_PARSE_ERROR_PREFIX, :NATIVE_VALIDATION_ERROR_PREFIX,
+                   :NATIVE_CONFIG_ERROR_PREFIX
+
   # Format Ruby source code
+  # Parsing, config resolution, and output validation all happen natively in Rust
   # @param source [String] Ruby source code to format
+  # @param config_path [String, nil] Explicit config file path; nil discovers
+  #   rfmt.yml/.rfmt.yml from the current directory upward (cached per process)
   # @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
+  def self.format(source, config_path: nil)
+    if config_path
+      format_code_with_config(source, config_path.to_s)
+    else
+      format_code(source)
+    end
   rescue StandardError => e
-    raise Error, "Unexpected error during formatting: #{e.class}: #{e.message}"
+    raise wrap_native_error(e)
+  end
+
+  def self.wrap_native_error(error)
+    message = error.message
+    if message.start_with?(NATIVE_PARSE_ERROR_PREFIX)
+      Error.new("Failed to parse Ruby code: #{message.delete_prefix(NATIVE_PARSE_ERROR_PREFIX)}")
+    elsif message.start_with?(NATIVE_VALIDATION_ERROR_PREFIX)
+      ValidationError.new(message.delete_prefix(NATIVE_VALIDATION_ERROR_PREFIX))
+    elsif message.start_with?(NATIVE_CONFIG_ERROR_PREFIX)
+      Error.new("Configuration error: #{message.delete_prefix(NATIVE_CONFIG_ERROR_PREFIX)}")
+    else
+      Error.new("Unexpected error during formatting: #{error.class}: #{message}")
+    end
   end
+  private_class_method :wrap_native_error
 
   # Format a Ruby file
   # @param path [String] Path to Ruby file
@@ -44,6 +61,15 @@ module Rfmt
     raise Error, "File not found: #{path}"
   end
 
+  # Effective configuration as the Rust formatter resolves it
+  # @param config_path [String, nil] Explicit config file path; nil discovers
+  # @return [String] YAML dump of the resolved configuration
+  def self.resolved_config(config_path: nil)
+    resolved_config_yaml(config_path&.to_s)
+  rescue StandardError => e
+    raise wrap_native_error(e)
+  end
+
   # Get version information
   # @return [String] Version string including Ruby and Rust versions
   def self.version_info
@@ -54,8 +80,9 @@ module Rfmt
   # @param source [String] Ruby source code
   # @return [String] AST representation
   def self.parse(source)
-    prism_json = PrismBridge.parse(source)
-    parse_to_json(prism_json)
+    parse_to_json(source)
+  rescue StandardError => e
+    raise wrap_native_error(e)
   end
 
   # Configuration management
@@ -114,7 +141,8 @@ module Rfmt
       current_dir = Dir.pwd
 
       loop do
-        ['.rfmt.yml', '.rfmt.yaml', 'rfmt.yml', 'rfmt.yaml'].each do |filename|
+        # Same search order as the Rust side (config/mod.rs CONFIG_FILE_NAMES)
+        ['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
@@ -132,7 +160,7 @@ module Rfmt
         nil
       end
       if home_dir
-        ['.rfmt.yml', '.rfmt.yaml', 'rfmt.yml', 'rfmt.yaml'].each do |filename|
+        ['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