rfmt 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d2092d9d53fa47024fcb8a13fb635a6da7eba5d4c51d3a8df854d551380037b
-  data.tar.gz: 59bb09f50cb7ee5a033328300a581e973879aaad56067d267b041c2070cac8bf
+  metadata.gz: cb4f41a4ba34f1bc106746712bf144fe6f5ee8cf5a80cf26efaecc8450645d89
+  data.tar.gz: 94f896c28015d9592d959ef3a42b4db80e309ad664ef97d5f28b0e8479605892
 SHA512:
-  metadata.gz: f7043e22d625b0b6a689f01950a6ed0fae7ab3fa1cfa2dcd51af544d72aadf8b0c3aa65a3465c9f9baabf2f1a000c37bddb2f2f57e2defd11344f6194ad3b68b
-  data.tar.gz: 407b70b3614da3ed19c74bd43d9491ee9bff1ce6cb1ef7f1e1d2d0b71068afb937bd5409668ae0c7454a6f2d12cb4764fa6df0273bef149980be30e0f9f1d7b6
+  metadata.gz: 0aef4d71101fd621bcecf87b0160e437ec9f7836e12759dbb28cd56416d1428bb3b54aabae888566548dc11557d1179e519aa5c971e613c3c37c775590eef981
+  data.tar.gz: 3ee34d6c250fdd9263822a8b361dc3fdde5005c36570a5a6a0be346f717090c581822c90cd08bee43674495c97a15fb22677558bd5be5b85f9ccd4c1d4fd9e51

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 ## [Unreleased]
 
+## [1.4.0] - 2026-01-17
+
+### Added
+- New `rfmt_fast` executable for optimized performance
+- Automatic parallel processing detection logic  
+- Enhanced logging and summary display functionality
+- CLI option mapping for `-v/--version` commands
+
+### Fixed
+- Fixed `-v` flag incorrectly triggering format instead of showing version
+- Fixed `--diff` option dependency issues (added `diffy` and `diff-lcs` to gemspec)
+- CLI option conflicts between verbose and version flags
+
+### Changed
+- Updated performance benchmarks documentation
+- Code formatting improvements with Rubocop compliance
+- Dependencies alphabetically sorted in gemspec
+
+## [1.3.4] - 2026-01-17
+
+### Added
+- New `rfmt_fast` executable for optimized performance
+- Automatic parallel processing detection logic
+- Enhanced logging and summary display functionality
+
+### Changed  
+- Optimize logging and summary display performance
+- Improve parallel execution logic with automatic detection
+- Update README with new features and usage examples
+- Code formatting improvements with Rubocop compliance
+
+### Fixed
+- Logger optimization to reduce overhead
+- Parallel processing logic refinements
+
 ## [1.3.3] - 2026-01-17
 
 ### Fixed

data/Cargo.lock

@@ -1214,7 +1214,7 @@ checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rfmt"
-version = "1.3.3"
+version = "1.4.0"
 dependencies = [
  "anyhow",
  "clap",

data/README.md

@@ -46,33 +46,31 @@ Enforces code style rules:
 - Quote style standardization
 - Method definition formatting
 
-## Performance Benchmarks
+## Performance
 
-Execution time comparison on a Rails project (111 files, 3,241 lines):
+rfmt delivers consistent, fast formatting across projects of any size:
 
-| Test Type | Files | rfmt | RuboCop | Ratio |
-|-----------|-------|------|---------|-------|
-| Single File | 1 | 191ms | 1.38s | 7.2x |
-| Directory | 14 | 176ms | 1.68s | 9.6x |
-| Full Project (check) | 111 | 172ms | 4.36s | 25.4x |
+| Project Size | Files | Execution Time | Throughput |
+|-------------|-------|----------------|------------|
+| Small | 9 files | ~105ms | 85 files/sec |
+| Medium | 35 files | ~110ms | 315 files/sec |
+| Large | 151 files | ~100ms | 1,560 files/sec |
 
-**About this comparison:**
-- RuboCop times include startup overhead and loading all cops (linting rules)
-- RuboCop was run with default configuration (all cops enabled)
-- rfmt is a formatting-only tool with minimal overhead
-- Both tools were measured in check mode (no file modifications)
-- Results are averages from 10 runs per test
+**Key Performance Characteristics:**
 
-**Observations:**
-- rfmt execution time remains constant (172-191ms) regardless of file count
-- Low variance across runs (standard deviation: 8-23ms)
+- **Constant Time**: Execution time stays around 100ms regardless of project size
+- **Parallel Processing**: Automatic scaling with available CPU cores
+- **High Throughput**: Up to 1,500+ files per second on large projects
+- **Low Overhead**: Minimal startup time and memory usage
 
 **Test Environment:**
 - CPU: Apple Silicon (arm64)
-- Ruby: 3.4.5
-- rfmt: 0.3.0, RuboCop: 1.81.7
+- Ruby: 3.4.8
+- Average of 5 runs per test
 
-See [detailed benchmark report](docs/benchmark.md) for complete data.
+*Built with Rust for optimal performance and memory efficiency.*
+
+For detailed performance comparisons and benchmarks, see [Performance Benchmarks](docs/benchmark.md).
 
 ## Installation
 
@@ -166,6 +164,12 @@ Format multiple files:
 rfmt lib/**/*.rb
 ```
 
+Format all files in your project:
+
+```bash
+rfmt .
+```
+
 Check if files need formatting (CI/CD):
 
 ```bash
@@ -178,12 +182,92 @@ Show diff without modifying files:
 rfmt lib/user.rb --diff
 ```
 
+Quiet mode (minimal output):
+
+```bash
+rfmt --quiet lib/**/*.rb
+```
+
 Enable verbose output for debugging:
 
 ```bash
-rfmt lib/user.rb --verbose
-# or use environment variable
-DEBUG=1 rfmt lib/user.rb
+rfmt --verbose lib/user.rb
+```
+
+#### Common Options
+
+| Option | Description |
+|--------|-------------|
+| `--check` | Check formatting without writing files |
+| `--diff` | Show diff of changes |
+| `--quiet` | Minimal output |
+| `--verbose` | Detailed output with timing |
+
+### Output Modes
+
+**Normal mode** (default):
+```bash
+$ rfmt app/
+Processing 25 file(s)...
+✓ Formatted app/controllers/users_controller.rb
+✓ Formatted app/models/user.rb
+
+✓ Processed 25 files
+  (3 formatted, 22 unchanged)
+```
+
+**Quiet mode** (`--quiet` or `-q`):
+```bash
+$ rfmt --quiet app/
+✓ 3 files formatted
+```
+
+**Verbose mode** (`--verbose` or `-v`):
+```bash
+$ rfmt --verbose app/
+Processing 25 file(s)...
+Using sequential processing for 25 files
+✓ Formatted app/controllers/users_controller.rb  
+✓ app/models/application_record.rb already formatted
+...
+
+✓ Processed 25 files
+  (3 formatted, 22 unchanged)
+
+Details:
+  Total files: 25
+  Total time: 0.45s
+  Files/sec: 55.6
+```
+
+### Parallel Processing
+
+rfmt automatically chooses the optimal processing mode:
+
+- **< 20 files**: Sequential processing (fastest for small batches)  
+- **20-49 files**: Automatic based on average file size
+- **≥ 50 files**: Parallel processing (utilizes multiple cores)
+
+You can override this behavior:
+
+```bash
+# Force parallel processing
+rfmt --parallel app/
+
+# Force sequential processing  
+rfmt --no-parallel app/
+```
+
+### Cache Management
+
+rfmt uses caching to improve performance on large codebases:
+
+```bash
+# Clear cache if needed
+rfmt cache clear
+
+# View cache statistics  
+rfmt cache stats
 ```
 
 ### Ruby API

data/exe/rfmt

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# Suppress gem warnings for performance (saves ~2 seconds)
+$VERBOSE = nil unless ENV['RFMT_VERBOSE']
+
 require 'rfmt/cli'
 
 # Known subcommands - if first arg is not one of these, prepend 'format'

data/ext/rfmt/Cargo.toml

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

data/lib/rfmt/cli.rb

@@ -3,7 +3,7 @@
 require 'thor'
 
 # Check for verbose flag before loading rfmt to set debug mode early
-ENV['RFMT_DEBUG'] = '1' if ARGV.include?('-v') || ARGV.include?('--verbose')
+ENV['RFMT_DEBUG'] = '1' if ARGV.include?('--verbose')
 
 require 'rfmt'
 require 'rfmt/configuration'
@@ -44,20 +44,29 @@ module Rfmt
 
   # Command Line Interface for rfmt
   class CLI < Thor
+    # Constants
+    PROGRESS_THRESHOLD = 20  # Show progress for file counts >= this
+    PROGRESS_INTERVAL = 10   # Update progress every N files
+
     class_option :config, type: :string, desc: 'Path to configuration file'
-    class_option :verbose, type: :boolean, aliases: '-v', desc: 'Verbose output'
+    class_option :verbose, type: :boolean, desc: 'Verbose output'
 
     default_command :format
 
+    # Map -v and --version to version command
+    map '-v' => 'version'
+    map '--version' => 'version'
+
     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'
     option :diff_format, type: :string, default: 'unified', desc: 'Diff format: unified, side_by_side, or color'
-    option :parallel, type: :boolean, default: true, desc: 'Process files in parallel'
+    option :parallel, type: :boolean, desc: 'Use parallel processing (auto-disabled for <20 files)'
     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)'
+    option :quiet, type: :boolean, aliases: '-q', desc: 'Minimal output (errors and summary only)'
     def format(*files)
       config = load_config
       files = files.empty? ? config.files_to_format : files.flatten
@@ -67,33 +76,32 @@ module Rfmt
         return
       end
 
-      # Initialize cache
-      cache = if options[:cache]
-                cache_opts = options[:cache_dir] ? { cache_dir: options[:cache_dir] } : {}
-                Cache.new(**cache_opts)
-              end
-
-      # Filter files using cache
-      if cache
-        original_count = files.size
-        files = files.select { |file| cache.needs_formatting?(file) }
-        skipped = original_count - files.size
-        say "ℹ Skipped #{skipped} unchanged file(s) (cached)", :cyan if skipped.positive? && options[:verbose]
-      end
+      # Initialize and use cache if enabled
+      cache = initialize_cache_if_enabled
+      files = filter_files_with_cache(files, cache)
 
       if files.empty?
-        say '✓ All files are already formatted (cached)', :green
+        say '✓ All files are already formatted (cached)', :cyan
         return
       end
 
-      # Show progress message
-      if files.size == 1
-        say "Processing #{files.first}...", :blue
-      else
-        say "Processing #{files.size} file(s)...", :blue
+      # Show progress message (unless in quiet mode)
+      unless options[:quiet]
+        if files.size == 1
+          say "Processing #{files.first}...", :blue
+        else
+          say "Processing #{files.size} file(s)...", :blue
+        end
+      end
+
+      use_parallel = should_use_parallel?(files)
+
+      if options[:verbose] && files.size > 1
+        mode = use_parallel ? "parallel (#{options[:jobs] || 'auto'} jobs)" : 'sequential'
+        say "Using #{mode} processing for #{files.size} files", :blue
       end
 
-      results = if options[:parallel] && files.size > 1
+      results = if use_parallel
                   format_files_parallel(files)
                 else
                   format_files_sequential(files)
@@ -140,6 +148,39 @@ module Rfmt
 
     private
 
+    # Intelligently decide whether to use parallel processing
+    def should_use_parallel?(files)
+      return false if files.size <= 1
+
+      # Check if parallel option was explicitly set via command line
+      # Thor sets options[:parallel] to true/false for --parallel/--no-parallel
+      # and nil when not specified
+      return options[:parallel] unless options[:parallel].nil?
+
+      # Auto decision based on workload characteristics
+      # Calculate total size for better decision
+      total_size = files.sum do |f|
+        File.size(f)
+      rescue StandardError
+        0
+      end
+      avg_size = total_size / files.size.to_f
+
+      # Decision matrix:
+      # - Less than 20 files: sequential (overhead > benefit)
+      # - 20-50 files with small size (<10KB avg): sequential
+      # - 20-50 files with large size (>10KB avg): parallel
+      # - More than 50 files: always parallel
+
+      if files.size < 20
+        false
+      elsif files.size < 50
+        avg_size > 10_000 # 10KB threshold
+      else
+        true
+      end
+    end
+
     def load_config
       if options[:config]
         Configuration.new(file: options[:config])
@@ -148,25 +189,68 @@ module Rfmt
       end
     end
 
+    def initialize_cache_if_enabled
+      return nil unless options[:cache]
+
+      cache_opts = options[:cache_dir] ? { cache_dir: options[:cache_dir] } : {}
+      Cache.new(**cache_opts)
+    end
+
+    def filter_files_with_cache(files, cache)
+      return files unless cache
+
+      original_count = files.size
+      filtered = files.select { |file| cache.needs_formatting?(file) }
+
+      log_cache_skip(original_count - filtered.size)
+      filtered
+    end
+
+    def log_cache_skip(skipped_count)
+      return unless skipped_count.positive? && options[:verbose]
+
+      say "ℹ Skipped #{skipped_count} unchanged file(s) (cached)", :cyan
+    end
+
     def format_files_sequential(files)
-      files.map do |file|
+      show_progress = should_show_progress?(files)
+
+      files.map.with_index do |file, index|
+        display_progress(index, files.size) if show_progress && (index % PROGRESS_INTERVAL).zero?
         format_single_file(file)
       end
     end
 
+    def should_show_progress?(files)
+      !options[:quiet] && files.size >= PROGRESS_THRESHOLD
+    end
+
+    def display_progress(index, total)
+      percentage = ((index.to_f / total) * 100).round
+      say "[#{index}/#{total}] #{percentage}% complete...", :blue
+    end
+
     def format_files_parallel(files)
       require 'parallel'
 
-      # Determine number of processes to use
-      process_count = options[:jobs] || Parallel.processor_count
-
-      say "Processing #{files.size} files with #{process_count} parallel jobs...", :blue if options[:verbose]
+      process_count = determine_process_count
+      log_parallel_processing(files.size, process_count)
 
       Parallel.map(files, in_processes: process_count) do |file|
         format_single_file(file)
       end
     end
 
+    def determine_process_count
+      options[:jobs] || Parallel.processor_count
+    end
+
+    def log_parallel_processing(file_count, process_count)
+      return unless options[:verbose]
+
+      say "Processing #{file_count} files with #{process_count} parallel jobs...", :blue
+    end
+
     def format_single_file(file)
       start_time = Time.now
       source = File.read(file)
@@ -191,69 +275,126 @@ module Rfmt
     end
 
     def handle_results(results, cache = nil)
-      failed_count = 0
-      changed_count = 0
-      error_count = 0
+      stats = process_results(results, cache)
+      stats[:total_duration] = results.sum { |r| r[:duration] || 0 }
+      cache&.save
+      display_summary(stats, results.size)
+      exit(1) if should_exit_with_error?(stats)
+    end
+
+    def process_results(results, cache)
+      stats = { changed: 0, errors: 0, failed: 0, duration: 0 }
 
       results.each do |result|
         if result[:error]
-          say "Error in #{result[:file]}: #{result[:error]}", :red
-          error_count += 1
-          next
+          handle_error_result(result, stats)
+        elsif result[:changed]
+          handle_changed_result(result, stats, cache)
+        else
+          handle_unchanged_result(result, cache)
         end
+      end
 
-        if result[:changed]
-          changed_count += 1
-
-          if options[:check]
-            say "#{result[:file]} needs formatting", :yellow
-            failed_count += 1
-            show_diff(result[:file], result[:original], result[:formatted]) if options[:diff]
-          elsif options[:diff]
-            show_diff(result[:file], result[:original], result[:formatted])
-          elsif options[:write]
-            File.write(result[:file], result[:formatted])
-            # Always show formatted files (not just in verbose mode)
-            say "✓ Formatted #{result[:file]}", :green
-
-            # Update cache after successful write
-            cache&.mark_formatted(result[:file])
-          else
-            puts result[:formatted]
-          end
-        else
-          # Show already formatted files in non-check mode
-          say "✓ #{result[:file]} already formatted", :cyan unless options[:check]
+      stats
+    end
 
-          # Update cache even if no changes (file was checked)
-          cache&.mark_formatted(result[:file])
-        end
+    def handle_error_result(result, stats)
+      say "Error in #{result[:file]}: #{result[:error]}", :red
+      stats[:errors] += 1
+    end
+
+    def handle_changed_result(result, stats, cache)
+      stats[:changed] += 1
+
+      if options[:check]
+        say "#{result[:file]} needs formatting", :yellow
+        stats[:failed] += 1
+        show_diff(result[:file], result[:original], result[:formatted]) if options[:diff]
+      elsif options[:diff]
+        show_diff(result[:file], result[:original], result[:formatted])
+      elsif options[:write]
+        write_formatted_file(result, cache)
+      else
+        puts result[:formatted]
       end
+    end
 
-      # Save cache to disk
-      cache&.save
+    def handle_unchanged_result(result, cache)
+      say "✓ #{result[:file]} already formatted", :white if options[:verbose] && !options[:check]
+      cache&.mark_formatted(result[:file])
+    end
 
-      # Summary - always show a summary message
-      if error_count.positive?
-        say "\n✗ Failed: #{error_count} error(s) occurred", :red
-      elsif options[:check] && failed_count.positive?
-        say "\n✗ Check failed: #{failed_count} file(s) need formatting", :yellow
-      elsif changed_count.positive?
-        # Success message with appropriate details
-        say "\n✓ Success! Formatted #{changed_count} file(s)", :green
-      elsif results.size == 1
-        say "\n✓ Success! File is already formatted", :green
+    def write_formatted_file(result, cache)
+      File.write(result[:file], result[:formatted])
+      say "✓ Formatted #{result[:file]}", :green unless options[:quiet]
+      cache&.mark_formatted(result[:file])
+    end
+
+    def display_summary(stats, total_files)
+      @last_stats = stats # Store for verbose details
+      unchanged_count = total_files - stats[:changed] - stats[:errors]
+
+      if stats[:errors].positive?
+        display_error_summary(stats[:errors])
+      elsif options[:check] && stats[:failed].positive?
+        display_check_failed_summary(stats[:failed])
+      elsif options[:quiet]
+        display_quiet_summary(stats[:changed])
       else
-        say "\n✓ Success! All #{results.size} files are already formatted", :green
+        display_normal_summary(stats[:changed], unchanged_count, total_files)
       end
 
-      # Detailed summary in verbose mode
-      if options[:verbose]
-        say "Total: #{results.size} file(s) processed", :blue
-        say "Changed: #{changed_count} file(s)", :yellow if changed_count.positive?
+      display_verbose_details(total_files) if options[:verbose] && !options[:quiet]
+    end
+
+    def display_error_summary(error_count)
+      say "\n✗ Failed: #{error_count} error(s) occurred", :red
+    end
+
+    def display_check_failed_summary(failed_count)
+      say "\n✗ Check failed: #{failed_count} file(s) need formatting", :yellow
+    end
+
+    def display_quiet_summary(changed_count)
+      say "✓ #{changed_count} files formatted", :cyan if changed_count.positive?
+    end
+
+    def display_normal_summary(changed_count, unchanged_count, total_files)
+      if total_files == 1
+        if changed_count.positive?
+          say "\n✓ Formatted 1 file", :cyan
+        else
+          say "\n✓ File is already formatted", :cyan
+        end
+      else
+        say "\n✓ Processed #{total_files} files", :cyan
+        display_file_breakdown(changed_count, unchanged_count)
       end
+    end
+
+    def display_file_breakdown(changed_count, unchanged_count)
+      return unless changed_count.positive? || unchanged_count.positive?
+
+      parts = []
+      parts << "#{changed_count} formatted" if changed_count.positive?
+      parts << "#{unchanged_count} unchanged" if unchanged_count.positive?
+      say "  (#{parts.join(', ')})", :white
+    end
+
+    def display_verbose_details(total_files)
+      say "\nDetails:", :blue
+      say "  Total files: #{total_files}", :blue
+
+      # Duration is collected if available
+      return unless defined?(@last_stats) && @last_stats[:total_duration]
+
+      duration = @last_stats[:total_duration].round(2)
+      say "  Total time: #{duration}s", :blue
+      say "  Files/sec: #{(total_files / duration).round(1)}", :blue if duration.positive?
+    end
 
-      exit(1) if (options[:check] && failed_count.positive?) || error_count.positive?
+    def should_exit_with_error?(stats)
+      (options[:check] && stats[:failed].positive?) || stats[:errors].positive?
     end
 
     def show_diff(file, original, formatted)

data/lib/rfmt/version.rb

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

data/lib/rfmt.rb

@@ -102,14 +102,9 @@ module Rfmt
     # @param force [Boolean] Overwrite existing file if true
     # @return [Boolean] true if file was created, false if already exists
     def self.init(path = '.rfmt.yml', force: false)
-      if File.exist?(path) && !force
-        warn "Configuration file already exists: #{path}"
-        warn 'Use force: true to overwrite'
-        return false
-      end
+      return false if File.exist?(path) && !force
 
       File.write(path, DEFAULT_CONFIG)
-      puts "Created rfmt configuration file: #{path}"
       true
     end
 

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.0
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-16 00:00:00.000000000 Z
+date: 2026-01-17 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rb_sys
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.120
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: Write a longer description or delete this line.
 email:
 - fujitanisora0414@gmail.com