rfmt 1.6.3-aarch64-linux → 2.0.0.beta1-aarch64-linux

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 2.0.0.beta1
 platform: aarch64-linux
 authors:
 - fujitani sora
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-04-24 00:00:00.000000000 Z
+date: 2026-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: language_server-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +85,7 @@ email:
 - fujitanisora0414@gmail.com
 executables:
 - rfmt
+- rfmt-lsp
 extensions: []
 extra_rdoc_files: []
 files:
@@ -64,15 +93,33 @@ files:
 - LICENSE.txt
 - README.md
 - exe/rfmt
+- exe/rfmt-lsp
+- exe/rfmt_fast
+- ext/rfmt/tests/fixtures/parity/comments_mixed.rb
+- ext/rfmt/tests/fixtures/parity/constructs.rb
+- ext/rfmt/tests/fixtures/parity/embdoc.rb
+- ext/rfmt/tests/fixtures/parity/heredoc_assign.rb
+- ext/rfmt/tests/fixtures/parity/heredoc_call_args.rb
+- ext/rfmt/tests/fixtures/parity/metadata_classes.rb
+- ext/rfmt/tests/fixtures/parity/metadata_conditionals.rb
+- ext/rfmt/tests/fixtures/parity/metadata_defs.rb
+- ext/rfmt/tests/fixtures/parity/multibyte.rb
+- ext/rfmt/tests/fixtures/parity/numeric.rb
+- ext/rfmt/tests/fixtures/parity/plain.rb
 - lib/rfmt.rb
 - lib/rfmt/3.3/rfmt.so
 - lib/rfmt/3.4/rfmt.so
 - lib/rfmt/cache.rb
 - lib/rfmt/cli.rb
 - lib/rfmt/configuration.rb
+- lib/rfmt/lsp.rb
+- lib/rfmt/lsp/document_store.rb
+- lib/rfmt/lsp/formatter.rb
+- lib/rfmt/lsp/message_io.rb
+- lib/rfmt/lsp/server.rb
+- lib/rfmt/lsp/uri.rb
+- lib/rfmt/lsp/workspace.rb
 - lib/rfmt/native_extension_loader.rb
-- lib/rfmt/prism_bridge.rb
-- lib/rfmt/prism_node_extractor.rb
 - lib/rfmt/version.rb
 - lib/ruby_lsp/rfmt/addon.rb
 - lib/ruby_lsp/rfmt/formatter_runner.rb