beniya 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e920583f6645634b10889369089e81e114db44a01be5b0baa177dc8279ca1bc
-  data.tar.gz: 7c3ec6afa823e45700e26fa02c50076cbdc268d136d11403599a6befc858aebf
+  metadata.gz: c82332a61b93f69a73371f2f9d4aa4488d04fc45b12f5db958bd0597476a8550
+  data.tar.gz: 5f689d6a5fb75451d3f8b75ff9f09343f342d80e451b19de39e0a024fdf688dc
 SHA512:
-  metadata.gz: bd20c3f4392c8d65aec9bc2e3261701d5f091e6baa73012e779f7417e0d2ea1bc8fe10ea4cac99117b70f82a70b68de0638ec05b390e97436c67691ac11bef90
-  data.tar.gz: b28475770533a0d8989eab47f72bf63a83e15546fa4e11a43027e45885c07b491498c0bd83296fe9e67a4568c3c1774f96b8b6ff9bd98d1ea6f2b9d185d4ea30
+  metadata.gz: f8e95d8c526f42619d798107a447b103a592005699a06392c61bf05919df0fe090c2066dc427aa6e047d35ec8d19285f11cd6696bf9ff4aa96d810b9bb465a82
+  data.tar.gz: 6baebd7f5d4c288589d0f1a88b7ed871f0d344529787cc42356ed741c51ca47aa8758c7f25dd4dc9e31ac3804180ea1e23ae14e80642ffb7ee972e7622aed32e

data/lib/beniya/application.rb

@@ -2,6 +2,9 @@
 
 module Beniya
   class Application
+    # Error display constants
+    BACKTRACE_LINES = 5  # Number of backtrace lines to show
+
     def initialize(start_directory = Dir.pwd)
       @start_directory = File.expand_path(start_directory)
       # Load configuration including language settings
@@ -22,7 +25,7 @@ module Beniya
       puts "\n\n#{ConfigLoader.message('app.interrupted')}"
     rescue StandardError => e
       puts "\n#{ConfigLoader.message('app.error_occurred')}: #{e.message}"
-      puts e.backtrace.first(5).join("\n")
+      puts e.backtrace.first(BACKTRACE_LINES).join("\n")
     end
   end
 end

data/lib/beniya/bookmark_manager.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative 'bookmark'
+require_relative 'config_loader'
+
+module Beniya
+  # Manages bookmark operations with interactive UI
+  class BookmarkManager
+    def initialize(bookmark = nil, dialog_renderer = nil)
+      @bookmark = bookmark || Bookmark.new
+      @dialog_renderer = dialog_renderer
+    end
+
+    # Show bookmark menu and handle user selection
+    # @param current_path [String] Current directory path
+    # @return [Symbol, nil] Action to perform (:navigate, :add, :list, :remove, :cancel)
+    def show_menu(current_path)
+      return :cancel unless @dialog_renderer
+
+      title = 'Bookmark Menu'
+      content_lines = [
+        '',
+        '[A]dd current directory to bookmarks',
+        '[L]ist bookmarks',
+        '[R]emove bookmark',
+        '',
+        'Press 1-9 to go to bookmark directly',
+        '',
+        'Press any other key to cancel'
+      ]
+
+      dialog_width = 45
+      dialog_height = 4 + content_lines.length
+      x, y = @dialog_renderer.calculate_center(dialog_width, dialog_height)
+
+      @dialog_renderer.draw_floating_window(x, y, dialog_width, dialog_height, title, content_lines, {
+                                               border_color: "\e[34m", # Blue
+                                               title_color: "\e[1;34m",   # Bold blue
+                                               content_color: "\e[37m"    # White
+                                             })
+
+      # Wait for key input
+      loop do
+        input = STDIN.getch.downcase
+
+        case input
+        when 'a'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :add, path: current_path }
+        when 'l'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :list }
+        when 'r'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :remove }
+        when '1', '2', '3', '4', '5', '6', '7', '8', '9'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :navigate, number: input.to_i }
+        else
+          # Cancel
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :cancel }
+        end
+      end
+    end
+
+    # Add a bookmark interactively
+    # @param path [String] Path to bookmark
+    # @return [Boolean] Success status
+    def add_interactive(path)
+      print ConfigLoader.message('bookmark.input_name') || 'Enter bookmark name: '
+      name = STDIN.gets.chomp
+      return false if name.empty?
+
+      if @bookmark.add(path, name)
+        puts "\n#{ConfigLoader.message('bookmark.added') || 'Bookmark added'}: #{name}"
+        true
+      else
+        puts "\n#{ConfigLoader.message('bookmark.add_failed') || 'Failed to add bookmark'}"
+        false
+      end
+    end
+
+    # Remove a bookmark interactively
+    # @return [Boolean] Success status
+    def remove_interactive
+      bookmarks = @bookmark.list
+
+      if bookmarks.empty?
+        puts "\n#{ConfigLoader.message('bookmark.no_bookmarks') || 'No bookmarks found'}"
+        return false
+      end
+
+      puts "\nBookmarks:"
+      bookmarks.each_with_index do |bookmark, index|
+        puts "  #{index + 1}. #{bookmark[:name]} (#{bookmark[:path]})"
+      end
+
+      print ConfigLoader.message('bookmark.input_number') || 'Enter number to remove: '
+      input = STDIN.gets.chomp
+      number = input.to_i
+
+      if number > 0 && number <= bookmarks.length
+        bookmark_to_remove = bookmarks[number - 1]
+        if @bookmark.remove(bookmark_to_remove[:name])
+          puts "\n#{ConfigLoader.message('bookmark.removed') || 'Bookmark removed'}: #{bookmark_to_remove[:name]}"
+          true
+        else
+          puts "\n#{ConfigLoader.message('bookmark.remove_failed') || 'Failed to remove bookmark'}"
+          false
+        end
+      else
+        puts "\n#{ConfigLoader.message('bookmark.invalid_number') || 'Invalid number'}"
+        false
+      end
+    end
+
+    # List all bookmarks interactively
+    # @return [Boolean] Success status
+    def list_interactive
+      bookmarks = @bookmark.list
+
+      if bookmarks.empty?
+        puts "\n#{ConfigLoader.message('bookmark.no_bookmarks') || 'No bookmarks found'}"
+        return false
+      end
+
+      puts "\nBookmarks:"
+      bookmarks.each_with_index do |bookmark, index|
+        puts "  #{index + 1}. #{bookmark[:name]} (#{bookmark[:path]})"
+      end
+
+      true
+    end
+
+    # Get bookmark by number
+    # @param number [Integer] Bookmark number (1-9)
+    # @return [Hash, nil] Bookmark hash with :path and :name
+    def find_by_number(number)
+      @bookmark.find_by_number(number)
+    end
+
+    # Validate bookmark path exists
+    # @param bookmark [Hash] Bookmark hash
+    # @return [Boolean]
+    def path_exists?(bookmark)
+      return false unless bookmark
+
+      Dir.exist?(bookmark[:path])
+    end
+
+    # Get all bookmarks
+    # @return [Array<Hash>]
+    def list
+      @bookmark.list
+    end
+
+    # Add bookmark
+    # @param path [String] Path to bookmark
+    # @param name [String] Bookmark name
+    # @return [Boolean] Success status
+    def add(path, name)
+      @bookmark.add(path, name)
+    end
+
+    # Remove bookmark
+    # @param name [String] Bookmark name
+    # @return [Boolean] Success status
+    def remove(name)
+      @bookmark.remove(name)
+    end
+  end
+end

data/lib/beniya/dialog_renderer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'text_utils'
+
+module Beniya
+  # Renders floating dialog windows in the terminal
+  class DialogRenderer
+    include TextUtils
+
+    # Draw a floating window with title, content, and customizable colors
+    # @param x [Integer] X position (column)
+    # @param y [Integer] Y position (row)
+    # @param width [Integer] Window width
+    # @param height [Integer] Window height
+    # @param title [String, nil] Window title (optional)
+    # @param content_lines [Array<String>] Content lines to display
+    # @param options [Hash] Customization options
+    # @option options [String] :border_color Border color ANSI code
+    # @option options [String] :title_color Title color ANSI code
+    # @option options [String] :content_color Content color ANSI code
+    def draw_floating_window(x, y, width, height, title, content_lines, options = {})
+      # Default options
+      border_color = options[:border_color] || "\e[37m"  # White
+      title_color = options[:title_color] || "\e[1;33m"  # Bold yellow
+      content_color = options[:content_color] || "\e[37m" # White
+      reset_color = "\e[0m"
+
+      # Draw top border
+      print "\e[#{y};#{x}H#{border_color}┌#{'─' * (width - 2)}┐#{reset_color}"
+
+      # Draw title line if title exists
+      if title
+        title_width = TextUtils.display_width(title)
+        title_padding = (width - 2 - title_width) / 2
+        padded_title = ' ' * title_padding + title
+        title_line = TextUtils.pad_string_to_width(padded_title, width - 2)
+        print "\e[#{y + 1};#{x}H#{border_color}│#{title_color}#{title_line}#{border_color}│#{reset_color}"
+
+        # Draw title separator
+        print "\e[#{y + 2};#{x}H#{border_color}├#{'─' * (width - 2)}┤#{reset_color}"
+        content_start_y = y + 3
+      else
+        content_start_y = y + 1
+      end
+
+      # Draw content lines
+      content_height = title ? height - 4 : height - 2
+      content_lines.each_with_index do |line, index|
+        break if index >= content_height
+
+        line_y = content_start_y + index
+        line_content = TextUtils.pad_string_to_width(line, width - 2)
+        print "\e[#{line_y};#{x}H#{border_color}│#{content_color}#{line_content}#{border_color}│#{reset_color}"
+      end
+
+      # Fill remaining lines with empty space
+      remaining_lines = content_height - content_lines.length
+      remaining_lines.times do |i|
+        line_y = content_start_y + content_lines.length + i
+        empty_line = ' ' * (width - 2)
+        print "\e[#{line_y};#{x}H#{border_color}│#{empty_line}│#{reset_color}"
+      end
+
+      # Draw bottom border
+      bottom_y = y + height - 1
+      print "\e[#{bottom_y};#{x}H#{border_color}└#{'─' * (width - 2)}┘#{reset_color}"
+    end
+
+    # Calculate center position for a window
+    # @param content_width [Integer] Window width
+    # @param content_height [Integer] Window height
+    # @return [Array<Integer>] [x, y] position
+    def calculate_center(content_width, content_height)
+      # Get terminal size
+      console = IO.console
+      if console
+        screen_width, screen_height = console.winsize.reverse
+      else
+        screen_width = 80
+        screen_height = 24
+      end
+
+      # Calculate center position
+      x = [(screen_width - content_width) / 2, 1].max
+      y = [(screen_height - content_height) / 2, 1].max
+
+      [x, y]
+    end
+
+    # Clear a rectangular area on the screen
+    # @param x [Integer] X position
+    # @param y [Integer] Y position
+    # @param width [Integer] Area width
+    # @param height [Integer] Area height
+    def clear_area(x, y, width, height)
+      height.times do |row|
+        print "\e[#{y + row};#{x}H#{' ' * width}"
+      end
+    end
+
+    # Calculate appropriate dimensions for content
+    # @param content_lines [Array<String>] Content lines
+    # @param options [Hash] Options
+    # @option options [String, nil] :title Window title
+    # @option options [Integer] :min_width Minimum width (default: 30)
+    # @option options [Integer] :max_width Maximum width (default: 80)
+    # @return [Array<Integer>] [width, height]
+    def calculate_dimensions(content_lines, options = {})
+      title = options[:title]
+      min_width = options[:min_width] || 30
+      max_width = options[:max_width] || 80
+
+      # Calculate required width based on content
+      max_content_width = content_lines.map { |line| TextUtils.display_width(line) }.max || 0
+      title_width = title ? TextUtils.display_width(title) : 0
+      required_width = [max_content_width, title_width].max + 4 # +4 for borders and padding
+
+      width = [[required_width, min_width].max, max_width].min
+
+      # Calculate height: borders + title (if exists) + separator + content
+      height = content_lines.length + 2 # +2 for top and bottom borders
+      height += 2 if title # +2 for title line and separator
+
+      [width, height]
+    end
+  end
+end

data/lib/beniya/file_operations.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Beniya
+  # 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/beniya/file_preview.rb

@@ -6,6 +6,13 @@ module Beniya
     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
@@ -19,7 +26,7 @@ module Beniya
 
       begin
         # binary file detection
-        sample = File.binread(file_path, [file_size, 512].min)
+        sample = File.binread(file_path, [file_size, BINARY_SAMPLE_SIZE].min)
         return binary_response(file_path) if binary_file?(sample)
 
         # process as text file
@@ -44,8 +51,9 @@ module Beniya
 
     def binary_file?(sample)
       return false if sample.empty?
-      
-      binary_chars = sample.bytes.count { |byte| byte < 32 && ![9, 10, 13].include?(byte) }
+
+      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