rfmt 1.5.2 → 1.6.0

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

@@ -0,0 +1,325 @@
+//! Loop rules - Formats Ruby while/until/for loops
+//!
+//! Handles:
+//! - while loops: `while cond ... end`
+//! - until loops: `until cond ... end`
+//! - for loops: `for x in collection ... end`
+//! - Postfix forms: `expr while/until cond`
+
+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_leading_comments, format_statements, format_trailing_comment, FormatRule,
+};
+
+/// Rule for formatting while loops.
+pub struct WhileRule;
+
+/// Rule for formatting until loops.
+pub struct UntilRule;
+
+/// Rule for formatting for loops.
+pub struct ForRule;
+
+impl FormatRule for WhileRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_while_until(node, ctx, registry, "while")
+    }
+}
+
+impl FormatRule for UntilRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_while_until(node, ctx, registry, "until")
+    }
+}
+
+impl FormatRule for ForRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_for(node, ctx, registry)
+    }
+}
+
+/// Formats while/until loop
+fn format_while_until(
+    node: &Node,
+    ctx: &mut FormatContext,
+    registry: &RuleRegistry,
+    keyword: &str,
+) -> Result<Doc> {
+    // Check if this is a postfix while/until (modifier form)
+    // In postfix form: "statement while/until condition"
+    let is_postfix = if node.children.len() >= 2 {
+        let predicate = &node.children[0];
+        let body = &node.children[1];
+        body.location.start_offset < predicate.location.start_offset
+    } else {
+        false
+    };
+
+    if is_postfix {
+        return format_postfix_while_until(node, ctx, keyword);
+    }
+
+    // Normal while/until with do...end
+    format_normal_while_until(node, ctx, registry, keyword)
+}
+
+/// Formats postfix while/until
+fn format_postfix_while_until(node: &Node, ctx: &mut FormatContext, keyword: &str) -> Result<Doc> {
+    let mut docs: Vec<Doc> = Vec::with_capacity(6);
+
+    // Leading comments
+    let leading = format_leading_comments(ctx, node.location.start_line);
+    if !leading.is_empty() {
+        docs.push(leading);
+    }
+
+    // Extract from source for postfix form
+    if let Some(source_text) = ctx.extract_source(node) {
+        docs.push(text(source_text));
+    }
+
+    // Trailing comment
+    let trailing = format_trailing_comment(ctx, node.location.end_line);
+    if !trailing.is_empty() {
+        docs.push(trailing);
+    }
+
+    let _ = keyword; // Used for potential future formatting
+
+    Ok(concat(docs))
+}
+
+/// Formats normal while/until with do...end
+fn format_normal_while_until(
+    node: &Node,
+    ctx: &mut FormatContext,
+    registry: &RuleRegistry,
+    keyword: &str,
+) -> Result<Doc> {
+    let mut docs: Vec<Doc> = Vec::with_capacity(8);
+
+    // Leading comments
+    let leading = format_leading_comments(ctx, node.location.start_line);
+    if !leading.is_empty() {
+        docs.push(leading);
+    }
+
+    docs.push(text(keyword));
+    docs.push(text(" "));
+
+    // Emit predicate (condition) - first child
+    if let Some(predicate) = node.children.first() {
+        if let Some(source_text) = ctx.extract_source(predicate) {
+            docs.push(text(source_text));
+        }
+    }
+
+    // Trailing comment on same line as while/until
+    let trailing = format_trailing_comment(ctx, node.location.start_line);
+    if !trailing.is_empty() {
+        docs.push(trailing);
+    }
+
+    // Emit body - second child (StatementsNode)
+    if let Some(body) = node.children.get(1) {
+        if matches!(body.node_type, NodeType::StatementsNode) {
+            let body_doc = format_statements(body, ctx, registry)?;
+            docs.push(indent(concat(vec![hardline(), body_doc])));
+        }
+    }
+
+    docs.push(hardline());
+    docs.push(text("end"));
+
+    // Trailing comment on end line
+    let end_trailing = format_trailing_comment(ctx, node.location.end_line);
+    if !end_trailing.is_empty() {
+        docs.push(end_trailing);
+    }
+
+    Ok(concat(docs))
+}
+
+/// Formats for loop
+fn format_for(node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+    let mut docs: Vec<Doc> = Vec::with_capacity(10);
+
+    // Leading comments
+    let leading = format_leading_comments(ctx, node.location.start_line);
+    if !leading.is_empty() {
+        docs.push(leading);
+    }
+
+    docs.push(text("for "));
+
+    // node.children: [index, collection, statements]
+    // index: LocalVariableTargetNode or MultiTargetNode
+    // collection: expression
+    // statements: StatementsNode
+
+    // Emit index variable - first child
+    if let Some(index) = node.children.first() {
+        if let Some(source_text) = ctx.extract_source(index) {
+            docs.push(text(source_text));
+        }
+    }
+
+    docs.push(text(" in "));
+
+    // Emit collection - second child
+    if let Some(collection) = node.children.get(1) {
+        if let Some(source_text) = ctx.extract_source(collection) {
+            docs.push(text(source_text));
+        }
+    }
+
+    // Emit body - third child (StatementsNode)
+    if let Some(body) = node.children.get(2) {
+        if matches!(body.node_type, NodeType::StatementsNode) {
+            let body_doc = format_statements(body, ctx, registry)?;
+            docs.push(indent(concat(vec![hardline(), body_doc])));
+        }
+    }
+
+    docs.push(hardline());
+    docs.push(text("end"));
+
+    // Trailing comment on end line
+    let trailing = format_trailing_comment(ctx, node.location.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_while_node(
+        children: Vec<Node>,
+        start_line: usize,
+        end_line: usize,
+        start_offset: usize,
+        end_offset: usize,
+    ) -> Node {
+        Node {
+            node_type: NodeType::WhileNode,
+            location: Location::new(start_line, 0, end_line, 3, start_offset, end_offset),
+            children,
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    fn make_for_node(children: Vec<Node>, start_line: usize, end_line: usize) -> Node {
+        Node {
+            node_type: NodeType::ForNode,
+            location: Location::new(start_line, 0, end_line, 3, 0, 50),
+            children,
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    #[test]
+    fn test_simple_while() {
+        let config = Config::default();
+        let source = "while true\n  puts 'loop'\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        // predicate: "true" at offset 6-10
+        let predicate = Node {
+            node_type: NodeType::TrueNode,
+            location: Location::new(1, 6, 1, 10, 6, 10),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        // body statements at offset 13-25
+        let body = Node {
+            node_type: NodeType::StatementsNode,
+            location: Location::new(2, 2, 2, 14, 13, 25),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let node = make_while_node(vec![predicate, body], 1, 3, 0, 29);
+        ctx.collect_comments(&node);
+
+        let rule = WhileRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert!(result.contains("while true"));
+        assert!(result.contains("end"));
+    }
+
+    #[test]
+    fn test_simple_for() {
+        let config = Config::default();
+        let source = "for x in items\n  puts x\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        // index: "x" at offset 4-5
+        let index = Node {
+            node_type: NodeType::LocalVariableReadNode,
+            location: Location::new(1, 4, 1, 5, 4, 5),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        // collection: "items" at offset 9-14
+        let collection = Node {
+            node_type: NodeType::LocalVariableReadNode,
+            location: Location::new(1, 9, 1, 14, 9, 14),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        // body
+        let body = Node {
+            node_type: NodeType::StatementsNode,
+            location: Location::new(2, 2, 2, 8, 17, 23),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let node = make_for_node(vec![index, collection, body], 1, 3);
+        ctx.collect_comments(&node);
+
+        let rule = ForRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert!(result.contains("for x in items"));
+        assert!(result.contains("end"));
+    }
+}

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

@@ -0,0 +1,31 @@
+//! Formatting rules for different AST node types
+//!
+//! This module contains the FormatRule implementations for each supported
+//! node type. Each rule is responsible for converting its node type to Doc IR.
+
+mod begin;
+mod body_end;
+mod call;
+mod case;
+mod class;
+mod def;
+mod fallback;
+mod if_unless;
+mod loops;
+mod module;
+mod singleton_class;
+mod statements;
+mod variable_write;
+
+pub use begin::{BeginRule, EnsureRule, RescueRule};
+pub use call::{BlockRule, CallRule, LambdaRule};
+pub use case::{CaseMatchRule, CaseRule, InRule, WhenRule};
+pub use class::ClassRule;
+pub use def::DefRule;
+pub use fallback::FallbackRule;
+pub use if_unless::{IfRule, UnlessRule};
+pub use loops::{ForRule, UntilRule, WhileRule};
+pub use module::ModuleRule;
+pub use singleton_class::SingletonClassRule;
+pub use statements::StatementsRule;
+pub use variable_write::{InstanceVariableWriteRule, LocalVariableWriteRule};

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

@@ -0,0 +1,150 @@
+//! ModuleRule - Formats Ruby module definitions
+//!
+//! Handles module definitions including:
+//! - Simple modules: `module Foo`
+//! - Nested modules: `module Foo::Bar`
+//! - Module bodies with methods and other declarations
+//! - Leading and trailing comments
+
+use crate::ast::Node;
+use crate::doc::{text, Doc};
+use crate::error::Result;
+use crate::format::context::FormatContext;
+use crate::format::registry::RuleRegistry;
+use crate::format::rule::FormatRule;
+
+use super::body_end::{format_body_end, BodyEndConfig};
+
+/// Rule for formatting module definitions.
+pub struct ModuleRule;
+
+impl FormatRule for ModuleRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        format_body_end(
+            ctx,
+            registry,
+            BodyEndConfig {
+                keyword: "module",
+                node,
+                header_builder: Box::new(build_module_header),
+                skip_same_line_children: false,
+            },
+        )
+    }
+}
+
+/// Builds the header portion for a module definition.
+///
+/// Returns: `ModuleName`
+fn build_module_header(node: &Node) -> Vec<Doc> {
+    let mut parts: Vec<Doc> = Vec::with_capacity(1);
+
+    // Get module name from metadata
+    if let Some(name) = node.metadata.get("name") {
+        parts.push(text(name));
+    }
+
+    parts
+}
+
+#[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_module_node(
+        name: &str,
+        children: Vec<Node>,
+        start_line: usize,
+        end_line: usize,
+    ) -> Node {
+        let mut metadata = HashMap::new();
+        metadata.insert("name".to_string(), name.to_string());
+
+        Node {
+            node_type: NodeType::ModuleNode,
+            location: Location::new(start_line, 0, end_line, 3, 0, 50),
+            children,
+            metadata,
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    #[test]
+    fn test_simple_module() {
+        let config = Config::default();
+        let source = "module Foo\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let node = make_module_node("Foo", Vec::new(), 1, 2);
+        ctx.collect_comments(&node);
+
+        let rule = ModuleRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert_eq!(result.trim(), "module Foo\nend");
+    }
+
+    #[test]
+    fn test_nested_module_name() {
+        let config = Config::default();
+        let source = "module Foo::Bar\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let node = make_module_node("Foo::Bar", Vec::new(), 1, 2);
+        ctx.collect_comments(&node);
+
+        let rule = ModuleRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert_eq!(result.trim(), "module Foo::Bar\nend");
+    }
+
+    #[test]
+    fn test_module_with_body() {
+        let config = Config::default();
+        let source = "module Foo\n  def bar\n  end\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        // Create a method node as child
+        let method_node = Node {
+            node_type: NodeType::DefNode,
+            location: Location::new(2, 2, 3, 5, 13, 25),
+            children: Vec::new(),
+            metadata: {
+                let mut m = HashMap::new();
+                m.insert("name".to_string(), "bar".to_string());
+                m
+            },
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let node = make_module_node("Foo", vec![method_node], 1, 4);
+        ctx.collect_comments(&node);
+
+        let rule = ModuleRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        // Should have the module, body, and end
+        assert!(result.contains("module Foo"));
+        assert!(result.contains("def bar"));
+        assert!(result.contains("end"));
+    }
+}

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

@@ -0,0 +1,202 @@
+//! SingletonClassRule - Formats Ruby singleton class definitions
+//!
+//! Handles singleton class definitions:
+//! - `class << self ... end`
+//! - `class << object ... end`
+
+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_comments_before_end, format_leading_comments, format_statements,
+    format_trailing_comment, FormatRule,
+};
+
+/// Rule for formatting singleton class definitions.
+///
+/// Handles `class << self` and `class << object` patterns.
+pub struct SingletonClassRule;
+
+impl FormatRule for SingletonClassRule {
+    fn format(&self, node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) -> Result<Doc> {
+        let mut docs: Vec<Doc> = Vec::with_capacity(8);
+
+        let start_line = node.location.start_line;
+        let end_line = node.location.end_line;
+
+        // 1. Leading comments before definition
+        let leading = format_leading_comments(ctx, start_line);
+        if !leading.is_empty() {
+            docs.push(leading);
+        }
+
+        // 2. Build header: "class << "
+        docs.push(text("class << "));
+
+        // 3. First child is the expression (self or an object)
+        if let Some(expression) = node.children.first() {
+            if let Some(expr_text) = ctx.extract_source(expression) {
+                docs.push(text(expr_text.to_string()));
+            }
+        }
+
+        // 4. Trailing comment on definition line
+        let trailing = format_trailing_comment(ctx, start_line);
+        if !trailing.is_empty() {
+            docs.push(trailing);
+        }
+
+        // 5. Body (children), skipping the first child (expression)
+        let mut body_docs: Vec<Doc> = Vec::new();
+        let mut has_body_content = false;
+
+        for (i, child) in node.children.iter().enumerate() {
+            // Skip the first child (expression: self or object)
+            if i == 0 {
+                continue;
+            }
+
+            if matches!(child.node_type, NodeType::StatementsNode) {
+                has_body_content = true;
+                body_docs.push(hardline());
+                body_docs.push(format_statements(child, ctx, registry)?);
+            } else if !is_structural_node_for_singleton(child) {
+                has_body_content = true;
+                body_docs.push(hardline());
+                body_docs.push(format_child(child, ctx, registry)?);
+            }
+        }
+
+        if has_body_content {
+            docs.push(indent(concat(body_docs)));
+        }
+
+        // 6. Comments before end
+        let comments_before_end = format_comments_before_end(ctx, start_line, end_line);
+        if !comments_before_end.is_empty() {
+            docs.push(indent(comments_before_end));
+        }
+
+        // 7. Add newline before end
+        docs.push(hardline());
+
+        // 8. End keyword
+        docs.push(text("end"));
+
+        // 9. Trailing comment on end line
+        let end_trailing = format_trailing_comment(ctx, end_line);
+        if !end_trailing.is_empty() {
+            docs.push(end_trailing);
+        }
+
+        Ok(concat(docs))
+    }
+}
+
+/// Check if a node is structural (should be skipped in body).
+fn is_structural_node_for_singleton(node: &Node) -> bool {
+    matches!(
+        node.node_type,
+        NodeType::ConstantReadNode
+            | NodeType::ConstantWriteNode
+            | NodeType::ConstantPathNode
+            | NodeType::SelfNode
+    )
+}
+
+#[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_singleton_class_node(children: Vec<Node>, start_line: usize, end_line: usize) -> Node {
+        Node {
+            node_type: NodeType::SingletonClassNode,
+            location: Location::new(start_line, 0, end_line, 3, 0, 50),
+            children,
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    fn make_self_node(line: usize, start_offset: usize) -> Node {
+        Node {
+            node_type: NodeType::SelfNode,
+            location: Location::new(line, 9, line, 13, start_offset, start_offset + 4),
+            children: Vec::new(),
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        }
+    }
+
+    #[test]
+    fn test_simple_singleton_class() {
+        let config = Config::default();
+        let source = "class << self\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let self_node = make_self_node(1, 9);
+        let node = make_singleton_class_node(vec![self_node], 1, 2);
+        ctx.collect_comments(&node);
+
+        let rule = SingletonClassRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert_eq!(result.trim(), "class << self\nend");
+    }
+
+    #[test]
+    fn test_singleton_class_with_body() {
+        let config = Config::default();
+        let source = "class << self\n  def foo\n  end\nend";
+        let mut ctx = FormatContext::new(&config, source);
+        let registry = RuleRegistry::default_registry();
+
+        let self_node = make_self_node(1, 9);
+        let method_node = Node {
+            node_type: NodeType::DefNode,
+            location: Location::new(2, 2, 3, 5, 16, 28),
+            children: Vec::new(),
+            metadata: {
+                let mut m = HashMap::new();
+                m.insert("name".to_string(), "foo".to_string());
+                m
+            },
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let statements_node = Node {
+            node_type: NodeType::StatementsNode,
+            location: Location::new(2, 2, 3, 5, 16, 28),
+            children: vec![method_node],
+            metadata: HashMap::new(),
+            comments: Vec::new(),
+            formatting: FormattingInfo::default(),
+        };
+
+        let node = make_singleton_class_node(vec![self_node, statements_node], 1, 4);
+        ctx.collect_comments(&node);
+
+        let rule = SingletonClassRule;
+        let doc = rule.format(&node, &mut ctx, &registry).unwrap();
+
+        let mut printer = Printer::new(&config);
+        let result = printer.print(&doc);
+
+        assert!(result.contains("class << self"));
+        assert!(result.contains("def foo"));
+        assert!(result.contains("end"));
+    }
+}