rfmt 1.7.0 → 2.0.0.beta1

data/Cargo.toml

@@ -5,3 +5,9 @@
 [workspace]
 members = ["./ext/rfmt"]
 resolver = "2"
+
+# panic = "abort" must not be set here: magnus relies on unwinding to convert
+# Rust panics into Ruby exceptions instead of killing the host process.
+[profile.release]
+lto = "thin"
+codegen-units = 1

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/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.7.0"
+version = "2.0.0-beta1"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"
@@ -8,7 +8,11 @@ publish = false
 
 [lib]
 name = "rfmt"
-crate-type = ["cdylib"]
+# rlib in addition to cdylib so integration tests (tests/) can link the crate
+crate-type = ["cdylib", "rlib"]
+# The doc examples are illustrative and were never compiled while the crate
+# was cdylib-only; keep them out of the test suite
+doctest = false
 
 [dependencies]
 # Ruby FFI
@@ -19,44 +23,21 @@ rb-sys = "0.9.124"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_yaml = "0.9"
-rmp-serde = "1.3"
 
 # Error handling
 thiserror = "1.0"
-anyhow = "1.0"
-
-# Parallel processing
-rayon = "1.8"
-
-# Caching
-lru = "0.12"
 
 # Logging
-log = "0.4"
-env_logger = "0.11"
+# "std" was previously enabled transitively via env_logger; set_boxed_logger needs it
+log = { version = "0.4", features = ["std"] }
 
 # Configuration
-config = "0.14"
-toml = "0.8"
 dirs = "5.0"
 globset = "0.4"
-
-# Security and resource management
-num_cpus = "1.16"
-
-# CLI (optional)
-clap = { version = "4.4", features = ["derive"], optional = true }
+ruby-prism = "1.9"
 
 [dev-dependencies]
-# Testing
-proptest = "1.4"
-insta = "1.34"
-criterion = "0.5"
 tempfile = "3.8"
 
-[features]
-default = ["cli"]
-cli = ["clap"]
-
 # Note: Benchmarks are included as part of the test suite due to Ruby FFI linking constraints.
 # Run performance tests with: cargo test --release perf_

data/ext/rfmt/src/ast/mod.rs

@@ -391,6 +391,8 @@ impl std::str::FromStr for NodeType {
 
 impl NodeType {
     /// Parse a node type from a string (convenience wrapper for `FromStr`)
+    // Infallible unlike the trait method; flagged only since the module went pub
+    #[allow(clippy::should_implement_trait)]
     pub fn from_str(s: &str) -> Self {
         s.parse().unwrap()
     }

data/ext/rfmt/src/config/mod.rs

@@ -1,4 +1,7 @@
 use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+use std::time::SystemTime;
 
 /// Complete configuration structure matching .rfmt.yml format
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -98,43 +101,114 @@ pub enum TrailingComma {
     Multiline,
 }
 
+/// Search order within each directory: rfmt.yml, rfmt.yaml, .rfmt.yml, .rfmt.yaml
+const CONFIG_FILE_NAMES: [&str; 4] = ["rfmt.yml", "rfmt.yaml", ".rfmt.yml", ".rfmt.yaml"];
+
+/// Discovery result cached per process so repeated format calls (CLI batch,
+/// long-lived LSP) skip the cwd-to-root-to-home filesystem walk.
+struct DiscoveryCache {
+    cwd: PathBuf,
+    /// Discovered file and its mtime; `None` when nothing was found.
+    found: Option<(PathBuf, SystemTime)>,
+    config: Config,
+}
+
+static DISCOVERY_CACHE: Mutex<Option<DiscoveryCache>> = Mutex::new(None);
+
+/// Explicit-path loads cached separately, keyed by canonical path + mtime,
+/// so a CLI batch does not re-parse the same YAML once per file.
+static EXPLICIT_CACHE: Mutex<Option<(PathBuf, SystemTime, Config)>> = Mutex::new(None);
+
 impl Config {
-    /// Discover configuration file in current directory or parent directories
-    /// Searches in order: rfmt.yml, rfmt.yaml, .rfmt.yml, .rfmt.yaml
-    pub fn discover() -> crate::error::Result<Self> {
-        let config_files = ["rfmt.yml", "rfmt.yaml", ".rfmt.yml", ".rfmt.yaml"];
-
-        // Try current directory and parent directories
-        if let Ok(mut current_dir) = std::env::current_dir() {
-            loop {
-                for filename in &config_files {
-                    let config_path = current_dir.join(filename);
-                    if config_path.exists() {
-                        log::info!("Found config file: {:?}", config_path);
-                        return Self::load_file(&config_path);
-                    }
-                }
-
-                // Move to parent directory
-                if !current_dir.pop() {
-                    break;
-                }
+    /// Resolve the effective configuration.
+    ///
+    /// Error handling differs by intent: an explicit path was asked for by
+    /// name, so load failures must surface loudly; discovery merely stumbles
+    /// on files, so a broken discovered file logs a warning and falls back
+    /// to defaults (an LSP mid-edit of .rfmt.yml must not break formatting).
+    pub fn resolve(explicit_path: Option<&Path>) -> crate::error::Result<Self> {
+        match explicit_path {
+            Some(path) => Self::load_explicit_cached(path),
+            None => {
+                let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+                Ok(Self::discover_cached_from(&cwd))
+            }
+        }
+    }
+
+    fn load_explicit_cached(path: &Path) -> crate::error::Result<Self> {
+        // Canonicalize so a relative path is not confused across cwd changes.
+        let key = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
+        // mtime read before the load: a racing write can only make the cache
+        // entry look older than the content, forcing a reload, never staleness.
+        let mtime = file_mtime(&key);
+
+        let mut guard = EXPLICIT_CACHE
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+
+        if let (Some((cached_path, cached_mtime, config)), Some(mtime)) = (guard.as_ref(), mtime) {
+            if *cached_path == key && *cached_mtime == mtime {
+                return Ok(config.clone());
+            }
+        }
+
+        let config = Self::load_file(path)?;
+        if let Some(mtime) = mtime {
+            *guard = Some((key, mtime, config.clone()));
+        }
+        Ok(config)
+    }
+
+    fn discover_cached_from(cwd: &Path) -> Self {
+        let mut guard = DISCOVERY_CACHE
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+
+        if let Some(cache) = guard.as_ref() {
+            if cache.cwd == cwd && cache_is_fresh(cwd, cache) {
+                return cache.config.clone();
             }
         }
 
-        // Try home directory
-        if let Some(home_dir) = dirs::home_dir() {
-            for filename in &config_files {
-                let config_path = home_dir.join(filename);
-                if config_path.exists() {
-                    log::debug!("Found config file in home: {:?}", config_path);
-                    return Self::load_file(&config_path);
-                }
+        let (config, found) = Self::discover_from(cwd);
+        *guard = Some(DiscoveryCache {
+            cwd: cwd.to_path_buf(),
+            found,
+            config: config.clone(),
+        });
+        config
+    }
+
+    /// Walk `start` up to the root, then the home directory.
+    fn find_config_file(start: &Path) -> Option<PathBuf> {
+        let mut current_dir = start.to_path_buf();
+        loop {
+            if let Some(path) = first_candidate_in(&current_dir) {
+                return Some(path);
+            }
+            if !current_dir.pop() {
+                break;
             }
         }
 
-        log::info!("No config file found, using defaults");
-        Ok(Config::default())
+        dirs::home_dir().and_then(|home| first_candidate_in(&home))
+    }
+
+    fn discover_from(start: &Path) -> (Self, Option<(PathBuf, SystemTime)>) {
+        let Some(path) = Self::find_config_file(start) else {
+            log::info!("No config file found, using defaults");
+            return (Config::default(), None);
+        };
+
+        // A broken file is still cached with its mtime so fixing it triggers a reload.
+        let config = Self::load_file(&path).unwrap_or_else(|e| {
+            log::warn!("Ignoring config file {:?}: {}", path, e);
+            Config::default()
+        });
+        let mtime = file_mtime(&path).unwrap_or(SystemTime::UNIX_EPOCH);
+        log::info!("Found config file: {:?}", path);
+        (config, Some((path, mtime)))
     }
 
     /// Load configuration from a YAML file
@@ -226,6 +300,35 @@ impl Config {
     }
 }
 
+fn first_candidate_in(dir: &Path) -> Option<PathBuf> {
+    CONFIG_FILE_NAMES
+        .iter()
+        .map(|name| dir.join(name))
+        .find(|path| path.exists())
+}
+
+fn file_mtime(path: &Path) -> Option<SystemTime> {
+    std::fs::metadata(path).and_then(|m| m.modified()).ok()
+}
+
+/// Cheap per-call re-validation replacing the full walk: stat the cwd
+/// candidates (catches a config newly created where formatting runs) and the
+/// discovered file's mtime (catches edits; a vanished file forces a re-walk).
+/// A config newly created outside cwd (parent directory or home) is not
+/// detected until something else invalidates the cache.
+fn cache_is_fresh(cwd: &Path, cache: &DiscoveryCache) -> bool {
+    let cwd_candidate = first_candidate_in(cwd);
+    match &cache.found {
+        Some((path, mtime)) => {
+            if cwd_candidate.is_some_and(|candidate| candidate != *path) {
+                return false;
+            }
+            file_mtime(path) == Some(*mtime)
+        }
+        None => cwd_candidate.is_none(),
+    }
+}
+
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -417,6 +520,140 @@ formatting:
         }
     }
 
+    // The discovery cache is process-global; serialize the tests that touch it.
+    static CACHE_TEST_LOCK: Mutex<()> = Mutex::new(());
+
+    fn write_indent_config(path: &Path, indent_width: usize) {
+        std::fs::write(
+            path,
+            format!("formatting:\n  indent_width: {indent_width}\n"),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn test_resolve_explicit_missing_path_errors_loudly() {
+        let result = Config::resolve(Some(Path::new("/nonexistent/rfmt.yml")));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_resolve_explicit_broken_file_errors_loudly() {
+        let mut file = NamedTempFile::new().unwrap();
+        file.write_all(b"formatting:\n  line_length: not_a_number\n")
+            .unwrap();
+        file.flush().unwrap();
+
+        assert!(Config::resolve(Some(file.path())).is_err());
+    }
+
+    #[test]
+    fn test_resolve_explicit_path_cached_and_reloaded_on_change() {
+        let _lock = CACHE_TEST_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("custom.yml");
+
+        write_indent_config(&path, 4);
+        assert_eq!(
+            Config::resolve(Some(&path))
+                .unwrap()
+                .formatting
+                .indent_width,
+            4
+        );
+
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        write_indent_config(&path, 3);
+        assert_eq!(
+            Config::resolve(Some(&path))
+                .unwrap()
+                .formatting
+                .indent_width,
+            3
+        );
+    }
+
+    #[test]
+    fn test_discovered_broken_file_falls_back_to_defaults() {
+        let _lock = CACHE_TEST_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(
+            dir.path().join("rfmt.yml"),
+            "formatting:\n  indent_width: 99\n",
+        )
+        .unwrap();
+
+        // Unlike an explicit path, discovery swallows load errors.
+        let config = Config::discover_cached_from(dir.path());
+        assert_eq!(config.formatting.indent_width, 2);
+    }
+
+    #[test]
+    fn test_discovery_cache_reloads_on_mtime_change() {
+        let _lock = CACHE_TEST_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("rfmt.yml");
+
+        write_indent_config(&path, 4);
+        assert_eq!(
+            Config::discover_cached_from(dir.path())
+                .formatting
+                .indent_width,
+            4
+        );
+
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        write_indent_config(&path, 3);
+        assert_eq!(
+            Config::discover_cached_from(dir.path())
+                .formatting
+                .indent_width,
+            3
+        );
+    }
+
+    #[test]
+    fn test_discovery_cache_missing_file_falls_back_to_walk() {
+        let _lock = CACHE_TEST_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        let sub = dir.path().join("sub");
+        std::fs::create_dir(&sub).unwrap();
+        let path = dir.path().join("rfmt.yml");
+
+        write_indent_config(&path, 4);
+        assert_eq!(
+            Config::discover_cached_from(&sub).formatting.indent_width,
+            4
+        );
+
+        std::fs::remove_file(&path).unwrap();
+        assert_eq!(
+            Config::discover_cached_from(&sub).formatting.indent_width,
+            2
+        );
+    }
+
+    #[test]
+    fn test_discovery_nothing_found_cached_then_new_config_in_cwd() {
+        let _lock = CACHE_TEST_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+
+        assert_eq!(
+            Config::discover_cached_from(dir.path())
+                .formatting
+                .indent_width,
+            2
+        );
+
+        write_indent_config(&dir.path().join("rfmt.yml"), 5);
+        assert_eq!(
+            Config::discover_cached_from(dir.path())
+                .formatting
+                .indent_width,
+            5
+        );
+    }
+
     #[test]
     fn test_partial_config_uses_defaults() {
         let yaml = r#"

data/ext/rfmt/src/error/mod.rs

@@ -8,6 +8,18 @@ pub enum RfmtError {
     #[error("Prism integration error: {0}")]
     PrismError(String),
 
+    // Message-only kinds: lib/rfmt.rb rewrites these into its public
+    // exception classes by their [Rfmt::...] prefix, so Display must not
+    // add any wrapper text around the message.
+    #[error("{0}")]
+    ParseError(String),
+
+    #[error("{0}")]
+    ValidationError(String),
+
+    #[error("{message}")]
+    ConfigError { message: String },
+
     #[error("Format error: {0}")]
     FormatError(String),
 
@@ -16,9 +28,6 @@ pub enum RfmtError {
         feature: String,
         explanation: String,
     },
-
-    #[error("Configuration error: {message}")]
-    ConfigError { message: String },
 }
 
 // Implement From for std::fmt::Error
@@ -33,6 +42,8 @@ impl RfmtError {
     pub fn to_magnus_error(&self, ruby: &Ruby) -> MagnusError {
         let exception_class = match self {
             RfmtError::PrismError(_) => "PrismError",
+            RfmtError::ParseError(_) => "ParseError",
+            RfmtError::ValidationError(_) => "ValidationError",
             RfmtError::FormatError(_) => "FormatError",
             RfmtError::UnsupportedFeature { .. } => "UnsupportedFeature",
             RfmtError::ConfigError { .. } => "ConfigError",

data/ext/rfmt/src/format/formatter.rs

@@ -23,8 +23,8 @@ use super::rule::format_remaining_comments;
 pub struct Formatter {
     /// Configuration for formatting
     config: Config,
-    /// Registry of formatting rules
-    registry: RuleRegistry,
+    /// Registry of formatting rules (shared: rules are stateless)
+    registry: &'static RuleRegistry,
 }
 
 impl Formatter {
@@ -32,15 +32,10 @@ impl Formatter {
     pub fn new(config: Config) -> Self {
         Self {
             config,
-            registry: RuleRegistry::default_registry(),
+            registry: RuleRegistry::shared(),
         }
     }
 
-    /// Creates a new formatter with a custom registry.
-    pub fn with_registry(config: Config, registry: RuleRegistry) -> Self {
-        Self { config, registry }
-    }
-
     /// Formats Ruby source code.
     ///
     /// # Arguments
@@ -71,7 +66,23 @@ impl Formatter {
 
         // 5. Print to string
         let mut printer = Printer::new(&self.config);
-        let result = printer.print(&final_doc);
+        let mut result = printer.print(&final_doc);
+
+        // 6. Re-append the `__END__` data section, which the AST excludes.
+        // Appended after printing (and its trailing-whitespace strip) so the
+        // data content survives byte-for-byte.
+        if let Some(data) = ast
+            .metadata
+            .get("data_start_offset")
+            .and_then(|offset| offset.parse::<usize>().ok())
+            .and_then(|offset| source.get(offset..))
+        {
+            if !result.is_empty() {
+                result.truncate(result.trim_end_matches('\n').len());
+                result.push('\n');
+            }
+            result.push_str(data);
+        }
 
         Ok(result)
     }
@@ -84,14 +95,14 @@ impl Formatter {
             _ => {
                 // Use the rule registry for specific node types
                 let rule = self.registry.get_rule(&node.node_type);
-                rule.format(node, ctx, &self.registry)
+                rule.format(node, ctx, self.registry)
             }
         }
     }
 
     /// Returns a reference to the registry for recursive formatting.
     pub fn registry(&self) -> &RuleRegistry {
-        &self.registry
+        self.registry
     }
 
     /// Formats the program node (root).

data/ext/rfmt/src/format/registry.rs

@@ -6,6 +6,7 @@
 use crate::ast::NodeType;
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::sync::OnceLock;
 
 use super::rule::{BoxedRule, FormatRule};
 use super::rules::{
@@ -104,6 +105,13 @@ impl RuleRegistry {
             .unwrap_or(self.fallback.as_ref())
     }
 
+    /// Rules are stateless, so one registry serves every format call;
+    /// building ~23 boxed rules per call was pure waste.
+    pub fn shared() -> &'static Self {
+        static SHARED: OnceLock<RuleRegistry> = OnceLock::new();
+        SHARED.get_or_init(Self::default_registry)
+    }
+
     pub fn default_registry() -> Self {
         Self::new()
             .add(NodeType::StatementsNode, StatementsRule)