rfmt 1.6.3-x86_64-linux → 1.7.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f590757d8569ca48a5312d0671759def5cee9bc6c23bed48354e19d594dddf5
-  data.tar.gz: 24d4c203675cf0a8fced50db72658c89c5fdda7ee74c75c2a9a5e9fb5b8bb26f
+  metadata.gz: 0f88fbe75db61892eb755ad85a5e726632948858b279080967c2272f1ab1d3c6
+  data.tar.gz: d9c3f992757e3179e9f26602c3410cb1609286c839d97603d07f38341b782238
 SHA512:
-  metadata.gz: a83cb835242ede397ed9ddeb821c37c20a42edca78aef496419161a920736492d64eedb0c2816264437048a4548d9b9bf31e0e39bd0b9973fd99c97383ecce82
-  data.tar.gz: f7a515ce7977a348b80efe89fb093ebeccf470ee80a2d63ba3cc25eb27585d8586f38ba008bc28c5cda70bfac4b4d1038f877a53a43ac6cb5b230619c7aa1d35
+  metadata.gz: 16c46e05a978c98a89b246205b2bfef36454412afbac175e7aef5dbe6d5581b39409101c7549ea7408840e2a6adbf21d43202af674fbd38950feaea559cbe9c0
+  data.tar.gz: a38fac5c2c9cc0070a59ef022d9efb6a76bfb5fb01b39d8d1ace700eb51165fa53522c06fc48f2f4b1fd1f64acbd5e3758c76c4e120b7f779b276a96f0fa68b2

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [1.7.0] - 2026-06-04
+
+rfmt now ships a standalone LSP server. Point any LSP-capable editor at `rfmt-lsp` and you get format-on-save — no Ruby LSP, no Gemfile, and no editor-specific plugin required. This makes rfmt usable from Helix, Neovim, Emacs, and any other LSP client, including in projects that don't bundle rfmt.
+
+### Added
+
+- Standalone LSP server `rfmt-lsp` (#108). Provides format-on-save in any LSP-capable editor without requiring Ruby LSP or a Gemfile:
+  - `textDocument/formatting` with full document sync; unsaved buffer contents are formatted via `didOpen`/`didChange` tracking
+  - `.rfmt.yml` is resolved relative to the workspace root (`rootUri`/`workspaceFolders`)
+  - Graceful handling of syntax errors (returns no edits instead of crashing), empty files, and unsupported LSP methods
+  - New `exe/rfmt-lsp` executable shipped with the gem
+- Editor setup guides for the standalone server (Neovim, Helix, Emacs eglot) in `docs/editors.md`
+
 ## [1.6.3] - 2026-04-24
 
 Minor stability refinements on top of the 1.6.x architecture release. See the 1.6.1 notes below for the feature set this series delivers.

data/README.md

@@ -361,7 +361,35 @@ end
 
 ## Editor Integration
 
-rfmt integrates with editors through [Ruby LSP](https://shopify.github.io/ruby-lsp/). For detailed setup instructions, see [Editor Integration Guide](docs/editors.md).
+rfmt can integrate with editors in two ways:
+
+- Standalone LSP: run `rfmt-lsp` directly from your editor. This works well for single
+  Ruby scripts or projects without a Gemfile.
+- Ruby LSP add-on: use rfmt as the formatter inside
+  [Ruby LSP](https://shopify.github.io/ruby-lsp/).
+
+For detailed setup instructions, see [Editor Integration Guide](docs/editors.md).
+
+### Standalone LSP
+
+After installing rfmt, configure your editor's Ruby language server command to `rfmt-lsp`.
+
+```bash
+gem install rfmt
+rfmt-lsp
+```
+
+Example Helix configuration:
+
+```toml
+[language-server.rfmt]
+command = "rfmt-lsp"
+
+[[language]]
+name = "ruby"
+language-servers = ["rfmt"]
+auto-format = true
+```
 
 ### VSCode (Quick Start)
 

data/exe/rfmt-lsp

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$VERBOSE = nil unless ENV['RFMT_VERBOSE']
+
+require 'rfmt/lsp/server'
+
+exit Rfmt::LSP::Server.new.run

data/exe/rfmt_fast

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Fast launcher for rfmt without gem warnings
+
+# Suppress all warnings
+$VERBOSE = nil
+
+# Direct load without rubygems overhead
+require_relative '../lib/rfmt/cli'
+
+Rfmt::CLI.start(ARGV)

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 = '1.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.7.0
 platform: x86_64-linux
 authors:
 - fujitani sora
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-04-24 00:00:00.000000000 Z
+date: 2026-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -38,6 +38,48 @@ 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: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +99,7 @@ email:
 - fujitanisora0414@gmail.com
 executables:
 - rfmt
+- rfmt-lsp
 extensions: []
 extra_rdoc_files: []
 files:
@@ -64,12 +107,21 @@ files:
 - LICENSE.txt
 - README.md
 - exe/rfmt
+- exe/rfmt-lsp
+- exe/rfmt_fast
 - 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