rfmt 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb4f41a4ba34f1bc106746712bf144fe6f5ee8cf5a80cf26efaecc8450645d89
-  data.tar.gz: 94f896c28015d9592d959ef3a42b4db80e309ad664ef97d5f28b0e8479605892
+  metadata.gz: 2df39db6eb525d4ca6bc42d55e01057e5a12772f0b61a7a8e3101e3a8fff76ec
+  data.tar.gz: b34bbf251457c8eb0d9174497c124f71d6a7b098ad506712acaec54812bcc674
 SHA512:
-  metadata.gz: 0aef4d71101fd621bcecf87b0160e437ec9f7836e12759dbb28cd56416d1428bb3b54aabae888566548dc11557d1179e519aa5c971e613c3c37c775590eef981
-  data.tar.gz: 3ee34d6c250fdd9263822a8b361dc3fdde5005c36570a5a6a0be346f717090c581822c90cd08bee43674495c97a15fb22677558bd5be5b85f9ccd4c1d4fd9e51
+  metadata.gz: 1d341d108c8875f683a2ef3654e6e540b1fe9840a4f908abc75725da544c0b8be2b27cf5534cdf634eb2e9eaaa36bed0df9500f978a6fffc95ec7379e2485cf3
+  data.tar.gz: 9cbce53637c758998c79c77af60d10130dd293dac67c4a7918d882e816d848ef525400bd6fcebc030523a2407e08140dc1bc9227cbd9c1cfc3f579f0e5b477be

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [1.5.0] - 2026-01-25
+
+### Added
+- Docker Compose test environment setup (#84)
+- Support for `then` expression emission (#80)
+- CI support for Ruby 3.4 and Ruby 4 (#82)
+
+### Changed
+- Upgrade Magnus (Rust-Ruby FFI library) (#83)
+- Optimize Docker build with multi-stage and caching (#84)
+- Upgrade unicode-emoji dependency
+
+### Fixed
+- Preserve heredoc content and closing identifier (#81)
+- Fix `rescue`/`ensure` clauses being deleted inside `do...end` blocks (#78)
+- Fix inline comment node handling (#77)
+- Fix BTreeMap range error (Issue #71)
+
+## [1.4.1] - 2026-01-17
+
+### Fixed
+- Fixed comment positioning issue where standalone comments before `end` statements were incorrectly attached to previous code lines
+- Improved comment semantic preservation to maintain developer's original placement intent
+- Enhanced standalone comment detection logic to distinguish between inline and independent comments
+
 ## [1.4.0] - 2026-01-17
 
 ### Added

data/Cargo.lock

@@ -838,9 +838,9 @@ dependencies = [
 
 [[package]]
 name = "magnus"
-version = "0.6.4"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1597ef40aa8c36be098249e82c9a20cf7199278ac1c1a1a995eeead6a184479"
+checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -850,9 +850,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
+checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1168,9 +1168,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-env"
-version = "0.1.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+checksum = "cca7ad6a7e21e72151d56fe2495a259b5670e204c3adac41ee7ef676ea08117a"
 
 [[package]]
 name = "redox_users"
@@ -1214,7 +1214,7 @@ checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rfmt"
-version = "1.4.0"
+version = "1.5.0"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.4.0"
+version = "1.5.0"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"
@@ -12,8 +12,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 # Ruby FFI
-magnus = { version = "0.6.2" }
-rb-sys = "0.9.117"
+magnus = { version = "0.8.2" }
+rb-sys = "0.9.124"
 
 # Serialization
 serde = { version = "1.0", features = ["derive"] }

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

@@ -144,6 +144,10 @@ impl Emitter {
     /// 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> {
+        // Guard against invalid range (e.g., endless methods where start_line >= end_line)
+        if start_line >= end_line {
+            return Vec::new();
+        }
         self.comments_by_line
             .range(start_line..end_line)
             .flat_map(|(_, indices)| indices.iter().copied())
@@ -228,6 +232,10 @@ 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 {
+        // Guard against invalid range (e.g., endless methods where start_line >= end_line)
+        if start_line >= end_line {
+            return false;
+        }
         self.comments_by_line
             .range(start_line..end_line)
             .flat_map(|(_, indices)| indices.iter())
@@ -237,34 +245,58 @@ impl Emitter {
             })
     }
 
-    /// 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(
+    /// Emit comments that appear immediately before the end statement while preserving their position
+    /// This is crucial for maintaining semantic relationships between comments and the code they precede
+    fn emit_comments_before_end(
         &mut self,
-        start_line: usize,
-        end_line: usize,
+        construct_start_line: usize,
+        construct_end_line: usize,
         indent_level: usize,
     ) -> Result<()> {
         self.ensure_indent_cache(indent_level);
 
-        let indices = self.get_comment_indices_in_range(start_line, end_line);
+        // Implement proper comment positioning logic
+        // Only emit standalone comments that appear on their own lines
+        // This prevents comments from being incorrectly attached to code statements
+
+        // Find comments that are between the construct and the end line
+        // Only emit comments that haven't been emitted yet AND are on their own lines
+        let indices =
+            self.get_comment_indices_in_range(construct_start_line + 1, construct_end_line);
 
         let mut comments_to_emit: Vec<_> = indices
             .into_iter()
-            .filter(|&idx| self.all_comments[idx].location.end_line < end_line)
+            .filter(|&idx| {
+                let comment = &self.all_comments[idx];
+                // Only emit if: not already emitted, before end line, and is standalone
+                !self.emitted_comment_indices.contains(&idx)
+                    && comment.location.end_line < construct_end_line
+                    && self.is_standalone_comment(comment)
+            })
             .map(|idx| {
                 let comment = &self.all_comments[idx];
                 (idx, comment.location.start_line, comment.location.end_line)
             })
             .collect();
 
+        if comments_to_emit.is_empty() {
+            return Ok(());
+        }
+
         comments_to_emit.sort_by_key(|(_, start, _)| *start);
 
-        let mut last_comment_end_line: Option<usize> = None;
+        // Ensure newline before first comment if buffer doesn't end with one
+        if !self.buffer.ends_with('\n') {
+            self.buffer.push('\n');
+        }
+
+        let mut last_emitted_line: Option<usize> = None;
 
+        // Emit comments while preserving their exact line positioning
         for (idx, comment_start_line, comment_end_line) in comments_to_emit {
-            if let Some(prev_end) = last_comment_end_line {
-                let gap = comment_start_line.saturating_sub(prev_end);
+            // Preserve blank lines between comments
+            if let Some(prev_line) = last_emitted_line {
+                let gap = comment_start_line.saturating_sub(prev_line);
                 for _ in 1..gap {
                     self.buffer.push('\n');
                 }
@@ -276,12 +308,75 @@ impl Emitter {
                 &self.indent_cache[indent_level], &self.all_comments[idx].text
             )?;
             self.emitted_comment_indices.insert(idx);
-            last_comment_end_line = Some(comment_end_line);
+            last_emitted_line = Some(comment_end_line);
         }
 
         Ok(())
     }
 
+    /// Check if a comment should be treated as standalone
+    /// A standalone comment is one that should appear on its own line,
+    /// not attached to the end of a code statement
+    fn is_standalone_comment(&self, comment: &Comment) -> bool {
+        let comment_line = comment.location.start_line;
+        let _comment_start_offset = comment.location.start_offset;
+
+        // Get the source lines to analyze the comment's position
+        let lines: Vec<&str> = self.source.lines().collect();
+
+        // Check if we have a valid line number (1-indexed to 0-indexed)
+        if comment_line == 0 || comment_line > lines.len() {
+            return false;
+        }
+
+        let line = lines[comment_line - 1]; // Convert to 0-indexed
+
+        // Find where the comment starts within the line
+        let comment_text = &comment.text;
+
+        // Look for the comment marker (#) in the line
+        if let Some(hash_pos) = line.find('#') {
+            // Check if there's only whitespace before the comment
+            let before_comment = &line[..hash_pos];
+            let is_only_whitespace = before_comment.trim().is_empty();
+
+            // Also verify this is actually our comment by checking the text matches
+            let line_comment_text = &line[hash_pos..];
+            let is_same_comment = line_comment_text.trim_end() == comment_text.trim_end();
+
+            return is_only_whitespace && is_same_comment;
+        }
+
+        // If we can't find the comment marker, assume it's standalone
+        // This is a fallback for edge cases
+        false
+    }
+
+    /// Check if the node spans only a single line
+    fn is_single_line(&self, node: &Node) -> bool {
+        node.location.start_line == node.location.end_line
+    }
+
+    /// Extract and write source text for a node
+    fn write_source_text(&mut self, node: &Node) -> Result<()> {
+        let start = node.location.start_offset;
+        let end = node.location.end_offset;
+        if let Some(text) = self.source.get(start..end) {
+            write!(self.buffer, "{}", text)?;
+        }
+        Ok(())
+    }
+
+    /// Extract and write trimmed source text for a node
+    fn write_source_text_trimmed(&mut self, node: &Node) -> Result<()> {
+        let start = node.location.start_offset;
+        let end = node.location.end_offset;
+        if let Some(text) = self.source.get(start..end) {
+            write!(self.buffer, "{}", text.trim())?;
+        }
+        Ok(())
+    }
+
     /// 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(
@@ -464,9 +559,8 @@ impl Emitter {
             self.emit_node(child, indent_level + 1)?;
         }
 
-        // Emit comments that are inside the class body but not attached to any node
-        // These are comments between class_start_line and class_end_line
-        self.emit_comments_in_range(class_start_line + 1, class_end_line, indent_level + 1)?;
+        // Emit comments that appear before the end statement while preserving their position
+        self.emit_comments_before_end(class_start_line, class_end_line, indent_level + 1)?;
 
         // Add newline before end if there was body content or internal comments
         if (has_body_content || self.has_comments_in_range(class_start_line + 1, class_end_line))
@@ -512,8 +606,8 @@ impl Emitter {
             self.emit_node(child, indent_level + 1)?;
         }
 
-        // Emit comments that are inside the module body but not attached to any node
-        self.emit_comments_in_range(module_start_line + 1, module_end_line, indent_level + 1)?;
+        // Emit comments that appear before the end statement while preserving their position
+        self.emit_comments_before_end(module_start_line, module_end_line, indent_level + 1)?;
 
         // Add newline before end if there was body content or internal comments
         if (has_body_content || self.has_comments_in_range(module_start_line + 1, module_end_line))
@@ -573,6 +667,13 @@ impl Emitter {
             self.emit_node(child, indent_level + 1)?;
         }
 
+        // Emit comments that appear before the end statement while preserving their position
+        self.emit_comments_before_end(
+            node.location.start_line,
+            node.location.end_line,
+            indent_level + 1,
+        )?;
+
         // Add newline before end if there was body content
         if node
             .children
@@ -831,25 +932,30 @@ impl Emitter {
 
         // 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)?;
-            }
+            self.write_source_text(cond)?;
             if i < conditions.len() - 1 {
                 write!(self.buffer, ", ")?;
             }
         }
 
-        self.buffer.push('\n');
-
-        // Emit statements body
-        if let Some(statements) = node
+        let statements = node
             .children
             .iter()
-            .find(|c| matches!(c.node_type, NodeType::StatementsNode))
-        {
-            self.emit_statements(statements, indent_level + 1)?;
+            .find(|c| matches!(c.node_type, NodeType::StatementsNode));
+
+        if self.is_single_line(node) {
+            // Inline style: when X then Y
+            if let Some(statements) = statements {
+                write!(self.buffer, " then ")?;
+                self.write_source_text(statements)?;
+            }
+        } else {
+            // Multi-line style: when X\n  Y
+            self.buffer.push('\n');
+
+            if let Some(statements) = statements {
+                self.emit_statements(statements, indent_level + 1)?;
+            }
         }
 
         Ok(())
@@ -883,14 +989,7 @@ impl Emitter {
             // Emit statement
             if let Some(statements) = node.children.get(1) {
                 if matches!(statements.node_type, NodeType::StatementsNode) {
-                    // Extract the statement text (without extra indentation)
-                    if !self.source.is_empty() {
-                        let start = statements.location.start_offset;
-                        let end = statements.location.end_offset;
-                        if let Some(text) = self.source.get(start..end) {
-                            write!(self.buffer, "{}", text.trim())?;
-                        }
-                    }
+                    self.write_source_text_trimmed(statements)?;
                 }
             }
 
@@ -898,13 +997,7 @@ impl Emitter {
 
             // Emit condition
             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.write_source_text(predicate)?;
             }
 
             return Ok(());
@@ -923,26 +1016,14 @@ impl Emitter {
 
             // Emit condition
             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.write_source_text(predicate)?;
             }
 
             write!(self.buffer, " ? ")?;
 
             // Emit then expression
             if let Some(statements) = node.children.get(1) {
-                if !self.source.is_empty() {
-                    let start = statements.location.start_offset;
-                    let end = statements.location.end_offset;
-                    if let Some(text) = self.source.get(start..end) {
-                        write!(self.buffer, "{}", text.trim())?;
-                    }
-                }
+                self.write_source_text_trimmed(statements)?;
             }
 
             write!(self.buffer, " : ")?;
@@ -950,19 +1031,40 @@ impl Emitter {
             // Emit else expression
             if let Some(else_node) = node.children.get(2) {
                 if let Some(else_statements) = else_node.children.first() {
-                    if !self.source.is_empty() {
-                        let start = else_statements.location.start_offset;
-                        let end = else_statements.location.end_offset;
-                        if let Some(text) = self.source.get(start..end) {
-                            write!(self.buffer, "{}", text.trim())?;
-                        }
-                    }
+                    self.write_source_text_trimmed(else_statements)?;
                 }
             }
 
             return Ok(());
         }
 
+        // Check for inline then style: "if true then 1 end"
+        // Single line, not postfix, not ternary, no else clause
+        let is_inline_then =
+            !is_elsif && self.is_single_line(node) && node.children.get(2).is_none();
+
+        if is_inline_then {
+            self.emit_comments_before(node.location.start_line, indent_level)?;
+            self.emit_indent(indent_level)?;
+            write!(self.buffer, "{} ", keyword)?;
+
+            // Emit condition
+            if let Some(predicate) = node.children.first() {
+                self.write_source_text(predicate)?;
+            }
+
+            write!(self.buffer, " then ")?;
+
+            // Emit statement
+            if let Some(statements) = node.children.get(1) {
+                self.write_source_text_trimmed(statements)?;
+            }
+
+            write!(self.buffer, " end")?;
+            self.emit_trailing_comments(node.location.end_line)?;
+            return Ok(());
+        }
+
         // Normal if/unless/elsif
         if !is_elsif {
             self.emit_comments_before(node.location.start_line, indent_level)?;
@@ -978,14 +1080,7 @@ impl Emitter {
 
         // Emit predicate (condition) - first child
         if let Some(predicate) = node.children.first() {
-            // Extract predicate from source
-            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.write_source_text(predicate)?;
         }
 
         // Emit trailing comment on same line as if/unless/elsif
@@ -1125,14 +1220,27 @@ impl Emitter {
         let mut last_stmt_end_line = block_start_line;
 
         for child in &block_node.children {
-            if matches!(child.node_type, NodeType::StatementsNode) {
-                self.emit_statements(child, indent_level + 1)?;
-                // Track the last statement's end line for blank line preservation
-                if let Some(last_child) = child.children.last() {
-                    last_stmt_end_line = last_child.location.end_line;
+            match &child.node_type {
+                NodeType::StatementsNode => {
+                    self.emit_statements(child, indent_level + 1)?;
+                    // Track the last statement's end line for blank line preservation
+                    if let Some(last_child) = child.children.last() {
+                        last_stmt_end_line = last_child.location.end_line;
+                    }
+                    self.buffer.push('\n');
+                    break;
+                }
+                NodeType::BeginNode => {
+                    // Block with rescue/ensure/else - delegate to emit_begin
+                    // which handles implicit begin (no "begin" keyword)
+                    self.emit_begin(child, indent_level + 1)?;
+                    self.buffer.push('\n');
+                    last_stmt_end_line = child.location.end_line;
+                    break;
+                }
+                _ => {
+                    // Skip parameter nodes
                 }
-                self.buffer.push('\n');
-                break;
             }
         }
 
@@ -1168,6 +1276,7 @@ impl Emitter {
     fn emit_brace_block(&mut self, block_node: &Node, indent_level: usize) -> Result<()> {
         // Determine if block should be inline or multiline
         let is_multiline = block_node.location.start_line != block_node.location.end_line;
+        let block_end_line = block_node.location.end_line;
 
         if is_multiline {
             // Multiline brace block
@@ -1186,6 +1295,7 @@ impl Emitter {
 
             self.emit_indent(indent_level)?;
             write!(self.buffer, "}}")?;
+            self.emit_trailing_comments(block_end_line)?;
         } else {
             // Inline brace block - extract from source to preserve spacing
             write!(self.buffer, " ")?;
@@ -1195,6 +1305,7 @@ impl Emitter {
             {
                 write!(self.buffer, "{}", text)?;
             }
+            self.emit_trailing_comments(block_end_line)?;
         }
 
         Ok(())
@@ -1457,8 +1568,8 @@ impl Emitter {
             }
         }
 
-        // Emit comments inside the singleton class body
-        self.emit_comments_in_range(class_start_line + 1, class_end_line, indent_level + 1)?;
+        // Emit comments that appear before the end statement while preserving their position
+        self.emit_comments_before_end(class_start_line, 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))
@@ -1503,7 +1614,6 @@ impl Emitter {
             match &child.node_type {
                 NodeType::InNode => {
                     self.emit_in(child, indent_level)?;
-                    self.buffer.push('\n');
                 }
                 NodeType::ElseNode => {
                     self.emit_indent(indent_level)?;
@@ -1539,19 +1649,25 @@ impl Emitter {
 
         // 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.write_source_text(pattern)?;
         }
 
-        self.buffer.push('\n');
+        if self.is_single_line(node) {
+            // Inline style: in X then Y
+            if let Some(statements) = node.children.get(1) {
+                write!(self.buffer, " then ")?;
+                self.write_source_text(statements)?;
+            }
+            self.buffer.push('\n');
+        } else {
+            // Multi-line style: in X\n  Y
+            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)?;
+            // 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)?;
+                }
             }
         }
 

data/ext/rfmt/src/lib.rs

@@ -10,7 +10,7 @@ use policy::SecurityPolicy;
 
 use config::Config;
 use emitter::Emitter;
-use magnus::{define_module, function, prelude::*, Error, Ruby};
+use magnus::{function, prelude::*, Error, Ruby};
 use parser::{PrismAdapter, RubyParser};
 
 fn format_ruby_code(ruby: &Ruby, source: String, json: String) -> Result<String, Error> {
@@ -45,10 +45,10 @@ fn rust_version() -> String {
 }
 
 #[magnus::init]
-fn init(_ruby: &Ruby) -> Result<(), Error> {
+fn init(ruby: &Ruby) -> Result<(), Error> {
     logging::RfmtLogger::init();
 
-    let module = define_module("Rfmt")?;
+    let module = ruby.define_module("Rfmt")?;
 
     module.define_singleton_method("format_code", function!(format_ruby_code, 2))?;
     module.define_singleton_method("parse_to_json", function!(parse_to_json, 1))?;

data/lib/rfmt/prism_bridge.rb

@@ -108,13 +108,42 @@ module Rfmt
     # Extract location information from node
     def self.extract_location(node)
       loc = node.location
+
+      # For heredoc nodes, the location only covers the opening tag (<<~CSV)
+      # We need to find the maximum end_offset including closing_loc
+      end_offset = loc.end_offset
+      end_line = loc.end_line
+      end_column = loc.end_column
+
+      # Check this node's closing_loc
+      if node.respond_to?(:closing_loc) && node.closing_loc
+        closing = node.closing_loc
+        if closing.end_offset > end_offset
+          end_offset = closing.end_offset
+          end_line = closing.end_line
+          end_column = closing.end_column
+        end
+      end
+
+      # Check child nodes for heredoc (e.g., LocalVariableWriteNode containing StringNode)
+      node.child_nodes.compact.each do |child|
+        next unless child.respond_to?(:closing_loc) && child.closing_loc
+
+        closing = child.closing_loc
+        next unless closing.end_offset > end_offset
+
+        end_offset = closing.end_offset
+        end_line = closing.end_line
+        end_column = closing.end_column
+      end
+
       {
         start_line: loc.start_line,
         start_column: loc.start_column,
-        end_line: loc.end_line,
-        end_column: loc.end_column,
+        end_line: end_line,
+        end_column: end_column,
         start_offset: loc.start_offset,
-        end_offset: loc.end_offset
+        end_offset: end_offset
       }
     end
 
@@ -176,6 +205,7 @@ module Rfmt
                      [
                        node.statements,
                        node.rescue_clause,
+                       node.else_clause,
                        node.ensure_clause
                      ].compact
                    when Prism::EnsureNode

data/lib/rfmt/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - fujitani sora
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -113,7 +112,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
@@ -128,8 +126,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.6.9
 specification_version: 4
 summary: Ruby Formatter impl Rust lang.
 test_files: []