rfmt 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c46c2c5129ef89717e76c7d187a0739389814d2ee01a1c50a5b64173d9b728f4
-  data.tar.gz: 63982b7a966f9a64b9b01ea9d5d22e55e3c020fa7f76c4d63333bb7114591a6c
+  metadata.gz: 3711e11ba344ee0b9e1e76d0885fd99bd7ccbd7901ab5ba819619ae40647365f
+  data.tar.gz: 95f1b17c4c9a542cc24d9b89df6dee44398f59d27da0446961ac320b338a6bb4
 SHA512:
-  metadata.gz: a1f3c26b649ea73a7a01c41c8d06e8d00137eb1b48946e8043ee632d9f5ea6465649999558a1c101779638d0383dadbbd610174de34c68ffcefb6a095c214b01
-  data.tar.gz: 8c6c55859f132cd0cf5cfedf8b3af6b785cbd52f73f9f6ae9d8493717068724357abec0ad82c64ba31fefd99d798154f0df6d9136f52ffff675f848aa57f7500
+  metadata.gz: 7bb8aff9825e2a8d44f3161786b7952a2b2e3b679d0e607eb748102971d4c8a417ca8dcaac80e171a97ef223814c229b14b63af505321309393edc9432550fe6
+  data.tar.gz: 110a42ff056ac3dd6939d0f67b50a4784bbdafd513c4c0a1ab6e9eb8d0a040a0aa65bc39d0b37975ffb1972cf81d8396868d33e627b71ed017894cf1674d3cc4

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [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.1"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

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

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

@@ -180,6 +180,58 @@ 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),
 }
 
@@ -290,6 +342,46 @@ 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()),
         }
     }

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,7 +73,7 @@ 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)
@@ -107,7 +119,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 +134,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 +222,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 +235,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 +289,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 +297,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 +305,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 +338,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 +346,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 +386,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(())
@@ -508,31 +571,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 +1270,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 +1303,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 +1313,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 +1441,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 +1599,8 @@ impl Emitter {
                 | NodeType::OptionalKeywordParameterNode
                 | NodeType::KeywordRestParameterNode
                 | NodeType::BlockParameterNode
+                | NodeType::ForwardingParameterNode
+                | NodeType::NoKeywordsParameterNode
         )
     }
 }

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.1'
 end

metadata

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