rfmt 1.5.3 → 1.6.1

data/ext/rfmt/src/format/rules/statements.rs

@@ -0,0 +1,122 @@
+//! StatementsRule - Handles StatementsNode (body of class/module/def)
+//!
+//! StatementsNode contains a sequence of statements that form the body
+//! of a construct. This rule formats each statement with proper spacing.
+
+use crate::ast::Node;
+use crate::doc::Doc;
+use crate::error::Result;
+use crate::format::context::FormatContext;
+use crate::format::registry::RuleRegistry;
+use crate::format::rule::{format_statements, FormatRule};
+
+/// Rule for formatting StatementsNode.
+///
+/// This rule delegates to the shared `format_statements` helper function
+/// which properly handles the sequence of child statements.
+pub struct StatementsRule;
+
+impl FormatRule for StatementsRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_statements(node, ctx, registry)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ast::{FormattingInfo, Location, NodeType};
+    use crate::config::Config;
+    use crate::doc::Printer;
+    use std::collections::HashMap;
+
+    fn make_statements_node(children: Vec<Node>, start_line: usize, end_line: usize) -> Node {
+        Node {
+            node_type: NodeType::StatementsNode,
+            location: Location::new(start_line, 0, end_line, 0, 0, 100),
+            children,
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    fn make_call_node(source: &str, line: usize, start_offset: usize) -> Node {
+        Node {
+            node_type: NodeType::CallNode,
+            location: Location::new(
+                line,
+                0,
+                line,
+                source.len(),
+                start_offset,
+                start_offset + source.len(),
+            ),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    #[test]
+    fn test_statements_single_statement() {
+        let config = Config::default();
+        let source = "puts 'hello'";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let call = make_call_node("puts 'hello'", 1, 0);
+        let stmt = make_statements_node(vec![call], 1, 1);
+
+        ctx.collect_comments(&stmt);
+
+        let rule = StatementsRule;
+        let doc = rule.format(&stmt, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert_eq!(result, "puts 'hello'\n");
+    }
+
+    #[test]
+    fn test_statements_multiple_statements() {
+        let config = Config::default();
+        let source = "a = 1\nb = 2";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let call1 = make_call_node("a = 1", 1, 0);
+        let call2 = make_call_node("b = 2", 2, 6);
+        let stmt = make_statements_node(vec![call1, call2], 1, 2);
+
+        ctx.collect_comments(&stmt);
+
+        let rule = StatementsRule;
+        let doc = rule.format(&stmt, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert!(result.contains("a = 1"));
+        assert!(result.contains("b = 2"));
+    }
+
+    #[test]
+    fn test_statements_empty() {
+        let config = Config::default();
+        let source = "";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let stmt = make_statements_node(vec![], 1, 1);
+
+        ctx.collect_comments(&stmt);
+
+        let rule = StatementsRule;
+        let doc = rule.format(&stmt, &mut ctx, &registry).unwrap();
+
+        assert!(matches!(doc, Doc::Empty));
+    }
+}

data/ext/rfmt/src/format/rules/variable_write.rs

@@ -0,0 +1,314 @@
+//! VariableWriteRule - Formats Ruby variable assignment expressions
+//!
+//! Handles variable assignments including:
+//! - Local variable writes: `x = value`
+//! - Instance variable writes: `@x = value`
+//! - Block value assignments: `x = if true then 1 else 2 end`
+//! - Multiline method chain assignments: `x = foo.bar.baz`
+
+use crate::ast::{Node, NodeType};
+use crate::doc::{concat, hardline, indent, text, Doc};
+use crate::error::Result;
+use crate::format::context::FormatContext;
+use crate::format::registry::RuleRegistry;
+use crate::format::rule::{
+    format_child, format_leading_comments, format_trailing_comment, line_leading_indent,
+    reformat_chain_lines, strip_one_trailing_newline, FormatRule,
+};
+
+/// Rule for formatting local variable write expressions.
+pub struct LocalVariableWriteRule;
+
+impl FormatRule for LocalVariableWriteRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_variable_write(node, ctx, registry)
+    }
+}
+
+/// Rule for formatting instance variable write expressions.
+pub struct InstanceVariableWriteRule;
+
+impl FormatRule for InstanceVariableWriteRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_variable_write(node, ctx, registry)
+    }
+}
+
+/// Shared implementation for variable write formatting.
+///
+/// Handles three cases:
+/// 1. Block value (if/unless/case/begin/while/until/for): formats on new line with indent
+/// 2. Multiline method chain: reformats with indented chain style
+/// 3. Simple value: inline assignment
+fn format_variable_write(
+    node: &Node,
+    ctx: &mut FormatContext,
+    registry: &RuleRegistry,
+) -> Result<Doc> {
+    let mut docs: Vec<Doc> = Vec::with_capacity(5);
+
+    let start_line = node.location.start_line;
+    let end_line = node.location.end_line;
+
+    // 1. Leading comments
+    let leading = format_leading_comments(ctx, start_line);
+    if !leading.is_empty() {
+        docs.push(leading);
+    }
+
+    // 2. Get variable name from metadata
+    let name = node.metadata.get("name").map(|s| s.as_str()).unwrap_or("_");
+
+    // 3. Get value node (first child)
+    let value = match node.children.first() {
+        Some(v) => v,
+        None => {
+            // No value: fallback to source extraction
+            if let Some(source_text) = ctx.extract_source(node) {
+                docs.push(text(source_text.to_string()));
+            }
+            let trailing = format_trailing_comment(ctx, end_line);
+            if !trailing.is_empty() {
+                docs.push(trailing);
+            }
+            return Ok(concat(docs));
+        }
+    };
+
+    // 4. Check if value is a block construct
+    let is_block_value = matches!(
+        value.node_type,
+        NodeType::IfNode
+            | NodeType::UnlessNode
+            | NodeType::CaseNode
+            | NodeType::CaseMatchNode
+            | NodeType::BeginNode
+            | NodeType::WhileNode
+            | NodeType::UntilNode
+            | NodeType::ForNode
+    );
+
+    // Only split the assignment across two lines when the block value
+    // actually begins below the `=`. When the user wrote
+    // `x = begin\n  …\nend` (the opener is on the same line as the
+    // assignment), preserve that shape — splitting it mangles a common
+    // Rails idiom used for defaulted constants and service objects.
+    let inline_block_value = is_block_value && value.location.start_line == start_line;
+
+    if is_block_value && !inline_block_value {
+        // Block value: format on new line with indent
+        // x =
+        //   if true
+        //     1
+        //   else
+        //     2
+        //   end
+        docs.push(text(format!("{} =", name)));
+        docs.push(indent(concat(vec![
+            hardline(),
+            format_child(value, ctx, registry)?,
+        ])));
+    } else if inline_block_value {
+        docs.push(text(format!("{} = ", name)));
+        docs.push(format_child(value, ctx, registry)?);
+    } else {
+        // Check for multiline method chain
+        let is_multiline_call = matches!(value.node_type, NodeType::CallNode)
+            && value.location.start_line != value.location.end_line;
+
+        docs.push(text(format!("{} = ", name)));
+
+        if is_multiline_call {
+            // Multiline call: reformat chain with indented style.
+            // Also trim a trailing newline left over from a heredoc tail
+            // (`x = foo(<<~SQL)\n…\nSQL\n`) so it doesn't compound with the
+            // surrounding hardline.
+            if let Some(source_text) = ctx.extract_source(value) {
+                let base_indent = line_leading_indent(ctx.source(), node.location.start_offset);
+                let reformatted = reformat_chain_lines(
+                    source_text,
+                    base_indent,
+                    ctx.config().formatting.indent_width,
+                );
+                let trimmed = strip_one_trailing_newline(reformatted.trim_start());
+                docs.push(text(trimmed.to_string()));
+            }
+        } else {
+            // Simple value: extract from source trimmed
+            if let Some(source_text) = ctx.extract_source(value) {
+                docs.push(text(source_text.trim().to_string()));
+            }
+        }
+    }
+
+    // 5. Trailing comment
+    let trailing = format_trailing_comment(ctx, end_line);
+    if !trailing.is_empty() {
+        docs.push(trailing);
+    }
+
+    Ok(concat(docs))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ast::{FormattingInfo, Location};
+    use crate::config::Config;
+    use crate::doc::Printer;
+    use std::collections::HashMap;
+
+    fn make_local_var_write_node(
+        name: &str,
+        children: Vec<Node>,
+        start_line: usize,
+        end_line: usize,
+        start_offset: usize,
+        end_offset: usize,
+    ) -> Node {
+        let mut metadata = HashMap::new();
+        metadata.insert("name".to_string(), name.to_string());
+
+        Node {
+            node_type: NodeType::LocalVariableWriteNode,
+            location: Location::new(start_line, 0, end_line, 10, start_offset, end_offset),
+            children,
+            metadata,
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    fn make_instance_var_write_node(
+        name: &str,
+        children: Vec<Node>,
+        start_line: usize,
+        end_line: usize,
+        start_offset: usize,
+        end_offset: usize,
+    ) -> Node {
+        let mut metadata = HashMap::new();
+        metadata.insert("name".to_string(), name.to_string());
+
+        Node {
+            node_type: NodeType::InstanceVariableWriteNode,
+            location: Location::new(start_line, 0, end_line, 10, start_offset, end_offset),
+            children,
+            metadata,
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    fn make_integer_node(line: usize, start_offset: usize, end_offset: usize) -> Node {
+        Node {
+            node_type: NodeType::IntegerNode,
+            location: Location::new(line, 0, line, 1, start_offset, end_offset),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    #[test]
+    fn test_simple_local_var_assignment() {
+        let config = Config::default();
+        let source = "x = 1";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let value_node = make_integer_node(1, 4, 5);
+        let node = make_local_var_write_node("x", vec![value_node], 1, 1, 0, 5);
+        ctx.collect_comments(&node);
+
+        let rule = LocalVariableWriteRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert_eq!(result.trim(), "x = 1");
+    }
+
+    #[test]
+    fn test_simple_instance_var_assignment() {
+        let config = Config::default();
+        let source = "@value = 42";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let value_node = make_integer_node(1, 9, 11);
+        let node = make_instance_var_write_node("@value", vec![value_node], 1, 1, 0, 11);
+        ctx.collect_comments(&node);
+
+        let rule = InstanceVariableWriteRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert_eq!(result.trim(), "@value = 42");
+    }
+
+    #[test]
+    fn test_block_value_assignment() {
+        let config = Config::default();
+        let source = "x = if true\n  1\nelse\n  2\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let if_node = Node {
+            node_type: NodeType::IfNode,
+            location: Location::new(1, 4, 5, 3, 4, 28),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let node = make_local_var_write_node("x", vec![if_node], 1, 5, 0, 28);
+        ctx.collect_comments(&node);
+
+        let rule = LocalVariableWriteRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        // Should format with value on new line
+        assert!(result.contains("x ="));
+        assert!(result.contains("if"));
+    }
+
+    #[test]
+    fn test_multiline_chain_assignment() {
+        let config = Config::default();
+        let source = "x = foo\n  .bar\n  .baz";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let call_node = Node {
+            node_type: NodeType::CallNode,
+            location: Location::new(1, 4, 3, 6, 4, 21),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let node = make_local_var_write_node("x", vec![call_node], 1, 3, 0, 21);
+        ctx.collect_comments(&node);
+
+        let rule = LocalVariableWriteRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        // Should reformat chain with indented style
+        assert!(result.contains("x = foo"));
+        assert!(result.contains(".bar"));
+        assert!(result.contains(".baz"));
+    }
+}

data/ext/rfmt/src/lib.rs

@@ -1,7 +1,8 @@
 mod ast;
-mod config;
-mod emitter;
+pub mod config;
+pub mod doc;
 mod error;
+pub mod format;
 mod logging;
 mod parser;
 mod policy;
@@ -9,7 +10,7 @@ mod policy;
 use policy::SecurityPolicy;
 
 use config::Config;
-use emitter::Emitter;
+use format::Formatter;
 use magnus::{function, prelude::*, Error, Ruby};
 use parser::{PrismAdapter, RubyParser};
 
@@ -24,9 +25,11 @@ fn format_ruby_code(ruby: &Ruby, source: String, json: String) -> Result<String,
     let ast = parser.parse(&json).map_err(|e| e.to_magnus_error(ruby))?;
 
     let config = Config::discover().map_err(|e| e.to_magnus_error(ruby))?;
-    let mut emitter = Emitter::with_source(config, source);
+    let formatter = Formatter::new(config);
 
-    let formatted = emitter.emit(&ast).map_err(|e| e.to_magnus_error(ruby))?;
+    let formatted = formatter
+        .format(&source, &ast)
+        .map_err(|e| e.to_magnus_error(ruby))?;
 
     Ok(formatted)
 }

data/ext/rfmt/src/parser/prism_adapter.rs

@@ -1,8 +1,9 @@
 use crate::ast::{Comment, CommentPosition, CommentType, FormattingInfo, Location, Node, NodeType};
 use crate::error::{Result, RfmtError};
 use crate::parser::RubyParser;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use std::collections::HashMap;
+use std::fmt;
 
 /// Prism parser adapter
 /// This integrates with Ruby Prism parser via Magnus FFI
@@ -144,7 +145,13 @@ pub struct PrismLocation {
 pub struct PrismComment {
     pub text: String,
     pub location: PrismLocation,
-    #[serde(rename = "type", default)]
+    /// PrismBridge sends `comment_type`; older payloads may use `type`.
+    #[serde(
+        default,
+        rename = "comment_type",
+        alias = "type",
+        deserialize_with = "deserialize_prism_comment_type"
+    )]
     pub comment_type: PrismCommentType,
     #[serde(default)]
     pub position: PrismCommentPosition,
@@ -158,6 +165,39 @@ pub enum PrismCommentType {
     Block,
 }
 
+/// Maps Ruby Prism comment class names (after `PrismBridge` normalization) to our enum.
+/// Unknown values default to `Line` so parsing never fails on new Prism comment kinds.
+fn deserialize_prism_comment_type<'de, D>(
+    deserializer: D,
+) -> std::result::Result<PrismCommentType, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::{self, Visitor};
+
+    struct CommentTypeVisitor;
+
+    impl Visitor<'_> for CommentTypeVisitor {
+        type Value = PrismCommentType;
+
+        fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.write_str("a Prism comment type string")
+        }
+
+        fn visit_str<E: de::Error>(self, v: &str) -> std::result::Result<Self::Value, E> {
+            Ok(match v {
+                // LineComment -> "line", InlineComment -> "inline"
+                "line" | "inline" => PrismCommentType::Line,
+                // EmbDocComment (=begin/=end) -> "embdoc"; keep "block" for compatibility
+                "block" | "embdoc" => PrismCommentType::Block,
+                _ => PrismCommentType::Line,
+            })
+        }
+    }
+
+    deserializer.deserialize_str(CommentTypeVisitor)
+}
+
 impl From<PrismCommentType> for CommentType {
     fn from(t: PrismCommentType) -> Self {
         match t {
@@ -199,6 +239,7 @@ pub struct PrismFormattingInfo {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ast::CommentType;
 
     #[test]
     fn test_parse_simple_program() {
@@ -426,4 +467,118 @@ mod tests {
         assert!(node.is_unknown());
         assert_eq!(node.unknown_type(), Some("totally_unknown_node"));
     }
+
+    /// Ruby PrismBridge uses `comment_type` (not `type`) and values like `embdoc` / `inline`.
+    #[test]
+    fn test_parse_wrapper_with_prism_bridge_comment_fields() {
+        let adapter = PrismAdapter::new();
+        let json = r##"{
+            "ast": {
+                "node_type": "program_node",
+                "location": {
+                    "start_line": 1,
+                    "start_column": 0,
+                    "end_line": 2,
+                    "end_column": 0,
+                    "start_offset": 0,
+                    "end_offset": 20
+                },
+                "children": [],
+                "metadata": {},
+                "comments": [],
+                "formatting": {
+                    "indent_level": 0,
+                    "needs_blank_line_before": false,
+                    "needs_blank_line_after": false,
+                    "preserve_newlines": false,
+                    "multiline": false,
+                    "original_formatting": null
+                }
+            },
+            "comments": [
+                {
+                    "text": "=begin\nnote\n=end",
+                    "comment_type": "embdoc",
+                    "location": {
+                        "start_line": 1,
+                        "start_column": 0,
+                        "end_line": 3,
+                        "end_column": 4,
+                        "start_offset": 0,
+                        "end_offset": 16
+                    },
+                    "position": "leading"
+                },
+                {
+                    "text": "# inline style",
+                    "comment_type": "inline",
+                    "location": {
+                        "start_line": 4,
+                        "start_column": 0,
+                        "end_line": 4,
+                        "end_column": 14,
+                        "start_offset": 17,
+                        "end_offset": 31
+                    },
+                    "position": "leading"
+                }
+            ]
+        }"##;
+
+        let result = adapter.parse(json);
+        assert!(result.is_ok(), "{:?}", result.err());
+        let node = result.unwrap();
+        assert_eq!(node.comments.len(), 2);
+        assert_eq!(node.comments[0].comment_type, CommentType::Block);
+        assert_eq!(node.comments[1].comment_type, CommentType::Line);
+    }
+
+    /// Legacy JSON that used the `type` key for comment_kind still parses.
+    #[test]
+    fn test_parse_wrapper_comment_type_alias_type_key() {
+        let adapter = PrismAdapter::new();
+        let json = r##"{
+            "ast": {
+                "node_type": "program_node",
+                "location": {
+                    "start_line": 1,
+                    "start_column": 0,
+                    "end_line": 1,
+                    "end_column": 0,
+                    "start_offset": 0,
+                    "end_offset": 1
+                },
+                "children": [],
+                "metadata": {},
+                "comments": [],
+                "formatting": {
+                    "indent_level": 0,
+                    "needs_blank_line_before": false,
+                    "needs_blank_line_after": false,
+                    "preserve_newlines": false,
+                    "multiline": false,
+                    "original_formatting": null
+                }
+            },
+            "comments": [
+                {
+                    "text": "# hi",
+                    "type": "line",
+                    "location": {
+                        "start_line": 1,
+                        "start_column": 0,
+                        "end_line": 1,
+                        "end_column": 4,
+                        "start_offset": 0,
+                        "end_offset": 4
+                    },
+                    "position": "leading"
+                }
+            ]
+        }"##;
+
+        let node = adapter.parse(json).unwrap();
+        assert_eq!(node.comments.len(), 1);
+        assert_eq!(node.comments[0].comment_type, CommentType::Line);
+    }
 }