rfmt 0.4.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f49bc8ba6c22392ac19d4f52cb9f82ee0476f849326745d821b952a75b13bb70
-  data.tar.gz: 59f68f137d3b769e17463c8c47b5ee3add7c06234caf50b3a20c03a34bf32cc0
+  metadata.gz: 75dece5f16cef2420a328e75f674416858eef7871c99a6aec1136c73f4b3b44c
+  data.tar.gz: f514b13a111e7113ed68beb1a1443b7815f8b11d47deee454ef352acf3e5ec7d
 SHA512:
-  metadata.gz: 8bd5393bab836f18a889ddac8e00e997bc7e1d45a6e9b2e5f4d232dd9589ce367ed76c60129631ca6a1626ba76031a8517cdd96e05ad41ebe960468f9933fb1e
-  data.tar.gz: f6692b5a16f284c59e5d8281c5bb11e96ce6f70aee47f6656c8e13986e20b27874f2dbcbee1168a6314a67f234909bb4e94a55903bcecddd072c1b9804475212
+  metadata.gz: 3a3575ed8e1e35770b6ac016521ee131fc1cf92b065c16ae91418a1835e7ab6695f30b9f1bb09c2b45c24801ae9427490ae835fffca228137c18ca1299416bf2
+  data.tar.gz: a5459089d49f7b905e565a3289dae2076df6a3d472a1332c0cca8f15ebab8d712a571e202b7053fcbbaeb85431d2f14f586e272e70966a0eeec1b72002e3fe4a

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [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
+- Synchronized markdown command documentation
+- Added project logo
+
+### Fixed
+- Removed unnecessary exec command
+
 ## [0.4.1] - 2025-11-28
 
 ### Fixed

data/Cargo.lock

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

data/README.md

@@ -13,6 +13,8 @@ A Ruby code formatter written in Rust
 [Documentation](#documentation) •
 [Contributing](#contributing)
 
+<a href="https://flatt.tech/oss/gmo/trampoline" target="_blank"><img src="https://flatt.tech/assets/images/badges/gmo-oss.svg" height="24px"/></a>
+
 </div>
 
 ---
@@ -154,13 +156,13 @@ rfmt init --force
 Format a single file:
 
 ```bash
-rfmt exec lib/user.rb
+rfmt lib/user.rb
 ```
 
 Format multiple files:
 
 ```bash
-rfmt exec lib/**/*.rb
+rfmt lib/**/*.rb
 ```
 
 Check if files need formatting (CI/CD):
@@ -172,15 +174,15 @@ rfmt check .
 Show diff without modifying files:
 
 ```bash
-rfmt exec lib/user.rb --diff
+rfmt lib/user.rb --diff
 ```
 
 Enable verbose output for debugging:
 
 ```bash
-rfmt exec lib/user.rb --verbose
+rfmt lib/user.rb --verbose
 # or use environment variable
-DEBUG=1 rfmt exec lib/user.rb
+DEBUG=1 rfmt lib/user.rb
 ```
 
 ### Ruby API

data/exe/rfmt

@@ -3,8 +3,14 @@
 
 require 'rfmt/cli'
 
+# Known subcommands - if first arg is not one of these, prepend 'format'
+SUBCOMMANDS = %w[format check version config cache init help].freeze
+
+args = ARGV.dup
+args.unshift('format') if args.empty? || (!SUBCOMMANDS.include?(args.first) && !args.first.start_with?('-'))
+
 begin
-  Rfmt::CLI.start(ARGV)
+  Rfmt::CLI.start(args)
 rescue Interrupt
   puts "\nInterrupted"
   exit(130)

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "0.4.1"
+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/cli.rb

@@ -47,7 +47,9 @@ module Rfmt
     class_option :config, type: :string, desc: 'Path to configuration file'
     class_option :verbose, type: :boolean, aliases: '-v', desc: 'Verbose output'
 
-    desc 'exec [FILES]', 'Format Ruby files'
+    default_command :format
+
+    desc 'format [FILES]', 'Format Ruby files (default command)'
     option :write, type: :boolean, default: true, desc: 'Write formatted output'
     option :check, type: :boolean, desc: "Check if files are formatted (don't write)"
     option :diff, type: :boolean, desc: 'Show diff of changes'
@@ -56,7 +58,7 @@ module Rfmt
     option :jobs, type: :numeric, desc: 'Number of parallel jobs (default: CPU count)'
     option :cache, type: :boolean, default: true, desc: 'Use cache to skip unchanged files'
     option :cache_dir, type: :string, desc: 'Cache directory (default: ~/.cache/rfmt)'
-    def exec(*files)
+    def format(*files)
       config = load_config
       files = files.empty? ? config.files_to_format : files.flatten
 
@@ -101,7 +103,7 @@ module Rfmt
 
     desc 'check [FILES]', 'Check if files need formatting'
     def check(*files)
-      invoke :exec, files, check: true, write: false
+      invoke :format, files, check: true, write: false
     end
 
     desc 'version', 'Show version'

data/lib/rfmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rfmt
-  VERSION = '0.4.1'
+  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.4.1
+  version: 1.0.0
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-27 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: