rfmt 1.3.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c46c2c5129ef89717e76c7d187a0739389814d2ee01a1c50a5b64173d9b728f4
-  data.tar.gz: 63982b7a966f9a64b9b01ea9d5d22e55e3c020fa7f76c4d63333bb7114591a6c
+  metadata.gz: 79f5e6c24f82f6552874aefda2a6b97d8f4612419810d76ebd9381e862edded4
+  data.tar.gz: f193dab59e9a02f62d3e599c8f0349ebbf6e7fda070ba55990e9a8d399990f72
 SHA512:
-  metadata.gz: a1f3c26b649ea73a7a01c41c8d06e8d00137eb1b48946e8043ee632d9f5ea6465649999558a1c101779638d0383dadbbd610174de34c68ffcefb6a095c214b01
-  data.tar.gz: 8c6c55859f132cd0cf5cfedf8b3af6b785cbd52f73f9f6ae9d8493717068724357abec0ad82c64ba31fefd99d798154f0df6d9136f52ffff675f848aa57f7500
+  metadata.gz: 6ebfd2c04793445912e1edc28db74e5cfa218fcd3fc28f6e3b42a88b1794fe0bfc6643890fa34477291c7ad8624696f3bb7207436ecfeb6f756439be5d9065ae
+  data.tar.gz: e209cf0a8671786af5e1560979f70f5fe8bb4e2de3912613a59e6d6269effe54f123407ca8989b50578f330d16e8a0d2fa7a1b47c8c07d5731e893664892fe1a

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 ## [Unreleased]
 
+## [1.3.2] - 2026-01-09
+
+### Added
+- Implement `std::str::FromStr` trait for `NodeType`
+- Unit tests for validation module
+
+### Changed
+- Use serde enum for comment type deserialization (type-safe JSON parsing)
+- Convert recursive `find_last_code_line` to iterative approach (prevent stack overflow)
+- Use BTreeMap index for comment lookup in `emit_statements` (O(n) → O(log n))
+
+### Fixed
+- Remove panic-prone `unwrap()` on Mutex lock in logger (prevent Ruby VM crash)
+
+## [1.3.1] - 2026-01-08
+
+### Added
+- Dedicated emitters for SingletonClassNode and pattern matching (CaseMatchNode, InNode)
+- Literal and pattern match node support
+- NoKeywordsParameterNode support
+
+### Changed
+- Performance: Comment lookup optimized with BTreeMap index (O(n) → O(log n))
+- Performance: HashSet for comment tracking (O(n) → O(1) contains check)
+- Performance: Cached indent strings to avoid repeated allocations
+
+### Fixed
+- DefNode parameter handling and missing node types
+- Deep nest JSON parse error (max_nesting: false)
+
 ## [1.3.0] - 2026-01-07
 
 ### Added

data/Cargo.lock

@@ -1214,7 +1214,7 @@ checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rfmt"
-version = "1.3.0"
+version = "1.3.2"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

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

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

@@ -180,12 +180,66 @@ pub enum NodeType {
     KeywordRestParameterNode,
     BlockParameterNode,
 
+    // Source metadata nodes
+    SourceFileNode,
+    SourceLineNode,
+    SourceEncodingNode,
+
+    // Pre/Post execution
+    PreExecutionNode,
+    PostExecutionNode,
+
+    // Numeric literals
+    RationalNode,
+    ImaginaryNode,
+
+    // String interpolation
+    EmbeddedVariableNode,
+
+    // Pattern matching patterns
+    ArrayPatternNode,
+    HashPatternNode,
+    FindPatternNode,
+    CapturePatternNode,
+    AlternationPatternNode,
+    PinnedExpressionNode,
+    PinnedVariableNode,
+
+    // Forwarding
+    ForwardingArgumentsNode,
+    ForwardingParameterNode,
+    NoKeywordsParameterNode,
+
+    // References
+    BackReferenceReadNode,
+    NumberedReferenceReadNode,
+
+    // Call/Index compound assignment
+    CallAndWriteNode,
+    CallOrWriteNode,
+    CallOperatorWriteNode,
+    IndexAndWriteNode,
+    IndexOrWriteNode,
+    IndexOperatorWriteNode,
+
+    // Match
+    MatchWriteNode,
+    MatchLastLineNode,
+    InterpolatedMatchLastLineNode,
+
+    // Other
+    FlipFlopNode,
+    ImplicitNode,
+    ImplicitRestNode,
+
     Unknown(String),
 }
 
-impl NodeType {
-    pub fn from_str(s: &str) -> Self {
-        match s {
+impl std::str::FromStr for NodeType {
+    type Err = std::convert::Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
             "program_node" => Self::ProgramNode,
             "statements_node" => Self::StatementsNode,
             "class_node" => Self::ClassNode,
@@ -290,8 +344,55 @@ impl NodeType {
             "block_argument_node" => Self::BlockArgumentNode,
             "multi_write_node" => Self::MultiWriteNode,
             "multi_target_node" => Self::MultiTargetNode,
+            "source_file_node" => Self::SourceFileNode,
+            "source_line_node" => Self::SourceLineNode,
+            "source_encoding_node" => Self::SourceEncodingNode,
+            "pre_execution_node" => Self::PreExecutionNode,
+            "post_execution_node" => Self::PostExecutionNode,
+            // Numeric literals
+            "rational_node" => Self::RationalNode,
+            "imaginary_node" => Self::ImaginaryNode,
+            // String interpolation
+            "embedded_variable_node" => Self::EmbeddedVariableNode,
+            // Pattern matching patterns
+            "array_pattern_node" => Self::ArrayPatternNode,
+            "hash_pattern_node" => Self::HashPatternNode,
+            "find_pattern_node" => Self::FindPatternNode,
+            "capture_pattern_node" => Self::CapturePatternNode,
+            "alternation_pattern_node" => Self::AlternationPatternNode,
+            "pinned_expression_node" => Self::PinnedExpressionNode,
+            "pinned_variable_node" => Self::PinnedVariableNode,
+            // Forwarding
+            "forwarding_arguments_node" => Self::ForwardingArgumentsNode,
+            "forwarding_parameter_node" => Self::ForwardingParameterNode,
+            "no_keywords_parameter_node" => Self::NoKeywordsParameterNode,
+            // References
+            "back_reference_read_node" => Self::BackReferenceReadNode,
+            "numbered_reference_read_node" => Self::NumberedReferenceReadNode,
+            // Call/Index compound assignment
+            "call_and_write_node" => Self::CallAndWriteNode,
+            "call_or_write_node" => Self::CallOrWriteNode,
+            "call_operator_write_node" => Self::CallOperatorWriteNode,
+            "index_and_write_node" => Self::IndexAndWriteNode,
+            "index_or_write_node" => Self::IndexOrWriteNode,
+            "index_operator_write_node" => Self::IndexOperatorWriteNode,
+            // Match
+            "match_write_node" => Self::MatchWriteNode,
+            "match_last_line_node" => Self::MatchLastLineNode,
+            "interpolated_match_last_line_node" => Self::InterpolatedMatchLastLineNode,
+            // Other
+            "flip_flop_node" => Self::FlipFlopNode,
+            "implicit_node" => Self::ImplicitNode,
+            "implicit_rest_node" => Self::ImplicitRestNode,
             _ => Self::Unknown(s.to_string()),
-        }
+        })
+    }
+}
+
+impl NodeType {
+    /// Parse a node type from a string (convenience wrapper for `FromStr`)
+    pub fn from_str(s: &str) -> Self {
+        s.parse().unwrap()
     }
 
     /// Check if this node type is a definition (class, module, or method)

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

@@ -1,6 +1,7 @@
 use crate::ast::{Comment, Node, NodeType};
 use crate::config::{Config, IndentStyle};
 use crate::error::Result;
+use std::collections::{BTreeMap, HashSet};
 use std::fmt::Write;
 
 /// Block style for Ruby blocks
@@ -16,7 +17,12 @@ pub struct Emitter {
     source: String,
     buffer: String,
     all_comments: Vec<Comment>,
-    emitted_comment_indices: Vec<usize>,
+    emitted_comment_indices: HashSet<usize>,
+    /// Cached indent strings by level (index = level, value = indent string)
+    indent_cache: Vec<String>,
+    /// Index of comment indices by start line for O(log n) lookup
+    /// Key: start_line, Value: Vec of comment indices that start on that line
+    comments_by_line: BTreeMap<usize, Vec<usize>>,
 }
 
 impl Emitter {
@@ -26,7 +32,9 @@ impl Emitter {
             source: String::new(),
             buffer: String::new(),
             all_comments: Vec::new(),
-            emitted_comment_indices: Vec::new(),
+            emitted_comment_indices: HashSet::new(),
+            indent_cache: Vec::new(),
+            comments_by_line: BTreeMap::new(),
         }
     }
 
@@ -37,7 +45,9 @@ impl Emitter {
             source,
             buffer: String::new(),
             all_comments: Vec::new(),
-            emitted_comment_indices: Vec::new(),
+            emitted_comment_indices: HashSet::new(),
+            indent_cache: Vec::new(),
+            comments_by_line: BTreeMap::new(),
         }
     }
 
@@ -45,8 +55,10 @@ impl Emitter {
     pub fn emit(&mut self, ast: &Node) -> Result<String> {
         self.buffer.clear();
         self.emitted_comment_indices.clear();
+        self.comments_by_line.clear();
 
         self.collect_comments(ast);
+        self.build_comment_index();
 
         self.emit_node(ast, 0)?;
 
@@ -61,18 +73,19 @@ impl Emitter {
             self.buffer.push('\n');
         }
 
-        Ok(self.buffer.clone())
+        Ok(std::mem::take(&mut self.buffer))
     }
 
     /// Find the last line of code in the AST (excluding comments)
     fn find_last_code_line(ast: &Node) -> usize {
         let mut max_line = ast.location.end_line;
-        for child in &ast.children {
-            let child_end = Self::find_last_code_line(child);
-            if child_end > max_line {
-                max_line = child_end;
-            }
+        let mut stack = vec![ast];
+
+        while let Some(node) = stack.pop() {
+            max_line = max_line.max(node.location.end_line);
+            stack.extend(node.children.iter());
         }
+
         max_line
     }
 
@@ -107,7 +120,7 @@ impl Emitter {
             }
 
             writeln!(self.buffer, "{}", comment.text)?;
-            self.emitted_comment_indices.push(idx);
+            self.emitted_comment_indices.insert(idx);
             last_end_line = Some(comment.location.end_line);
             is_first_comment = false;
         }
@@ -122,28 +135,75 @@ impl Emitter {
         }
     }
 
+    /// Build the comment index by start line for O(log n) range lookups
+    fn build_comment_index(&mut self) {
+        for (idx, comment) in self.all_comments.iter().enumerate() {
+            self.comments_by_line
+                .entry(comment.location.start_line)
+                .or_default()
+                .push(idx);
+        }
+    }
+
+    /// Get comment indices in the given line range [start_line, end_line)
+    /// Uses BTreeMap range for O(log n) lookup instead of O(n) iteration
+    fn get_comment_indices_in_range(&self, start_line: usize, end_line: usize) -> Vec<usize> {
+        self.comments_by_line
+            .range(start_line..end_line)
+            .flat_map(|(_, indices)| indices.iter().copied())
+            .filter(|&idx| !self.emitted_comment_indices.contains(&idx))
+            .collect()
+    }
+
+    /// Get comment indices before a given line (exclusive)
+    /// Uses BTreeMap range for O(log n) lookup
+    fn get_comment_indices_before(&self, line: usize) -> Vec<usize> {
+        self.comments_by_line
+            .range(..line)
+            .flat_map(|(_, indices)| indices.iter().copied())
+            .filter(|&idx| {
+                !self.emitted_comment_indices.contains(&idx)
+                    && self.all_comments[idx].location.end_line < line
+            })
+            .collect()
+    }
+
+    /// Get comment indices on a specific line (for trailing comments)
+    /// Uses BTreeMap get for O(log n) lookup
+    fn get_comment_indices_on_line(&self, line: usize) -> Vec<usize> {
+        self.comments_by_line
+            .get(&line)
+            .map(|indices| {
+                indices
+                    .iter()
+                    .copied()
+                    .filter(|&idx| !self.emitted_comment_indices.contains(&idx))
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
     /// Emit comments that appear before a given line
+    /// Uses BTreeMap index for O(log n) lookup instead of O(n) iteration
     fn emit_comments_before(&mut self, line: usize, indent_level: usize) -> Result<()> {
-        let indent_str = match self.config.formatting.indent_style {
-            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * indent_level),
-            IndentStyle::Tabs => "\t".repeat(indent_level),
-        };
+        let indent_str = self.get_indent(indent_level).to_string();
 
-        let mut comments_to_emit = Vec::new();
-        for (idx, comment) in self.all_comments.iter().enumerate() {
-            if self.emitted_comment_indices.contains(&idx) {
-                continue;
-            }
+        // Use indexed lookup instead of iterating all comments
+        let indices = self.get_comment_indices_before(line);
 
-            if comment.location.end_line < line {
-                comments_to_emit.push((
+        // Build list of comments to emit with their data
+        let mut comments_to_emit: Vec<_> = indices
+            .into_iter()
+            .map(|idx| {
+                let comment = &self.all_comments[idx];
+                (
                     idx,
                     comment.text.clone(),
                     comment.location.start_line,
                     comment.location.end_line,
-                ));
-            }
-        }
+                )
+            })
+            .collect();
 
         // Sort by start_line to emit in order
         comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
@@ -163,7 +223,7 @@ impl Emitter {
             }
 
             writeln!(self.buffer, "{}{}", indent_str, text)?;
-            self.emitted_comment_indices.push(idx);
+            self.emitted_comment_indices.insert(idx);
             last_comment_end_line = Some(comment_end_line);
 
             // Add blank line after the LAST comment if there was a gap to the code
@@ -176,41 +236,44 @@ impl Emitter {
     }
 
     /// Check if there are any unemitted comments in the given line range
+    /// Uses BTreeMap index for O(log n) lookup instead of O(n) iteration
     fn has_comments_in_range(&self, start_line: usize, end_line: usize) -> bool {
-        self.all_comments.iter().enumerate().any(|(idx, comment)| {
-            !self.emitted_comment_indices.contains(&idx)
-                && comment.location.start_line >= start_line
-                && comment.location.end_line < end_line
-        })
+        self.comments_by_line
+            .range(start_line..end_line)
+            .flat_map(|(_, indices)| indices.iter())
+            .any(|&idx| {
+                !self.emitted_comment_indices.contains(&idx)
+                    && self.all_comments[idx].location.end_line < end_line
+            })
     }
 
     /// Emit comments that are within a given line range (exclusive of end_line)
+    /// Uses BTreeMap index for O(log n) lookup instead of O(n) iteration
     fn emit_comments_in_range(
         &mut self,
         start_line: usize,
         end_line: usize,
         indent_level: usize,
     ) -> Result<()> {
-        let indent_str = match self.config.formatting.indent_style {
-            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * indent_level),
-            IndentStyle::Tabs => "\t".repeat(indent_level),
-        };
-
-        let mut comments_to_emit = Vec::new();
-        for (idx, comment) in self.all_comments.iter().enumerate() {
-            if self.emitted_comment_indices.contains(&idx) {
-                continue;
-            }
-
-            if comment.location.start_line >= start_line && comment.location.end_line < end_line {
-                comments_to_emit.push((
+        let indent_str = self.get_indent(indent_level).to_string();
+
+        // Use indexed lookup instead of iterating all comments
+        let indices = self.get_comment_indices_in_range(start_line, end_line);
+
+        // Build list of comments to emit, filtering by end_line
+        let mut comments_to_emit: Vec<_> = indices
+            .into_iter()
+            .filter(|&idx| self.all_comments[idx].location.end_line < end_line)
+            .map(|idx| {
+                let comment = &self.all_comments[idx];
+                (
                     idx,
                     comment.text.clone(),
                     comment.location.start_line,
                     comment.location.end_line,
-                ));
-            }
-        }
+                )
+            })
+            .collect();
 
         // Sort by start_line to emit in order
         comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
@@ -227,7 +290,7 @@ impl Emitter {
             }
 
             writeln!(self.buffer, "{}{}", indent_str, text)?;
-            self.emitted_comment_indices.push(idx);
+            self.emitted_comment_indices.insert(idx);
             last_comment_end_line = Some(comment_end_line);
         }
 
@@ -235,6 +298,7 @@ impl Emitter {
     }
 
     /// Emit comments that are within a given line range, preserving blank lines from prev_line
+    /// Uses BTreeMap index for O(log n) lookup instead of O(n) iteration
     fn emit_comments_in_range_with_prev_line(
         &mut self,
         start_line: usize,
@@ -242,26 +306,25 @@ impl Emitter {
         indent_level: usize,
         prev_line: usize,
     ) -> Result<()> {
-        let indent_str = match self.config.formatting.indent_style {
-            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * indent_level),
-            IndentStyle::Tabs => "\t".repeat(indent_level),
-        };
-
-        let mut comments_to_emit = Vec::new();
-        for (idx, comment) in self.all_comments.iter().enumerate() {
-            if self.emitted_comment_indices.contains(&idx) {
-                continue;
-            }
-
-            if comment.location.start_line >= start_line && comment.location.end_line < end_line {
-                comments_to_emit.push((
+        let indent_str = self.get_indent(indent_level).to_string();
+
+        // Use indexed lookup instead of iterating all comments
+        let indices = self.get_comment_indices_in_range(start_line, end_line);
+
+        // Build list of comments to emit, filtering by end_line
+        let mut comments_to_emit: Vec<_> = indices
+            .into_iter()
+            .filter(|&idx| self.all_comments[idx].location.end_line < end_line)
+            .map(|idx| {
+                let comment = &self.all_comments[idx];
+                (
                     idx,
                     comment.text.clone(),
                     comment.location.start_line,
                     comment.location.end_line,
-                ));
-            }
-        }
+                )
+            })
+            .collect();
 
         // Sort by start_line to emit in order
         comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
@@ -276,7 +339,7 @@ impl Emitter {
             }
 
             writeln!(self.buffer, "{}{}", indent_str, text)?;
-            self.emitted_comment_indices.push(idx);
+            self.emitted_comment_indices.insert(idx);
             last_end_line = comment_end_line;
         }
 
@@ -284,23 +347,21 @@ impl Emitter {
     }
 
     /// Emit comments that appear on the same line (trailing comments)
+    /// Uses BTreeMap index for O(log n) lookup instead of O(n) iteration
     fn emit_trailing_comments(&mut self, line: usize) -> Result<()> {
-        let mut indices_to_emit = Vec::new();
-        for (idx, comment) in self.all_comments.iter().enumerate() {
-            if self.emitted_comment_indices.contains(&idx) {
-                continue;
-            }
+        // Use indexed lookup for O(log n) access
+        let indices = self.get_comment_indices_on_line(line);
 
-            // Collect comments on the same line (trailing)
-            if comment.location.start_line == line {
-                indices_to_emit.push((idx, comment.text.clone()));
-            }
-        }
+        // Build list of comments to emit
+        let indices_to_emit: Vec<_> = indices
+            .into_iter()
+            .map(|idx| (idx, self.all_comments[idx].text.clone()))
+            .collect();
 
         // Now emit the collected comments
         for (idx, text) in indices_to_emit {
             write!(self.buffer, " {}", text)?;
-            self.emitted_comment_indices.push(idx);
+            self.emitted_comment_indices.insert(idx);
         }
 
         Ok(())
@@ -326,6 +387,9 @@ impl Emitter {
             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)?,
+            NodeType::SingletonClassNode => self.emit_singleton_class(node, indent_level)?,
+            NodeType::CaseMatchNode => self.emit_case_match(node, indent_level)?,
+            NodeType::InNode => self.emit_in(node, indent_level)?,
             _ => self.emit_generic(node, indent_level)?,
         }
         Ok(())
@@ -363,15 +427,12 @@ impl Emitter {
                 let next_start_line = next_child.location.start_line;
 
                 // Find the first comment between current and next node (if any)
+                // Uses BTreeMap range for O(log n) lookup instead of O(n) iteration
                 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();
+                    .comments_by_line
+                    .range((current_end_line + 1)..next_start_line)
+                    .next()
+                    .map(|(line, _)| *line);
 
                 // Calculate line diff based on whether there's a comment
                 let effective_next_line = first_comment_line.unwrap_or(next_start_line);
@@ -508,31 +569,17 @@ impl Emitter {
             write!(self.buffer, "{}", name)?;
         }
 
-        // TODO: Handle parameters properly
-        // For now, extract from source if method has parameters
-        if node
-            .metadata
-            .get("parameters_count")
-            .and_then(|s| s.parse::<usize>().ok())
-            .unwrap_or(0)
-            > 0
-        {
-            // Extract parameter part 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)
-                {
-                    // Find parameters in source (between def name and \n or ;)
-                    if let Some(def_line) = source_text.lines().next() {
-                        if let Some(params_start) = def_line.find('(') {
-                            if let Some(params_end) = def_line.find(')') {
-                                let params = &def_line[params_start..=params_end];
-                                write!(self.buffer, "{}", params)?;
-                            }
-                        }
-                    }
-                }
+        // Emit parameters using metadata from prism_bridge
+        if let Some(params_text) = node.metadata.get("parameters_text") {
+            let has_parens = node
+                .metadata
+                .get("has_parens")
+                .map(|v| v == "true")
+                .unwrap_or(false);
+            if has_parens {
+                write!(self.buffer, "({})", params_text)?;
+            } else {
+                write!(self.buffer, " {}", params_text)?;
             }
         }
 
@@ -1221,7 +1268,7 @@ impl Emitter {
                         && comment.location.start_line >= node.location.start_line
                         && comment.location.end_line < node.location.end_line
                     {
-                        self.emitted_comment_indices.push(idx);
+                        self.emitted_comment_indices.insert(idx);
                     }
                 }
 
@@ -1254,7 +1301,7 @@ impl Emitter {
                         && comment.location.start_line >= node.location.start_line
                         && comment.location.end_line < node.location.end_line
                     {
-                        self.emitted_comment_indices.push(idx);
+                        self.emitted_comment_indices.insert(idx);
                     }
                 }
 
@@ -1264,13 +1311,23 @@ impl Emitter {
         Ok(())
     }
 
+    /// Get cached indent string for a given level
+    fn get_indent(&mut self, level: usize) -> &str {
+        // Extend cache if needed
+        while self.indent_cache.len() <= level {
+            let len = self.indent_cache.len();
+            let indent = match self.config.formatting.indent_style {
+                IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * len),
+                IndentStyle::Tabs => "\t".repeat(len),
+            };
+            self.indent_cache.push(indent);
+        }
+        &self.indent_cache[level]
+    }
+
     /// Emit indentation
     fn emit_indent(&mut self, level: usize) -> Result<()> {
-        let indent_str = match self.config.formatting.indent_style {
-            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * level),
-            IndentStyle::Tabs => "\t".repeat(level),
-        };
-
+        let indent_str = self.get_indent(level).to_string();
         write!(self.buffer, "{}", indent_str)?;
         Ok(())
     }
@@ -1382,6 +1439,148 @@ impl Emitter {
         Ok(())
     }
 
+    /// Emit singleton class definition (class << self / class << object)
+    fn emit_singleton_class(&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, "class << ")?;
+
+        // First child is the expression (self or an object)
+        if let Some(expression) = node.children.first() {
+            if !self.source.is_empty() {
+                let start = expression.location.start_offset;
+                let end = expression.location.end_offset;
+                if let Some(text) = self.source.get(start..end) {
+                    write!(self.buffer, "{}", text)?;
+                }
+            }
+        }
+
+        // Emit trailing comments on the class << line
+        self.emit_trailing_comments(node.location.start_line)?;
+        self.buffer.push('\n');
+
+        let class_start_line = node.location.start_line;
+        let class_end_line = node.location.end_line;
+        let mut has_body_content = false;
+
+        // Emit body (skip the first child which is the expression)
+        for (i, child) in node.children.iter().enumerate() {
+            if i == 0 {
+                // Skip the expression (self or object)
+                continue;
+            }
+            if matches!(child.node_type, NodeType::StatementsNode) {
+                has_body_content = true;
+                self.emit_statements(child, indent_level + 1)?;
+            } else if !self.is_structural_node(&child.node_type) {
+                has_body_content = true;
+                self.emit_node(child, indent_level + 1)?;
+            }
+        }
+
+        // Emit comments inside the singleton class body
+        self.emit_comments_in_range(class_start_line + 1, class_end_line, indent_level + 1)?;
+
+        // Add newline before end if there was body content
+        if (has_body_content || self.has_comments_in_range(class_start_line + 1, class_end_line))
+            && !self.buffer.ends_with('\n')
+        {
+            self.buffer.push('\n');
+        }
+
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+        self.emit_trailing_comments(node.location.end_line)?;
+
+        Ok(())
+    }
+
+    /// Emit case match (Ruby 3.0+ pattern matching with case...in)
+    fn emit_case_match(&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 InNode or ElseNode)
+        let mut in_start_idx = 0;
+        if let Some(first_child) = node.children.first() {
+            if !matches!(first_child.node_type, NodeType::InNode | 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)?;
+                }
+                in_start_idx = 1;
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Emit in clauses and else
+        for child in node.children.iter().skip(in_start_idx) {
+            match &child.node_type {
+                NodeType::InNode => {
+                    self.emit_in(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")?;
+        self.emit_trailing_comments(node.location.end_line)?;
+
+        Ok(())
+    }
+
+    /// Emit in node (pattern matching clause)
+    fn emit_in(&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, "in ")?;
+
+        // First child is the pattern
+        if let Some(pattern) = node.children.first() {
+            let start = pattern.location.start_offset;
+            let end = pattern.location.end_offset;
+            if let Some(text) = self.source.get(start..end) {
+                write!(self.buffer, "{}", text)?;
+            }
+        }
+
+        self.buffer.push('\n');
+
+        // Second child is the statements body
+        if let Some(statements) = node.children.get(1) {
+            if matches!(statements.node_type, NodeType::StatementsNode) {
+                self.emit_statements(statements, indent_level + 1)?;
+            }
+        }
+
+        Ok(())
+    }
+
     /// Check if node is structural (part of definition syntax, not body)
     /// These nodes are part of class/module/method definitions and should not be emitted as body
     fn is_structural_node(&self, node_type: &NodeType) -> bool {
@@ -1398,6 +1597,8 @@ impl Emitter {
                 | NodeType::OptionalKeywordParameterNode
                 | NodeType::KeywordRestParameterNode
                 | NodeType::BlockParameterNode
+                | NodeType::ForwardingParameterNode
+                | NodeType::NoKeywordsParameterNode
         )
     }
 }

data/ext/rfmt/src/logging/logger.rs

@@ -54,7 +54,12 @@ impl Log for RfmtLogger {
             return;
         }
 
-        let mut output = self.output.lock().unwrap();
+        // Use unwrap_or_else to recover from poisoned mutex.
+        // Logging should never cause a panic, even if another thread panicked while holding the lock.
+        let mut output = self
+            .output
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
 
         writeln!(
             output,
@@ -67,7 +72,11 @@ impl Log for RfmtLogger {
     }
 
     fn flush(&self) {
-        let mut output = self.output.lock().unwrap();
+        // Recover from poisoned mutex - flushing should not panic
+        let mut output = self
+            .output
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
         output.flush().ok();
     }
 }

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

@@ -13,8 +13,8 @@ impl PrismAdapter {
         Self
     }
 
-    /// Parse JSON from Ruby's PrismBridge
-    fn parse_json(&self, json: &str) -> Result<(PrismNode, Vec<PrismComment>)> {
+    /// Parse JSON from Ruby's `PrismBridge`
+    fn parse_json(json: &str) -> Result<(PrismNode, Vec<PrismComment>)> {
         // Try to parse as new format with comments first
         if let Ok(wrapper) = serde_json::from_str::<PrismWrapper>(json) {
             return Ok((wrapper.ast, wrapper.comments));
@@ -26,8 +26,8 @@ impl PrismAdapter {
         Ok((node, Vec::new()))
     }
 
-    /// Convert PrismNode to internal Node representation
-    fn convert_node(&self, prism_node: &PrismNode) -> Result<Node> {
+    /// Convert `PrismNode` to internal `Node` representation
+    fn convert_node(prism_node: &PrismNode) -> Result<Node> {
         // Convert node type (always succeeds, returns Unknown for unsupported types)
         let node_type = NodeType::from_str(&prism_node.node_type);
 
@@ -42,18 +42,15 @@ impl PrismAdapter {
         );
 
         // Convert children recursively
-        let children: Result<Vec<Node>> = prism_node
-            .children
-            .iter()
-            .map(|child| self.convert_node(child))
-            .collect();
+        let children: Result<Vec<Node>> =
+            prism_node.children.iter().map(Self::convert_node).collect();
         let children = children?;
 
         // Convert comments
         let comments: Vec<Comment> = prism_node
             .comments
             .iter()
-            .map(|c| self.convert_comment(c))
+            .map(Self::convert_comment)
             .collect();
 
         // Convert formatting info
@@ -76,21 +73,8 @@ impl PrismAdapter {
         })
     }
 
-    /// Convert PrismComment to internal Comment
-    fn convert_comment(&self, comment: &PrismComment) -> Comment {
-        let comment_type = match comment.comment_type.as_str() {
-            "line" => CommentType::Line,
-            "block" => CommentType::Block,
-            _ => CommentType::Line, // default to line comment
-        };
-
-        let position = match comment.position.as_str() {
-            "leading" => CommentPosition::Leading,
-            "trailing" => CommentPosition::Trailing,
-            "inner" => CommentPosition::Inner,
-            _ => CommentPosition::Leading, // default to leading
-        };
-
+    /// Convert `PrismComment` to internal `Comment`
+    fn convert_comment(comment: &PrismComment) -> Comment {
         Comment {
             text: comment.text.clone(),
             location: Location::new(
@@ -101,21 +85,21 @@ impl PrismAdapter {
                 comment.location.start_offset,
                 comment.location.end_offset,
             ),
-            comment_type,
-            position,
+            comment_type: comment.comment_type.into(),
+            position: comment.position.into(),
         }
     }
 }
 
 impl RubyParser for PrismAdapter {
     fn parse(&self, json: &str) -> Result<Node> {
-        let (prism_ast, top_level_comments) = self.parse_json(json)?;
-        let mut node = self.convert_node(&prism_ast)?;
+        let (prism_ast, top_level_comments) = Self::parse_json(json)?;
+        let mut node = Self::convert_node(&prism_ast)?;
 
         // Attach top-level comments to the root node
         if !top_level_comments.is_empty() {
             node.comments
-                .extend(top_level_comments.iter().map(|c| self.convert_comment(c)));
+                .extend(top_level_comments.iter().map(Self::convert_comment));
         }
 
         Ok(node)
@@ -160,8 +144,46 @@ pub struct PrismLocation {
 pub struct PrismComment {
     pub text: String,
     pub location: PrismLocation,
-    pub comment_type: String,
-    pub position: String,
+    #[serde(rename = "type", default)]
+    pub comment_type: PrismCommentType,
+    #[serde(default)]
+    pub position: PrismCommentPosition,
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PrismCommentType {
+    #[default]
+    Line,
+    Block,
+}
+
+impl From<PrismCommentType> for CommentType {
+    fn from(t: PrismCommentType) -> Self {
+        match t {
+            PrismCommentType::Line => CommentType::Line,
+            PrismCommentType::Block => CommentType::Block,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PrismCommentPosition {
+    #[default]
+    Leading,
+    Trailing,
+    Inner,
+}
+
+impl From<PrismCommentPosition> for CommentPosition {
+    fn from(p: PrismCommentPosition) -> Self {
+        match p {
+            PrismCommentPosition::Leading => CommentPosition::Leading,
+            PrismCommentPosition::Trailing => CommentPosition::Trailing,
+            PrismCommentPosition::Inner => CommentPosition::Inner,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

data/ext/rfmt/src/policy/validation.rs

@@ -16,3 +16,38 @@ pub fn validate_source_size(source: &str, max_size: u64) -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_source_size_ok() {
+        assert!(validate_source_size("small", 1000).is_ok());
+    }
+
+    #[test]
+    fn test_validate_source_size_at_limit() {
+        let source = "a".repeat(1000);
+        assert!(validate_source_size(&source, 1000).is_ok());
+    }
+
+    #[test]
+    fn test_validate_source_size_exceeds_limit() {
+        let source = "a".repeat(1001);
+        assert!(validate_source_size(&source, 1000).is_err());
+    }
+
+    #[test]
+    fn test_validate_source_size_empty() {
+        assert!(validate_source_size("", 1000).is_ok());
+    }
+
+    #[test]
+    fn test_validate_source_size_unicode() {
+        // "日本語" = 9 bytes in UTF-8
+        let source = "日本語";
+        assert!(validate_source_size(source, 9).is_ok());
+        assert!(validate_source_size(source, 8).is_err());
+    }
+}

data/lib/rfmt/prism_bridge.rb

@@ -56,7 +56,7 @@ module Rfmt
 
     # Serialize the Prism AST to JSON
     def self.serialize_ast(node)
-      JSON.generate(convert_node(node))
+      JSON.generate(convert_node(node), max_nesting: false)
     end
 
     # Serialize the Prism AST with comments to JSON
@@ -80,7 +80,7 @@ module Rfmt
       JSON.generate({
                       ast: convert_node(result.value),
                       comments: comments
-                    })
+                    }, max_nesting: false)
     end
 
     # Convert a Prism node to our internal representation
@@ -241,8 +241,6 @@ module Rfmt
                      [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 || []
@@ -293,6 +291,55 @@ module Rfmt
                      [*node.lefts, node.rest, *node.rights, node.value].compact
                    when Prism::MultiTargetNode
                      [*node.lefts, node.rest, *node.rights].compact
+                   when Prism::SourceFileNode, Prism::SourceLineNode, Prism::SourceEncodingNode
+                     []
+                   when Prism::PreExecutionNode, Prism::PostExecutionNode
+                     [node.statements].compact
+                   # Numeric literals
+                   when Prism::RationalNode, Prism::ImaginaryNode
+                     [node.numeric].compact
+                   # String interpolation
+                   when Prism::EmbeddedVariableNode
+                     [node.variable].compact
+                   # Pattern matching patterns
+                   when Prism::ArrayPatternNode
+                     [*node.requireds, node.rest, *node.posts].compact
+                   when Prism::HashPatternNode
+                     [*node.elements, node.rest].compact
+                   when Prism::FindPatternNode
+                     [node.left, *node.requireds, node.right].compact
+                   when Prism::CapturePatternNode
+                     [node.value, node.target].compact
+                   when Prism::AlternationPatternNode
+                     [node.left, node.right].compact
+                   when Prism::PinnedExpressionNode
+                     [node.expression].compact
+                   when Prism::PinnedVariableNode
+                     [node.variable].compact
+                   # Forwarding and special parameters
+                   when Prism::ForwardingArgumentsNode, Prism::ForwardingParameterNode,
+                        Prism::NoKeywordsParameterNode
+                     []
+                   # References
+                   when Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode
+                     []
+                   # Call/Index compound assignment
+                   when Prism::CallAndWriteNode, Prism::CallOrWriteNode, Prism::CallOperatorWriteNode
+                     [node.receiver, node.value].compact
+                   when Prism::IndexAndWriteNode, Prism::IndexOrWriteNode, Prism::IndexOperatorWriteNode
+                     [node.receiver, node.arguments, node.value].compact
+                   # Match
+                   when Prism::MatchWriteNode
+                     [node.call, *node.targets].compact
+                   when Prism::MatchLastLineNode, Prism::InterpolatedMatchLastLineNode
+                     []
+                   # Other
+                   when Prism::FlipFlopNode
+                     [node.left, node.right].compact
+                   when Prism::ImplicitNode
+                     [node.value].compact
+                   when Prism::ImplicitRestNode
+                     []
                    else
                      # For unknown types, try to get child nodes if they exist
                      []
@@ -327,6 +374,11 @@ module Rfmt
           metadata['name'] = name
         end
         metadata['parameters_count'] = extract_parameter_count(node).to_s
+        # Extract parameters text directly from source
+        if node.parameters
+          metadata['parameters_text'] = node.parameters.location.slice
+          metadata['has_parens'] = (!node.lparen_loc.nil?).to_s
+        end
         # Check if this is a class method (def self.method_name)
         if node.respond_to?(:receiver) && node.receiver
           receiver = node.receiver

data/lib/rfmt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.2
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-06 00:00:00.000000000 Z
+date: 2026-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys