rfmt 1.7.0-arm64-darwin → 2.0.0.beta1-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8621a28b9236c204fe7174a5bc1f39ea57c6e34e46d14e5cb8d16e25ce31249
-  data.tar.gz: 9ac7b22412b88d0e02fd80fcebc3f8187bf85b364e78727ffd27d0034c4f2e0a
+  metadata.gz: 2e48a20dec3297e9b379a630a804d753f3d64c0ad799008cc82afe8901939180
+  data.tar.gz: 271e9efdd6b8147ced7f01edd322b04979ebee53a1697e0d942ddc370e82ff70
 SHA512:
-  metadata.gz: c782de5fec224978ded24cd5b39de018caa202d5f606720e5206cf3a58a73c73f54ad730040d28de66a2c1453e44273dae6e97eaa06fa04f65e7ce2c3242898b
-  data.tar.gz: 0ad930fbcd8e78419d27b6f94ffbccafde5386cbe60dcb9f8e92ef6752369f6c111469df721d46ff67e2a4c69dd117fc56a0c7c991df343e1a32d77f4ec3170f
+  metadata.gz: e9e6eb7d91b7af5b66a61a62653d65b51675d9c097812fdd22cd5a5970cf1e04d626e9a1ac14775f3d37f7962a9ff07c561e33526de752bc476bf7cbf492b90a
+  data.tar.gz: 612c79ff387d04cb287d300084c8a5abd96dfb6a6fc090d3165438bde58049d406cf5b71bc74403bb9bd1cef4b53eb256bc6fd2a40ef178f1172722cc460dd41

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [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.

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
@@ -379,18 +372,29 @@ gem install rfmt
 rfmt-lsp
 ```
 
-Example Helix configuration:
+Example Neovim configuration (with `nvim-lspconfig`):
 
-```toml
-[language-server.rfmt]
-command = "rfmt-lsp"
+```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
 
-[[language]]
-name = "ruby"
-language-servers = ["rfmt"]
-auto-format = true
+lspconfig.rfmt.setup({})
 ```
 
+Helix, Emacs, and Zed configurations are covered in the
+[Editor Integration Guide](docs/editors.md).
+
 ### VSCode (Quick Start)
 
 1. Install [Ruby LSP extension](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rfmt
-  VERSION = '1.7.0'
+  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