typr 1.1.0

data/lib/browser.rb

@@ -0,0 +1,431 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'etc'
+require 'find'
+require_relative 'grid.rb'
+require_relative 'line.rb'
+
+module Typr
+
+  MIMETYPES = eval File.read( __dir__ + "/../share/mimetypes" )
+
+  # A file-system directory browser built on Grid. Renders entries as rows
+  # with columns for name, symlink target, permissions, owner/group, size,
+  # timestamps, and MIME type. Directories sort to the top and appear in
+  # yellow; files get per-MIME-type foreground colors.
+  #
+  # == Column Views
+  #
+  #   :simple   - name
+  #   :compact  - name, size, type
+  #   :stats    - name, size, permissions, owner, group, modified
+  #   :full     - all columns
+  #
+  # == Navigation Keys (interactive picker)
+  #
+  #   [h]             | help
+  #   [r]             | reset view
+  #   [d]             | directory history
+  #   [m] / [M]       | mark / mark range
+  #   [a] / [i]       | mark all / invert mark
+  #   [`] / [~] / [..] | root / home / back
+  #   [v]             | switch view
+  #   [s] / [f]       | sort / filter
+  #   Return          | confirm (cd on directories)
+  #   Escape          | quit, returns nil
+
+  class Browser < Grid
+    attr_accessor :directory, :user, :pwd, :view, :dir_history
+    attr_accessor :mimetype_db, :mimetype_magic
+
+    ## Height minus 2 rows reserved for path bar and command line.
+
+    def bottom; super - 2 end
+
+    ## Top offset plus one row for the path info bar.
+
+    def top; super + 1 end
+
+    ##
+    # Change to +dir+ (absolute path, +".."+, +"~"+, or integer index into
+    # dir_history). When +append+ is false (default), clears data and colors
+    # before scanning. Pushes onto dir_history.
+    #
+    #   browser.cd "/tmp"        # => changes to /tmp
+    #   browser.cd "~"           # => changes to home
+    #   browser.cd ".."          # => parent directory
+    #   browser.cd 2             # => jump to history entry 2
+
+    def cd dir, append=false
+      return unless dir
+      data, missing = [],{}
+      unless append
+        @colors[:fields] = {}
+        dir = @dir_history[dir+1] if dir.is_a? Integer
+        clear
+        Dir.chdir( @directory = File.expand_path( dir ) )
+        unless [?/, ENV["HOME"]].include? dir
+          @dir_history.unshift @directory
+          @dir_history.uniq!
+        end
+      end
+      data = Dir.new(@directory).children.map.with_index do |file,id|
+        if File.symlink? file
+          target = File.readlink( file ) rescue $!.to_s
+          next [file, target] + [??]*7 + ["inode","symlink"] unless File.exist?(file)
+        end
+        stat = File.stat(file)
+        type = stat.ftype.to_sym
+
+        mime = { "directory": "inode/directory",
+          "characterSpecial": "inode/chardevice",
+          "blockSpecial": "inode/blockdevice", "link": "inode/symlink",
+          "fifo": "inode/fifo", "socket": "inode/socket"}[type]
+        if type == :file and @mimetype_db
+          ext = file.match(/.+\.(\w+)$/)
+          mime ||= MIMETYPES[ext[1].to_sym] if ext
+        end
+
+        ( missing[file] = id ; mime = "?/?" ) unless mime
+        [  file, target, stat.mode.to_s(8)[-3..-1].chars.map{|d|
+          "rwx".chars.map.with_index{|c,i| d.to_i[2-i]==0 ? ?- : c } }.join,
+          stat.uid, stat.gid, stat.size,
+          stat.atime.to_i, stat.mtime.to_i, stat.ctime.to_i,
+          *mime.to_s.split( ?/ ) ]
+      end
+
+      `file --mime-type '#{missing.keys.join "' '"}'
+        `.split($/).each.with_index{ |line,id|
+          next unless line[/^.+:\s+\w+\/[\w\-\.]+$/]
+          file, mime = line.split(/:\s*/)
+          data[ missing[file] ][-2,2] = mime.rstrip.split( ?/ ) } if
+            @mimetype_magic and not missing.empty?
+      self << data
+      sort
+      filter
+      unless append
+        @directory += ?/ unless @directory == ?/
+        switch_to @view
+        reset :position
+      end
+      return
+    end
+
+    ##
+    # Colors symlink names green/red based on target existence and applies
+    # per-MIME-type foreground colors from +@colors[:types]+.
+    #
+    #   browser.process 0   # => sets colors for row 0
+
+    def process row; super
+      color = @colors[:types][@data[row][SUBTYPE].to_sym] ||
+        @colors[:types][@data[row][TYPE].to_sym]
+      @colors[:fields][[row,NAME]] = color if color
+    end
+
+    ##
+    # Switch to a named or indexed column view. Resets format widths.
+    #
+    #   browser.switch_to :full      # all columns
+    #   browser.switch_to 0          # first view key
+    #   browser.switch_to :stats     # name, size, perms, owner, group, modified
+
+    def switch_to view=nil
+      return unless view
+      view = @views.keys[ view ] if view.is_a? Integer
+      @sequence = @views[ view ].map{|title| @header.index title.to_s}
+      reset :format
+      @view = view
+      return
+    end
+
+    ##
+    # Resolves hint characters typed on a row. Returns the matching row id
+    # for fast navigation, otherwise falls through to Stack#send.
+    #
+    #   browser.send "1"   # => row id if hint "1" is visible
+
+    def send key
+      if key.is_a?(String) and
+        id = @hints[0..[height, rows-1+headspace].min-@hints_start-1].index(key)
+        return page[id+@hints_start]
+      else super end
+    end
+
+    ## Returns the current directory path as the confirm result.
+
+    def confirm; return @directory end
+
+    ## Prompts to select rows by index. Returns chosen ids or nil.
+    #
+    #   browser.mark   # => [0, 2, 5] or nil
+
+    def mark; return @user.ask( 'mark files': [self, :rows] ) end
+
+    ## Toggles selection for every row within a "from..to" range.
+    #
+    #   browser.mark_range   # prompts for from/to, toggles selection
+
+    def mark_range; return ids[ ( eval @user.ask(
+      'mark from': [self, :relative_row], 'to': [self, :relative_row]
+      ).join '..' ) ].each{|id| @selected[:rows].include?(id) ?
+        @selected[:rows].delete(id) : @selected[:rows] << id } end
+
+    ## Selects all non-directory rows.
+    #
+    #   browser.mark_all   # => [0, 3, 7] (file ids only)
+
+    def mark_all; return @selected[:rows] = ids - directories end
+
+    ## Inverts selection across all non-directory rows.
+    #
+    #   browser.mark_invert   # => toggled ids
+
+    def mark_invert; return @selected[:rows] = ids - @selected[:rows] end
+
+    ## Navigate up one directory.
+    #
+    #   browser.back   # equivalent to cd ".."
+
+    def back; cd ".." end
+
+    ## Navigate to the root directory.
+    #
+    #   browser.root   # => cd "/"
+
+    def root; cd ?/ end
+
+    ## Navigate to the home directory.
+    #
+    #   browser.home   # => cd "~"
+
+    def home; cd ?~ end
+
+    ## Display a help grid listing all keybindings.
+
+    def help; @user.help end
+
+    ##
+    # Recurse through the directory tree, adding subdirectory entries inline
+    # via +cd(path, true)+. Sorts by name with the filetree processor.
+    #
+    #   browser.recurse   # flattens tree into leaf names
+
+    def recurse
+      sort_by NAME
+      @procs[NAME] = :filetree
+    end
+
+    ## Reset display, selection, and position state then re-sort.
+    #
+    #   browser.reset_view
+
+    def reset_view; reset [:display, :selection, :position]; sort end
+
+    ## Open a filter popup on the chosen row/column and apply the input.
+    #
+    #   browser.filter_view   # prompts for filter text
+
+    def filter_view; add_filter *@user.ask(
+      filter: [ popup( type: :"[f]ilter" ), :row], with: :line ) end
+
+    ## Open a sort-picker popup to choose a column to sort by.
+    #
+    #   browser.sort_view   # pick a column header to sort
+
+    def sort_view; sort_by @user.ask( "sort by": [ popup( type: :"[s]ort" ), :row] ) end
+
+    ## Open a view-picker popup and switch to the selected view.
+    #
+    #   browser.views   # choose :simple, :compact, :stats, or :full
+
+    def views; switch_to( popup( type: :"[v]iews", input: @views.keys ).pick :row )  end
+
+    ## Open a directory history picker and cd to the chosen entry.
+    #
+    #   browser.dir_history   # pick from previously visited dirs
+
+    def dir_history; cd( popup( { input: @dir_history[1..-1],
+      colors: { columns: [ colors[:dir_history] ] },
+      align: [:left], left: left } ).pick(:row) )  end
+
+    ## True when the row is a directory or passes base Grid filtering.
+    #
+    #   browser.check 0   # => true if navigable
+
+    def check row; super or @data[row][SUBTYPE] == "directory" end
+
+    ##
+    # Interactive file/directory picker. Blocks until a selection or Escape.
+    # Return on a file wraps the path in single quotes. Enter on a directory
+    # triggers cd. +type+ optionally filters by MIME family (audio, video,
+    # image, text, application, inode).
+    #
+    #   browser.pick              # => '/home/user/file.txt'
+    #   browser.pick 'image'      # => '/path/to/photo.png' (images only)
+    #   browser.pick nil          # => anything, same as 'file'
+
+    def pick type='file'
+      type ||= 'file'
+      type = type.to_s
+      return super if type[/row|column|field|none/]
+      add_filter ( %w[audio video image text application inode].include?(
+        type) ? TYPE : SUBTYPE ), type if type != 'file'
+      loop do
+        draw
+        draw_hints :row
+        key = Typr.read( :key )
+        next unless choice = send( key )
+        case choice
+          when Array; choice = ?' + choice.map{ |id|
+            @directory+?/+@data[id][NAME] }.join("' '") + ?'
+          when Integer; file = @data[ choice ]
+            if file[SUBTYPE] == 'directory'; cd file[TARGET] || file[NAME]; next
+            else choice = ?'+@directory+?/+file[NAME]+?' end
+        end
+        reset :display
+        return choice
+      end
+    end
+
+    ##
+    # Renders the grid with an info bar above showing the current directory
+    # path and colored status items for filter, sort, and view.
+    #
+    #   browser.draw   # draws browser with info bar
+
+    def draw; super
+      info = { "[f]ilter": @filters.empty? ? "no filter" : @filters.to_s[1..-2],
+        "[s]ort": sorted_by(true), "[v]iews": @view }
+      move left, top - 1
+      show prepare( @directory, width - info.values.join.size - 3, :left, :left, 5 )
+      @colors[:actions].each do |type,col|
+        color col
+        show ' ' + info[type].to_s
+        @positions[type] = Typr.column - (type==@positions.keys.last ? 0:1 )
+      end
+      @user.draw
+    end
+
+    ## Returns row ids for all directories in the current listing.
+    #
+    #   browser.directories   # => [0, 1, 3]
+
+    def directories; ids.select{ |id| @data[id][SUBTYPE] == 'directory' } end
+
+    ##
+    # Sort by NAME by default; directories always appear before files
+    # within each prefix grouping.
+    #
+    #   browser.sort   # re-sorts with dirs first
+
+    def sort
+      @sort ||= NAME
+      super
+      dirs = ids.select{ |id| @data[id][SUBTYPE] == 'directory' }
+      @map = (directories + ids).uniq
+      nil
+    end
+
+    ##
+    # Create a small Grid popup under an info bar item for column selection.
+    # +args+ must include +:type+ matching an actions key for positioning.
+    #
+    #   browser.popup type: :"[s]ort"   # sort-picker popup
+
+    def popup args={}
+      Grid.new( { alternate:false, border: :light,
+        borders:{ top:nil, top_left:nil, top_right:nil },
+        top: top, align: [:right], input:@header,
+        left: left + ( @positions[args[:type]] || 0 ) -
+          ( args[:input] || @header ).map( &:size ).max - 1,
+        colors:{ columns: [ @colors[:actions][args[:type]] ] } }.merge args )
+    end
+
+    ##
+    # Construct a Browser widget. Keyword arguments:
+    #
+    #   Option               | Default                         | Description
+    #   --------------------|---------------------------------|-----------------------------------
+    #   +directory+          | +"~"+                           | Starting directory to browse
+    #   +mimetype_db+       | true                            | Load MIME from file extensions
+    #   +mimetype_magic+    | true                            | Use +file --mime-type+ for unknowns
+    #   +colors[:actions]+  | { "[f]ilter": :red, ... }       | Status bar item colors
+    #   +colors[:dir_history]+ | :yellow                      | History picker column color
+    #   +colors[:types]+     | (see below)                    | Per MIME-type foreground color
+    #
+    # == Type Color Defaults
+    #
+    #   image: :blue          audio: :green         video: :cyan
+    #   text: 146             pdf: 136              inode: :magenta
+    #   directory: :yellow    symlink: 123          'x-empty': :grey70
+    #   'x-msdownload': :red  'x-pie-executable': :red
+
+    def initialize args={}
+      @dir_history, @mimetype_db, @mimetype_magic = [], true, true
+      @view, @sort, @views, @positions = :compact, 0, {}, {}
+      super
+      @directory ||= ?~
+      @colors[:actions] = { "[f]ilter": :red, "[s]ort": :blue, "[v]iews": :green
+        }.merge @colors[:actions] || {}
+      @colors[:dir_history] ||= :yellow
+      @colors[ :types ] = {
+            image: :blue,
+            audio: :green,
+            video: :cyan,
+             text: 146, pdf: 136, 'epub+zip': 136,
+             html: 150, xhtml: 150, javascript: 150,
+        'x-bzip2': 190, 'x-xz': 190, 'x-compressed': 190,
+            inode: :magenta, blockdevice:148, chardevice:144, symlink:123,
+        directory: :yellow,
+        'x-empty': :grey70, '?': :grey70,
+        'x-msdownload': :red, 'x-pie-executable': :red
+      }.merge( @colors[ :types ] || {} )
+
+      @keymap = { back: KEY_BACKSPACE, confirm: KEY_RETURN, help: ?h,
+        home: ?~, root: ?`, views: ?v, sort_view: ?s, dir_history: ?d,
+        mark: ?m, mark_range: ?M, mark_all: ?a, mark_invert: ?i,
+        filter_view: ?f, reset_view: ?r, recurse: ?R}.merge @keymap
+
+      self.header = %w[ name target permissions owner group size accessed
+        modified created type subtype ]
+
+      @format[NAME] = :max
+      @format[TYPE] = 5
+      @ignore[NAME] = @ignore[TARGET] = true
+      @hints = "1234567890"
+      [NAME, SIZE, ACCESSED, MODIFIED, CREATED].each{|col| @rawsort[col] = true}
+
+      @procs[ACCESSED] = @procs[MODIFIED] = @procs[CREATED] = :datetime
+      @procs[SIZE] = :magnitudes
+      @procs[OWNER] = Proc.new{|uid| Etc.getpwuid(uid).name rescue uid }
+      @procs[GROUP] = Proc.new{|gid| Etc.getgrgid(gid).name rescue gid }
+
+      @procs[NAME] = Proc.new{ |name, row| target = @data[row][TARGET]
+        name + ( target ? " > " + color_code(File.exist?(target) ? :green : :red) +
+          target : "" ) }
+
+      @views = { simple: %i[ name ],
+        compact: %i[ name size type],
+        stats:   %i[ name size permissions owner group modified ],
+        full:    %i[ name size permissions owner group
+                     accessed modified created type subtype ] }.merge @views
+      @parent = self
+      @head ||= Grid.new( parent:self, left: ->{@parent.left}, top: ->{@parent.top-1},
+        input: [ [->{@parent.directory}, ->{@parent.filters.empty? ? "no filter" :
+          @parent.filters.to_s[1..-2] }, ->{@parent.sorted_by(true)},
+          ->{@parent.view} ] ], format: [:max, :min, :min, :min],
+        colors: { columns: [@colors[:default]] + @colors[:actions].values } )
+
+      @user ||= Line.new( parent:self, left:->{@parent.left},top:->{@parent.bottom+1},
+        bindings: %w[ [h]elp ] + @colors[:actions].map{|name,color|
+          color_code( color ) + name.to_s + color_code(@colors[:default]) } +
+            %w[ [r]eset [d]irectories [m]ark [M]ark\ range mark\ [a]ll
+            [i]nvert\ mark [`]:root [~]:home [back]:.. [up] [down] [pageup] [pagedown] [home] [end] [esc]:quit [return]:confirm\  ])
+      cd @directory
+    end
+  end
+
+end

data/lib/curses.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/ruby
+
+require 'ncursesw'
+require_relative 'frontend'
+  
+module Visuals
+
+  include Ncurses
+  KEY_ESCAPE = 27
+  KEY_RETURN = 10
+  KEY_TAB = 9
+  KEY_PAGEDOWN = KEY_NPAGE
+  KEY_PAGEUP = KEY_PPAGE
+  KEY_INSERT = KEY_IC
+  KEY_DELETE = KEY_DC
+  
+  $colors = COLORS.keys
+  $pairs = []
+#  COLORS = %w[ black red green yellow blue magenta cyan white grey]
+#  KEY_TAB = 9
+#  HEIGHT,WIDTH = IO.console.winsize
+
+%w[color pair].each{ |name| method = <<STR 
+  def %s_for obj; #return unless obj
+    if id = $%ss.index( obj ) then return id
+    else last = ( $%ss << obj.dup ).count - 1
+      Ncurses.init_%s( last, *obj ) 
+      return last
+    end
+  end
+STR
+eval( method % ([name]*4) )
+}
+  
+  def self.width;  Ncurses.COLS end
+  def self.height; Ncurses.LINES end
+  def self.row; Ncurses.getcury $creen end
+  def self.column; Ncurses.getcurx $creen end
+  
+  def self.exit
+    Ncurses.echo
+    Ncurses.nocbreak
+    Ncurses.nl
+    Ncurses.endwin
+#    system "reset"
+  end
+
+  def read input 
+    case input
+      when :key
+        key = Ncurses.getch 
+        key = key.chr if key.between? 32, 126 
+        return key
+      when :line #string
+        Ncurses.echo
+        Ncurses.curs_set 1        
+#        Ncurses.getstr str=""
+        str = Readline.readline
+        Ncurses.curs_set 0
+        Ncurses.noecho
+        return str
+    end
+  end
+
+  def move x=0,y=0; Ncurses.move y, x end
+  def refresh; Ncurses.refresh end
+  def enable attr; Ncurses.attron attr end
+  def disable attr; Ncurses.attroff attr end
+  def clear type=:screen; 
+    case type 
+      when :screen; Ncurses.erase
+      when :line; Ncurses.clrtoeol
+      when :down; Ncurses.clrtobot
+    end 
+  end
+  def change; Ncurses.color_set pair_for( $color ), 0 end
+  def show string; Ncurses.addstr string.to_s end
+
+  def get_background; $color[1] end
+  def get_foreground; $color[0] end
+  def background color; 
+    $color[1] = (color ? color_for( color ) : $default[1]); change  
+  end
+  def foreground color; 
+    $color[0] = (color ? color_for( color ) : $default[0]); change 
+  end
+
+  def color c
+    c = [c] unless c.is_a? Array and c.count == 2
+    foreground c[0] if c[0] 
+    background c[1] if c[1] 
+  end
+
+#  def color_pair pair
+#    if id = $color_pairs.index( pair ) return id
+#    else last = ( $color_pairs << c ).count - 1
+#      Ncurses.init_pair( last, *pair ) 
+#      return last
+#    end
+#    pair = p.map{ |col| 
+#      unless id = $colors.index( col ) 
+#        id = ($colors << col).count - 1 
+#        Ncurses.init_color id, *col
+#      end
+#      id
+#    }      
+#    unless ( id = $color_pairs.index( pair ) ) 
+#      id = ( $color_pairs << pair ).count - 1
+#      Ncurses.init_pair id, *pair
+#    end
+#    id
+#  end
+
+  def self.init args={} 
+#    SCREEN = Ncurses.initscr
+    $creen = Ncurses.initscr
+    Ncurses.cbreak           # provide unbuffered input
+    Ncurses.noecho             # turn on input echoing
+    Ncurses.nl             # turn on newline translation
+#    Ncurses.nonl             # turn off newline translation
+    Ncurses.curs_set 0
+    Ncurses.start_color
+    Ncurses.stdscr.intrflush(false) # turn off flush-on-interrupt
+    Ncurses.stdscr.keypad(true)     # turn on keypad mode
+
+    $default = [ 
+      color_for( args[:foreground] || :grey80 ), 
+      color_for( args[:background] || :grey10 ) ]
+    $color = $default.dup
+
+    COLORS.each_with_index{ |c,i| 
+      $pairs << [ i, $default[1] ] 
+      Ncurses.init_color i, *c[1] 
+      Ncurses.init_pair i, i, $default[1] }
+    
+    Ncurses.bkgd Ncurses::COLOR_PAIR( pair_for $default )
+
+  end  
+
+end
+
+if __FILE__ == $0
+  include Visuals
+  Visuals.init #background: :blue
+  characters = (32..126).map(&:chr).join
+  loop do
+    clear
+    $colors.each_with_index{ |c,i| 
+      foreground c; move 0,i; show characters }
+    refresh
+    exit if read(:key) == KEY_ESCAPE
+  end
+end

data/lib/frontend.rb

@@ -0,0 +1,33 @@
+require 'readline'
+
+module Visuals
+
+#   COLORS = { 
+#     black:   [   0,    0,    0],
+#     red:     [ 700,  400,  400],
+#     green:   [ 400,  700,  400],
+#     yellow:  [ 700,  700,  400],
+#     blue:    [ 400,  400,  700],
+#     magenta: [ 700,  400,  700],
+#     cyan:    [ 400,  700,  700],
+#     white:   [ 999,  999,  999],
+#     grey:    [ 618,  618,  618] }
+ 
+  COLORS = { 
+    black:   [   0,    0,    0],
+    red:     [ 180,  100,  100],
+    green:   [ 100,  180,  100],
+    yellow:  [ 180,  180,  100],
+    blue:    [ 100,  100,  180],
+    magenta: [ 180,  100,  180],
+    cyan:    [ 100,  180,  180],
+    white:   [ 255,  255,  255],
+    grey:    [ 158,  158,  158] }
+
+  COLORS.merge! 1.upto(9).map{ |i| 
+    ["grey#{ i*10 }".to_sym, [i*25]*3 ] }.to_h  
+
+  # COLORS.merge! 1.upto(9).map{ |i| 
+  #   ["grey#{ i*10 }".to_sym, [i*100]*3 ] }.to_h  
+
+end