rfmt 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e72bec96df5da8aafa6e1cd49ab3c14af9aaaaf79a880cbf2a6b05715a61aa7c
-  data.tar.gz: 381c235d258b0db3f7c770dd360cc3816ccaa1fdbe1af4fc857e0f871618d29b
+  metadata.gz: 75dece5f16cef2420a328e75f674416858eef7871c99a6aec1136c73f4b3b44c
+  data.tar.gz: f514b13a111e7113ed68beb1a1443b7815f8b11d47deee454ef352acf3e5ec7d
 SHA512:
-  metadata.gz: 97261a648e5aa560d4b3a2499ed82e208d445f422b50dc0d17be0b0aa2065b7d54cc8547e09a8632019a8538cafae750468e2f95ad73bf881955bc982e527d5c
-  data.tar.gz: 8ee6c5ec43066f7d70d07198dc72032c87fe4be1759a74196f4c17c74bfbf91579116a0744ea2b39cb8a222748a61b1e65e723e43e22d19b4589c4a28ce4baed
+  metadata.gz: 3a3575ed8e1e35770b6ac016521ee131fc1cf92b065c16ae91418a1835e7ab6695f30b9f1bb09c2b45c24801ae9427490ae835fffca228137c18ca1299416bf2
+  data.tar.gz: a5459089d49f7b905e565a3289dae2076df6a3d472a1332c0cca8f15ebab8d712a571e202b7053fcbbaeb85431d2f14f586e272e70966a0eeec1b72002e3fe4a

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [1.0.0] - 2025-12-11
+
+### Breaking Changes
+- First stable release (v1.0.0)
+
+### Changed
+- Set JSON as default output format
+- Updated Japanese documentation
+- Code formatting improvements
+
+### Fixed
+- TOML configuration parsing fix
+- Logger initialization fix
+
 ## [0.5.0] - 2025-12-07
 
 ### Changed

data/Cargo.lock

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

data/ext/rfmt/Cargo.toml

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

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

@@ -3,6 +3,13 @@ use crate::config::{Config, IndentStyle};
 use crate::error::Result;
 use std::fmt::Write;
 
+/// Block style for Ruby blocks
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BlockStyle {
+    DoEnd,  // do ... end
+    Braces, // { ... }
+}
+
 /// Code emitter that converts AST back to Ruby source code
 pub struct Emitter {
     config: Config,
@@ -115,6 +122,7 @@ impl Emitter {
             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")?,
+            NodeType::CallNode => self.emit_call(node, indent_level)?,
             _ => self.emit_generic(node, indent_level)?,
         }
         Ok(())
@@ -429,6 +437,183 @@ impl Emitter {
         Ok(())
     }
 
+    /// Emit method call, handling blocks specially for proper indentation
+    fn emit_call(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        // Emit any comments before this call
+        self.emit_comments_before(node.location.start_line, indent_level)?;
+
+        // Check if this call has a block (last child is BlockNode)
+        let has_block = node
+            .children
+            .last()
+            .map(|c| matches!(c.node_type, NodeType::BlockNode))
+            .unwrap_or(false);
+
+        if !has_block {
+            // No block - use generic emission (extracts from source)
+            return self.emit_generic_without_comments(node, indent_level);
+        }
+
+        // Has block - need to handle specially
+        let block_node = node.children.last().unwrap();
+
+        // Determine block style from source (do...end vs { })
+        let block_style = self.detect_block_style(block_node);
+
+        // Emit the call part (receiver.method(args)) from source
+        self.emit_call_without_block(node, block_node, indent_level)?;
+
+        match block_style {
+            BlockStyle::DoEnd => self.emit_do_end_block(block_node, indent_level)?,
+            BlockStyle::Braces => self.emit_brace_block(block_node, indent_level)?,
+        }
+
+        Ok(())
+    }
+
+    /// Detect whether block uses do...end or { } style
+    fn detect_block_style(&self, block_node: &Node) -> BlockStyle {
+        if self.source.is_empty() {
+            return BlockStyle::DoEnd; // Default fallback
+        }
+
+        let start = block_node.location.start_offset;
+        if let Some(first_char) = self.source.get(start..start + 1) {
+            if first_char == "{" {
+                return BlockStyle::Braces;
+            }
+        }
+
+        BlockStyle::DoEnd // Default (includes 'do' keyword)
+    }
+
+    /// Emit the method call part without the block
+    fn emit_call_without_block(
+        &mut self,
+        call_node: &Node,
+        block_node: &Node,
+        indent_level: usize,
+    ) -> Result<()> {
+        self.emit_indent(indent_level)?;
+
+        if !self.source.is_empty() {
+            let start = call_node.location.start_offset;
+            let end = block_node.location.start_offset;
+
+            if let Some(text) = self.source.get(start..end) {
+                // Trim trailing whitespace but preserve the content
+                write!(self.buffer, "{}", text.trim_end())?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Emit a do...end style block with proper indentation
+    fn emit_do_end_block(&mut self, block_node: &Node, indent_level: usize) -> Result<()> {
+        // Add space before 'do' and emit 'do'
+        write!(self.buffer, " do")?;
+
+        // Emit block parameters if present (|x, y|)
+        self.emit_block_parameters(block_node)?;
+
+        self.buffer.push('\n');
+
+        // Find and emit the body (StatementsNode among children)
+        for child in &block_node.children {
+            if matches!(child.node_type, NodeType::StatementsNode) {
+                self.emit_statements(child, indent_level + 1)?;
+                self.buffer.push('\n');
+                break;
+            }
+        }
+
+        // Emit 'end'
+        self.emit_indent(indent_level)?;
+        write!(self.buffer, "end")?;
+
+        Ok(())
+    }
+
+    /// Emit a { } style block
+    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;
+
+        if is_multiline {
+            // Multiline brace block
+            write!(self.buffer, " {{")?;
+            self.emit_block_parameters(block_node)?;
+            self.buffer.push('\n');
+
+            // Emit body
+            for child in &block_node.children {
+                if matches!(child.node_type, NodeType::StatementsNode) {
+                    self.emit_statements(child, indent_level + 1)?;
+                    self.buffer.push('\n');
+                    break;
+                }
+            }
+
+            self.emit_indent(indent_level)?;
+            write!(self.buffer, "}}")?;
+        } else {
+            // Inline brace block - extract from source to preserve spacing
+            write!(self.buffer, " ")?;
+            if let Some(text) = self
+                .source
+                .get(block_node.location.start_offset..block_node.location.end_offset)
+            {
+                write!(self.buffer, "{}", text)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Emit block parameters (|x, y|)
+    fn emit_block_parameters(&mut self, block_node: &Node) -> Result<()> {
+        if self.source.is_empty() {
+            return Ok(());
+        }
+
+        let start = block_node.location.start_offset;
+        let end = block_node.location.end_offset;
+
+        if let Some(block_source) = self.source.get(start..end) {
+            // Only look at the first line of the block for parameters
+            let first_line = block_source.lines().next().unwrap_or("");
+
+            // Find |...| pattern in the first line only
+            if let Some(pipe_start) = first_line.find('|') {
+                // Find matching pipe after first one
+                if let Some(pipe_end) = first_line[pipe_start + 1..].find('|') {
+                    let params = &first_line[pipe_start..=pipe_start + 1 + pipe_end];
+                    write!(self.buffer, " {}", params)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Emit generic node without re-emitting comments (for use when comments already handled)
+    fn emit_generic_without_comments(&mut self, node: &Node, indent_level: usize) -> Result<()> {
+        if !self.source.is_empty() {
+            let start = node.location.start_offset;
+            let end = node.location.end_offset;
+
+            let text_owned = self.source.get(start..end).map(|s| s.to_string());
+
+            if let Some(text) = text_owned {
+                self.emit_indent(indent_level)?;
+                write!(self.buffer, "{}", text)?;
+                self.emit_trailing_comments(node.location.end_line)?;
+            }
+        }
+        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

@@ -54,7 +54,7 @@ fn rust_version() -> String {
 }
 
 #[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
+fn init(_ruby: &Ruby) -> Result<(), Error> {
     logging::RfmtLogger::init();
     log::info!("Initializing rfmt Rust extension");
 
@@ -64,15 +64,6 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_singleton_method("parse_to_json", function!(parse_to_json, 1))?;
     module.define_singleton_method("rust_version", function!(rust_version, 0))?;
 
-    let rfmt_error = ruby.define_error("RfmtError", ruby.exception_standard_error())?;
-    ruby.define_error("ParseError", rfmt_error)?;
-    ruby.define_error("ConfigError", rfmt_error)?;
-    ruby.define_error("PrismError", rfmt_error)?;
-    ruby.define_error("RuleError", rfmt_error)?;
-    ruby.define_error("InternalError", rfmt_error)?;
-    ruby.define_error("FormattingError", rfmt_error)?;
-    ruby.define_error("UnsupportedFeature", rfmt_error)?;
-
     log::info!("rfmt Rust extension initialized successfully");
     Ok(())
 }

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

@@ -37,8 +37,10 @@ impl RfmtLogger {
                 LevelFilter::Warn
             });
         let logger = Self::new(level);
-        log::set_boxed_logger(Box::new(logger)).expect("Failed to initialize logger");
-        log::set_max_level(LevelFilter::Trace);
+        // Ignore if logger is already set (e.g., in ruby_lsp environment)
+        if log::set_boxed_logger(Box::new(logger)).is_ok() {
+            log::set_max_level(LevelFilter::Trace);
+        }
     }
 }
 

data/lib/rfmt/version.rb

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

data/lib/ruby_lsp/rfmt/addon.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'ruby_lsp/addon'
+require_relative 'formatter_runner'
+
+module RubyLsp
+  module Rfmt
+    class Addon < ::RubyLsp::Addon
+      def name
+        'rfmt'
+      end
+
+      def activate(global_state, _message_queue)
+        global_state.register_formatter('rfmt', FormatterRunner.new)
+      end
+
+      def deactivate; end
+    end
+  end
+end

data/lib/ruby_lsp/rfmt/formatter_runner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rfmt'
+
+module RubyLsp
+  module Rfmt
+    class FormatterRunner
+      # @param uri [URI::Generic] Document URI
+      # @param document [RubyLsp::RubyDocument] Target document
+      # @return [String, nil] Formatted text or nil on error
+      def run_formatting(_uri, document)
+        source = document.source
+        ::Rfmt.format(source)
+      rescue ::Rfmt::Error
+        nil
+      end
+
+      # @param uri [URI::Generic] Document URI
+      # @param document [RubyLsp::RubyDocument] Target document
+      # @return [Array<RubyLsp::Interface::Diagnostic>]
+      def run_diagnostic(_uri, _document)
+        []
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-07 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -62,6 +62,8 @@ files:
 - lib/rfmt/prism_node_extractor.rb
 - lib/rfmt/rfmt.so
 - lib/rfmt/version.rb
+- lib/ruby_lsp/rfmt/addon.rb
+- lib/ruby_lsp/rfmt/formatter_runner.rb
 homepage: https://github.com/fs0414/rfmt
 licenses:
 - MIT
@@ -70,6 +72,7 @@ metadata:
   homepage_uri: https://github.com/fs0414/rfmt
   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: