rfmt 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c712093f002557a29995a2838caede692a26e86d492c7f9f735e8fe9f2a5f5f4
-  data.tar.gz: a7ce48fbf06a56879d803cb848786310ff5e6dc091de1d8f8a9ff47a0bb00dac
+  metadata.gz: d42c0061474a8e7ef36fc5cbce1d7bfdad2bc5a9dbbff9b1a2c2b700b373c6ca
+  data.tar.gz: f12d17ab726936fbdf69e4e5aaf3bca55fadf49230aa641adf0cba61c363f5ca
 SHA512:
-  metadata.gz: '05954d426b7b6951e330d55d469ea78ebbf75350d755e0107eb0c4de32f5b11afd9373fbeabff3f7c2c902cfada70f4fae276c8b5d0d4d3b00eb3514a467fa0e'
-  data.tar.gz: cd4b6992cd4d795dfe8bd91f74504212337bcf7c13c736822919a071abda7ff0e1712f24e277786fa8b9a3ba6150b0727d33f415631c1707b6277c5612c94dbe
+  metadata.gz: 51948c8616f667de54435f87f7e154209c27777e82a84ada9f73d97c8928f68a063da72c1d7268035ca7d8d6e3eec658e4f6d874770658501edaad68a512ecdf
+  data.tar.gz: e9a794b23d30ba314aa2b0f5fcacb6bbaff7408430bab6623169ef7d76fad53f32f58789e2a0a828a3b9e38dc074ca22bb0c4ff93f023e7c1a8c000081ba66e5

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.2.4] - 2025-11-25
+
+### Fixed
+- Fixed if-else expression formatting
+
 ## [0.2.3] - 2025-01-25
 
 ### Added

data/Cargo.lock

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

data/ext/rfmt/Cargo.toml

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

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

@@ -40,6 +40,7 @@ pub enum NodeType {
     // Expressions
     CallNode,
     IfNode,
+    ElseNode,
     UnlessNode,
 
     // Literals
@@ -83,6 +84,7 @@ impl NodeType {
             "def_node" => Self::DefNode,
             "call_node" => Self::CallNode,
             "if_node" => Self::IfNode,
+            "else_node" => Self::ElseNode,
             "unless_node" => Self::UnlessNode,
             "string_node" => Self::StringNode,
             "integer_node" => Self::IntegerNode,

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

@@ -110,7 +110,7 @@ impl Config {
                 for filename in &config_files {
                     let config_path = current_dir.join(filename);
                     if config_path.exists() {
-                        log::debug!("Found config file: {:?}", config_path);
+                        log::info!("Found config file: {:?}", config_path);
                         return Self::load_file(&config_path);
                     }
                 }
@@ -133,7 +133,7 @@ impl Config {
             }
         }
 
-        log::debug!("No config file found, using defaults");
+        log::info!("No config file found, using defaults");
         Ok(Config::default())
     }
 

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

@@ -113,6 +113,8 @@ impl Emitter {
             NodeType::ClassNode => self.emit_class(node, indent_level)?,
             NodeType::ModuleNode => self.emit_module(node, indent_level)?,
             NodeType::DefNode => self.emit_method(node, indent_level)?,
+            NodeType::IfNode => self.emit_if_unless(node, indent_level, false, "if")?,
+            NodeType::UnlessNode => self.emit_if_unless(node, indent_level, false, "unless")?,
             _ => self.emit_generic(node, indent_level)?,
         }
         Ok(())
@@ -304,6 +306,122 @@ impl Emitter {
         Ok(())
     }
 
+    /// Emit if/unless/elsif/else node
+    /// is_elsif: true if this is an elsif clause (don't emit 'end')
+    /// keyword: "if" or "unless"
+    fn emit_if_unless(&mut self, node: &Node, indent_level: usize, is_elsif: bool, keyword: &str) -> Result<()> {
+        // Check if this is a postfix if (modifier form)
+        // In postfix if, the statements come before the if keyword in source
+        let is_postfix = if let (Some(predicate), Some(statements)) =
+            (node.children.first(), node.children.get(1)) {
+            statements.location.start_offset < predicate.location.start_offset
+        } else {
+            false
+        };
+
+        // Postfix if/unless: "statement if/unless condition"
+        if is_postfix && !is_elsif {
+            self.emit_comments_before(node.location.start_line, indent_level)?;
+            self.emit_indent(indent_level)?;
+
+            // 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())?;
+                        }
+                    }
+                }
+            }
+
+            write!(self.buffer, " {} ", keyword)?;
+
+            // 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)?;
+                    }
+                }
+            }
+
+            return Ok(());
+        }
+
+        // Normal if/unless/elsif
+        if !is_elsif {
+            self.emit_comments_before(node.location.start_line, indent_level)?;
+        }
+
+        // Emit 'if'/'unless' or 'elsif' keyword
+        self.emit_indent(indent_level)?;
+        if is_elsif {
+            write!(self.buffer, "elsif ")?;
+        } else {
+            write!(self.buffer, "{} ", keyword)?;
+        }
+
+        // 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.buffer.push('\n');
+
+        // Emit then clause (second child is StatementsNode)
+        if let Some(statements) = node.children.get(1) {
+            if matches!(statements.node_type, NodeType::StatementsNode) {
+                self.emit_statements(statements, indent_level + 1)?;
+                self.buffer.push('\n');
+            }
+        }
+
+        // Check for elsif/else (third child)
+        if let Some(consequent) = node.children.get(2) {
+            match &consequent.node_type {
+                NodeType::IfNode => {
+                    // This is an elsif clause (only valid for if, not unless)
+                    self.emit_if_unless(consequent, indent_level, true, "if")?;
+                }
+                NodeType::ElseNode => {
+                    // This is an else clause
+                    self.emit_indent(indent_level)?;
+                    write!(self.buffer, "else\n")?;
+
+                    // Emit else body (first child of ElseNode)
+                    if let Some(else_statements) = consequent.children.first() {
+                        if matches!(else_statements.node_type, NodeType::StatementsNode) {
+                            self.emit_statements(else_statements, indent_level + 1)?;
+                            self.buffer.push('\n');
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Only emit 'end' for the outermost if (not for elsif)
+        if !is_elsif {
+            self.emit_indent(indent_level)?;
+            write!(self.buffer, "end")?;
+        }
+
+        Ok(())
+    }
+
     /// Emit generic node by extracting from source
     fn emit_generic(&mut self, node: &Node, indent_level: usize) -> Result<()> {
         // Emit any comments before this node

data/ext/rfmt/src/lib.rs

@@ -14,6 +14,7 @@ use magnus::{define_module, function, prelude::*, Error, Ruby};
 use parser::{PrismAdapter, RubyParser};
 
 fn format_ruby_code(ruby: &Ruby, source: String, json: String) -> Result<String, Error> {
+    log::info!("format_ruby_code called");
     let policy = SecurityPolicy::default();
 
     policy
@@ -26,7 +27,9 @@ fn format_ruby_code(ruby: &Ruby, source: String, json: String) -> Result<String,
     let ast = parser.parse(&json).map_err(|e| e.to_magnus_error(ruby))?;
 
     // Load configuration from file or use defaults
+    log::info!("Attempting to discover config file...");
     let config = Config::discover().map_err(|e| e.to_magnus_error(ruby))?;
+    log::info!("Config loaded successfully, line_length: {}", config.formatting.line_length);
     let mut emitter = Emitter::with_source(config, source);
 
     let formatted = emitter.emit(&ast).map_err(|e| e.to_magnus_error(ruby))?;

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

@@ -22,7 +22,11 @@ impl RfmtLogger {
     }
 
     pub fn init() {
-        let logger = Self::new(LevelFilter::Info);
+        let level = std::env::var("RFMT_LOG")
+            .ok()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(LevelFilter::Info);
+        let logger = Self::new(level);
         log::set_boxed_logger(Box::new(logger)).expect("Failed to initialize logger");
         log::set_max_level(LevelFilter::Trace);
     }

data/lib/rfmt/prism_bridge.rb

@@ -159,6 +159,8 @@ module Rfmt
                        node.statements,
                        node.consequent
                      ].compact
+                   when Prism::ElseNode
+                     [node.statements].compact
                    when Prism::ArrayNode
                      node.elements || []
                    when Prism::HashNode

data/lib/rfmt/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - fujitani sora