rfmt 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3711e11ba344ee0b9e1e76d0885fd99bd7ccbd7901ab5ba819619ae40647365f
-  data.tar.gz: 95f1b17c4c9a542cc24d9b89df6dee44398f59d27da0446961ac320b338a6bb4
+  metadata.gz: 79f5e6c24f82f6552874aefda2a6b97d8f4612419810d76ebd9381e862edded4
+  data.tar.gz: f193dab59e9a02f62d3e599c8f0349ebbf6e7fda070ba55990e9a8d399990f72
 SHA512:
-  metadata.gz: 7bb8aff9825e2a8d44f3161786b7952a2b2e3b679d0e607eb748102971d4c8a417ca8dcaac80e171a97ef223814c229b14b63af505321309393edc9432550fe6
-  data.tar.gz: 110a42ff056ac3dd6939d0f67b50a4784bbdafd513c4c0a1ab6e9eb8d0a040a0aa65bc39d0b37975ffb1972cf81d8396868d33e627b71ed017894cf1674d3cc4
+  metadata.gz: 6ebfd2c04793445912e1edc28db74e5cfa218fcd3fc28f6e3b42a88b1794fe0bfc6643890fa34477291c7ad8624696f3bb7207436ecfeb6f756439be5d9065ae
+  data.tar.gz: e209cf0a8671786af5e1560979f70f5fe8bb4e2de3912613a59e6d6269effe54f123407ca8989b50578f330d16e8a0d2fa7a1b47c8c07d5731e893664892fe1a

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [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

data/Cargo.lock

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

data/ext/rfmt/Cargo.toml

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

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

@@ -235,9 +235,11 @@ pub enum NodeType {
     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,
@@ -383,7 +385,14 @@ impl NodeType {
             "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

@@ -79,12 +79,13 @@ impl Emitter {
     /// 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
     }
 
@@ -426,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);

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/version.rb

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

metadata

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