rfd 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8531a85da40abf299418a5db10c44a8df36510c
+  data.tar.gz: 20dd4b8c0560d21f506a41ad64aeec7fbacc0c35
+SHA512:
+  metadata.gz: 6a045b387ff889e51b0e0af604f6248849f0e160bff2b41d5ee4da3b3db4de93d35422f84aa1dbdf0fc979db08cc2ce9c68bdd9f345c7caa90c3cf524e18b119
+  data.tar.gz: 4b4701049e945298a437cdf42616f71e3b7ad7b556c6c244c16e8d38cab2c8957d6e8c5538799853bf58f56fa48b28c2ee424565059264ba0c0b8be442fb6ad9

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rfd.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Akira Matsuda
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# rfd (Ruby on Files and Directories)
+
+rfd is a terminal based File explorer, inpsired by the legendary freesoft MS-DOS filer, "FD".
+
+## Installation
+
+    % gem install rfd
+
+## Requirements
+
+* Ruby 2.0, Ruby 2.1
+* NCurses
+* (FFI)
+
+## Tested environment
+
+Max OSX Snow Leopard
+
+## Usage
+
+Open up your terminal and type in:
+
+    % rfd
+
+You can command rfd by pressing some chars on your keyboard, just like Vim.
+
+All available commands are defined here. https://github.com/amatsuda/rfd/tree/master/lib/rfd/commands.rb
+
+## Contributing
+
+Send me your pull requests here. https://github.com/amatsuda/rfd

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rfd

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../lib/rfd', __FILE__)
+
+rfd = Rfd.start ARGV[0] || '.'
+rfd.run

data/lib/rfd.rb

@@ -0,0 +1,456 @@
+require 'ffi-ncurses'
+Curses = FFI::NCurses
+require 'fileutils'
+require_relative 'rfd/commands'
+require_relative 'rfd/item'
+require_relative 'rfd/windows'
+
+module Rfd
+  VERSION = Gem.loaded_specs['rfd'].version.to_s
+
+  # :nodoc:
+  def self.init_curses
+    Curses.initscr
+    Curses.raw
+    Curses.noecho
+    Curses.curs_set 0
+    Curses.keypad Curses.stdscr, true
+    Curses.start_color
+
+    [Curses::COLOR_WHITE, Curses::COLOR_CYAN, Curses::COLOR_MAGENTA, Curses::COLOR_GREEN, Curses::COLOR_RED].each do |c|
+      Curses.init_pair c, c, Curses::COLOR_BLACK
+    end
+  end
+
+  # Start the app here!
+  #
+  # ==== Parameters
+  # * +dir+ - The initial directory.
+  def self.start(dir = '.')
+    init_curses
+    rfd = Rfd::Controller.new
+    rfd.cd dir
+    rfd.ls
+    rfd
+  end
+
+  class Controller
+    include Rfd::Commands
+
+    attr_reader :header_l, :header_r, :main, :command_line, :items, :displayed_items, :current_row, :current_page, :current_dir
+
+    # :nodoc:
+    def initialize
+      @main = MainWindow.new
+      @header_l = HeaderLeftWindow.new
+      @header_r = HeaderRightWindow.new
+      @command_line = CommandLineWindow.new
+    end
+
+    # The main loop.
+    def run
+      loop do
+        begin
+          case (c = Curses.getch)
+          when Curses::KEY_RETURN
+            enter
+          when Curses::KEY_ESCAPE
+            q
+          when 32  # space
+            space
+          when 127  # DEL
+            del
+          when Curses::KEY_DOWN
+            j
+          when Curses::KEY_UP
+            k
+          when Curses::KEY_LEFT
+            h
+          when Curses::KEY_RIGHT
+            l
+          when Curses::KEY_CTRL_A..Curses::KEY_CTRL_Z
+            chr = ((c - 1 + 65) ^ 0b0100000).chr
+            public_send "ctrl_#{chr}" if respond_to?("ctrl_#{chr}")
+          when 0..255
+            if respond_to? c.chr
+              public_send c.chr
+            else
+              debug "key: #{c}" if ENV['DEBUG']
+            end
+          else
+            debug "key: #{c}" if ENV['DEBUG']
+          end
+        rescue StopIteration
+          raise
+        rescue => e
+          command_line.show_error e.to_s
+          raise if ENV['DEBUG']
+        end
+      end
+    ensure
+      Curses.endwin
+    end
+
+    # Change the number of columns in the main window.
+    def spawn_panes(num)
+      main.spawn_panes num
+      @current_row = @current_page = 0
+    end
+
+    # The file or directory on which the cursor is on.
+    def current_item
+      items[current_row]
+    end
+
+    # * marked files and directories.
+    def marked_items
+      items.select(&:marked?)
+    end
+
+    # Marked files and directories or Array(the current file or directory).
+    #
+    # . and .. will not be included.
+    def selected_items
+      ((m = marked_items).any? ? m : Array(current_item)).reject {|i| %w(. ..).include? i.name}
+    end
+
+    # Move the cursor to specified row.
+    #
+    # The main window and the headers will be updated reflecting the displayed files and directories.
+    # The row number can be out of range of the current page.
+    def move_cursor(row = nil)
+      if row
+        page, item_index_in_page = row.divmod max_items
+        if page != current_page
+          switch_page page
+        else
+          if (prev_item = items[current_row])
+            main.draw_item prev_item
+          end
+        end
+        main.activate_pane item_index_in_page / maxy
+        @current_row = row
+      else
+        @current_row = 0
+      end
+
+      item = items[current_row]
+      main.draw_item item, current: true
+
+      header_l.draw_current_file_info item
+      header_l.wrefresh
+    end
+
+    # Change the current directory.
+    def cd(dir, pushd: true)
+      target = File.expand_path(dir.is_a?(Rfd::Item) ? dir.path : dir.start_with?('/') ? dir : current_dir ? File.join(current_dir, dir) : dir)
+      if File.readable? target
+        Dir.chdir target
+        (@dir_history ||= []) << current_dir if current_dir && pushd
+        @current_dir, @current_page, @current_row = target, 0, nil
+        main.activate_pane 0
+      end
+    end
+
+    # cd to the previous directory.
+    def popd
+      if defined?(@dir_history) && @dir_history.any?
+        cd @dir_history.pop, pushd: false
+        ls
+      end
+    end
+
+    # Fetch files from current directory.
+    # Then update each windows reflecting the newest information.
+    def ls
+      fetch_items_from_filesystem
+      sort_items_according_to_current_direction
+
+      @current_page ||= 0
+      draw_items
+      move_cursor current_row
+
+      draw_marked_items
+      draw_total_items
+    end
+
+    # Sort the whole files and directories in the current directory, then refresh the screen.
+    #
+    # ==== Parameters
+    # * +direction+ - Sort order in a String.
+    #                 nil   : order by name
+    #                 r     : reverse order by name
+    #                 s, S  : order by file size
+    #                 sr, Sr: reverse order by file size
+    #                 t     : order by mtime
+    #                 tr    : reverse order by mtime
+    #                 c     : order by ctime
+    #                 cr    : reverse order by ctime
+    #                 u     : order by atime
+    #                 ur    : reverse order by atime
+    #                 e     : order by extname
+    #                 er    : reverse order by extname
+    def sort(direction = nil)
+      @direction, @current_page = direction, 0
+      sort_items_according_to_current_direction
+      switch_page 0
+      move_cursor 0
+    end
+
+    # Change the file permission of the selected files and directories.
+    #
+    # ==== Parameters
+    # * +mode+ - Unix chmod string (e.g. +w, g-r)
+    #
+    #TODO: accept number forms such as 755, 0644
+    def chmod(mode = nil)
+      return unless mode
+      FileUtils.chmod mode, selected_items.map(&:path)
+      ls
+    end
+
+    # Fetch files from current directory.
+    def fetch_items_from_filesystem
+      @items = Dir.foreach(current_dir).map {|fn| Item.new dir: current_dir, name: fn, window_width: maxx}.to_a
+    end
+
+    # Focus at the first file or directory of which name starts with the given String.
+    def find(str)
+      index = items.index {|i| i.name.start_with? str}
+      move_cursor index if index
+    end
+
+    # Focus at the last file or directory of which name starts with the given String.
+    def find_reverse(str)
+      index = items.reverse.index {|i| i.name.start_with? str}
+      move_cursor items.length - index - 1 if index
+    end
+
+    # Width of the currently active pane.
+    def maxx
+      main.maxx
+    end
+
+    # Height of the currently active pane.
+    def maxy
+      main.maxy
+    end
+
+    # Number of files or directories that the current main window can show in a page.
+    def max_items
+      main.max_items
+    end
+
+    # Update the main window with the loaded files and directories. Also update the header.
+    def draw_items
+      main.draw_items_to_each_pane (@displayed_items = items[current_page * max_items, max_items])
+      header_l.draw_path_and_page_number path: current_dir, current: current_page + 1, total: total_pages
+    end
+
+    # Sort the loaded files and directories in already given sort order.
+    def sort_items_according_to_current_direction
+      case @direction
+      when nil
+        @items = items.shift(2) + items.partition(&:directory?).flat_map(&:sort)
+      when 'r'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort.reverse}
+      when 'S', 's'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort_by {|i| -i.size}}
+      when 'Sr', 'sr'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort_by(&:size)}
+      when 't'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort {|x, y| y.mtime <=> x.mtime}}
+      when 'tr'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort_by(&:mtime)}
+      when 'c'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort {|x, y| y.ctime <=> x.ctime}}
+      when 'cr'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort_by(&:ctime)}
+      when 'u'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort {|x, y| y.atime <=> x.atime}}
+      when 'ur'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort_by(&:atime)}
+      when 'e'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort {|x, y| y.extname <=> x.extname}}
+      when 'er'
+        @items = items.shift(2) + items.partition(&:directory?).flat_map {|arr| arr.sort_by(&:extname)}
+      end
+      items.each.with_index {|item, index| item.index = index}
+    end
+
+    # Search files and directories from the current directory, and update the screen.
+    #
+    # * +pattern+ - Search pattern against file names in Ruby Regexp string.
+    #
+    # === Example
+    #
+    # a        : Search files that contains the letter "a" in their file name
+    # .*\.pdf$ : Search PDF files
+    def grep(pattern = '.*')
+      regexp = Regexp.new(pattern)
+      fetch_items_from_filesystem
+      @items = items.shift(2) + items.select {|i| i.name =~ regexp}
+      sort_items_according_to_current_direction
+      switch_page 0
+      move_cursor 0
+
+      draw_total_items
+    end
+
+    # Copy selected files and directories to the destination.
+    def cp(dest)
+      src = (m = marked_items).any? ? m.map(&:path) : current_item.path
+      FileUtils.cp_r src, File.join(current_dir, dest)
+      ls
+    end
+
+    # Move selected files and directories to the destination.
+    def mv(dest)
+      src = (m = marked_items).any? ? m.map(&:path) : current_item.path
+      FileUtils.mv src, File.join(current_dir, dest)
+      ls
+    end
+
+    # Rename selected files and directories.
+    #
+    # ==== Parameters
+    # * +pattern+ - / separated Regexp like string
+    def rename(pattern)
+      from, to = pattern.split '/'
+      from = Regexp.new from
+      selected_items.each do |item|
+        name = item.name.gsub from, to
+        FileUtils.mv item.path, File.join(current_dir, name)
+      end
+      ls
+    end
+
+    # Create a new directory.
+    def mkdir(dir)
+      FileUtils.mkdir_p File.join(current_dir, dir)
+      ls
+    end
+
+    # Create a new empty file.
+    def touch(filename)
+      FileUtils.touch File.join(current_dir, filename)
+      ls
+    end
+
+    # Current page is the first page?
+    def first_page?
+      current_page == 0
+    end
+
+    # Do we have more pages?
+    def last_page?
+      current_page == total_pages - 1
+    end
+
+    # Number of pages in the current directory.
+    def total_pages
+      items.length / max_items + 1
+    end
+
+    # Move to the given page number.
+    #
+    # ==== Parameters
+    # * +page+ - Target page number
+    def switch_page(page)
+      @current_page = page
+      draw_items
+    end
+
+    # Update the header information concerning currently marked files or directories.
+    def draw_marked_items
+      items = marked_items
+      header_r.draw_marked_items count: items.size, size: items.inject(0) {|sum, i| sum += i.size}
+    end
+
+    # Update the header information concerning total files and directories in the current directory.
+    def draw_total_items
+      header_r.draw_total_items count: items.size, size: items.inject(0) {|sum, i| sum += i.size}
+    end
+
+    def toggle_mark
+      main.toggle_mark current_item
+    end
+
+    # Accept user input, and directly execute it as a Ruby method call to the controller.
+    #
+    # ==== Parameters
+    # * +preset_command+ - A command that would be displayed at the command line before user input.
+    def process_command_line(preset_command: nil)
+      prompt = preset_command ? ":#{preset_command} " : ':'
+      command_line.set_prompt prompt
+      cmd, *args = command_line.get_command(prompt: prompt).split(' ')
+      if cmd && !cmd.empty? && respond_to?(cmd)
+        self.public_send cmd, *args
+        command_line.wclear
+        command_line.wrefresh
+      end
+    rescue Interrupt
+      command_line.wclear
+      command_line.wrefresh
+    end
+
+    # Accept user input, and directly execute it in an external shell.
+    def process_shell_command
+      command_line.set_prompt ':!'
+      cmd = command_line.get_command(prompt: ':!')[1..-1]
+      execute_external_command pause: true do
+        system cmd
+      end
+    rescue Interrupt
+    ensure
+      command_line.wclear
+      command_line.wrefresh
+    end
+
+    # Let the user answer y or n.
+    #
+    # ==== Parameters
+    # * +prompt+ - Prompt message
+    def ask(prompt = '(y/n)')
+      command_line.set_prompt prompt
+      command_line.wrefresh
+      while (c = Curses.getch)
+        next unless [78, 89, 110, 121, 3, 27] .include? c  # N, Y, n, y, ^c, esc
+        command_line.wclear
+        command_line.wrefresh
+        break [89, 121].include? c  # Y, y
+      end
+    end
+
+    # Open current file or directory with the editor.
+    def edit
+      execute_external_command do
+        editor = ENV['EDITOR'] || 'vim'
+        system %Q[#{editor} "#{current_item.path}"]
+      end
+    end
+
+    # Open current file or directory with the viewer.
+    def view
+      execute_external_command do
+        pager = ENV['PAGER'] || 'less'
+        system %Q[#{pager} "#{current_item.path}"]
+      end
+    end
+
+    private
+    def execute_external_command(pause: false)
+      Curses.def_prog_mode
+      Curses.endwin
+      yield
+    ensure
+      Curses.reset_prog_mode
+      Curses.getch if pause
+      Curses.refresh
+    end
+
+    def debug(str)
+      header_r.debug str
+    end
+  end
+end