typr 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f04e1f9234a97079a70786d6a427c7c6394775515c78a19feee8e17e3dc1370e
-  data.tar.gz: b82771f5976e12fabbd56446d347ac8f49739e41d4dbe089b7ffc5738938dd17
+  metadata.gz: 3fc328e46b4b4d36e0d3f68eb0a50f8068934469ec5e9d5d84099755685732ad
+  data.tar.gz: 254c5a5842474b4fc550a0aff5fbaa772e961a6aca9a9a8f90ed1a89cc761e51
 SHA512:
-  metadata.gz: 99278addeb2d176281564448ddb5b34de23aebb1bac5a3e186c0a4735aafad0387274100bd38fa33018988d7672a7959c6c9791fd2bb8bf50c2e2545075552c6
-  data.tar.gz: 9efd4720c0cc7c58f41acf31ca8a38827300127b72ffadaf9d18ebd53b8be0500f53de1386eed6255149f858ab3e5a943523ba79630cadf11eddf8c0f8a6e072
+  metadata.gz: eeae3cd67ce492706bc952e8422adea09d300f115928c074411c2589f5dae577ff4ad73e610e6a9b279007a93205e81fa9579c59d3f404f2778f52b06cb26e24
+  data.tar.gz: 735a2236dbd0868674f4727572f578237f34165ab04d683179dd45464918099719c422503b386915f2df4895f1d5228550e6ee9bc25a9bf607d650eff8e8153c

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [vx.y.z] — __DATE__
+
+## [v1.6.0] — 2026-09-30
+
+### Added
+- `regex:` color — every component's `colors:` hash accepts a `Regexp => color` map. Typed input (`read_line`/`Line#cli`) colors matching regions and restores the prompt's trailing color code; `Typr::Text` paints its whole buffer once at build (per logical row, keeping its `default` colors as the restore base) so rendering stays a pure emit. Additive `Typr.paint(str, regex, base)` helper; when patterns overlap the earlier key wins. Painted rows re-sanitize before append/rebuild, so a new paint never stacks escape codes
+- Default `regex:` schemes — `Typr::Text` colors numbers cyan, colon-separated keys yellow, quoted strings green, bracketed groups magenta, and remaining punctuation grey60; `Line#cli` colors the first word red and `--options` blue. Both install only when `regex:` is absent, so a custom map replaces them and `regex: {}` turns them off. Colors may be any value `color_code` accepts, including 8-bit indices and RGB triplets
+- `Line#cli` — prompts a single command line (default-colored prompt, answer-colored input) with TAB completion matched against the shell. The typed command tints with the default `regex:` scheme; completion candidates are plain strings; bash_completion completers are loaded dynamically on each match so per-command option sets (`ls`/`git`/...) appear rather than just `--help`
+- `Typr.drain_input` — discards bytes already waiting on the input stream so input confirmed at one prompt cannot auto-answer the next (e.g. a double-tapped Enter confirming a destructive default)
+- `Browser#printable` column — boolean that replaces a "binary" concept from the other side: a regular file is printable when the first 8KB contain no NUL byte and decode as valid UTF-8 (directories, links, and special files are false). It sits next to `executable` in the `full` view and the header auto-defines `Typr::PRINTABLE`
+
+### Changed
+- Header bars render bold by default — `Stack#show` applies the bold attribute around the header row and resets it before the content rows, so Grid and Text headers are emphasized without affecting the body. `mode_code` now matches its attribute by symbol (the string lookup always missed and emitted nothing)
+- Tabs in `Typr::Text` areas expand to `tabspace` spaces (default 2) instead of passing the raw byte through to the terminal's own tab stops, so width math and wrapping see the same cells as the rendered output
+- `Typr::Text` regex paint restores only the `default` foreground after each matched span instead of also forcing the background to black, so Stack's per-row background (alternating stripes, search highlight, padding) stays intact for the rest of the line
+- `color_code` stays callable with an explicit receiver — `module_function` kept its module copy alive for `paint` but made the instance copy private, which broke includers that called it as `object.color_code`; the instance method is public again (term.rb)
+- The `executable` and `printable` boolean columns render as `yes`/`no` (a display proc replaces the raw true/false) and sort correctly — booleans lack a spaceship operator, so the comparator fell back to 0 and every row compared equal; sorting now runs on the proc'd `yes`/`no` strings. `Grid#process` no longer drops `false` cells, which would have left a `nil` in the layer map
+- Tab completion moves out of `read_line` into the callers: `read_line` now takes `completions:` as a content-agnostic callable (`->(query, cursor) { candidates }`) and TAB merely matches the current word through its pick grid; `Line#ask` keeps its plain `:line` behaviour and no longer forwards a `completions` option
+- `Grid#pick` with a column filter confirms the single remaining match instantly — when the live search narrows the list to one row it returns immediately and arms a 0.5s quiet window: overtyped keys are discarded at the next in-app read (`read_key`) and the tty queue is flushed before any subprocess handoff, so neither the picker nor a spawned editor sees them
+- Command-line history can be navigated in `read_line` and `Line#cli`; `Line#cli` also accepts a command `prefixes:` parameter so completion strips the command prefix before matching the current word
+
+### Fixed
+- Editing recalled command-line history no longer fails on frozen strings and restores the colored prompt when returning to the recalled entry
+
 ## [v1.5.1] — 2026-09-11
 
 ## [v1.5.0] — 2026-09-05
@@ -24,7 +48,10 @@
 - `reset_view` reloads the directory again — it calls `cd @directory` before clearing display/selection/position and re-sorting, so reset picks up new and removed files instead of only reshuffling the stale listing
 - Head path lookup — `@head.path_at(x, y)` maps a click to a target directory: the username column returns the resolved home directory, each `/`-separated segment of the directory cell returns that ancestor path (padding, action columns and array listings return nil); mouse `x` is adjusted from 1-based terminal columns so boundary clicks resolve to the cell under the cursor
 - `Mouse#alt?` — reports the SGRmeta bit, so callers can treat Alt+click like a right-click (e.g. opening a command list where right-click is hard to send, as on Termux touchscreens)
+- User-definable base palette — `$palette` maps the eight basic color names to Integer/`[r,g,b]` values and `color_code` consults it first, so apps can override terminal colors from config (absent names keep terminal resolution)
 - `cd` survives unreadable directories — `chdir` and the listing are probed before any state changes, so `EACCES`/`ENOENT` (e.g. Android's `/data`) shows a warning and stays put instead of crashing on an emptied listing; returns `false` on failure
+- Refresh keeps scroll position and hints — `cd` only resets `@start`/`@hints_start` when actually navigating somewhere new, and `reset_view` clears filters/selection without touching position (filters are cleared before the reload so the re-filter doesn't snap to top either)
+- Enter picks the first result in search-filtered `Grid#pick` — confirming the filter line returns the top visible row (honoring cycled hints) instead of applying the filter and picking nothing; with no matches left the old commit-filter behavior (and nil return) is kept, so `Browser#search` still works
 
 ## [v1.4.0] — 2026-08-15
 

data/README.md

@@ -31,14 +31,13 @@ The default terminal frontend is pure ANSI on raw TTY input — **no ncurses**.
 
 ### Colors
 
-Named colors (basic, shades, and `dark_*`), grey shades `grey0`–`grey100`, the terminal's 8-bit palette, and RGB triplets for true-color terminals. Every component takes a per-part `colors:` hash (columns, headers, hints, search matches, …).
+Named colors (basic, shades, and `dark_*`), grey shades `grey0`–`grey100`, the terminal's 8-bit palette, and RGB triplets for true-color terminals. Every component takes a per-part `colors:` hash (columns, headers, hints, search matches, …). A component-level `regex:` key maps `Regexp => color` to tint typed input (`Typr.read_line`/`Line#cli`) and the rows of `Typr::Text` areas; when two patterns match the same span the earlier key wins, so order overlapping patterns longest-first. Colors may be any value `color_code` accepts — named color, `greyN`, an 8-bit index, an RGB triplet like `[10, 200, 30]`, or a `[fg, bg]` pair. Header bars render bold by default.
 
-### Frontends
+`Typr::Text` paints numbers cyan, colon-separated keys yellow, quoted strings green, bracketed groups magenta, and remaining punctuation grey — override with `regex:`, disable with `regex: {}`. Each painted span restores only the `default` foreground, so the row's own background (alternating stripes, search highlight, padding) survives; `Line#cli` colors the typed command (first word red, `--options` blue); it no longer tints the completion grid. Set `regex: {}` to turn a scheme off.
 
-- **Terminal** (`require 'typr'`) — the default: raw terminal IO, no ncurses, works over SSH and on Termux
-- **Graphical** (`require 'typr/graphical'`) — experimental: SDL2-based windows
+### Frontends
 
-All components work identically across frontends.
+The Terminal frontend (`require 'typr'`) is the default: raw terminal IO, no ncurses, works over SSH and on Termux.
 
 ## Installation
 
@@ -187,13 +186,12 @@ Clears the full screen or a single line (`:line`).
 Reads a single keypress in raw mode. Returns the key as a String (`KEY_ESCAPE`, `?q`, arrow escape sequences), a `Typr::Mouse` struct for mouse reports, or `nil` when input is unavailable.
 
 ### `Typr.read_line(prompt, ...)`
-The shared interactive line editor. Renders a prompt and query at any position with arrow keys, ctrl-arrow word jumps, Home/End/Delete/Backspace; Enter confirms, Escape aborts (`nil`). An optional block runs after each keypress and may short-circuit with a result:
+The shared interactive line editor. Renders a prompt and query at any position with arrow keys, ctrl-arrow word jumps, Home/End/Delete/Backspace; Enter confirms, Escape aborts (`nil`). An optional block runs after each keypress and may short-circuit with a result. Pass `completions:` — a callable `->(query, cursor) { candidates }` — and TAB matches the current word against `candidates` in a pick grid: a candidate is either a string or `[text, color-pair]` to tint its pick entry. Pass `regex:` — a Hash of `Regexp => color` — and matching regions of the query are colored as they are typed, restoring the prompt's trailing color code. The editor is agnostic to where candidates come from.
 
 ```ruby
-Typr.read_line "/" do |key, query, cursor|
-  filter query
-  nil
-end
+Typr.read_line "/", completions: ->(query, cursor) {
+  songs.select { |s| s.start_with? query[0...cursor] }
+}
 ```
 
 ### `Line#ask`
@@ -204,6 +202,13 @@ Strict question types:
 
 The question and answer are rendered in `@colors[:question]`/`@colors[:answer]`.
 
+### `Line#cli`
+Prompts for a single command line with TAB completion matched against the shell (bash commands, options, and files). `completions: true` switches on the content; `initial:` seeds the line; `redraw:` repaints while the completion grid is up. The typed command tints with `@colors[:regex]` — default red for the first word, blue for `--options`. Completion candidates are plain strings.
+
+```ruby
+line.cli "> ", initial: "cp %name %dir", completions: true, redraw: -> { show }
+```
+
 ### Layout properties (all components)
 - `top`, `bottom`, `left`, `right` — placement. Integers for absolute offsets, floats (0-1) for relative sizing. Negative values position from the opposite edge. (`bottom: -1` = last row)
 
@@ -225,6 +230,7 @@ The question and answer are rendered in `@colors[:question]`/`@colors[:answer]`.
 | `input` | String or IO-like stream to display |
 | `header` | Header bar text |
 | `border` | Border style: `:round`, `" "`, etc. |
+| `tabspace` | Tab width; tabs expand to this many spaces (default 2) |
 | `.search` | Search the text (`/`); `.search_next`/`.search_prev` (`n`/`p`) |
 
 ### Browser options

data/lib/browser.rb

@@ -54,10 +54,11 @@ module Typr
     #   browser.cd ".."          # => parent directory
     #   browser.cd 2             # => jump to history entry 2
 
-    def cd dir, append=false
+    def cd dir, append=false, trim=0
       return unless dir
       data, missing = [],{}
       unless append
+        same = File.expand_path( dir ) == File.expand_path( @directory.to_s )
         begin
           path = File.expand_path( dir )
           Dir.chdir( path )
@@ -71,7 +72,8 @@ module Typr
         clear
         @directory = path
       else
-        entries = Dir.new( @directory ).children
+        Dir.chdir( dir )
+        entries = Dir.new( dir ).children
       end
       data = entries.reject{|f|
         !@show_hidden and f[0] == ?. }.map { |file| scan_file file }
@@ -103,36 +105,44 @@ module Typr
           next unless file
           data[ missing[file] ][TYPE, 2] = mime.split( ?/ ) if missing[file] }
       end
-      data.each { |row| row[0] = File.join(@directory, row[0]) }
+      data.each { |row|
+        row[0] = File.join(append ? dir : @directory, row[0])
+        row[PATH] = "./" + (File.dirname(row[0])[(trim > 1 ? trim + 1 : trim)..-1] || "")
+      }
       self << data
       sort
       filter
       unless append
         @directory += ?/ unless @directory == ?/
         change_view @view
-        reset :position
+        reset :position unless same
       end
       return
     end
 
     ##
-    # Build a row for a single directory entry from filesystem metadata only.
-    # MIME type detection (extension database and +file --mime-type+) happens
-    # in a batch pass inside {#cd}; type/subtype are left as +"?"+ here.
+    # Build a row for a single directory entry from filesystem metadata plus a
+    # cheap content probe for the +printable+ flag (no NUL byte and valid
+    # UTF-8 in the first 8KB). MIME type detection (extension database and
+    # +file --mime-type+) happens in a batch pass inside {#cd}; type/subtype
+    # are left as +"?"+ here.
     #
-    #   browser.scan_file "image.png"   # => 12-column row
+    #   browser.scan_file "image.png"   # => 14-column row
 
     def scan_file file
       target = nil
       if File.symlink? file
         target = File.readlink( file ) rescue $!.to_s
-        return [file, target, "????", false, "?", "?", 0, 0, 0, 0, "?", "?", nil] unless File.exist?(file)
+        return [file, target, "????", false, false, "?", "?", 0, 0, 0, 0, "?", "?", nil] unless File.exist?(file)
       end
       stat = File.stat(file) rescue nil
-      return [file, "", "????", false, "?", "?", 0, 0, 0, 0, "?", "?", nil] unless stat
-      [  file, target, stat.mode.to_s(8)[-3..-1].chars.map{|d|
+      return [file, "", "????", false, false, "?", "?", 0, 0, 0, 0, "?", "?", nil] unless stat
+      chunk = stat.file? ? ( File.open( file, "rb"){ |f| f.read 8192 } rescue nil ) : nil
+      printable = !!chunk && !chunk.include?("\x00") &&
+        chunk.dup.force_encoding( Encoding::UTF_8 ).valid_encoding?
+      [ 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,
-        ( File.executable?(file) and stat.file? ), stat.uid, stat.gid, stat.size,
+        ( File.executable?(file) and stat.file? ), printable, stat.uid, stat.gid, stat.size,
         stat.atime.to_i, stat.mtime.to_i, stat.ctime.to_i, "?", "?", nil ]
     end
 
@@ -159,10 +169,7 @@ module Typr
       return unless view
       view = @views.keys[ view ] if view.is_a? Integer
       @sequence = @views[ view ].map{|title| @header.index title.to_s}
-      if @show_path
-        @data.each { |row| row[PATH] = File.dirname(row[NAME]) } if @data.any?
-        @sequence.insert(@sequence.index(NAME) || 0, PATH) unless @sequence.include?(PATH)
-      end
+      @sequence.insert(0, PATH) if @show_path
       reset :format
       @view = view
       return
@@ -260,7 +267,7 @@ module Typr
     #
     #   browser.reset_view
 
-    def reset_view; cd @directory; reset [:display, :selection, :position]; sort end
+    def reset_view; reset [:display, :selection]; cd @directory; sort end
 
     ## Open a filter popup on the chosen row/column and apply the input.
     #
@@ -415,7 +422,7 @@ module Typr
         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 )
+        colors:{ columns: [ @colors[:actions][args[:type].to_s.gsub(/[\[\]]/, '').downcase.to_sym] ] } }.merge args )
     end
 
     ##
@@ -426,7 +433,7 @@ module Typr
     #   +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[:actions]+  | { filter: :red, ... }           | Status bar item colors
     #   +colors[:dir_history]+ | :yellow                      | History picker column color
     #   +colors[:types]+     | (see below)                    | Per MIME-type foreground color
     #
@@ -445,7 +452,7 @@ module Typr
       @left ||= 0
       @top ||= 0
       @directory ||= ?~
-      @colors[:actions] = { "[f]ilter": :red, "[s]ort": :blue, "[v]iews": :green
+      @colors[:actions] = { filter: :red, sort: :blue, views: :green
         }.merge @colors[:actions] || {}
       @colors[ :types ] = {
             image: :blue,
@@ -460,13 +467,11 @@ module Typr
         'x-msdownload': :red, 'x-pie-executable': :red
       }.merge( @colors[ :types ] || {} )
 
-      @keymap = { back: KEY_BACKSPACE, confirm: KEY_RETURN, help: ?h,
-        home: ?~, views: ?v,         sort_view: ?s, search: ?/,
-        mark: ?m, mark_range: ?M, mark_all: ?a, mark_invert: ?i,
-        filter_view: ?f, reset_view: ?r,
-        toggle_hidden: ?H}.merge @keymap
+      @keymap = { back: KEY_BACKSPACE, confirm: KEY_RETURN,
+        page_down: KEY_PAGEDOWN, page_up: KEY_PAGEUP, up: KEY_UP,
+        down: KEY_DOWN, to_top: KEY_HOME, to_bottom: KEY_END }.merge @keymap
 
-      self.header = %w[ name target permissions executable owner group size
+      self.header = %w[ name target permissions executable printable owner group size
         accessed modified created type subtype path ]
 
       @format[NAME] = :max
@@ -474,9 +479,11 @@ module Typr
       @ignore[NAME] = @ignore[TARGET] = true
       @hints = "1234567890"
       [NAME, SIZE, ACCESSED, MODIFIED, CREATED].each{|col| @rawsort[col] = true}
+      @rawsort[PRINTABLE] = @rawsort[EXECUTABLE] = false
 
       @procs[ACCESSED] = @procs[MODIFIED] = @procs[CREATED] = :datetime
       @procs[SIZE] = :magnitudes
+      @procs[EXECUTABLE] = @procs[PRINTABLE] = ->(v) { v ? "yes" : "no" }
       @procs[OWNER] = Proc.new{|uid| Etc.getpwuid(uid).name rescue uid }
       @procs[GROUP] = Proc.new{|gid| Etc.getgrgid(gid).name rescue gid }
 
@@ -487,8 +494,8 @@ module Typr
       @views = { simple: %i[ name ],
         compact: %i[ name size type],
         stats:   %i[ name size permissions owner group modified ],
-        full:    %i[ name size permissions executable owner group
-                     accessed modified created type subtype ] }.merge @views
+full:    %i[ name size permissions executable printable owner group
+             accessed modified created type subtype ] }.merge @views
       @parent = self
       @head ||= Grid.new( parent:self, left: ->{@parent.left}, margin: '',
         right: ->{@parent.width + @parent.left - 1}, top: ->{@parent.top-1},
@@ -498,8 +505,8 @@ module Typr
             "#{s} #{@parent.reverse ? "\u2193" : "\u2191"}"},
           ->{@parent.view} ] ], format: [:min, :max, :min, :min, :min],
         colors: { columns: [@colors[:default], @colors[:default],
-          @colors[:actions][:"[f]ilter"], @colors[:actions][:"[s]ort"],
-          @colors[:actions][:"[v]iews"]] } )
+          @colors[:actions][:filter], @colors[:actions][:sort],
+          @colors[:actions][:views]] } )
       @head.define_singleton_method( :data_at ) do |x, y|
         return unless x and y and y.between?( top + 1, bottom + 1 ) and
           x.between?( left, right )
@@ -522,11 +529,28 @@ module Typr
         ( pre + ( pre.end_with?( "/" ) ? "" : text[pre.length..-1][/\A[^\/]*/] ) ).sub( %r{(?<=.)/$}, "" )
       end
 
-      @user ||= Line.new( parent:self, left:->{@parent.left},top:->{@parent.bottom+1},
-        bindings: %w[ [h]elp [/]:search ] + @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 [~]:home [H]idden_files [back]:.. [up] [down] [pageup] [pagedown] [home] [end] [esc]:quit [return]:confirm\  ])
+      if args[:bindings]
+        bindings_labels = []
+        args[:bindings].each do |label, cmd|
+          name = label.gsub( /[\[\]]/, '' ).downcase.to_sym
+          colored = @colors[:actions][name] ?
+            color_code( @colors[:actions][name] ) + label + color_code(@colors[:default]) : label
+          bindings_labels << colored
+          key = extract_key(label)
+          next unless key
+          method = cmd.start_with?('!') ? cmd[1..-1].to_sym : cmd.to_sym
+          @keymap[method] = key
+        end
+        @user ||= Line.new( parent:self, left:->{@parent.left}, top:->{@parent.bottom+1},
+          bindings: bindings_labels )
+      else
+        @user ||= Line.new( parent:self, left:->{@parent.left},top:->{@parent.bottom+1},
+          bindings: %w[ [h]elp [/]:search ] + @colors[:actions].map{|name,color|
+            label = "[" + name.to_s[0] + "]" + name.to_s[1..]
+            color_code( color ) + label + color_code(@colors[:default]) } +
+              %w[ [r]eset [d]irectories [m]ark [M]ark_range mark_[a]ll
+              [i]nvert_mark [~]:home [H]idden_files [back]:.. [up] [down] [pageup] [pagedown] [home] [end] [esc]:quit [return]:confirm\  ])
+      end
       cd @directory
     end
   end

data/lib/grid.rb

@@ -169,11 +169,10 @@ module Typr
       @layer ||= @data.class.new
       return if @procs.empty?
       @layer[row] = @procs.map{ |col,proc|
-        proc = @functions[proc] if proc.is_a? Symbol
         cell = @data[row][col]
-        next unless cell
-        [ col, proc.lambda? ? proc.call( cell ) : proc.call( cell, row, col ) ] unless
-          cell.is_a?(Proc) }.to_h
+        next if cell.nil? or cell.is_a?(Proc)
+        proc = @functions[proc] if proc.is_a? Symbol
+        [ col, proc.lambda? ? proc.call( cell ) : proc.call( cell, row, col ) ] }.to_h
     end
 
     ##
@@ -256,6 +255,7 @@ module Typr
 
     def pick type = :row, row=0, column: nil
       return super(type, row) unless column
+      auto = !type.to_s['none']
 
       saved = [@filters.dup, @map, @start]
       base = @map || ids
@@ -286,6 +286,7 @@ module Typr
             @filters = [[column, query]]
             @map = base.select{ |id| check id }
             @start = 0
+            return @map.first if auto and @map.one?
           end
           show
           draw_hints
@@ -293,10 +294,15 @@ module Typr
         }
       case result
       when nil, :outside; @filters, @map, @start = saved
-      when Integer; return result
+      when Integer; Typr.suppress_keys if auto; return result
       else
-        @filters = result.empty? ? saved[0] : saved[0] + [[column, result]]
-        filter :all
+        picked = page.to_a[@hints_start]
+        if picked; Typr.suppress_keys if auto; return picked end
+        return begin
+          @filters = result.empty? ? saved[0] : saved[0] + [[column, result]]
+          filter :all
+          nil
+        end
       end
       return
     end

data/lib/line.rb

@@ -123,10 +123,17 @@ class Line < Space
         draw prepare( colored, width, @align, @trim )
         color( @colors[:answer] )
         case object
-          when Array then answer << object.first.pick( object[1], **(object[3] || {}) )
+          when Array
+            if object.first == :line
+              opts = object[1] || {}
+              answer << Typr.read_line(colored + color_code(@colors[:answer]),
+                left: left, top: top, initial: opts[:initial] || "")
+            else
+              answer << object.first.pick(object[1], **(object[3] || {}))
+            end
           when :key then answer << Typr.read_key
-          when :line then answer << Typr.read_line( colored + color_code( @colors[:answer] ),
-            left: left, top: top )
+          when :line then answer << Typr.read_line(colored + color_code(@colors[:answer]),
+            left: left, top: top)
         end
         return if !answer.last or answer.last == @keymap[:exit]
         text = ( object.is_a?(Array) and object[2] ) ?
@@ -142,6 +149,54 @@ class Line < Space
     return ( answer.one? ? answer.first : answer )
   end
 
+  # Prompt for a single command line at the cursor: +prompt+ rendered in the
+  # line's default color, typed input in the answer color. When +completions+
+  # is truthy, TAB matches the current word against the shell (commands,
+  # options, files) and replaces it through the pick grid. Regions of the
+  # typed input matching @colors[:regex] are colored as they are typed: the
+  # first word red (the command), double-dash options blue.
+  #
+  #   line.cli "> ", initial: "cp %name"
+  #   #=> "cp source.txt" (or nil on Escape)
+
+  def cli prompt, initial: '', redraw: nil, history: nil, prefixes: nil
+    re = /\A[#{Regexp.escape(prefixes || '|+=!')}]/
+    source = ->(query) {
+      bash_candidates(query.sub(re, '')).split("\n").reject(&:empty?).uniq }
+    colored = color_code(@colors[:default]).to_s + prompt + color_code(@colors[:answer])
+    Typr.read_line(colored, left: left, top: top, initial: initial,
+      completions: source, redraw: redraw, regex: @colors[:regex], history: history)
+  end
+
+  private
+
+  def bash_candidates part
+    IO.popen([{ 'COMP_LINE' => part, 'COMP_POINT' => part.bytesize.to_s },
+      'bash', '-ic', <<~SH], err: '/dev/null', &:read)
+      set +m; shopt -s expand_aliases
+      export PS1= PS2= PS3= PS4= PROMPT_COMMAND=
+      read -r -a COMP_WORDS <<< "$COMP_LINE"
+      [ "$COMP_LINE" != "${COMP_LINE% }" ] && COMP_WORDS+=( "" )
+      COMP_CWORD=$(( ${#COMP_WORDS[@]} - 1 ))
+      [ "$COMP_CWORD" -lt 0 ] && COMP_CWORD=0
+      cur=${COMP_WORDS[COMP_CWORD]}
+      if declare -F __load_completion >/dev/null 2>&1; then
+        __load_completion "${COMP_WORDS[0]}" 2>/dev/null
+      elif declare -F _completion_loader >/dev/null 2>&1; then
+        _completion_loader "${COMP_WORDS[0]}" 2>/dev/null
+      fi
+      Fn=$(complete -p "${COMP_WORDS[0]}" 2>/dev/null | awk '{print $(NF-1)}')
+      type "$Fn" >/dev/null 2>&1 && "$Fn" "${COMP_WORDS[0]}" "$cur" 2>/dev/null
+      if [ -z "${COMPREPLY[*]}" ]; then
+        if [ "$COMP_CWORD" -eq 0 ]; then compgen -A command -A alias -A file -- "$cur"
+        else compgen -A file -- "$cur"; fi
+      else printf '%s\n' "${COMPREPLY[@]}"
+      fi
+    SH
+  end
+
+  public
+
   def initialize args
     @right= -1
     @align = :left
@@ -149,7 +204,9 @@ class Line < Space
     @prompt = ?>
     super
     @bottom = @top
+    regex = { /(?:^|\s)--[^\s]+/ => :blue, /\A\S+/ => :red }
     @colors = { question: :green, answer: :yellow }.merge @colors
+    @colors[:regex] = regex if @colors[:regex].nil?
     reset
   end
 end

data/lib/space.rb

@@ -117,7 +117,7 @@ eval( method % ([name]*11) ) }
       instance_variable_set ?@ + name.to_s, value }
     @colors = symbolize( @colors ) if @colors.is_a? Hash
     @keymap = { exit: KEY_ESCAPE }.merge @keymap
-    @colors = { default: [:white, :black], border: [:white, :black] }.merge(@colors)
+    @colors = { default: [:white, :black], border: [:white, :black], regex: nil }.merge(@colors)
     borders = @borders.dup
     self.border = @border
     @borders.merge! borders

data/lib/stack.rb

@@ -127,7 +127,9 @@ module Typr
         color @colors[ :header ]
         move left,top
         draw @margin
+        mode :bold
         print :header
+        mode :reset
       end
       list = page.to_a
       list[ height-1 ] = nil if list.length < height

data/lib/terminal.rb

@@ -7,6 +7,10 @@ require 'unicode/display_width'
 
 module Typr
 
+  # User palette overriding the eight basic colors (black red green yellow
+  # blue magenta cyan white); absent names fall back to terminal resolution.
+  $palette = {}
+
   # Raw /dev/tty used for key input; falls back to $stdin when unavailable.
   INPUT = (IO.new IO.sysopen("/dev/tty", "r")) rescue $stdin
 
@@ -208,7 +212,7 @@ module Typr
   # Apply a text attribute (+mode+); mode_code returns the escape sequence
   # without writing it.
   def mode name; draw mode_code(name) end
-  def mode_code name; if id = MODES.index(name.to_s) then "\e[#{ id }m" end end
+  def mode_code name; if id = MODES.index(name.to_s.to_sym) then "\e[#{ id }m" end end
 
   # Build the ANSI code for +color+ (a Symbol name, greyN, Integer palette id,
   # or [r,g,b] / [fg,bg] Array), optionally as a background; when false the
@@ -217,7 +221,9 @@ module Typr
     color = color.to_sym if color.is_a? String
     case color
       when Symbol;
-        if id = COLORS.index(color); "\e[#{ id + (bg ? 40 : 30) }m"
+        if (spec = $palette[color]) and (spec.is_a?(Integer) or spec.is_a?(Array))
+          color_code(spec, bg)
+        elsif id = COLORS.index(color); "\e[#{ id + (bg ? 40 : 30) }m"
         elsif color[/^gr[ae]y\d{,2}$/]
           "\e[%i;5;%im" % [bg ? 48 : 38, 232 + (color[/\d+/].to_f/100*23).to_i]
         elsif id = COLOR_MAP[color]
@@ -230,6 +236,24 @@ module Typr
       end
     end
   end
+  module_function :color_code
+  public :color_code
+
+  # Returns +str+ with every region matched by the keys of +regex+ wrapped in
+  # the associated color, restoring +base+ after each region. Non-matching
+  # text passes through untouched. +regex+ may be nil or empty (no-op), and
+  # +base+ may be empty (color then persists to the end of the string).
+  #
+  # When two patterns match the same span, the earlier key in the Hash wins,
+  # so order overlapping keys longest-first.
+  #
+  #   Typr.paint "fix WARN now", { /WARN/ => :yellow }, "\e[39;49m"
+  def self.paint str, regex, base
+    return str if regex.nil? or regex.empty?
+    str.gsub( Regexp.union( regex.keys ) ) { |m|
+      color = regex[ regex.keys.find{ |k| k === m } ]
+      color_code( color ).to_s + m + base }
+  end
 
   # Read the current background/foreground color pair.
   def get_background; $color[1] end
@@ -260,6 +284,14 @@ module Typr
   # input is unavailable.
 
   def self.read_key
+    if quiet_window?
+      loop do
+        remaining = @suppress_until - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        break if remaining <= 0
+        break unless IO.select([INPUT], nil, nil, remaining)
+        begin INPUT.read_nonblock(1024) rescue break end
+      end
+    end
     read = ->(tty) do
       str = tty.sysread 6
       if str.start_with?("\e[M") and str.size < 6
@@ -303,6 +335,43 @@ module Typr
     Mouse.new button, x, y, action, modifiers
   end
 
+  ## Discard any bytes already waiting on the input stream, so input confirmed
+  # at a previous prompt cannot auto-answer the next one (e.g. a double-tapped
+  # Enter confirming a destructive default). Best-effort: never raises.
+  #
+  #   Typr.drain_input   # => nil
+
+  def self.drain_input
+    while IO.select([INPUT], nil, nil, 0)
+      begin
+        INPUT.read_nonblock(1024)
+      rescue IO::WaitReadable
+        break
+      end
+    end
+    nil
+  rescue StandardError
+    nil
+  end
+
+  # Post-auto-confirm input guard: keys within OVERTYPE_QUIET seconds of an
+  # auto-selected pick are discarded — in-app via +read_key+, and before a
+  # subprocess handoff via +flush_overtype+.
+  OVERTYPE_QUIET = 0.5
+
+  def self.suppress_keys timeout=OVERTYPE_QUIET
+    @suppress_until = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+  end
+
+  def self.quiet_window?
+    @suppress_until and $stdin.tty? and
+      @suppress_until > Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def self.flush_overtype
+    drain_input if quiet_window?
+  end
+
   ## Interactive line editor used for string prompts (search, %str, ...).
   #
   # Renders +prompt+ and the query at (left, top) and edits it with
@@ -312,14 +381,24 @@ module Typr
   # editor and becomes its return value. When stdin is not a tty, the
   # query is read from a single line of piped input instead.
   #
+  # +completions+ may be a callable matching the current word to a list
+  # of candidates; TAB then replaces the word through a pick grid. Each
+  # candidate is either a plain String or [text, color-pair] to tint the
+  # pick entry. The callable's content is arbitrary - shells, tags, ...
+  #
+  # +regex+ is a Hash of Regexp => color (see {.paint}) applied to the
+  # query as it is rendered; matched regions restore the prompt's trailing
+  # color code.
+  #
   #   Typr.read_line "/" do |key, query, cursor|
   #     filter query
   #     nil
   #   end
 
-  def self.read_line prompt='', left: 0, top: 0, initial: '', completions: nil, redraw: nil, &block
+  def self.read_line prompt='', left: 0, top: 0, initial: '', completions: nil, redraw: nil, regex: nil, history: nil, &block
     return $stdin.gets&.chomp unless $stdin.tty?
     query, cursor = initial.dup, initial.length
+    hist_idx = nil
     $>.print CURSOR_NORMAL
     begin
       loop do
@@ -327,7 +406,8 @@ module Typr
         $>.print ERASE_LINE
         before = text_width( prompt + query[0...cursor] )
         offset = [ left + before - Typr.width, 0 ].max
-        $>.print slice_width( prompt + query, offset, Typr.width - left + 1 )
+        display = prompt + paint( query, regex, prompt[/\e\[[0-9;]*m\z/].to_s )
+        $>.print slice_width( display, offset, Typr.width - left + 1 )
         $>.print "\e[%i;%if" % [ top + 1, left + 1 + before - offset ]
         key = read_key
         return nil if key.nil? or key == KEY_ESCAPE
@@ -339,6 +419,24 @@ module Typr
           when KEY_ALT_RIGHT, "\eC";   cursor = word_next query, cursor
           when KEY_HOME;            cursor = 0
           when KEY_END;             cursor = query.length
+          when KEY_UP, "\eOA";
+            if history&.any?
+              hist_idx = [((hist_idx || -1) + 1), history.size - 1].min
+              query = history[hist_idx].dup
+              cursor = query.length
+            end
+          when KEY_DOWN, "\eOB";
+            if history&.any? && hist_idx
+              hist_idx -= 1
+              if hist_idx < 0
+                query = +''
+                cursor = 0
+                hist_idx = nil
+              else
+                query = history[hist_idx].dup
+                cursor = query.length
+              end
+            end
           when KEY_DC, "\e[3~";     query.slice!(cursor, 1) if cursor < query.length
           when KEY_ALT_BACKSPACE
             old = cursor
@@ -360,32 +458,29 @@ module Typr
         result = block.call( key, query, cursor ) if block
         return result unless result.nil?
         if completions and key == KEY_TAB
-          raw = query[0...cursor]
-          cmd = raw[/\w+/]
-          if cmd
-            items = IO.popen([{ 'COMP_LINE' => raw, 'COMP_POINT' => raw.bytesize.to_s },
-              'bash', '-c', <<~SH], err: '/dev/null', &:read)
-              _init_completion(){ cur=${COMP_WORDS[COMP_CWORD]}; prev=${COMP_WORDS[COMP_CWORD-1]}; }
-              source /usr/share/bash-completion/completions/#{cmd} 2>/dev/null || exit
-              COMP_WORDS=($COMP_LINE) COMP_CWORD=$(( ${#COMP_WORDS[@]} - 1 ))
-              Fn=$(complete -p #{cmd} 2>/dev/null | awk '{print $(NF-1)}')
-              eval "$Fn" 2>/dev/null && printf '%s\\n' "${COMPREPLY[@]}"
-            SH
-            items = items.split("\n").reject(&:empty?).uniq
-            if items.any?
-              grid = Grid.new(left: left, top: [top - items.size - 3, 0].max,
-                input: items.map{ |s| [s] }, border: :light,
-                colors: { columns: [[:blue, :default]] })
-              picked = grid.pick(:row, column: 0)
-              redraw&.call
-              $>.print CURSOR_NORMAL
-              if picked.is_a?(Integer)
-                word_start = cursor
-                word_start -= 1 while word_start > 0 and query[word_start - 1] != ' '
-                query[word_start...cursor] = items[picked]
-                cursor = word_start + items[picked].length
+            items = Array(completions.call( query[0...cursor] ))
+          if items.any?
+            fields = {}
+            input = items.each_with_index.map do |item, index|
+              if item.is_a?(Array)
+                fields[[index, 0]] = item[1]
+                item[0]
+              else
+                item
               end
             end
+            grid = Grid.new(left: left, top: [top - input.size - 3, 0].max,
+              input: input.map{ |s| [s] }, border: :light,
+              colors: { columns: [[:blue, :default]], fields: fields })
+            picked = grid.pick(:row, column: 0)
+            redraw&.call
+            $>.print CURSOR_NORMAL
+            if picked.is_a?(Integer)
+              word_start = cursor
+              word_start -= 1 while word_start > 0 and query[word_start - 1] != ' '
+              query[word_start...cursor] = input[picked]
+              cursor = word_start + input[picked].length
+            end
           end
         end
       end

data/lib/text.rb

@@ -33,9 +33,14 @@ module Typr
     #   text << "appended line"       # alias for build
 
     def build input=nil
-      ( input, @data, @lines = @data, "", [0] ) if rebuild = !input
+      ( input, @data, @lines = sanitize(@data), "", [0] ) if rebuild = !input
       return self if rebuild && input == ""
+      rows = @lines[0...-1].each_index.map{ |i| sanitize(@data[@lines[i]...@lines[i+1]]) }
+      @data = rows.join
+      off = [ 0 ]; rows.each{ |row| off << off.last + row.length }
+      @lines = off
       str = input.respond_to?(:read) ? input.read : input.to_s
+      str = str.gsub("\t", " " * @tabspace)
       @tail = ""
       pos = 0
       while pos < str.size || !@tail.empty?
@@ -80,6 +85,14 @@ module Typr
         end
       end
       @lines << @data.length unless @lines.last == @data.length
+      if (r = @colors[:regex]) and !r.empty?
+        base = color_code( @colors[:default][0] ).to_s
+        painted = @lines[0...-1].each_index.map{ |i|
+          Typr.paint @data[@lines[i]...@lines[i+1]], r, base }
+        @data = painted.join
+        off = [ 0 ]; painted.each{ |line| off << off.last + line.length }
+        @lines = off
+      end
       highlight if @re
     end
     alias :<< :build
@@ -109,7 +122,8 @@ module Typr
     #   text.positions(2)  # => [0, 6, 10, ...]
 
     def positions row
-      [0] + @page[row-1].chars.map.with_index{|c,i| i+1 if c == @separator}.compact
+      [0] + sanitize(@page[row-1]).chars.
+        map.with_index{ |c, i| i + 1 if c == @separator }.compact
     end
 
     # Full draw cycle: rebuilds on resize, computes visible lines,
@@ -197,7 +211,15 @@ module Typr
       @data, @lines, @tail = "", [0], ""
       @search = { pattern: nil, dir: :forward, last: nil, matches: [] }
       super args
-      @colors = { header: :yellow, search: :grey20 }.merge( @colors || {} )
+      regex = {
+      /\[[^\]]*\]|\([^)]*\)|\{[^}]*\}/ => :magenta,
+      /".*?"|'.*?'/                   => :green,
+      /\b\d+(?:\.\d+)?\b/             => :cyan,
+      /\b[\w.-]+:/                    => :yellow,
+      /[^\w\s]/                       => :grey60
+    }
+    @colors = { header: :yellow, search: :grey20 }.merge( @colors || {} )
+    @colors[:regex] = regex if @colors[:regex].nil?
       @keymap = { search: ?/, search_next: ?n, search_prev: ?p }.merge @keymap
       @lastwidth = width
       self << @input

data/typr.gemspec

@@ -2,8 +2,8 @@
 
 Gem::Specification.new do |s|
   s.name = "typr"
-  s.version = "1.5.1"
-  s.date = "2026-07-25"
+  s.version = "1.6.0"
+  s.date = "2026-09-30"
   s.homepage = "https://codeberg.org/typr/typr"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: typr
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Kilian Reitmayr
 bindir: bin
 cert_chain: []
-date: 2026-07-25 00:00:00.000000000 Z
+date: 2026-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
@@ -37,8 +37,6 @@ files:
 - example/text
 - example/top500.csv
 - lib/browser.rb
-- lib/frontend.rb
-- lib/graphical.rb
 - lib/grid.rb
 - lib/line.rb
 - lib/space.rb

data/lib/frontend.rb

@@ -1,23 +0,0 @@
-module Visuals
-
-  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],
-    dark_red:     [  90,   30,   30],
-    dark_green:   [  30,   90,   30],
-    dark_yellow:  [  90,   80,   30],
-    dark_blue:    [  30,   30,   90],
-    dark_magenta: [  90,   30,   90],
-    dark_cyan:    [  30,   80,   80] }
-
-  COLORS.merge! 1.upto(9).map{ |i|
-    ["grey#{ i*10 }".to_sym, [i*25]*3 ] }.to_h
-
-end

data/lib/graphical.rb

@@ -1,121 +0,0 @@
-require 'sdl3'
-require_relative 'frontend'
-
-module Visuals
-  include SDL2
-
-  SDL2.init(SDL2::INIT_VIDEO)
-  TTF.init
-  WINDOW = Window.create("visuals",
-    Window::POS_CENTERED,
-    Window::POS_CENTERED,
-    1324, 768, 0)
-  GO = WINDOW.create_renderer(-1,
-    Renderer::Flags::ACCELERATED|Renderer::Flags::TARGETTEXTURE)
-  Key.constants.each{ |c| c = c.to_s
-    eval 'KEY_'+c.upcase+'=Key::'+c }
-
-  def self.width;  WINDOW.size[0] / $charsize[1] end
-  def self.height; WINDOW.size[1] / $charsize[0] end
-  def self.row; $row end
-  def self.column; $col end
-  def self.x; $x end
-  def self.y; $y end
-
-  def color_for c
-    return unless c
-    c = COLORS[c] if c.is_a?( Symbol )
-    c.map{ |c| (c/1000.0*256).to_i }
-  end
-
-  def get_background; $color[1] end
-  def get_foreground; $color[0] end
-  def background color; return unless color
-    $color[1] = color_for( color ) end
-  def foreground color;
-    $color[0] = (color ? color_for( color ) : $default[0]) end
-
-  def color c
-    c = [c] unless c.is_a? Array and c.count == 2
-    foreground c[0]
-    background c[1]
-  end
-
-  def move col, row
-    $x = ($col = col) * $charsize[1]
-    $y = ($row = row) * $charsize[0]
-  end
-
-  def clear type = :screen
-    GO.draw_color = $default[1]
-    case type
-      when :screen; GO.fill_rect Rect.new(0, 0, *WINDOW.size)
-      when :line; GO.fill_rect Rect.new(
-        Visuals.x, Visuals.y, WINDOW.size[0], Visuals.y+$charsize[0])
-      when :down; GO.fill_rect Rect.new(
-        0, Visuals.y, *WINDOW.size)
-    end
-  end
-
-  def draw( str )
-    return unless str
-    if get_background
-      GO.draw_color = get_background
-      GO.fill_rect Rect.new($x, $y, str.size*$charsize[1], $charsize[0])
-    end
-    text = str.rstrip
-    unless text.empty?
-      image = $font.render_blended( text, get_foreground )
-      GO.copy GO.create_texture_from( image ), nil,
-        Rect.new($x, $y, image.w, $charsize[0])
-    end
-    move $col+str.size, $row
-  end
-
-  def refresh; GO.present end
-
-  def read input
-    case input
-      when :event then e = Event.poll until e
-      when :key then
-        e = Event.poll until e.is_a? Event::KeyDown
-        return e.sym.between?(32, 126) ? e.sym.chr : e.sym
-      when :line
-        str = ''
-        loop do
-          e = Event.poll
-          next unless e.is_a? Event::KeyDown
-          return nil if e.sym == KEY_ESCAPE
-          return str if e.sym == KEY_RETURN
-          str << e.sym.chr if e.sym.between? 32, 126
-        end
-    end
-  end
-
-  def self.exit
-  end
-
-  def self.init args={}
-    $default = [
-      color_for( args[:foreground] || :grey80 ),
-      color_for( args[:background] || :grey10 ) ]
-    $color = $default.dup
-    $charsize = args[:charsize] || [18,11]
-    $font = TTF.open( args[:font] || "/usr/share/fonts/X11/TTF/VeraMono.ttf", $charsize[0] )
-    move 0, 0
-  end
-
-end
-
-if __FILE__ == $0
-  include Visuals
-  Visuals.init font:ARGV[0]
-  characters = (32..126).map(&:chr).join
-  loop do
-    clear
-    COLORS.keys.each_with_index{ |c,i|
-      foreground c; move 0,i; draw characters }
-    refresh
-    exit if read(:key) == KEY_ESCAPE
-  end
-end