rfmt 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7db146878fe1bbf37f4211f11ded67e98ebfb1830989a4fb64fbe1cc51a72fc7
-  data.tar.gz: bb87cfab19f7513ddd99b939c03286827687a5da6071c317390dc990924dbe05
+  metadata.gz: 21876b488a79df7b3a136bfc563ea91312bc86569205b4349b5ccc0371338071
+  data.tar.gz: 7896e3c94fe83d0de8a3a4bebd9d10e0f277f92bfd069384ff05c4cb524d57b5
 SHA512:
-  metadata.gz: 2018f31f65afd41842a51e21290448a753784b840dd67f9d8e7e41d223f509227143b18a15309b4a3cf19543b8638ce28045d0c1a68cf97dda8781811b058657
-  data.tar.gz: 888d036c08f29f166d1089a2cce27d9c456d57c83fbbd1c518142bdfaa15b32c551ab1ccda12c97bd48c9ddf63f57545ef47b6cbdcf8a774f8ea4eb1e17d1729
+  metadata.gz: e50633a81f18a263109deac74be48dbb067f39a1139d166d2e6d5d02c271f7dba232ad5512d8a63d7a571c23dc246ee8d41c82be2e477493c89ed92b7949dd19
+  data.tar.gz: eae8574579a5b30cef07472ef90ce854162282c84bb379c507796ee2984f5f6ee2004ec82a9e8100c04b5e047b0e8a4894564ada404f789e2180d7302f5842fc

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [1.2.0] - 2026-01-04
+
+### Added
+- Loop node types support (`for`, `while`, `until`)
+- Case/When statement support
+- Ensure and Lambda node support
+- Begin/End block handling for explicit `begin...end` blocks
+- High-priority node types support
+- Medium-priority node types support
+- Prism supported node viewer task
+
+### Changed
+- Consolidated and simplified test suite
+
+### Fixed
+- Exclude `.DS_Store` from Git tracking (@topi0247)
+- Repository URL changed from `fujitanisora` to `fs0414` (@topi0247)
+- End line space handling
+- Comment location fix
+- End expression indent fix
+- Begin formatting fix
+
 ## [1.1.0] - 2025-12-12
 
 ### Added

data/Cargo.lock

@@ -1219,7 +1219,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rfmt"
-version = "1.0.0"
+version = "1.2.0"
 dependencies = [
  "anyhow",
  "clap",

data/README.md

@@ -102,7 +102,7 @@ bundle install
 ### From Source
 
 ```bash
-git clone https://github.com/fujitanisora/rfmt.git
+git clone https://github.com/fs0414/rfmt.git
 cd rfmt
 bundle install
 bundle exec rake compile
@@ -379,7 +379,7 @@ Everyone interacting in the rfmt project's codebases, issue trackers, chat rooms
 ## Support
 
 - 📖 [Documentation](docs/)
-- 🐛 [Issues](https://github.com/fujitanisora/rfmt/issues)
+- 🐛 [Issues](https://github.com/fs0414/rfmt/issues)
 - 📧 Email: fujitanisora0414@gmail.com
 
 ## Acknowledgments

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.0.0"
+version = "1.2.0"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"

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

@@ -43,6 +43,10 @@ pub enum NodeType {
     ElseNode,
     UnlessNode,
 
+    // Exception handling
+    BeginNode,
+    RescueNode,
+
     // Literals
     StringNode,
     IntegerNode,
@@ -52,10 +56,115 @@ pub enum NodeType {
     TrueNode,
     FalseNode,
     NilNode,
+    SymbolNode,
 
     // Blocks
     BlockNode,
 
+    // Case/When
+    CaseNode,
+    WhenNode,
+
+    // HashNode
+    AssocNode,
+    KeywordHashNode,
+
+    // Variables
+    LocalVariableReadNode,
+    LocalVariableWriteNode,
+    InstanceVariableReadNode,
+    InstanceVariableWriteNode,
+
+    // Lambda
+    LambdaNode,
+
+    // Control flow
+    ReturnNode,
+    EnsureNode,
+
+    // Strings
+    InterpolatedStringNode,
+    EmbeddedStatementsNode,
+
+    // Logical
+    OrNode,
+    AndNode,
+    NotNode,
+
+    // Loop constructs
+    WhileNode,
+    UntilNode,
+    ForNode,
+
+    // Control flow
+    BreakNode,
+    NextNode,
+    RedoNode,
+    RetryNode,
+    YieldNode,
+    SuperNode,
+    ForwardingSuperNode,
+    RescueModifierNode,
+
+    // Ranges
+    RangeNode,
+
+    // Other literals
+    RegularExpressionNode,
+    SplatNode,
+    InterpolatedRegularExpressionNode,
+    InterpolatedSymbolNode,
+    XStringNode,
+    InterpolatedXStringNode,
+
+    // Class variables
+    ClassVariableReadNode,
+    ClassVariableWriteNode,
+    ClassVariableOrWriteNode,
+    ClassVariableAndWriteNode,
+    ClassVariableOperatorWriteNode,
+
+    // Global variables
+    GlobalVariableReadNode,
+    GlobalVariableWriteNode,
+    GlobalVariableOrWriteNode,
+    GlobalVariableAndWriteNode,
+    GlobalVariableOperatorWriteNode,
+
+    // Compound assignment
+    LocalVariableOrWriteNode,
+    LocalVariableAndWriteNode,
+    LocalVariableOperatorWriteNode,
+    InstanceVariableOrWriteNode,
+    InstanceVariableAndWriteNode,
+    InstanceVariableOperatorWriteNode,
+    ConstantOrWriteNode,
+    ConstantAndWriteNode,
+    ConstantOperatorWriteNode,
+    ConstantPathOrWriteNode,
+    ConstantPathAndWriteNode,
+    ConstantPathOperatorWriteNode,
+    ConstantPathWriteNode,
+
+    // Pattern matching
+    CaseMatchNode,
+    InNode,
+    MatchPredicateNode,
+    MatchRequiredNode,
+
+    // Other common nodes
+    SelfNode,
+    ParenthesesNode,
+    DefinedNode,
+    SingletonClassNode,
+    AliasMethodNode,
+    AliasGlobalVariableNode,
+    UndefNode,
+    AssocSplatNode,
+    BlockArgumentNode,
+    MultiWriteNode,
+    MultiTargetNode,
+
     // Constants (structural nodes, part of definitions)
     ConstantReadNode,
     ConstantWriteNode,
@@ -75,8 +184,6 @@ pub enum NodeType {
 }
 
 impl NodeType {
-    /// Parse node type from Prism type string
-    /// Returns Unknown variant for unsupported node types
     pub fn from_str(s: &str) -> Self {
         match s {
             "program_node" => Self::ProgramNode,
@@ -88,6 +195,8 @@ impl NodeType {
             "if_node" => Self::IfNode,
             "else_node" => Self::ElseNode,
             "unless_node" => Self::UnlessNode,
+            "begin_node" => Self::BeginNode,
+            "rescue_node" => Self::RescueNode,
             "string_node" => Self::StringNode,
             "integer_node" => Self::IntegerNode,
             "float_node" => Self::FloatNode,
@@ -108,6 +217,79 @@ impl NodeType {
             "optional_keyword_parameter_node" => Self::OptionalKeywordParameterNode,
             "keyword_rest_parameter_node" => Self::KeywordRestParameterNode,
             "block_parameter_node" => Self::BlockParameterNode,
+            "symbol_node" => Self::SymbolNode,
+            "case_node" => Self::CaseNode,
+            "when_node" => Self::WhenNode,
+            "assoc_node" => Self::AssocNode,
+            "keyword_hash_node" => Self::KeywordHashNode,
+            "local_variable_read_node" => Self::LocalVariableReadNode,
+            "local_variable_write_node" => Self::LocalVariableWriteNode,
+            "instance_variable_read_node" => Self::InstanceVariableReadNode,
+            "instance_variable_write_node" => Self::InstanceVariableWriteNode,
+            "lambda_node" => Self::LambdaNode,
+            "return_node" => Self::ReturnNode,
+            "ensure_node" => Self::EnsureNode,
+            "interpolated_string_node" => Self::InterpolatedStringNode,
+            "embedded_statements_node" => Self::EmbeddedStatementsNode,
+            "or_node" => Self::OrNode,
+            "and_node" => Self::AndNode,
+            "not_node" => Self::NotNode,
+            "while_node" => Self::WhileNode,
+            "until_node" => Self::UntilNode,
+            "for_node" => Self::ForNode,
+            "break_node" => Self::BreakNode,
+            "next_node" => Self::NextNode,
+            "redo_node" => Self::RedoNode,
+            "retry_node" => Self::RetryNode,
+            "yield_node" => Self::YieldNode,
+            "super_node" => Self::SuperNode,
+            "forwarding_super_node" => Self::ForwardingSuperNode,
+            "rescue_modifier_node" => Self::RescueModifierNode,
+            "range_node" => Self::RangeNode,
+            "regular_expression_node" => Self::RegularExpressionNode,
+            "splat_node" => Self::SplatNode,
+            "interpolated_regular_expression_node" => Self::InterpolatedRegularExpressionNode,
+            "interpolated_symbol_node" => Self::InterpolatedSymbolNode,
+            "x_string_node" => Self::XStringNode,
+            "interpolated_x_string_node" => Self::InterpolatedXStringNode,
+            "class_variable_read_node" => Self::ClassVariableReadNode,
+            "class_variable_write_node" => Self::ClassVariableWriteNode,
+            "class_variable_or_write_node" => Self::ClassVariableOrWriteNode,
+            "class_variable_and_write_node" => Self::ClassVariableAndWriteNode,
+            "class_variable_operator_write_node" => Self::ClassVariableOperatorWriteNode,
+            "global_variable_read_node" => Self::GlobalVariableReadNode,
+            "global_variable_write_node" => Self::GlobalVariableWriteNode,
+            "global_variable_or_write_node" => Self::GlobalVariableOrWriteNode,
+            "global_variable_and_write_node" => Self::GlobalVariableAndWriteNode,
+            "global_variable_operator_write_node" => Self::GlobalVariableOperatorWriteNode,
+            "local_variable_or_write_node" => Self::LocalVariableOrWriteNode,
+            "local_variable_and_write_node" => Self::LocalVariableAndWriteNode,
+            "local_variable_operator_write_node" => Self::LocalVariableOperatorWriteNode,
+            "instance_variable_or_write_node" => Self::InstanceVariableOrWriteNode,
+            "instance_variable_and_write_node" => Self::InstanceVariableAndWriteNode,
+            "instance_variable_operator_write_node" => Self::InstanceVariableOperatorWriteNode,
+            "constant_or_write_node" => Self::ConstantOrWriteNode,
+            "constant_and_write_node" => Self::ConstantAndWriteNode,
+            "constant_operator_write_node" => Self::ConstantOperatorWriteNode,
+            "constant_path_or_write_node" => Self::ConstantPathOrWriteNode,
+            "constant_path_and_write_node" => Self::ConstantPathAndWriteNode,
+            "constant_path_operator_write_node" => Self::ConstantPathOperatorWriteNode,
+            "constant_path_write_node" => Self::ConstantPathWriteNode,
+            "case_match_node" => Self::CaseMatchNode,
+            "in_node" => Self::InNode,
+            "match_predicate_node" => Self::MatchPredicateNode,
+            "match_required_node" => Self::MatchRequiredNode,
+            "self_node" => Self::SelfNode,
+            "parentheses_node" => Self::ParenthesesNode,
+            "defined_node" => Self::DefinedNode,
+            "singleton_class_node" => Self::SingletonClassNode,
+            "alias_method_node" => Self::AliasMethodNode,
+            "alias_global_variable_node" => Self::AliasGlobalVariableNode,
+            "undef_node" => Self::UndefNode,
+            "assoc_splat_node" => Self::AssocSplatNode,
+            "block_argument_node" => Self::BlockArgumentNode,
+            "multi_write_node" => Self::MultiWriteNode,
+            "multi_target_node" => Self::MultiTargetNode,
             _ => Self::Unknown(s.to_string()),
         }
     }

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

@@ -46,10 +46,15 @@ impl Emitter {
         self.buffer.clear();
         self.emitted_comment_indices.clear();
 
-        // Collect all comments from the AST
         self.collect_comments(ast);
 
         self.emit_node(ast, 0)?;
+
+        // Ensure file ends with a newline
+        if !self.buffer.ends_with('\n') {
+            self.buffer.push('\n');
+        }
+
         Ok(self.buffer.clone())
     }
 
@@ -68,22 +73,26 @@ impl Emitter {
             IndentStyle::Tabs => "\t".repeat(indent_level),
         };
 
-        let mut indices_to_emit = Vec::new();
+        let mut comments_to_emit = Vec::new();
         for (idx, comment) in self.all_comments.iter().enumerate() {
             if self.emitted_comment_indices.contains(&idx) {
                 continue;
             }
 
-            // Collect comments that end before this line
             if comment.location.end_line < line {
-                indices_to_emit.push((idx, comment.text.clone()));
+                comments_to_emit.push((idx, comment.text.clone(), comment.location.end_line));
             }
         }
 
-        // Now emit the collected comments
-        for (idx, text) in indices_to_emit {
+        let comments_count = comments_to_emit.len();
+        for (i, (idx, text, comment_end_line)) in comments_to_emit.into_iter().enumerate() {
             writeln!(self.buffer, "{}{}", indent_str, text)?;
             self.emitted_comment_indices.push(idx);
+
+            // Only add blank line after the LAST comment if there was a gap in the original
+            if i == comments_count - 1 && line > comment_end_line + 1 {
+                self.buffer.push('\n');
+            }
         }
 
         Ok(())
@@ -123,6 +132,15 @@ impl Emitter {
             NodeType::IfNode => self.emit_if_unless(node, indent_level, false, "if")?,
             NodeType::UnlessNode => self.emit_if_unless(node, indent_level, false, "unless")?,
             NodeType::CallNode => self.emit_call(node, indent_level)?,
+            NodeType::BeginNode => self.emit_begin(node, indent_level)?,
+            NodeType::RescueNode => self.emit_rescue(node, indent_level)?,
+            NodeType::EnsureNode => self.emit_ensure(node, indent_level)?,
+            NodeType::LambdaNode => self.emit_lambda(node, indent_level)?,
+            NodeType::CaseNode => self.emit_case(node, indent_level)?,
+            NodeType::WhenNode => self.emit_when(node, indent_level)?,
+            NodeType::WhileNode => self.emit_while_until(node, indent_level, "while")?,
+            NodeType::UntilNode => self.emit_while_until(node, indent_level, "until")?,
+            NodeType::ForNode => self.emit_for(node, indent_level)?,
             _ => self.emit_generic(node, indent_level)?,
         }
         Ok(())
@@ -154,14 +172,28 @@ impl Emitter {
         for (i, child) in node.children.iter().enumerate() {
             self.emit_node(child, indent_level)?;
 
-            // Add newlines between statements, normalizing to max 1 blank line
             if i < node.children.len() - 1 {
                 let current_end_line = child.location.end_line;
-                let next_start_line = node.children[i + 1].location.start_line;
-                let line_diff = next_start_line.saturating_sub(current_end_line);
+                let next_child = &node.children[i + 1];
+                let next_start_line = next_child.location.start_line;
+
+                // Find the first comment between current and next node (if any)
+                let first_comment_line = self
+                    .all_comments
+                    .iter()
+                    .filter(|c| {
+                        c.location.start_line > current_end_line
+                            && c.location.end_line < next_start_line
+                    })
+                    .map(|c| c.location.start_line)
+                    .min();
+
+                // Calculate line diff based on whether there's a comment
+                let effective_next_line = first_comment_line.unwrap_or(next_start_line);
+                let line_diff = effective_next_line.saturating_sub(current_end_line);
 
-                // Add 1 newline if consecutive, 2 newlines (1 blank line) if there was a gap
                 let newlines = if line_diff > 1 { 2 } else { 1 };
+
                 for _ in 0..newlines {
                     self.buffer.push('\n');
                 }
@@ -314,6 +346,217 @@ impl Emitter {
         Ok(())
     }
 
+    /// Emit begin node
+    /// BeginNode can be either:
+    /// 1. Explicit begin...end block (source starts with "begin")
+    /// 2. Implicit begin wrapping method body with rescue/ensure
+    fn emit_begin(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Check if this is an explicit begin block by looking at source
+        let is_explicit_begin = if !self.source.is_empty() {
+            self.source
+                .get(node.location.start_offset..)
+                .map(|s| s.trim_start().starts_with("begin"))
+                .unwrap_or(false)
+        } else {
+            false
+        };
+
+        if is_explicit_begin {
+            self.emit_comments_before(node.location.start_line, indent_level)?;
+            self.emit_indent(indent_level)?;
+            writeln!(self.buffer, "begin")?;
+
+            for child in &node.children {
+                self.emit_node(child, indent_level + 1)?;
+                self.buffer.push('\n');
+            }
+
+            self.emit_indent(indent_level)?;
+            write!(self.buffer, "end")?;
+        } else {
+            // Implicit begin - emit children directly
+            for (i, child) in node.children.iter().enumerate() {
+                if i > 0 {
+                    self.buffer.push('\n');
+                }
+                self.emit_node(child, indent_level)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Emit rescue node
+    fn emit_rescue(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Rescue node structure:
+        // - First children are exception class references (ConstantReadNode)
+        // - Then exception variable (LocalVariableTargetNode)
+        // - Last child is StatementsNode with the rescue body
+
+        // Dedent by 1 level since rescue is at the same level as method body
+        let rescue_indent = indent_level.saturating_sub(1);
+        self.emit_indent(rescue_indent)?;
+        write!(self.buffer, "rescue")?;
+
+        // Extract exception classes and variable from source
+        if !self.source.is_empty() && node.location.end_offset <= self.source.len() {
+            if let Some(source_text) = self
+                .source
+                .get(node.location.start_offset..node.location.end_offset)
+            {
+                // Get the rescue line to extract exception class and variable
+                if let Some(rescue_line) = source_text.lines().next() {
+                    // Remove "rescue" prefix and get the rest (exception class => var)
+                    let after_rescue = rescue_line.trim_start_matches("rescue").trim();
+                    if !after_rescue.is_empty() {
+                        write!(self.buffer, " {}", after_rescue)?;
+                    }
+                }
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit rescue body (last child is typically StatementsNode)
+        if let Some(body) = node.children.last() {
+            if matches!(body.node_type, NodeType::StatementsNode) {
+                self.emit_node(body, indent_level)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Emit ensure node
+    fn emit_ensure(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // ensure keyword should be at same level as begin/rescue
+        let ensure_indent = indent_level.saturating_sub(1);
+
+        self.emit_comments_before(node.location.start_line, ensure_indent)?;
+        self.emit_indent(ensure_indent)?;
+        writeln!(self.buffer, "ensure")?;
+
+        // Emit ensure body statements
+        for child in &node.children {
+            match &child.node_type {
+                NodeType::StatementsNode => {
+                    self.emit_statements(child, indent_level)?;
+                }
+                _ => {
+                    self.emit_node(child, indent_level)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Emit lambda node
+    fn emit_lambda(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+
+        // Lambda syntax is complex (-> vs lambda, {} vs do-end)
+        // Use source extraction to preserve original style
+        self.emit_generic_without_comments(node, indent_level)
+    }
+
+    /// Emit case node
+    fn emit_case(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+        self.emit_indent(indent_level)?;
+
+        // Write "case" keyword
+        write!(self.buffer, "case")?;
+
+        // Find predicate (first child that isn't WhenNode or ElseNode)
+        let mut when_start_idx = 0;
+        if let Some(first_child) = node.children.first() {
+            if !matches!(
+                first_child.node_type,
+                NodeType::WhenNode | NodeType::ElseNode
+            ) {
+                // This is the predicate - extract from source
+                let start = first_child.location.start_offset;
+                let end = first_child.location.end_offset;
+                if let Some(text) = self.source.get(start..end) {
+                    write!(self.buffer, " {}", text)?;
+                }
+                when_start_idx = 1;
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit when clauses and else
+        for child in node.children.iter().skip(when_start_idx) {
+            match &child.node_type {
+                NodeType::WhenNode => {
+                    self.emit_when(child, indent_level)?;
+                    self.buffer.push('\n');
+                }
+                NodeType::ElseNode => {
+                    self.emit_indent(indent_level)?;
+                    writeln!(self.buffer, "else")?;
+                    // Emit else body
+                    for else_child in &child.children {
+                        if matches!(else_child.node_type, NodeType::StatementsNode) {
+                            self.emit_statements(else_child, indent_level + 1)?;
+                        } else {
+                            self.emit_node(else_child, indent_level + 1)?;
+                        }
+                    }
+                    self.buffer.push('\n');
+                }
+                _ => {}
+            }
+        }
+
+        // Emit "end" keyword
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
+    /// Emit when node
+    fn emit_when(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+        self.emit_indent(indent_level)?;
+
+        write!(self.buffer, "when ")?;
+
+        // Collect conditions (all children except StatementsNode)
+        let conditions: Vec<_> = node
+            .children
+            .iter()
+            .filter(|c| !matches!(c.node_type, NodeType::StatementsNode))
+            .collect();
+
+        // Emit conditions with comma separator
+        for (i, cond) in conditions.iter().enumerate() {
+            let start = cond.location.start_offset;
+            let end = cond.location.end_offset;
+            if let Some(text) = self.source.get(start..end) {
+                write!(self.buffer, "{}", text)?;
+            }
+            if i < conditions.len() - 1 {
+                write!(self.buffer, ", ")?;
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit statements body
+        if let Some(statements) = node
+            .children
+            .iter()
+            .find(|c| matches!(c.node_type, NodeType::StatementsNode))
+        {
+            self.emit_statements(statements, indent_level + 1)?;
+        }
+
+        Ok(())
+    }
+
     /// Emit if/unless/elsif/else node
     /// is_elsif: true if this is an elsif clause (don't emit 'end')
     /// keyword: "if" or "unless"
@@ -616,22 +859,29 @@ impl Emitter {
 
     /// Emit generic node by extracting from source
     fn emit_generic(&mut self, node: &Node, indent_level: usize) -> Result<()> {
-        // Emit any comments before this node
         self.emit_comments_before(node.location.start_line, indent_level)?;
 
         if !self.source.is_empty() {
             let start = node.location.start_offset;
             let end = node.location.end_offset;
 
-            // Clone text first to avoid borrow conflict
             let text_owned = self.source.get(start..end).map(|s| s.to_string());
 
             if let Some(text) = text_owned {
-                // Add indentation before the extracted text
                 self.emit_indent(indent_level)?;
                 write!(self.buffer, "{}", text)?;
 
-                // Emit any trailing comments on the same line
+                // Mark comments within this node's range as emitted
+                // (they are included in the source extraction)
+                for (idx, comment) in self.all_comments.iter().enumerate() {
+                    if !self.emitted_comment_indices.contains(&idx)
+                        && comment.location.start_line >= node.location.start_line
+                        && comment.location.end_line <= node.location.end_line
+                    {
+                        self.emitted_comment_indices.push(idx);
+                    }
+                }
+
                 self.emit_trailing_comments(node.location.end_line)?;
             }
         }
@@ -649,6 +899,107 @@ impl Emitter {
         Ok(())
     }
 
+    /// Emit while/until loop
+    fn emit_while_until(&mut self, node: &Node, indent_level: usize, keyword: &str) -> Result<()> {
+        // Check if this is a postfix while/until (modifier form)
+        // In postfix form: "statement while/until condition"
+        // Check if body starts before predicate in source
+        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 {
+            // Postfix form: extract from source as-is
+            return self.emit_generic(node, indent_level);
+        }
+
+        // Normal while/until with do...end
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "{} ", keyword)?;
+
+        // Emit predicate (condition) - first child
+        if let Some(predicate) = node.children.first() {
+            if !self.source.is_empty() {
+                let start = predicate.location.start_offset;
+                let end = predicate.location.end_offset;
+                if let Some(text) = self.source.get(start..end) {
+                    write!(self.buffer, "{}", text)?;
+                }
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit body - second child (StatementsNode)
+        if let Some(body) = node.children.get(1) {
+            if matches!(body.node_type, NodeType::StatementsNode) {
+                self.emit_statements(body, indent_level + 1)?;
+                self.buffer.push('\n');
+            }
+        }
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
+    /// Emit for loop
+    fn emit_for(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "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 !self.source.is_empty() {
+                let start = index.location.start_offset;
+                let end = index.location.end_offset;
+                if let Some(text) = self.source.get(start..end) {
+                    write!(self.buffer, "{}", text)?;
+                }
+            }
+        }
+
+        write!(self.buffer, " in ")?;
+
+        // Emit collection - second child
+        if let Some(collection) = node.children.get(1) {
+            if !self.source.is_empty() {
+                let start = collection.location.start_offset;
+                let end = collection.location.end_offset;
+                if let Some(text) = self.source.get(start..end) {
+                    write!(self.buffer, "{}", text)?;
+                }
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit body - third child (StatementsNode)
+        if let Some(body) = node.children.get(2) {
+            if matches!(body.node_type, NodeType::StatementsNode) {
+                self.emit_statements(body, indent_level + 1)?;
+                self.buffer.push('\n');
+            }
+        }
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
     /// Check if node is structural (part of definition syntax, not body)
     fn is_structural_node(&self, node_type: &NodeType) -> bool {
         matches!(

data/lib/rfmt/prism_bridge.rb

@@ -172,6 +172,127 @@ module Rfmt
                                 []
                               end
                      params + [node.body].compact
+                   when Prism::BeginNode
+                     [
+                       node.statements,
+                       node.rescue_clause,
+                       node.ensure_clause
+                     ].compact
+                   when Prism::EnsureNode
+                     [node.statements].compact
+                   when Prism::LambdaNode
+                     params = if node.parameters
+                                node.parameters.child_nodes.compact
+                              else
+                                []
+                              end
+                     params + [node.body].compact
+                   when Prism::RescueNode
+                     result = []
+                     result.concat(node.exceptions) if node.exceptions
+                     result << node.reference if node.reference
+                     result << node.statements if node.statements
+                     result << node.subsequent if node.subsequent
+                     result
+                   when Prism::SymbolNode, Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode
+                     []
+                   when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode
+                     [node.value].compact
+                   when Prism::ReturnNode
+                     node.arguments ? node.arguments.child_nodes.compact : []
+                   when Prism::OrNode
+                     [node.left, node.right].compact
+                   when Prism::AssocNode
+                     [node.key, node.value].compact
+                   when Prism::KeywordHashNode
+                     node.elements || []
+                   when Prism::InterpolatedStringNode
+                     node.parts || []
+                   when Prism::EmbeddedStatementsNode
+                     [node.statements].compact
+                   when Prism::CaseNode
+                     [node.predicate, *node.conditions, node.else_clause].compact
+                   when Prism::WhenNode
+                     [*node.conditions, node.statements].compact
+                   when Prism::WhileNode, Prism::UntilNode
+                     [node.predicate, node.statements].compact
+                   when Prism::ForNode
+                     [node.index, node.collection, node.statements].compact
+                   when Prism::BreakNode, Prism::NextNode
+                     node.arguments ? node.arguments.child_nodes.compact : []
+                   when Prism::RedoNode, Prism::RetryNode
+                     []
+                   when Prism::YieldNode
+                     node.arguments ? node.arguments.child_nodes.compact : []
+                   when Prism::SuperNode
+                     result = []
+                     result.concat(node.arguments.child_nodes.compact) if node.arguments
+                     result << node.block if node.block
+                     result
+                   when Prism::ForwardingSuperNode
+                     node.block ? [node.block] : []
+                   when Prism::RescueModifierNode
+                     [node.expression, node.rescue_expression].compact
+                   when Prism::RangeNode
+                     [node.left, node.right].compact
+                   when Prism::RegularExpressionNode
+                     []
+                   when Prism::SplatNode
+                     [node.expression].compact
+                   when Prism::AndNode
+                     [node.left, node.right].compact
+                   when Prism::NotNode
+                     [node.expression].compact
+                   when Prism::InterpolatedRegularExpressionNode, Prism::InterpolatedSymbolNode,
+                        Prism::InterpolatedXStringNode
+                     node.parts || []
+                   when Prism::XStringNode
+                     []
+                   when Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::SelfNode
+                     []
+                   when Prism::ClassVariableWriteNode, Prism::GlobalVariableWriteNode
+                     [node.value].compact
+                   when Prism::ClassVariableOrWriteNode, Prism::ClassVariableAndWriteNode,
+                        Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableAndWriteNode,
+                        Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
+                        Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+                        Prism::ConstantOrWriteNode, Prism::ConstantAndWriteNode
+                     [node.value].compact
+                   when Prism::ClassVariableOperatorWriteNode, Prism::GlobalVariableOperatorWriteNode,
+                        Prism::LocalVariableOperatorWriteNode, Prism::InstanceVariableOperatorWriteNode,
+                        Prism::ConstantOperatorWriteNode
+                     [node.value].compact
+                   when Prism::ConstantPathOrWriteNode, Prism::ConstantPathAndWriteNode,
+                        Prism::ConstantPathOperatorWriteNode
+                     [node.target, node.value].compact
+                   when Prism::ConstantPathWriteNode
+                     [node.target, node.value].compact
+                   when Prism::CaseMatchNode
+                     [node.predicate, *node.conditions, node.else_clause].compact
+                   when Prism::InNode
+                     [node.pattern, node.statements].compact
+                   when Prism::MatchPredicateNode, Prism::MatchRequiredNode
+                     [node.value, node.pattern].compact
+                   when Prism::ParenthesesNode
+                     [node.body].compact
+                   when Prism::DefinedNode
+                     [node.value].compact
+                   when Prism::SingletonClassNode
+                     [node.expression, node.body].compact
+                   when Prism::AliasMethodNode
+                     [node.new_name, node.old_name].compact
+                   when Prism::AliasGlobalVariableNode
+                     [node.new_name, node.old_name].compact
+                   when Prism::UndefNode
+                     node.names || []
+                   when Prism::AssocSplatNode
+                     [node.value].compact
+                   when Prism::BlockArgumentNode
+                     [node.expression].compact
+                   when Prism::MultiWriteNode
+                     [*node.lefts, node.rest, *node.rights, node.value].compact
+                   when Prism::MultiTargetNode
+                     [*node.lefts, node.rest, *node.rights].compact
                    else
                      # For unknown types, try to get child nodes if they exist
                      []

data/lib/rfmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rfmt
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/rfmt.rb

@@ -61,7 +61,7 @@ module Rfmt
     DEFAULT_CONFIG = <<~YAML
       # rfmt Configuration File
       # This file controls how rfmt formats your Ruby code.
-      # See https://github.com/fujitanisora/rfmt for full documentation.
+      # See https://github.com/fs0414/rfmt for full documentation.
 
       version: "1.0"
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - fujitani sora
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -58,7 +57,7 @@ files:
 - lib/rfmt/configuration.rb
 - lib/rfmt/prism_bridge.rb
 - lib/rfmt/prism_node_extractor.rb
-- lib/rfmt/rfmt.so
+- lib/rfmt/rfmt.bundle
 - lib/rfmt/version.rb
 - lib/ruby_lsp/rfmt/addon.rb
 - lib/ruby_lsp/rfmt/formatter_runner.rb
@@ -71,7 +70,6 @@ metadata:
   source_code_uri: https://github.com/fs0414/rfmt
   changelog_uri: https://github.com/fs0414/rfmt/releases
   ruby_lsp_addon: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.0.0
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Ruby Formatter impl Rust lang.
 test_files: []