rfmt 1.3.0-x86_64-linux-musl

data/lib/rfmt/cache.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Rfmt
+  # Cache system for formatted files
+  # Uses mtime (modification time) to determine if formatting is needed
+  class Cache
+    class CacheError < StandardError; end
+
+    DEFAULT_CACHE_DIR = File.expand_path('~/.cache/rfmt').freeze
+    CACHE_VERSION = '1'
+
+    attr_reader :cache_dir
+
+    def initialize(cache_dir: DEFAULT_CACHE_DIR)
+      @cache_dir = cache_dir
+      @cache_data = {}
+      ensure_cache_dir
+      load_cache
+    end
+
+    # Check if file needs formatting
+    # Returns true if file mtime has changed or not in cache
+    def needs_formatting?(file_path)
+      return true unless File.exist?(file_path)
+
+      current_mtime = File.mtime(file_path).to_i
+      cached_mtime = @cache_data.dig(file_path, 'mtime')
+
+      current_mtime != cached_mtime
+    end
+
+    # Mark file as formatted with current mtime
+    def mark_formatted(file_path)
+      return unless File.exist?(file_path)
+
+      @cache_data[file_path] = {
+        'mtime' => File.mtime(file_path).to_i,
+        'formatted_at' => Time.now.to_i,
+        'version' => CACHE_VERSION
+      }
+    end
+
+    # Save cache to disk
+    def save
+      cache_file = File.join(@cache_dir, 'cache.json')
+      File.write(cache_file, JSON.pretty_generate(@cache_data))
+    end
+
+    # Clear all cache data
+    def clear
+      @cache_data = {}
+      save
+    end
+
+    # Remove cache for specific file
+    def invalidate(file_path)
+      @cache_data.delete(file_path)
+    end
+
+    # Get cache statistics
+    def stats
+      {
+        total_files: @cache_data.size,
+        cache_dir: @cache_dir,
+        cache_size_bytes: cache_size
+      }
+    end
+
+    # Prune old cache entries (files that no longer exist)
+    def prune
+      before_count = @cache_data.size
+      @cache_data.delete_if { |file_path, _| !File.exist?(file_path) }
+      after_count = @cache_data.size
+      pruned = before_count - after_count
+
+      save if pruned.positive?
+      pruned
+    end
+
+    private
+
+    def ensure_cache_dir
+      FileUtils.mkdir_p(@cache_dir)
+    rescue StandardError => e
+      raise CacheError, "Failed to create cache directory: #{e.message}"
+    end
+
+    def load_cache
+      cache_file = File.join(@cache_dir, 'cache.json')
+      return unless File.exist?(cache_file)
+
+      content = File.read(cache_file)
+      @cache_data = JSON.parse(content)
+    rescue JSON::ParserError => e
+      warn "Warning: Failed to parse cache file, starting with empty cache: #{e.message}"
+      @cache_data = {}
+    rescue StandardError => e
+      warn "Warning: Failed to load cache, starting with empty cache: #{e.message}"
+      @cache_data = {}
+    end
+
+    def cache_size
+      cache_file = File.join(@cache_dir, 'cache.json')
+      return 0 unless File.exist?(cache_file)
+
+      File.size(cache_file)
+    end
+  end
+end

data/lib/rfmt/cli.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+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')
+
+require 'rfmt'
+require 'rfmt/configuration'
+require 'rfmt/cache'
+
+module Rfmt
+  # Cache management commands
+  class CacheCommands < Thor
+    desc 'clear', 'Clear all cache data'
+    option :cache_dir, type: :string, desc: 'Cache directory (default: ~/.cache/rfmt)'
+    def clear
+      cache_opts = options[:cache_dir] ? { cache_dir: options[:cache_dir] } : {}
+      cache = Cache.new(**cache_opts)
+      cache.clear
+      say 'Cache cleared', :green
+    end
+
+    desc 'stats', 'Show cache statistics'
+    option :cache_dir, type: :string, desc: 'Cache directory (default: ~/.cache/rfmt)'
+    def stats
+      cache_opts = options[:cache_dir] ? { cache_dir: options[:cache_dir] } : {}
+      cache = Cache.new(**cache_opts)
+      stats = cache.stats
+      say "Cache directory: #{stats[:cache_dir]}", :blue
+      say "Total files in cache: #{stats[:total_files]}", :blue
+      say "Cache size: #{(stats[:cache_size_bytes] / 1024.0).round(2)} KB", :blue
+    end
+
+    desc 'prune', 'Remove cache entries for files that no longer exist'
+    option :cache_dir, type: :string, desc: 'Cache directory (default: ~/.cache/rfmt)'
+    def prune
+      cache_opts = options[:cache_dir] ? { cache_dir: options[:cache_dir] } : {}
+      cache = Cache.new(**cache_opts)
+      pruned = cache.prune
+      say "Pruned #{pruned} stale cache entries", :green
+    end
+  end
+
+  # Command Line Interface for rfmt
+  class CLI < Thor
+    class_option :config, type: :string, desc: 'Path to configuration file'
+    class_option :verbose, type: :boolean, aliases: '-v', desc: 'Verbose output'
+
+    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'
+    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 :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 format(*files)
+      config = load_config
+      files = files.empty? ? config.files_to_format : files.flatten
+
+      if files.empty?
+        say 'No files to format', :yellow
+        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
+
+      if files.empty?
+        say '✓ All files are already formatted (cached)', :green
+        return
+      end
+
+      # Show progress message
+      if files.size == 1
+        say "Processing #{files.first}...", :blue
+      else
+        say "Processing #{files.size} file(s)...", :blue
+      end
+
+      results = if options[:parallel] && files.size > 1
+                  format_files_parallel(files)
+                else
+                  format_files_sequential(files)
+                end
+      handle_results(results, cache)
+    end
+
+    desc 'check [FILES]', 'Check if files need formatting'
+    def check(*files)
+      invoke :format, files, check: true, write: false
+    end
+
+    desc 'version', 'Show version'
+    def version
+      say "rfmt #{Rfmt::VERSION}"
+      say "Rust extension: #{Rfmt.rust_version}"
+    end
+
+    desc 'config', 'Show current configuration'
+    def config_cmd
+      config = load_config
+      require 'json'
+      say JSON.pretty_generate(config.config)
+    end
+
+    desc 'cache SUBCOMMAND', 'Manage cache'
+    subcommand 'cache', CacheCommands
+
+    desc 'init', 'Initialize rfmt configuration'
+    option :force, type: :boolean, desc: 'Overwrite existing configuration'
+    option :path, type: :string, default: '.rfmt.yml', desc: 'Configuration file path'
+    def init
+      config_file = options[:path] || '.rfmt.yml'
+
+      # Use Rfmt::Config module for consistent behavior
+      result = Rfmt::Config.init(config_file, force: options[:force] || false)
+
+      if result
+        say "Created #{config_file}", :green
+      else
+        say "Configuration file already exists at #{config_file}. Use --force to overwrite.", :yellow
+      end
+    end
+
+    private
+
+    def load_config
+      if options[:config]
+        Configuration.new(file: options[:config])
+      else
+        Configuration.discover
+      end
+    end
+
+    def format_files_sequential(files)
+      files.map do |file|
+        format_single_file(file)
+      end
+    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]
+
+      Parallel.map(files, in_processes: process_count) do |file|
+        format_single_file(file)
+      end
+    end
+
+    def format_single_file(file)
+      start_time = Time.now
+      source = File.read(file)
+
+      formatted = Rfmt.format(source)
+      changed = source != formatted
+
+      {
+        file: file,
+        changed: changed,
+        original: source,
+        formatted: formatted,
+        duration: Time.now - start_time,
+        error: nil
+      }
+    rescue StandardError => e
+      {
+        file: file,
+        error: e.message,
+        duration: Time.now - start_time
+      }
+    end
+
+    def handle_results(results, cache = nil)
+      failed_count = 0
+      changed_count = 0
+      error_count = 0
+
+      results.each do |result|
+        if result[:error]
+          say "Error in #{result[:file]}: #{result[:error]}", :red
+          error_count += 1
+          next
+        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]
+
+          # Update cache even if no changes (file was checked)
+          cache&.mark_formatted(result[:file])
+        end
+      end
+
+      # Save cache to disk
+      cache&.save
+
+      # 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
+      else
+        say "\n✓ Success! All #{results.size} files are already formatted", :green
+      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?
+      end
+
+      exit(1) if (options[:check] && failed_count.positive?) || error_count.positive?
+    end
+
+    def show_diff(file, original, formatted)
+      require 'diffy'
+
+      say "\n#{'=' * 80}", :blue
+      say "Diff for #{file}:", :yellow
+      say '=' * 80, :blue
+
+      case options[:diff_format]
+      when 'unified'
+        diff = Diffy::Diff.new(original, formatted, context: 3)
+        puts diff.to_s(:color)
+      when 'side_by_side'
+        diff = Diffy::Diff.new(original, formatted, context: 3)
+        # Side-by-side is not well supported in terminal, use unified with more context
+        puts diff.to_s(:color)
+      when 'color'
+        show_colored_line_diff(original, formatted)
+      else
+        diff = Diffy::Diff.new(original, formatted, context: 3)
+        puts diff.to_s(:color)
+      end
+
+      say "#{'=' * 80}\n", :blue
+    end
+
+    def show_colored_line_diff(original, formatted)
+      require 'diff/lcs'
+
+      original_lines = original.split("\n")
+      formatted_lines = formatted.split("\n")
+
+      diffs = Diff::LCS.sdiff(original_lines, formatted_lines)
+
+      diffs.each_with_index do |diff, idx|
+        line_num = idx + 1
+        case diff.action
+        when '-'
+          say "#{line_num}: - #{diff.old_element}", :red
+        when '+'
+          say "#{line_num}: + #{diff.new_element}", :green
+        when '='
+          say "#{line_num}:   #{diff.old_element}", :white
+        when '!'
+          say "#{line_num}: - #{diff.old_element}", :red
+          say "#{line_num}: + #{diff.new_element}", :green
+        end
+      end
+    end
+  end
+end

data/lib/rfmt/configuration.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Rfmt
+  # Configuration management for rfmt
+  class Configuration
+    class ConfigError < StandardError; end
+
+    DEFAULT_CONFIG = {
+      'version' => '1.0',
+      'formatting' => {
+        'line_length' => 100,
+        'indent_width' => 2,
+        'indent_style' => 'spaces'
+      },
+      'include' => ['**/*.rb'],
+      'exclude' => ['vendor/**/*', 'tmp/**/*', 'node_modules/**/*']
+    }.freeze
+
+    CONFIG_FILES = ['rfmt.yml', 'rfmt.yaml', '.rfmt.yml', '.rfmt.yaml'].freeze
+
+    attr_reader :config
+
+    def initialize(options = {})
+      @config = load_configuration(options)
+    end
+
+    # Discover configuration file in current directory
+    def self.discover
+      config_file = CONFIG_FILES.find { |file| File.exist?(file) }
+      config_file ? new(file: config_file) : new
+    end
+
+    # Get list of files to format based on include/exclude patterns
+    def files_to_format(base_path: '.')
+      include_patterns = @config['include']
+      exclude_patterns = @config['exclude']
+
+      included_files = include_patterns.flat_map { |pattern| Dir.glob(File.join(base_path, pattern)) }
+      excluded_files = exclude_patterns.flat_map { |pattern| Dir.glob(File.join(base_path, pattern)) }
+
+      (included_files - excluded_files).select { |f| File.file?(f) }
+    end
+
+    # Get formatting configuration
+    def formatting_config
+      @config['formatting']
+    end
+
+    private
+
+    def load_configuration(options)
+      config = deep_dup(DEFAULT_CONFIG)
+
+      # Load from file if specified
+      if (file = options[:file] || options['file'])
+        file_config = YAML.load_file(file)
+        config = deep_merge(config, file_config)
+      end
+
+      # Override with options
+      options.delete(:file)
+      options.delete('file')
+      config = deep_merge(config, options) unless options.empty?
+
+      validate_config!(config)
+      config
+    end
+
+    def validate_config!(config)
+      line_length = config.dig('formatting', 'line_length')
+      raise ConfigError, 'line_length must be positive' if line_length && line_length <= 0
+
+      indent_width = config.dig('formatting', 'indent_width')
+      raise ConfigError, 'indent_width must be positive' if indent_width && indent_width <= 0
+    end
+
+    def deep_merge(hash1, hash2)
+      hash1.merge(hash2) do |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+
+    def deep_dup(hash)
+      hash.transform_values do |value|
+        value.is_a?(Hash) ? deep_dup(value) : value.dup
+      end
+    end
+  end
+end