rfmt 1.5.3 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9257e8d3dca2d3c849ce3040387b7f0430bf110f70f4ca3951b24ada8365b43e
-  data.tar.gz: c3a1a6ac54502ae6cce494534964f80078bca40fd7818b75b5b483010db91b2a
+  metadata.gz: 327f57f105df77a0d6b77bda9ab87c4f234f03f23fb918d74679942456c5a8ec
+  data.tar.gz: 482a5406275e422fb306970ffb47708f37be0c3115bc92485996d2adde6c9463
 SHA512:
-  metadata.gz: 53dbf78b4b9e7bf20f52ddb430464bae9e449c874963665d9748f77ea6aa918e9c0160ef1f6358f8ed4cbe4e29b1e13e4d37a532cd43d401333746a12cd188d3
-  data.tar.gz: b84e983d37f74f7c3bcb8ff98d4b382093cd47a29249bc8a4f50a4a2456d0b0a264f28defa76e203a55d62b376e0207351dbbd566d0eba327aa42ba46f4cd699
+  metadata.gz: 52982745650ed439f2ac7a5a1a9a26ae2dcf9e9df8015526278f58508929e15a1d72425d2d3c5963c0a4008968e20fcb6c374881122a3e99618d2cef15434eaf
+  data.tar.gz: 10e8282f05caacdffcbb2d7042e9f95a08c5d08c9b081307a12752840549fbb08b6bc557a256a9a46fd012986369fd7cfd0442a46d1d81146c2fb234d0b936f7

data/CHANGELOG.md

@@ -1,5 +1,56 @@
 ## [Unreleased]
 
+## [1.6.1] - 2026-04-24
+
+Follow-up release consolidating the 1.6.0 architecture work.
+
+### Rule-based formatter
+
+The rule-based `format/` pipeline (`Formatter`, `Registry`, `Rule`) is the canonical formatting path, replacing the legacy monolithic emitter. Rules covering body indentation (`StatementsRule`), singleton classes (`SingletonClassRule`), and variable writes (`VariableWriteRule`) ship as part of the default registry. The Intermediate Representation (IR) module decouples parsing from emission for composability and testability.
+
+### Method chain reformatting
+
+Multi-line method chains can be reformatted from aligned style (indented under the first dot) to indented style (one level beyond the receiver), preserving the source's base indent. The pass is wired into the fallback path for resilience.
+
+### Printer optimizations
+
+The printer carries a pre-computed indent cache and inline hints for the hot path; `reformat_chain_lines` has been deduplicated across rules and uses `Cow<str>` to avoid allocations on pass-through.
+
+### Editor integration
+
+Setup guides for VSCode, Neovim, Helix, Emacs, and Zed land in the repository; every editor uses the Ruby LSP addon system, so there are no editor-specific plugins to maintain. The README's Editor Integration section replaces the previous "Coming Soon" placeholder with a VSCode quick start.
+
+## [1.6.0] - 2026-04-23
+
+### Added
+- **Rule-based formatter architecture**: new modular `format/` pipeline (`Formatter`, `Registry`, `Rule`) replacing the legacy monolithic emitter
+- **Intermediate Representation (IR) module**: decouples parsing from emission for composability and testability
+- New formatter rules: `StatementsRule` (body indentation), `SingletonClassRule`, `VariableWriteRule`
+- Method chain reformatting: convert aligned style to indented style when lines exceed the configured width
+- Chain reformatting wired into the fallback path for resilience
+- `config` module exported for test consumption
+- **Editor Integration Documentation**: comprehensive setup guides for VSCode, Neovim, Helix, Emacs, and Zed
+  - VSCode: Format on Save configuration with Ruby LSP, settings reference table, project-specific setup
+  - Zed: full configuration with `initialization_options` and `format_on_save`
+  - All editors work through the Ruby LSP addon system — no editor-specific plugins required
+- README: Editor Integration section updated with VSCode quick start (replacing "Coming Soon")
+
+### Changed
+- Printer optimized with indent cache and inline hints
+- `reformat_chain_lines` deduplicated across rules and optimized with `Cow` to reduce allocations
+- README: Neovim integration updated from CLI-based to Ruby LSP-based approach
+- Removed Sublime Text section from editor documentation (replaced by Zed)
+
+### Fixed
+- Prism comment JSON deserialization now accepts `comment_type` and `embdoc` fields (#97)
+- BTreeMap range panic when computing comment indices on edge inputs
+- Comment duplication during source extraction
+- Empty source input handled gracefully by the formatter runner
+- Clippy warnings: use `repeat_n`
+
+### Removed
+- Legacy `Emitter` module (1844 LOC) — superseded by the new `Formatter`
+
 ## [1.5.3] - 2026-02-22
 
 ### Changed

data/Cargo.lock

@@ -1251,7 +1251,7 @@ checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "rfmt"
-version = "1.5.3"
+version = "1.6.1"
 dependencies = [
  "anyhow",
  "clap",

data/README.md

@@ -361,30 +361,34 @@ end
 
 ## Editor Integration
 
-### Neovim
+rfmt integrates with editors through [Ruby LSP](https://shopify.github.io/ruby-lsp/). For detailed setup instructions, see [Editor Integration Guide](docs/editors.md).
+
+### VSCode (Quick Start)
 
-Format Ruby files on save using autocmd:
+1. Install [Ruby LSP extension](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
+2. Add to your `settings.json`:
+
+```json
+{
+  "rubyLsp.formatter": "rfmt",
+  "editor.formatOnSave": true,
+  "[ruby]": {
+    "editor.defaultFormatter": "Shopify.ruby-lsp"
+  }
+}
+```
+
+### Neovim
 
 ```lua
--- ~/.config/nvim/init.lua
-
-vim.api.nvim_create_autocmd("BufWritePre", {
-  pattern = { "*.rb", "*.rake", "Gemfile", "Rakefile" },
-  callback = function()
-    local filepath = vim.fn.expand("%:p")
-    local result = vim.fn.system({ "rfmt", filepath })
-    if vim.v.shell_error == 0 then
-      vim.cmd("edit!")
-    end
-  end,
+require("lspconfig").ruby_lsp.setup({
+  init_options = {
+    formatter = "rfmt"
+  }
 })
 ```
 
-### Coming Soon
-
-- **VS Code** - Extension in development
-- **RubyMine** - Plugin in development
-- **Zed** - Extension in development
+See [Editor Integration Guide](docs/editors.md) for Helix, Emacs, Sublime Text, and more.
 
 ## Development
 

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.5.3"
+version = "1.6.1"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"
@@ -57,3 +57,6 @@ 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/doc/builders.rs

@@ -0,0 +1,528 @@
+//! Builder functions for constructing Doc IR.
+//!
+//! These functions provide a convenient API for building Doc trees.
+//! They are inspired by Prettier's document builders.
+//!
+//! # Example
+//!
+//! ```rust
+//! use rfmt::doc::builders::*;
+//!
+//! // Build a simple Ruby method
+//! let doc = concat(vec![
+//!     text("def foo"),
+//!     hardline(),
+//!     indent(concat(vec![
+//!         text("puts \"hello\""),
+//!     ])),
+//!     hardline(),
+//!     text("end"),
+//! ]);
+//! ```
+
+use super::{Doc, GroupId};
+
+/// Creates a text document.
+///
+/// # Example
+/// ```rust
+/// let doc = text("hello");
+/// ```
+pub fn text<S: Into<String>>(s: S) -> Doc {
+    Doc::Text(s.into())
+}
+
+/// Concatenates multiple documents.
+///
+/// # Example
+/// ```rust
+/// let doc = concat(vec![text("a"), text("b"), text("c")]);
+/// // Prints: "abc"
+/// ```
+pub fn concat(docs: Vec<Doc>) -> Doc {
+    // Flatten nested Concats and remove Empty docs
+    let flattened: Vec<Doc> = docs
+        .into_iter()
+        .flat_map(|doc| match doc {
+            Doc::Concat(inner) => inner,
+            Doc::Empty => vec![],
+            other => vec![other],
+        })
+        .collect();
+
+    match flattened.len() {
+        0 => Doc::Empty,
+        1 => flattened.into_iter().next().unwrap(),
+        _ => Doc::Concat(flattened),
+    }
+}
+
+/// Creates a group that tries to fit on one line.
+///
+/// If the contents fit within the line width, Line docs become spaces.
+/// Otherwise, they become newlines.
+///
+/// # Example
+/// ```rust
+/// let doc = group(concat(vec![
+///     text("["),
+///     softline(),
+///     text("1, 2, 3"),
+///     softline(),
+///     text("]"),
+/// ]));
+/// // Short version: "[1, 2, 3]"
+/// // Long version:
+/// // [
+/// //   1, 2, 3
+/// // ]
+/// ```
+pub fn group(contents: Doc) -> Doc {
+    Doc::Group {
+        contents: Box::new(contents),
+        break_parent: false,
+        id: None,
+    }
+}
+
+/// Creates a group with a specific ID for IfBreak references.
+pub fn group_with_id(contents: Doc, id: GroupId) -> Doc {
+    Doc::Group {
+        contents: Box::new(contents),
+        break_parent: false,
+        id: Some(id),
+    }
+}
+
+/// Creates a group that forces parent groups to break.
+pub fn group_break(contents: Doc) -> Doc {
+    Doc::Group {
+        contents: Box::new(contents),
+        break_parent: true,
+        id: None,
+    }
+}
+
+/// Increases indentation for the contents.
+///
+/// # Example
+/// ```rust
+/// let doc = concat(vec![
+///     text("class Foo"),
+///     hardline(),
+///     indent(text("def bar; end")),
+///     hardline(),
+///     text("end"),
+/// ]);
+/// // Prints:
+/// // class Foo
+/// //   def bar; end
+/// // end
+/// ```
+pub fn indent(contents: Doc) -> Doc {
+    Doc::Indent(Box::new(contents))
+}
+
+/// A line break that becomes a space in flat mode.
+///
+/// - In flat mode (group fits on one line): prints a space
+/// - In break mode (group doesn't fit): prints a newline + indentation
+///
+/// # Example
+/// ```rust
+/// group(concat(vec![text("a"), line(), text("b")]))
+/// // Flat: "a b"
+/// // Break: "a\n  b"
+/// ```
+pub fn line() -> Doc {
+    Doc::Line {
+        soft: false,
+        hard: false,
+        literal: false,
+    }
+}
+
+/// A line break that disappears in flat mode.
+///
+/// - In flat mode: prints nothing
+/// - In break mode: prints a newline + indentation
+///
+/// # Example
+/// ```rust
+/// group(concat(vec![text("["), softline(), text("1"), softline(), text("]")]))
+/// // Flat: "[1]"
+/// // Break: "[\n  1\n]"
+/// ```
+pub fn softline() -> Doc {
+    Doc::Line {
+        soft: true,
+        hard: false,
+        literal: false,
+    }
+}
+
+/// A line break that always prints a newline.
+///
+/// This forces a line break regardless of whether the content fits.
+///
+/// # Example
+/// ```rust
+/// concat(vec![text("line1"), hardline(), text("line2")])
+/// // Always prints:
+/// // line1
+/// // line2
+/// ```
+pub fn hardline() -> Doc {
+    Doc::Line {
+        soft: false,
+        hard: true,
+        literal: false,
+    }
+}
+
+/// A literal line break without indentation.
+///
+/// Used for heredocs where the content should not be indented.
+///
+/// # Example
+/// ```rust
+/// concat(vec![text("<<~HEREDOC"), literalline(), text("content"), literalline(), text("HEREDOC")])
+/// ```
+pub fn literalline() -> Doc {
+    Doc::Line {
+        soft: false,
+        hard: true,
+        literal: true,
+    }
+}
+
+/// Conditional content based on group break state.
+///
+/// # Arguments
+/// - `break_contents`: Printed when the group is broken (multi-line)
+/// - `flat_contents`: Printed when the group is flat (single line)
+///
+/// # Example
+/// ```rust
+/// group(concat(vec![
+///     text("["),
+///     if_break(
+///         concat(vec![hardline(), indent(text("1, 2, 3")), hardline()]),
+///         text("1, 2, 3"),
+///     ),
+///     text("]"),
+/// ]))
+/// // Flat: "[1, 2, 3]"
+/// // Break:
+/// // [
+/// //   1, 2, 3
+/// // ]
+/// ```
+pub fn if_break(break_contents: Doc, flat_contents: Doc) -> Doc {
+    Doc::IfBreak {
+        break_contents: Box::new(break_contents),
+        flat_contents: Box::new(flat_contents),
+        group_id: None,
+    }
+}
+
+/// Conditional content referencing a specific group.
+pub fn if_break_with_group(break_contents: Doc, flat_contents: Doc, group_id: GroupId) -> Doc {
+    Doc::IfBreak {
+        break_contents: Box::new(break_contents),
+        flat_contents: Box::new(flat_contents),
+        group_id: Some(group_id),
+    }
+}
+
+/// Joins documents with a separator.
+///
+/// # Example
+/// ```rust
+/// join(text(", "), vec![text("a"), text("b"), text("c")])
+/// // Prints: "a, b, c"
+/// ```
+pub fn join(separator: Doc, docs: Vec<Doc>) -> Doc {
+    if docs.is_empty() {
+        return Doc::Empty;
+    }
+
+    let mut result = Vec::with_capacity(docs.len() * 2 - 1);
+    let mut first = true;
+
+    for doc in docs {
+        if !first {
+            result.push(separator.clone());
+        }
+        result.push(doc);
+        first = false;
+    }
+
+    concat(result)
+}
+
+/// Joins documents with a line separator.
+///
+/// In flat mode, uses spaces. In break mode, uses newlines.
+///
+/// # Example
+/// ```rust
+/// group(join_line(vec![text("a"), text("b"), text("c")]))
+/// // Flat: "a b c"
+/// // Break:
+/// // a
+/// // b
+/// // c
+/// ```
+pub fn join_line(docs: Vec<Doc>) -> Doc {
+    join(line(), docs)
+}
+
+/// Joins documents with a softline separator.
+pub fn join_softline(docs: Vec<Doc>) -> Doc {
+    join(softline(), docs)
+}
+
+/// Joins documents with a hardline separator.
+pub fn join_hardline(docs: Vec<Doc>) -> Doc {
+    join(hardline(), docs)
+}
+
+/// Creates an empty document.
+pub fn empty() -> Doc {
+    Doc::Empty
+}
+
+/// Creates a trailing comment.
+///
+/// # Example
+/// ```rust
+/// concat(vec![text("code"), trailing_comment("# comment")])
+/// // Prints: "code # comment"
+/// ```
+pub fn trailing_comment<S: Into<String>>(text: S) -> Doc {
+    Doc::TrailingComment(text.into())
+}
+
+/// Creates a leading comment.
+///
+/// # Example
+/// ```rust
+/// concat(vec![leading_comment("# comment", true), text("code")])
+/// // Prints:
+/// // # comment
+/// // code
+/// ```
+pub fn leading_comment<S: Into<String>>(text: S, hard_line_after: bool) -> Doc {
+    Doc::LeadingComment {
+        text: text.into(),
+        hard_line_after,
+    }
+}
+
+/// Aligns content to a specific column offset.
+pub fn align(n: usize, contents: Doc) -> Doc {
+    Doc::Align {
+        n,
+        contents: Box::new(contents),
+    }
+}
+
+/// Content to be appended at the end of the line.
+pub fn line_suffix(contents: Doc) -> Doc {
+    Doc::LineSuffix(Box::new(contents))
+}
+
+/// Fill: packs content into lines as tightly as possible.
+pub fn fill(docs: Vec<Doc>) -> Doc {
+    Doc::Fill(docs)
+}
+
+/// Creates multiple hardlines (blank lines).
+///
+/// # Example
+/// ```rust
+/// blank_lines(2)
+/// // Prints two newlines (one blank line between)
+/// ```
+pub fn blank_lines(count: usize) -> Doc {
+    if count == 0 {
+        return Doc::Empty;
+    }
+
+    let lines: Vec<Doc> = (0..count).map(|_| hardline()).collect();
+    concat(lines)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_text() {
+        let doc = text("hello");
+        assert_eq!(doc, Doc::Text("hello".to_string()));
+    }
+
+    #[test]
+    fn test_concat_flattens() {
+        let doc = concat(vec![
+            text("a"),
+            concat(vec![text("b"), text("c")]),
+            text("d"),
+        ]);
+
+        // Should flatten to a single Concat with 4 elements
+        if let Doc::Concat(docs) = doc {
+            assert_eq!(docs.len(), 4);
+        } else {
+            panic!("Expected Concat");
+        }
+    }
+
+    #[test]
+    fn test_concat_removes_empty() {
+        let doc = concat(vec![text("a"), empty(), text("b")]);
+
+        if let Doc::Concat(docs) = doc {
+            assert_eq!(docs.len(), 2);
+        } else {
+            panic!("Expected Concat");
+        }
+    }
+
+    #[test]
+    fn test_concat_single_element() {
+        let doc = concat(vec![text("a")]);
+        assert_eq!(doc, Doc::Text("a".to_string()));
+    }
+
+    #[test]
+    fn test_concat_empty() {
+        let doc = concat(vec![]);
+        assert_eq!(doc, Doc::Empty);
+    }
+
+    #[test]
+    fn test_group() {
+        let doc = group(text("hello"));
+        if let Doc::Group {
+            contents,
+            break_parent,
+            id,
+        } = doc
+        {
+            assert_eq!(*contents, Doc::Text("hello".to_string()));
+            assert!(!break_parent);
+            assert!(id.is_none());
+        } else {
+            panic!("Expected Group");
+        }
+    }
+
+    #[test]
+    fn test_indent() {
+        let doc = indent(text("body"));
+        if let Doc::Indent(contents) = doc {
+            assert_eq!(*contents, Doc::Text("body".to_string()));
+        } else {
+            panic!("Expected Indent");
+        }
+    }
+
+    #[test]
+    fn test_line_variants() {
+        let l = line();
+        assert_eq!(
+            l,
+            Doc::Line {
+                soft: false,
+                hard: false,
+                literal: false
+            }
+        );
+
+        let sl = softline();
+        assert_eq!(
+            sl,
+            Doc::Line {
+                soft: true,
+                hard: false,
+                literal: false
+            }
+        );
+
+        let hl = hardline();
+        assert_eq!(
+            hl,
+            Doc::Line {
+                soft: false,
+                hard: true,
+                literal: false
+            }
+        );
+
+        let ll = literalline();
+        assert_eq!(
+            ll,
+            Doc::Line {
+                soft: false,
+                hard: true,
+                literal: true
+            }
+        );
+    }
+
+    #[test]
+    fn test_join() {
+        let doc = join(text(", "), vec![text("a"), text("b"), text("c")]);
+
+        if let Doc::Concat(docs) = doc {
+            assert_eq!(docs.len(), 5); // a, ", ", b, ", ", c
+        } else {
+            panic!("Expected Concat");
+        }
+    }
+
+    #[test]
+    fn test_join_empty() {
+        let doc = join(text(", "), vec![]);
+        assert_eq!(doc, Doc::Empty);
+    }
+
+    #[test]
+    fn test_join_single() {
+        let doc = join(text(", "), vec![text("a")]);
+        assert_eq!(doc, Doc::Text("a".to_string()));
+    }
+
+    #[test]
+    fn test_if_break() {
+        let doc = if_break(text("broken"), text("flat"));
+        if let Doc::IfBreak {
+            break_contents,
+            flat_contents,
+            group_id,
+        } = doc
+        {
+            assert_eq!(*break_contents, Doc::Text("broken".to_string()));
+            assert_eq!(*flat_contents, Doc::Text("flat".to_string()));
+            assert!(group_id.is_none());
+        } else {
+            panic!("Expected IfBreak");
+        }
+    }
+
+    #[test]
+    fn test_blank_lines() {
+        let doc = blank_lines(0);
+        assert_eq!(doc, Doc::Empty);
+
+        let doc = blank_lines(2);
+        if let Doc::Concat(docs) = doc {
+            assert_eq!(docs.len(), 2);
+        } else {
+            panic!("Expected Concat");
+        }
+    }
+}