rfmt 0.5.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e72bec96df5da8aafa6e1cd49ab3c14af9aaaaf79a880cbf2a6b05715a61aa7c
-  data.tar.gz: 381c235d258b0db3f7c770dd360cc3816ccaa1fdbe1af4fc857e0f871618d29b
+  metadata.gz: 7db146878fe1bbf37f4211f11ded67e98ebfb1830989a4fb64fbe1cc51a72fc7
+  data.tar.gz: bb87cfab19f7513ddd99b939c03286827687a5da6071c317390dc990924dbe05
 SHA512:
-  metadata.gz: 97261a648e5aa560d4b3a2499ed82e208d445f422b50dc0d17be0b0aa2065b7d54cc8547e09a8632019a8538cafae750468e2f95ad73bf881955bc982e527d5c
-  data.tar.gz: 8ee6c5ec43066f7d70d07198dc72032c87fe4be1759a74196f4c17c74bfbf91579116a0744ea2b39cb8a222748a61b1e65e723e43e22d19b4589c4a28ce4baed
+  metadata.gz: 2018f31f65afd41842a51e21290448a753784b840dd67f9d8e7e41d223f509227143b18a15309b4a3cf19543b8638ce28045d0c1a68cf97dda8781811b058657
+  data.tar.gz: 888d036c08f29f166d1089a2cce27d9c456d57c83fbbd1c518142bdfaa15b32c551ab1ccda12c97bd48c9ddf63f57545ef47b6cbdcf8a774f8ea4eb1e17d1729

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## [Unreleased]
 
+## [1.1.0] - 2025-12-12
+
+### Added
+- Editor integration (Ruby LSP support)
+- Required/Optional keyword parameter node type support
+
+### Fixed
+- Migration file superclass corruption (ActiveRecord::Migration[8.1] etc.)
+
+### Changed
+- Removed unused scripts and test files (reduced Ruby code by ~38%)
+
+## [1.0.0] - 2025-12-11
+
+### Breaking Changes
+- First stable release (v1.0.0)
+
+### Added
+- Neovim integration: format-on-save support with autocmd configuration
+
+### 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/README.md

@@ -10,6 +10,7 @@ A Ruby code formatter written in Rust
 [Installation](#installation) •
 [Usage](#usage) •
 [Features](#features) •
+[Editor Integration](#editor-integration) •
 [Documentation](#documentation) •
 [Contributing](#contributing)
 
@@ -273,6 +274,33 @@ class User < ApplicationRecord
 end
 ```
 
+## Editor Integration
+
+### Neovim
+
+Format Ruby files on save using autocmd:
+
+```lua
+-- ~/.config/nvim/init.lua
+
+vim.api.nvim_create_autocmd("BufWritePre", {
+  pattern = { "*.rb", "*.rake", "Gemfile", "Rakefile" },
+  callback = function()
+    local filepath = vim.fn.expand("%:p")
+    local result = vim.fn.system({ "rfmt", filepath })
+    if vim.v.shell_error == 0 then
+      vim.cmd("edit!")
+    end
+  end,
+})
+```
+
+### Coming Soon
+
+- **VS Code** - Extension in development
+- **RubyMine** - Plugin in development
+- **Zed** - Extension in development
+
 ## Development
 
 ### Setup

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/ast/mod.rs

@@ -66,6 +66,8 @@ pub enum NodeType {
     OptionalParameterNode,
     RestParameterNode,
     KeywordParameterNode,
+    RequiredKeywordParameterNode,
+    OptionalKeywordParameterNode,
     KeywordRestParameterNode,
     BlockParameterNode,
 
@@ -102,6 +104,8 @@ impl NodeType {
             "optional_parameter_node" => Self::OptionalParameterNode,
             "rest_parameter_node" => Self::RestParameterNode,
             "keyword_parameter_node" => Self::KeywordParameterNode,
+            "required_keyword_parameter_node" => Self::RequiredKeywordParameterNode,
+            "optional_keyword_parameter_node" => Self::OptionalKeywordParameterNode,
             "keyword_rest_parameter_node" => Self::KeywordRestParameterNode,
             "block_parameter_node" => Self::BlockParameterNode,
             _ => Self::Unknown(s.to_string()),

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
@@ -475,6 +660,8 @@ impl Emitter {
                 | NodeType::OptionalParameterNode
                 | NodeType::RestParameterNode
                 | NodeType::KeywordParameterNode
+                | NodeType::RequiredKeywordParameterNode
+                | NodeType::OptionalKeywordParameterNode
                 | NodeType::KeywordRestParameterNode
                 | NodeType::BlockParameterNode
         )

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

@@ -27,16 +27,25 @@ module Rfmt
       when Prism::ConstantReadNode
         sc.name.to_s
       when Prism::ConstantPathNode
-        # Try full_name first, fall back to name
+        # Try full_name first, fall back to slice for original source
         if sc.respond_to?(:full_name)
           sc.full_name.to_s
-        elsif sc.respond_to?(:name)
-          sc.name.to_s
+        elsif sc.respond_to?(:slice)
+          sc.slice
         else
-          sc.to_s
+          sc.location.slice
         end
+      when Prism::CallNode
+        # Handle cases like ActiveRecord::Migration[8.1]
+        # Use slice to get the original source text
+        sc.slice
       else
-        sc.to_s
+        # Fallback: try to get original source text
+        if sc.respond_to?(:slice)
+          sc.slice
+        else
+          sc.location.slice
+        end
       end
     end
 

data/lib/rfmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rfmt
-  VERSION = '0.5.0'
+  VERSION = '1.1.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.1.0
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-07 00:00:00.000000000 Z
+date: 2025-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -41,8 +41,6 @@ files:
 - exe/rfmt
 - ext/rfmt/Cargo.toml
 - ext/rfmt/extconf.rb
-- ext/rfmt/spec/config_spec.rb
-- ext/rfmt/spec/spec_helper.rb
 - ext/rfmt/src/ast/mod.rs
 - ext/rfmt/src/config/mod.rs
 - ext/rfmt/src/emitter/mod.rs
@@ -62,6 +60,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 +70,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:

data/ext/rfmt/spec/config_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Configuration' do
-  describe 'configuration system integration' do
-    it 'can load YAML configuration' do
-      require 'tempfile'
-      require 'yaml'
-
-      config = {
-        'version' => '1.0',
-        'formatting' => {
-          'line_length' => 120,
-          'indent_width' => 4,
-          'indent_style' => 'tabs',
-          'quote_style' => 'single'
-        }
-      }
-
-      Tempfile.create(['test_config', '.yml']) do |file|
-        file.write(YAML.dump(config))
-        file.flush
-
-        loaded_config = YAML.load_file(file.path)
-        expect(loaded_config['formatting']['line_length']).to eq(120)
-        expect(loaded_config['formatting']['indent_width']).to eq(4)
-        expect(loaded_config['formatting']['indent_style']).to eq('tabs')
-        expect(loaded_config['formatting']['quote_style']).to eq('single')
-      end
-    end
-
-    it 'validates configuration values' do
-      # Configuration validation is tested in Rust tests
-      # 11 Rust tests verify all validation logic
-      expect(true).to be true
-    end
-  end
-end

data/ext/rfmt/spec/spec_helper.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'rfmt'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-end