rufio 0.9.0

data/lib/rufio/file_operations.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Rufio
+  # Handles file operations (move, copy, delete)
+  class FileOperations
+    # Operation result structure
+    # @return [Hash] { success: Boolean, message: String, count: Integer }
+    OperationResult = Struct.new(:success, :message, :count, :errors, keyword_init: true)
+
+    # Move files/directories to destination
+    # @param items [Array<String>] Item names to move
+    # @param source_directory [String] Source directory path
+    # @param destination [String] Destination directory path
+    # @return [OperationResult]
+    def move(items, source_directory, destination)
+      perform_operation(:move, items, source_directory, destination)
+    end
+
+    # Copy files/directories to destination
+    # @param items [Array<String>] Item names to copy
+    # @param source_directory [String] Source directory path
+    # @param destination [String] Destination directory path
+    # @return [OperationResult]
+    def copy(items, source_directory, destination)
+      perform_operation(:copy, items, source_directory, destination)
+    end
+
+    # Delete files/directories
+    # @param items [Array<String>] Item names to delete
+    # @param source_directory [String] Source directory path
+    # @return [OperationResult]
+    def delete(items, source_directory)
+      success_count = 0
+      error_messages = []
+
+      items.each do |item_name|
+        item_path = File.join(source_directory, item_name)
+
+        begin
+          # Check if file/directory exists
+          unless File.exist?(item_path)
+            error_messages << "#{item_name}: File not found"
+            next
+          end
+
+          is_directory = File.directory?(item_path)
+
+          if is_directory
+            FileUtils.rm_rf(item_path)
+          else
+            FileUtils.rm(item_path)
+          end
+
+          # Verify deletion
+          sleep(0.01) # Wait for file system sync
+          if File.exist?(item_path)
+            error_messages << "#{item_name}: Deletion failed"
+          else
+            success_count += 1
+          end
+        rescue StandardError => e
+          error_messages << "#{item_name}: #{e.message}"
+        end
+      end
+
+      OperationResult.new(
+        success: error_messages.empty?,
+        message: build_delete_message(success_count, items.length),
+        count: success_count,
+        errors: error_messages
+      )
+    end
+
+    # Create a new file
+    # @param directory [String] Directory path
+    # @param filename [String] File name
+    # @return [OperationResult]
+    def create_file(directory, filename)
+      # Validate filename
+      if filename.include?('/') || filename.include?('\\')
+        return OperationResult.new(
+          success: false,
+          message: 'Invalid filename: cannot contain path separators',
+          count: 0,
+          errors: []
+        )
+      end
+
+      file_path = File.join(directory, filename)
+
+      # Check if file already exists
+      if File.exist?(file_path)
+        return OperationResult.new(
+          success: false,
+          message: 'File already exists',
+          count: 0,
+          errors: []
+        )
+      end
+
+      begin
+        File.write(file_path, '')
+        OperationResult.new(
+          success: true,
+          message: "File created: #{filename}",
+          count: 1,
+          errors: []
+        )
+      rescue StandardError => e
+        OperationResult.new(
+          success: false,
+          message: "Creation error: #{e.message}",
+          count: 0,
+          errors: [e.message]
+        )
+      end
+    end
+
+    # Create a new directory
+    # @param parent_directory [String] Parent directory path
+    # @param dirname [String] Directory name
+    # @return [OperationResult]
+    def create_directory(parent_directory, dirname)
+      # Validate dirname
+      if dirname.include?('/') || dirname.include?('\\')
+        return OperationResult.new(
+          success: false,
+          message: 'Invalid directory name: cannot contain path separators',
+          count: 0,
+          errors: []
+        )
+      end
+
+      dir_path = File.join(parent_directory, dirname)
+
+      # Check if directory already exists
+      if File.exist?(dir_path)
+        return OperationResult.new(
+          success: false,
+          message: 'Directory already exists',
+          count: 0,
+          errors: []
+        )
+      end
+
+      begin
+        Dir.mkdir(dir_path)
+        OperationResult.new(
+          success: true,
+          message: "Directory created: #{dirname}",
+          count: 1,
+          errors: []
+        )
+      rescue StandardError => e
+        OperationResult.new(
+          success: false,
+          message: "Creation error: #{e.message}",
+          count: 0,
+          errors: [e.message]
+        )
+      end
+    end
+
+    private
+
+    # Perform move or copy operation
+    # @param operation [Symbol] :move or :copy
+    # @param items [Array<String>] Item names
+    # @param source_directory [String] Source directory path
+    # @param destination [String] Destination directory path
+    # @return [OperationResult]
+    def perform_operation(operation, items, source_directory, destination)
+      success_count = 0
+      error_messages = []
+
+      items.each do |item_name|
+        source_path = File.join(source_directory, item_name)
+        dest_path = File.join(destination, item_name)
+
+        begin
+          if File.exist?(dest_path)
+            error_messages << "#{item_name}: Already exists in destination"
+            next
+          end
+
+          case operation
+          when :move
+            FileUtils.mv(source_path, dest_path)
+          when :copy
+            if File.directory?(source_path)
+              FileUtils.cp_r(source_path, dest_path)
+            else
+              FileUtils.cp(source_path, dest_path)
+            end
+          end
+
+          success_count += 1
+        rescue StandardError => e
+          operation_name = operation == :move ? 'move' : 'copy'
+          error_messages << "#{item_name}: Failed to #{operation_name} (#{e.message})"
+        end
+      end
+
+      operation_name = operation == :move ? 'Moved' : 'Copied'
+      message = "#{operation_name} #{success_count} item(s)"
+      message += " (#{error_messages.length} failed)" unless error_messages.empty?
+
+      OperationResult.new(
+        success: error_messages.empty?,
+        message: message,
+        count: success_count,
+        errors: error_messages
+      )
+    end
+
+    # Build delete operation message
+    # @param success_count [Integer] Number of successfully deleted items
+    # @param total_count [Integer] Total number of items
+    # @return [String]
+    def build_delete_message(success_count, total_count)
+      if success_count == total_count
+        "Deleted #{success_count} item(s)"
+      else
+        failed_count = total_count - success_count
+        "#{success_count} deleted, #{failed_count} failed"
+      end
+    end
+  end
+end

data/lib/rufio/file_preview.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Rufio
+  class FilePreview
+    BINARY_THRESHOLD = 0.3  # treat as binary if 30% or more binary characters
+    DEFAULT_MAX_LINES = 50
+    MAX_LINE_LENGTH = 500
+
+    # Binary detection constants
+    BINARY_SAMPLE_SIZE = 512
+    PRINTABLE_CHAR_THRESHOLD = 32
+    CONTROL_CHAR_TAB = 9
+    CONTROL_CHAR_NEWLINE = 10
+    CONTROL_CHAR_CARRIAGE_RETURN = 13
+
+    def initialize
+      # future: hold syntax highlight settings etc.
+    end
+
+    def preview_file(file_path, max_lines: DEFAULT_MAX_LINES)
+      return error_response(ConfigLoader.message('file.not_found')) unless File.exist?(file_path)
+      return error_response(ConfigLoader.message('file.not_readable')) unless File.readable?(file_path)
+
+      file_size = File.size(file_path)
+      return empty_response if file_size == 0
+
+      begin
+        # binary file detection
+        sample = File.binread(file_path, [file_size, BINARY_SAMPLE_SIZE].min)
+        return binary_response(file_path) if binary_file?(sample)
+
+        # process as text file
+        lines = read_text_file(file_path, max_lines)
+        file_type = determine_file_type(file_path)
+        
+        {
+          type: file_type[:type],
+          language: file_type[:language],
+          lines: lines[:content],
+          truncated: lines[:truncated],
+          size: file_size,
+          modified: File.mtime(file_path),
+          encoding: lines[:encoding]
+        }
+      rescue => e
+        error_response("#{ConfigLoader.message('file.read_error')}: #{e.message}")
+      end
+    end
+
+    private
+
+    def binary_file?(sample)
+      return false if sample.empty?
+
+      allowed_control_chars = [CONTROL_CHAR_TAB, CONTROL_CHAR_NEWLINE, CONTROL_CHAR_CARRIAGE_RETURN]
+      binary_chars = sample.bytes.count { |byte| byte < PRINTABLE_CHAR_THRESHOLD && !allowed_control_chars.include?(byte) }
+      (binary_chars.to_f / sample.bytes.length) > BINARY_THRESHOLD
+    end
+
+    def read_text_file(file_path, max_lines)
+      lines = []
+      truncated = false
+      encoding = "UTF-8"
+
+      File.open(file_path, "r:UTF-8") do |file|
+        file.each_line.with_index do |line, index|
+          break if index >= max_lines
+          
+          # truncate too long lines
+          if line.length > MAX_LINE_LENGTH
+            line = line[0...MAX_LINE_LENGTH] + "..."
+          end
+          
+          lines << line.chomp
+        end
+        
+        # check if there are more lines to read
+        truncated = !file.eof?
+      end
+
+      {
+        content: lines,
+        truncated: truncated,
+        encoding: encoding
+      }
+    rescue Encoding::InvalidByteSequenceError
+      # try Shift_JIS if UTF-8 fails
+      begin
+        lines = []
+        File.open(file_path, "r:Shift_JIS:UTF-8") do |file|
+          file.each_line.with_index do |line, index|
+            break if index >= max_lines
+            lines << line.chomp
+          end
+          truncated = !file.eof?
+        end
+        {
+          content: lines,
+          truncated: truncated,
+          encoding: "Shift_JIS"
+        }
+      rescue
+        {
+          content: ["(#{ConfigLoader.message('file.encoding_error')})"],
+          truncated: false,
+          encoding: "unknown"
+        }
+      end
+    end
+
+    def determine_file_type(file_path)
+      extension = File.extname(file_path).downcase
+      
+      case extension
+      when ".rb"
+        { type: "code", language: "ruby" }
+      when ".py"
+        { type: "code", language: "python" }
+      when ".js", ".mjs"
+        { type: "code", language: "javascript" }
+      when ".ts"
+        { type: "code", language: "typescript" }
+      when ".html", ".htm"
+        { type: "code", language: "html" }
+      when ".css"
+        { type: "code", language: "css" }
+      when ".json"
+        { type: "code", language: "json" }
+      when ".yml", ".yaml"
+        { type: "code", language: "yaml" }
+      when ".md", ".markdown"
+        { type: "code", language: "markdown" }
+      when ".txt", ".log"
+        { type: "text", language: nil }
+      when ".zip", ".tar", ".gz", ".bz2", ".xz", ".7z"
+        { type: "archive", language: nil }
+      when ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"
+        { type: "image", language: nil }
+      when ".pdf"
+        { type: "document", language: nil }
+      when ".exe", ".dmg", ".deb", ".rpm"
+        { type: "executable", language: nil }
+      else
+        { type: "text", language: nil }
+      end
+    end
+
+    def empty_response
+      {
+        type: "empty",
+        lines: [],
+        size: 0,
+        modified: File.mtime(""),
+        encoding: "UTF-8"
+      }
+    rescue
+      {
+        type: "empty",
+        lines: [],
+        size: 0,
+        modified: Time.now,
+        encoding: "UTF-8"
+      }
+    end
+
+    def binary_response(file_path = nil)
+      file_size = file_path ? File.size(file_path) : 0
+      modified_time = file_path ? File.mtime(file_path) : Time.now
+      
+      {
+        type: "binary",
+        message: "#{ConfigLoader.message('file.binary_file')} - #{ConfigLoader.message('file.cannot_preview')}",
+        lines: ["(#{ConfigLoader.message('file.binary_file')})"],
+        size: file_size,
+        modified: modified_time,
+        encoding: "binary"
+      }
+    rescue => e
+      {
+        type: "binary",
+        message: "#{ConfigLoader.message('file.binary_file')} - #{ConfigLoader.message('file.cannot_preview')}",
+        lines: ["(#{ConfigLoader.message('file.binary_file')})"],
+        size: 0,
+        modified: Time.now,
+        encoding: "binary"
+      }
+    end
+
+    def error_response(message)
+      {
+        type: "error",
+        message: message,
+        lines: ["#{ConfigLoader.message('file.error_prefix')}: #{message}"],
+        size: 0,
+        modified: Time.now,
+        encoding: "UTF-8"
+      }
+    end
+  end
+end

data/lib/rufio/filter_manager.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Rufio
+  # Manages filtering of directory entries
+  class FilterManager
+    attr_reader :filter_query, :filter_mode
+
+    def initialize
+      @filter_mode = false
+      @filter_query = ''
+      @original_entries = []
+      @filtered_entries = []
+    end
+
+    # Start filter mode with the given entries
+    # @param entries [Array<Hash>] Directory entries to filter
+    def start_filter_mode(entries)
+      @filter_mode = true
+      @filter_query = ''
+      @original_entries = entries.dup
+      @filtered_entries = @original_entries.dup
+      true
+    end
+
+    # Handle filter input character
+    # @param key [String] Input key
+    # @return [Symbol] :exit_clear, :exit_keep, :continue, or :backspace_exit
+    def handle_filter_input(key)
+      case key
+      when "\e" # ESC - clear filter and exit
+        :exit_clear
+      when "\r", "\n" # Enter - keep filter and exit
+        :exit_keep
+      when "\u007f", "\b" # Backspace
+        if @filter_query.length > 0
+          @filter_query = @filter_query[0...-1]
+          apply_filter
+          :continue
+        else
+          :backspace_exit
+        end
+      else
+        # Printable characters (alphanumeric, symbols, Japanese, etc.)
+        if key.length == 1 && key.ord >= 32 && key.ord < 127 # ASCII printable
+          @filter_query += key
+          apply_filter
+          :continue
+        elsif key.bytesize > 1 # Multi-byte characters (Japanese, etc.)
+          @filter_query += key
+          apply_filter
+          :continue
+        else
+          # Ignore other keys (Ctrl+c, etc.)
+          :continue
+        end
+      end
+    end
+
+    # Apply filter to entries
+    # @return [Array<Hash>] Filtered entries
+    def apply_filter
+      if @filter_query.empty?
+        @filtered_entries = @original_entries.dup
+      else
+        query_downcase = @filter_query.downcase
+        @filtered_entries = @original_entries.select do |entry|
+          entry[:name].downcase.include?(query_downcase)
+        end
+      end
+      @filtered_entries
+    end
+
+    # Clear filter mode
+    def clear_filter
+      @filter_mode = false
+      @filter_query = ''
+      @filtered_entries = []
+      @original_entries = []
+    end
+
+    # Exit filter mode while keeping the filter
+    def exit_filter_mode_keep_filter
+      @filter_mode = false
+      # Keep @filter_query and @filtered_entries
+    end
+
+    # Check if filter is active
+    # @return [Boolean]
+    def filter_active?
+      @filter_mode || !@filter_query.empty?
+    end
+
+    # Get filtered entries
+    # @return [Array<Hash>]
+    def filtered_entries
+      @filtered_entries
+    end
+
+    # Update original entries (e.g., after directory refresh)
+    # @param entries [Array<Hash>] New entries
+    def update_entries(entries)
+      @original_entries = entries.dup
+      apply_filter if filter_active?
+    end
+
+    # Restart filter mode with existing query
+    # @param entries [Array<Hash>] Directory entries
+    def restart_filter_mode(entries)
+      @filter_mode = true
+      @original_entries = entries.dup if @original_entries.empty?
+      apply_filter
+    end
+  end
+end