rfmt 0.1.0 → 0.2.2

data/lib/rfmt/cli.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'thor'
+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'
+
+    desc 'format [FILES]', 'Format Ruby files'
+    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) (cache hit)", :blue if skipped.positive? && options[:verbose]
+      end
+
+      if files.empty?
+        say 'All files are already formatted', :green
+        return
+      end
+
+      say "Formatting #{files.size} file(s)...", :blue if options[:verbose]
+
+      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])
+            say "Formatted #{result[:file]}", :green if options[:verbose]
+
+            # Update cache after successful write
+            cache&.mark_formatted(result[:file])
+          else
+            puts result[:formatted]
+          end
+        else
+          say "#{result[:file]} already formatted", :blue if options[:verbose]
+
+          # Update cache even if no changes (file was checked)
+          cache&.mark_formatted(result[:file])
+        end
+      end
+
+      # Save cache to disk
+      cache&.save
+
+      # Summary
+      say "\n#{results.size} file(s) processed", :blue if options[:verbose]
+      say "#{changed_count} file(s) changed", :yellow if changed_count.positive? && options[:verbose]
+      say "#{error_count} error(s)", :red if error_count.positive?
+
+      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

data/lib/rfmt/prism_bridge.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'json'
+require_relative 'prism_node_extractor'
+
+module Rfmt
+  # PrismBridge provides the Ruby-side integration with the Prism parser
+  # It parses Ruby source code and converts the AST to a JSON format
+  # that can be consumed by the Rust formatter
+  class PrismBridge
+    extend PrismNodeExtractor
+
+    class ParseError < StandardError; end
+
+    # Parse Ruby source code and return serialized AST
+    # @param source [String] Ruby source code to parse
+    # @return [String] JSON-serialized AST with comments
+    # @raise [ParseError] if parsing fails
+    def self.parse(source)
+      result = Prism.parse(source)
+
+      handle_parse_errors(result) if result.failure?
+
+      serialize_ast_with_comments(result)
+    end
+
+    # Parse Ruby source code from a file
+    # @param file_path [String] Path to Ruby file
+    # @return [String] JSON-serialized AST
+    # @raise [ParseError] if parsing fails
+    # @raise [Errno::ENOENT] if file doesn't exist
+    def self.parse_file(file_path)
+      source = File.read(file_path)
+      parse(source)
+    rescue Errno::ENOENT
+      raise ParseError, "File not found: #{file_path}"
+    end
+
+    # Handle parsing errors from Prism
+    def self.handle_parse_errors(result)
+      errors = result.errors.map do |error|
+        {
+          line: error.location.start_line,
+          column: error.location.start_column,
+          message: error.message
+        }
+      end
+
+      error_messages = errors.map do |err|
+        "#{err[:line]}:#{err[:column]}: #{err[:message]}"
+      end.join("\n")
+
+      raise ParseError, "Parse errors:\n#{error_messages}"
+    end
+
+    # Serialize the Prism AST to JSON
+    def self.serialize_ast(node)
+      JSON.generate(convert_node(node))
+    end
+
+    # Serialize the Prism AST with comments to JSON
+    def self.serialize_ast_with_comments(result)
+      comments = result.comments.map do |comment|
+        {
+          comment_type: comment.class.name.split('::').last.downcase.gsub('comment', ''),
+          location: {
+            start_line: comment.location.start_line,
+            start_column: comment.location.start_column,
+            end_line: comment.location.end_line,
+            end_column: comment.location.end_column,
+            start_offset: comment.location.start_offset,
+            end_offset: comment.location.end_offset
+          },
+          text: comment.location.slice,
+          position: 'leading' # Default position, will be refined by Rust
+        }
+      end
+
+      JSON.generate({
+                      ast: convert_node(result.value),
+                      comments: comments
+                    })
+    end
+
+    # Convert a Prism node to our internal representation
+    def self.convert_node(node)
+      return nil if node.nil?
+
+      {
+        node_type: node_type_name(node),
+        location: extract_location(node),
+        children: extract_children(node),
+        metadata: extract_metadata(node),
+        comments: extract_comments(node),
+        formatting: extract_formatting(node)
+      }
+    end
+
+    # Get the node type name from Prism node
+    def self.node_type_name(node)
+      # Prism node class names are like "Prism::ProgramNode"
+      # We want just "program_node" in snake_case
+      node.class.name.split('::').last.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    end
+
+    # Extract location information from node
+    def self.extract_location(node)
+      loc = node.location
+      {
+        start_line: loc.start_line,
+        start_column: loc.start_column,
+        end_line: loc.end_line,
+        end_column: loc.end_column,
+        start_offset: loc.start_offset,
+        end_offset: loc.end_offset
+      }
+    end
+
+    # Extract child nodes
+    def self.extract_children(node)
+      children = []
+
+      begin
+        # Different node types have different child accessors
+        children = case node
+                   when Prism::ProgramNode
+                     node.statements ? node.statements.body : []
+                   when Prism::StatementsNode
+                     node.body || []
+                   when Prism::ClassNode
+                     [
+                       node.constant_path,
+                       node.superclass,
+                       node.body
+                     ].compact
+                   when Prism::ModuleNode
+                     [
+                       node.constant_path,
+                       node.body
+                     ].compact
+                   when Prism::DefNode
+                     params = if node.parameters
+                                node.parameters.child_nodes.compact
+                              else
+                                []
+                              end
+                     params + [node.body].compact
+                   when Prism::CallNode
+                     result = []
+                     result << node.receiver if node.receiver
+                     result.concat(node.arguments.child_nodes.compact) if node.arguments
+                     result << node.block if node.block
+                     result
+                   when Prism::IfNode, Prism::UnlessNode
+                     [
+                       node.predicate,
+                       node.statements,
+                       node.consequent
+                     ].compact
+                   when Prism::ArrayNode
+                     node.elements || []
+                   when Prism::HashNode
+                     node.elements || []
+                   when Prism::BlockNode
+                     params = if node.parameters
+                                node.parameters.child_nodes.compact
+                              else
+                                []
+                              end
+                     params + [node.body].compact
+                   else
+                     # For unknown types, try to get child nodes if they exist
+                     []
+                   end
+      rescue StandardError => e
+        # Log warning in debug mode but continue processing
+        warn "Warning: Failed to extract children from #{node.class}: #{e.message}" if $DEBUG
+        children = []
+      end
+
+      children.compact.map { |child| convert_node(child) }
+    end
+
+    # Extract metadata specific to node type
+    def self.extract_metadata(node)
+      metadata = {}
+
+      case node
+      when Prism::ClassNode
+        if (name = extract_node_name(node))
+          metadata['name'] = name
+        end
+        if (superclass = extract_superclass_name(node))
+          metadata['superclass'] = superclass
+        end
+      when Prism::ModuleNode
+        if (name = extract_node_name(node))
+          metadata['name'] = name
+        end
+      when Prism::DefNode
+        if (name = extract_node_name(node))
+          metadata['name'] = name
+        end
+        metadata['parameters_count'] = extract_parameter_count(node).to_s
+      when Prism::CallNode
+        if (name = extract_node_name(node))
+          metadata['name'] = name
+        end
+        if (message = extract_message_name(node))
+          metadata['message'] = message
+        end
+      when Prism::StringNode
+        if (content = extract_string_content(node))
+          metadata['content'] = content
+        end
+      when Prism::IntegerNode
+        if (value = extract_literal_value(node))
+          metadata['value'] = value
+        end
+      when Prism::FloatNode
+        if (value = extract_literal_value(node))
+          metadata['value'] = value
+        end
+      when Prism::SymbolNode
+        if (value = extract_literal_value(node))
+          metadata['value'] = value
+        end
+      end
+
+      metadata
+    end
+
+    # Extract comments associated with the node
+    def self.extract_comments(_node)
+      # Prism attaches comments to the parse result, not individual nodes
+      # For Phase 1, we'll return empty array and implement in Phase 2
+      []
+    end
+
+    # Extract formatting information
+    def self.extract_formatting(node)
+      loc = node.location
+      {
+        indent_level: 0, # Will be calculated during formatting
+        needs_blank_line_before: false,
+        needs_blank_line_after: false,
+        preserve_newlines: false,
+        multiline: loc.start_line != loc.end_line,
+        original_formatting: nil # Can store original text if needed
+      }
+    end
+  end
+end

data/lib/rfmt/prism_node_extractor.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Rfmt
+  # PrismNodeExtractor provides safe methods to extract information from Prism nodes
+  # This module encapsulates the logic for accessing Prism node properties,
+  # making the code resilient to Prism API changes
+  module PrismNodeExtractor
+    # Extract the name from a node
+    # @param node [Prism::Node] The node to extract name from
+    # @return [String, nil] The node name or nil if not available
+    def extract_node_name(node)
+      return nil unless node.respond_to?(:name)
+
+      node.name.to_s
+    end
+
+    # Extract superclass name from a class node
+    # @param class_node [Prism::ClassNode] The class node
+    # @return [String, nil] The superclass name or nil if not available
+    def extract_superclass_name(class_node)
+      return nil unless class_node.respond_to?(:superclass)
+
+      sc = class_node.superclass
+      return nil if sc.nil?
+
+      case sc
+      when Prism::ConstantReadNode
+        sc.name.to_s
+      when Prism::ConstantPathNode
+        # Try full_name first, fall back to name
+        if sc.respond_to?(:full_name)
+          sc.full_name.to_s
+        elsif sc.respond_to?(:name)
+          sc.name.to_s
+        else
+          sc.to_s
+        end
+      else
+        sc.to_s
+      end
+    end
+
+    # Extract parameter count from a method definition node
+    # @param def_node [Prism::DefNode] The method definition node
+    # @return [Integer] The number of parameters (0 if none)
+    def extract_parameter_count(def_node)
+      return 0 unless def_node.respond_to?(:parameters)
+      return 0 if def_node.parameters.nil?
+      return 0 unless def_node.parameters.respond_to?(:child_nodes)
+
+      def_node.parameters.child_nodes.compact.length
+    end
+
+    # Extract message name from a call node
+    # @param call_node [Prism::CallNode] The call node
+    # @return [String, nil] The message name or nil if not available
+    def extract_message_name(call_node)
+      return nil unless call_node.respond_to?(:message)
+
+      call_node.message.to_s
+    end
+
+    # Extract content from a string node
+    # @param string_node [Prism::StringNode] The string node
+    # @return [String, nil] The string content or nil if not available
+    def extract_string_content(string_node)
+      return nil unless string_node.respond_to?(:content)
+
+      string_node.content
+    end
+
+    # Extract value from a literal node (Integer, Float, Symbol)
+    # @param node [Prism::Node] The literal node
+    # @return [String, nil] The value as string or nil if not available
+    def extract_literal_value(node)
+      return nil unless node.respond_to?(:value)
+
+      node.value.to_s
+    end
+  end
+end