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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be2a07afb756e17769afe0d1036e8bea93935fa58438ee277f5d49358d4b067f
-  data.tar.gz: 761e3b33656a52fa953a22bd74cc485726002d06ad507275145e1564171ece17
+  metadata.gz: f0c6681074bc422a604388e60cc5dee756651e2a645363f8226b81f5dd96992b
+  data.tar.gz: 0bddc889fcf62ba16e2868e4ea47254430954aea4755267e83e38e515d321c93
 SHA512:
-  metadata.gz: 7076830aa866c79630799d381ec4c25de31d614c18dc590530a40abb6bcd222134c7f7f060d6951acbbb82550e548dd05afb218eb7c0fff674bf3366b007fa12
-  data.tar.gz: fd6cb75b7f92f5add6ab88bbfc4a20c53c51b78db138c2ebf4ddb6408a536156dfae007cf7a9669be623626936be44c886021edfe5b1da12c2842d001318cfb3
+  metadata.gz: 87fe10e37abd3c2b7f9c63ec96899201aa7cb3c320baf427a7e9501b0dbe8541761e43438a7e5cc4b9c97e1137d6b052ceb3017602dad3891cd4ce560ba36d61
+  data.tar.gz: fdf482ae1350e6aa4ad44c70e68c9246eaf8a22e35a8f39bfb821a4f5ebc11756b8245c4af69b86b54a950ee88dcb97b4fadb89282f19e817624eac4803c53f8

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## [Unreleased]
 
+## [2.0.0.beta1] - 2026-07-22
+
+Parsing now happens natively in Rust. The Ruby-side Prism parse and JSON handoff have been replaced by the ruby-prism crate with prism statically linked into the extension; Ruby remains the CLI/LSP shell.
+
+### Changed
+
+- Native parsing via the ruby-prism crate: in-process formatting is about 22x faster: 0.19 ms/file measured with `scripts/bench_format.rb`, against a historical pre-migration baseline of 4.28 ms/file
+- `--config` is now honored when formatting
+- File writes are atomic (write to a temp file, then rename)
+
+### Added
+
+- Output-validation guard: formatted output is re-parsed and rejected if it fails to parse
+- Corpus check (`scripts/corpus_check.rb`): reformats every Ruby file in the repository and verifies AST equivalence with the prism gem; runs in CI alongside the parity fixtures
+
+### Fixed
+
+- The `__END__` data section is no longer dropped from formatted output; everything from `__END__` to EOF is preserved byte-for-byte
+- Method chain continuation indentation is now computed from the statement's output position instead of its input column, so misindented input converges in a single pass; heredoc bodies inside a reformatted chain keep their content byte-identical
+- A trailing comment on an `else` line stays on that line instead of moving below it
+
+### Removed
+
+- prism gem runtime dependency; it remains a development-only dependency for the corpus check and parity fixtures
+
+## [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

@@ -30,7 +30,7 @@ A Ruby code formatter written in Rust
 - **Opinionated**: Minimal configuration with consistent output
 - **Idempotent**: Running multiple times produces identical results
 - **Comment preservation**: Maintains existing comment placement
-- **Rust implementation**: Core formatter implemented in Rust
+- **Rust implementation**: Parsing and formatting both run natively in Rust (via the [ruby-prism](https://crates.io/crates/ruby-prism) crate); Ruby provides the CLI and LSP shell
 
 ## Features
 
@@ -49,35 +49,28 @@ Enforces code style rules:
 
 ## Performance
 
-rfmt delivers consistent, fast formatting across projects of any size:
+Parsing and formatting both run natively in Rust (the [ruby-prism](https://crates.io/crates/ruby-prism) crate, with prism statically linked), so the per-file cost is well under a millisecond:
 
-| Project Size | Files | Execution Time | Throughput |
-|-------------|-------|----------------|------------|
-| Small | 9 files | ~105ms | 85 files/sec |
-| Medium | 35 files | ~110ms | 315 files/sec |
-| Large | 151 files | ~100ms | 1,560 files/sec |
+| Pipeline | In-process format time |
+|----------|------------------------|
+| Before native parsing (Ruby Prism parse + JSON handoff to Rust; historical, not reproducible from this checkout) | 4.28 ms/file |
+| Now (parsing and formatting in Rust) | 0.19 ms/file |
 
-**Key Performance Characteristics:**
+Measured with `scripts/bench_format.rb` over rfmt's own `lib/` corpus on arm64 macOS, Ruby 3.4. Reproduce with:
 
-- **Constant Time**: Execution time stays around 100ms regardless of project size
-- **Parallel Processing**: Automatic scaling with available CPU cores
-- **High Throughput**: Up to 1,500+ files per second on large projects
-- **Low Overhead**: Minimal startup time and memory usage
-
-**Test Environment:**
-- CPU: Apple Silicon (arm64)
-- Ruby: 3.4.8
-- Average of 5 runs per test
+```bash
+bundle exec ruby scripts/bench_format.rb
+```
 
-*Built with Rust for optimal performance and memory efficiency.*
+A cold CLI invocation (`rfmt --check FILE`) takes roughly 0.1-0.25 s of wall-clock time; that is Ruby VM startup, not formatting.
 
-For detailed performance comparisons and benchmarks, see [Performance Benchmarks](docs/benchmark.md).
+For more detail and a historical comparison against RuboCop, see [Performance Benchmarks](docs/benchmark.md).
 
 ## Installation
 
 ### Requirements
 
-- Ruby 3.0 or higher
+- Ruby 3.3 or higher
 - Rust 1.70 or higher (for building from source)
 
 ### From RubyGems
@@ -361,7 +354,46 @@ 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 Neovim configuration (with `nvim-lspconfig`):
+
+```lua
+local configs = require("lspconfig.configs")
+local lspconfig = require("lspconfig")
+
+if not configs.rfmt then
+  configs.rfmt = {
+    default_config = {
+      cmd = { "rfmt-lsp" },
+      filetypes = { "ruby" },
+      root_dir = lspconfig.util.root_pattern(".rfmt.yml", ".git"),
+      single_file_support = true,
+    },
+  }
+end
+
+lspconfig.rfmt.setup({})
+```
+
+Helix, Emacs, and Zed configurations are covered in the
+[Editor Integration Guide](docs/editors.md).
 
 ### 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/ext/rfmt/tests/fixtures/parity/comments_mixed.rb

@@ -0,0 +1,9 @@
+# leading comment
+x = 1 # trailing comment
+
+=begin
+embdoc line one
+line two
+=end
+y = 2
+# final comment

data/ext/rfmt/tests/fixtures/parity/constructs.rb

@@ -0,0 +1,50 @@
+expected = :ready
+
+case payload
+in [Integer => first, *rest]
+  first + rest.sum
+in { status: String => status, code: 200 | 201 }
+  status
+in ^expected
+  :pinned
+else
+  :unmatched
+end
+
+begin
+  risky!
+rescue KeyError => e
+  recover(e)
+rescue StandardError
+  retry_count += 1
+  retry if retry_count < 3
+else
+  celebrate
+ensure
+  cleanup
+end
+
+counters = Hash.new(0)
+counters[:hits] ||= 0
+counters[:hits] += 1
+@cache &&= @cache.compact
+$verbose ||= false
+CONFIG = { a: 3r, b: 3.14r, c: 2i, d: 2ri }
+
+class << self
+  def singleton_helper = :ok
+end
+
+alias aka singleton_helper
+alias $err $stderr
+undef :aka
+
+flip = items.select { |l| (l == first)..(l == last) }
+
+lines = ->(input) { input.each_line.to_a }
+x, *middle, z = lines.call(<<~TXT)
+  alpha
+  beta
+  gamma
+TXT
+puts x, middle, z

data/ext/rfmt/tests/fixtures/parity/embdoc.rb

@@ -0,0 +1,12 @@
+=begin
+Block documentation spanning
+multiple lines.
+=end
+value = 42
+
+=begin
+Another embedded document right before a method.
+=end
+def answer
+  value
+end

data/ext/rfmt/tests/fixtures/parity/heredoc_assign.rb

@@ -0,0 +1,15 @@
+sql = <<~SQL
+  SELECT *
+  FROM users
+  WHERE active = true
+SQL
+
+body = <<-TEXT
+  indented terminator keeps its column
+  TEXT
+
+plain = <<HTML
+<p>no squiggly</p>
+HTML
+
+after = sql.length + body.length

data/ext/rfmt/tests/fixtures/parity/heredoc_call_args.rb

@@ -0,0 +1,17 @@
+result = execute(<<~SQL, timeout: 5)
+  SELECT id
+  FROM events
+SQL
+
+logger.info(prefix, <<~MSG)
+  first line
+  second line
+MSG
+
+wrap(inner(<<~ONE), <<~TWO)
+  one body
+ONE
+  two body
+TWO
+
+puts result

data/ext/rfmt/tests/fixtures/parity/metadata_classes.rb

@@ -0,0 +1,30 @@
+class Foo::Bar < Baz::Qux
+  def change
+    x = compute(1)
+    @count = x
+  end
+end
+
+class AddUsers < ActiveRecord::Migration[8.1]
+  def change
+    create_table :users
+  end
+end
+
+class Simple < Base
+end
+
+class Plain
+end
+
+module Alpha::Beta
+end
+
+module Gamma
+end
+
+class ::TopScoped < ::Deep::Nested::Base
+end
+
+module Alpha::Beta::Gamma
+end

data/ext/rfmt/tests/fixtures/parity/metadata_conditionals.rb

@@ -0,0 +1,14 @@
+result = flag ? 1 : 2
+
+if flag
+  a = 1
+else
+  a = 2
+end
+
+unless flag
+  b = 3
+end
+
+c = 4 if flag
+d = 5 unless flag

data/ext/rfmt/tests/fixtures/parity/metadata_defs.rb

@@ -0,0 +1,33 @@
+def !@
+  true
+end
+
+def +@
+  self
+end
+
+def []=(key, value)
+  store(key, value)
+end
+
+def self.build(name)
+  new(name)
+end
+
+obj = Object.new
+
+def obj.run
+  1
+end
+
+def bare arg
+  arg
+end
+
+def none
+  0
+end
+
+def empty_parens()
+  nil
+end

data/ext/rfmt/tests/fixtures/parity/multibyte.rb

@@ -0,0 +1,14 @@
+greeting = "こんにちは、世界"
+farewell = 'さようなら'; short = "あ"
+
+def label(polite: false)
+  polite ? "です" : "だ"
+end
+
+mixed = "emoji 🎉 と 日本語"
+message = <<~TEXT
+  一行目の本文
+  二行目の本文
+TEXT
+
+combined = "#{greeting} #{mixed}".freeze

data/ext/rfmt/tests/fixtures/parity/numeric.rb

@@ -0,0 +1,6 @@
+a = 3r
+b = 3.14r
+c = 2i
+d = 2ri
+e = 6.02e2i
+f = a + b * c - d / e

data/ext/rfmt/tests/fixtures/parity/plain.rb

@@ -0,0 +1,31 @@
+class Greeter
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def greet(loud: false)
+    message = "hello, #{name}"
+    if loud
+      message.upcase
+    else
+      message
+    end
+  end
+end
+
+module Registry
+  DEFAULT = Greeter.new("world")
+
+  def self.lookup(key)
+    entries.fetch(key) { DEFAULT }
+  end
+end
+
+items = [1, 2.5, :three, nil, true]
+totals = { "sum" => items.compact.size, count: items.length }
+items.each_with_index do |item, index|
+  puts "#{index}: #{item}" unless item.nil?
+end
+result = Registry.lookup(:default)&.greet(loud: totals[:count] > 3)

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