booker 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 072d423925a81f2c79870c6019e99615906fdca3391ce795abc80bac49e4688b
-  data.tar.gz: e01d49d23c0f36282e387c7b2391c225dde73c0aaa5d6106765296e6f0b333e2
+  metadata.gz: 51a33aad3cbed45ed09f6fa35f2046223dca0d5dd82fe15be7c49cb8aaa4c41d
+  data.tar.gz: 3054f0c7657e98c6c794b768ca9450992d3ee83b91526fc9cb88c5de6a4bc5ad
 SHA512:
-  metadata.gz: d5facfef0a12be688be4960b4f76f982765870239a43ca1ea1197fcad4c8225d33bea1e14521bd556219d5b6b0ae51f0083ece20f405f53d9fec438e62f69722
-  data.tar.gz: 2b01bbb94d2a50d124b31fd42289f4d2ab24155d333fccc0c96b14f0cc2898dd7823d8cba881f5eaa48b778d13df7c4c48a50f9e79420ce9b166919ce5e3f56d
+  metadata.gz: e6ced499e2b20d75987fc8c538b95bfb5a9912549b49848c0b6e827bc3c5f8dd3aed72c17c585b5080d16c60a48832d57f6a829d5ebf465f9068969418dc4898
+  data.tar.gz: fb1a648048fbe579ae1cdaee106da02fc1dc345874119fa0ef846dbc1d0631e63dbec150c5509b66a325ecce991969acf369ce5b096b9571d4c97269294bb66a

data/bin/booker

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative "../lib/booker"
 
 # booker by jeremy warner
-# open up a website or search in google chrome from cli
-# also show and/or open up google chrome bookmarks
+# open up a website or search from the cli, or open one of your bookmarks
 
-Booker.new(ARGV)
+Booker::CLI.new(ARGV)

data/completions/_booker

@@ -0,0 +1,115 @@
+#compdef booker
+#autoload
+
+
+_booker_bookmarks() {
+    #http://zsh.sourceforge.net/Guide/zshguide06.html#l147
+    setopt glob bareglobqual nullglob rcexpandparam extendedglob automenu
+    unsetopt allexport aliases errexit octalzeroes ksharrays cshnullglob
+
+    #get bookmarks
+    local -a bookmarks sites search_terms
+    search_terms=()
+
+    #filter out 'booker', flags, already-completed URLs, and bookmark IDs typed
+    #by hand. completion inserts URLs, so anything carrying a scheme is a
+    #previous pick rather than a search term. the id pattern mirrors
+    #BOOKMARK_ID in lib/booker/cli.rb, which is the source of truth - safari
+    #ids are uuids, so digits alone do not cover them
+    for arg in "$@"; do
+        if [[ "$arg" != "booker" && "$arg" != -* && "$arg" != *://* \
+              && ! "$arg" =~ ^([0-9]+_[a-zA-Z0-9-]+|[0-9_]+)$ ]]; then
+            search_terms+=("$arg")
+        fi
+    done
+
+    #join search terms and get matching bookmarks. --complete-raw is the
+    #machine readable feed: id \t title \t url, never truncated or padded
+    local search="${search_terms[*]}"
+    sites=`booker --complete-raw $search`
+    bookmarks=("${(f)${sites}}")
+
+    #terminal colors
+    BLUE=`echo -e "\033[4;34m"`
+    RESET=`echo -e "\033[0;0m"`
+
+    #parse parts, color. the p flag makes zsh read \t as a real tab.
+    #
+    #every description has to fit on one screen line. -l below prints one match
+    #per line and zsh sizes the list on that basis, so a description that wraps
+    #makes the geometry wrong by however many lines it spilled onto - the menu
+    #then redraws over itself and over the scrollback above it. browsers happily
+    #store a whole page blurb as a title, so this is not a rare case: only the
+    #display is trimmed, and `urls` keeps the full link that actually gets
+    #inserted
+    #the colour escapes below are characters zsh counts when it sizes the list
+    #but the terminal draws as nothing, so the budget has to leave room for
+    #them (13) on top of a margin. erring small only trims a title slightly
+    #early; erring large puts the wrapping back
+    local -i width=$(( ${COLUMNS:-100} - 16 ))
+    (( width < 40 )) && width=40
+    local -a urls links
+    for bookmark in ${bookmarks[@]}; do
+        local -a split
+        split=("${(@ps:\t:)bookmark}")
+        urls+=( $split[3] )
+
+        #the url is the useful half, but cap it so one long link cannot crowd
+        #the title out entirely
+        local name=$split[2] link=$split[3]
+        local -i maxlink=$(( width / 2 ))
+        (( ${#link} > maxlink )) && link="${link[1,maxlink-1]}…"
+
+        local -i room=$(( width - ${#link} - 1 ))
+        (( room < 20 )) && room=20
+        (( ${#name} > room )) && name="${name[1,room-1]}…"
+
+        links+=("$name $BLUE$link$RESET")
+    done
+
+    #finally, add completions. the inserted value is the URL rather than the
+    #bookmark id: the id was opaque on the command line, and booker opens a URL
+    #argument directly, so both land in the same place. no -Q, so zsh quotes the
+    #query strings and fragments that URLs are full of.
+    #
+    #'list force' keeps the list on screen even when a single bookmark matches,
+    #so you can still read the folder and title of what is about to be inserted
+    compstate[insert]=menu
+    compstate[list]='list force'
+    compadd -U -l -X 'found bookmarks:' -d links -a urls
+}
+
+
+_booker() {
+    compstate[insert]=menu
+    local curcontext state line
+    typeset -A opt_args
+
+    _arguments -C \
+        '(-b)-b[do bookmark completion]'\
+        '(--bookmark)--bookmark[do bookmark completion]'\
+        '(-c)-c[show bookmark completions]'\
+        '(--complete)--complete[show bookmark completions]'\
+        '(--complete-raw)--complete-raw[tab completions, tab separated]'\
+        '(-l)-l[print the bookmark table, skipping the picker]'\
+        '(--list)--list[print the bookmark table, skipping the picker]'\
+        '(-i)-i[perform installations (all, bookmarks, completion, config, safari)]'\
+        '(--install)--install[perform installations (all, bookmarks, completion, config, safari)]'\
+        '(-s)-s[search google for...]'\
+        '(--search)--search[search google for...]'\
+        '(-h)-h[show booker help]'\
+        '(--help)--help[show booker help]'\
+        '(-v)-v[show version]'\
+        '(--version)--version[show version]'\
+        '*::bookmarks:->bookmarks'
+
+    # Handle the bookmarks state for repeated completions
+    case $state in
+        bookmarks)
+            _booker_bookmarks $words
+            ;;
+    esac
+}
+
+
+_booker

data/completions/booker.bash

@@ -0,0 +1,52 @@
+# bash completion for booker
+#
+# Candidates are bookmark URLs, not bookmark ids. bash has no per-candidate
+# descriptions (unlike zsh and fish), so a menu of bare ids -- 0_1, 2_7, ... --
+# would tell you nothing about what you are picking. booker opens a URL
+# argument directly, so completing to one lands in the same place as
+# completing to an id.
+#
+# Install with: booker --install bash
+
+_booker() {
+    local cur arg
+    local -a search_terms=()
+
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    COMPREPLY=()
+
+    # flags complete against the option list, not against bookmarks
+    if [[ "$cur" == -* ]]; then
+        COMPREPLY=($(compgen -W "-b --bookmark -i --install -s --search \
+            -l --list -c --complete --complete-raw -v --version -h --help" -- "$cur"))
+        return 0
+    fi
+
+    # everything typed so far, minus the command name, flags, any URL already
+    # completed onto the line, and any bookmark id typed by hand
+    for arg in "${COMP_WORDS[@]:1}"; do
+        [[ -z "$arg" ]] && continue
+        [[ "$arg" == -* ]] && continue
+        # completion inserts URLs, so a scheme marks a previous pick rather
+        # than something to search for
+        [[ "$arg" == *://* ]] && continue
+        # mirrors BOOKMARK_ID in lib/booker/cli.rb: safari ids are uuids
+        [[ "$arg" =~ ^([0-9]+_[a-zA-Z0-9-]+|[0-9_]+)$ ]] && continue
+        search_terms+=("$arg")
+    done
+
+    # --complete-raw prints one "id <tab> title <tab> url" per match, never
+    # truncated. read -r into fields so URLs containing glob characters (?, *)
+    # survive intact -- an unquoted $(...) would let bash try to expand them.
+    local id title url
+    while IFS=$'\t' read -r id title url; do
+        [[ -n "$url" ]] && COMPREPLY+=("$url")
+    done < <(booker --complete-raw "${search_terms[@]}" 2>/dev/null)
+
+    # NOTE: deliberately not filtered through `compgen -W ... -- "$cur"`.
+    # booker matches on bookmark title as well as URL, so a candidate often
+    # does not start with what the user typed, and compgen would drop it.
+    return 0
+}
+
+complete -F _booker booker

data/completions/booker.fish

@@ -0,0 +1,49 @@
+# fish completion for booker
+#
+# Candidates are bookmark URLs, matching zsh and bash. booker opens a URL
+# argument directly, so this lands in the same place a bookmark id would, and
+# the command line says what it is about to open. fish shows a description next
+# to each candidate, so the folder and title go there.
+#
+# Install with: booker --install fish
+
+function __booker_bookmarks --description 'list booker bookmarks matching the current commandline'
+    set -l tokens (commandline -poc) (commandline -ct)
+
+    # drop the command name itself
+    set -e tokens[1]
+
+    # keep the search terms: no flags, no already-completed URLs, no bookmark
+    # ids typed by hand
+    set -l terms
+    for arg in $tokens
+        test -z "$arg"; and continue
+        string match -qr '^-' -- $arg; and continue
+        # completion inserts URLs, so a scheme marks a previous pick
+        string match -qr '://' -- $arg; and continue
+        # mirrors BOOKMARK_ID in lib/booker/cli.rb: safari ids are uuids
+        string match -qr '^([0-9]+_[a-zA-Z0-9-]+|[0-9_]+)$' -- $arg; and continue
+        set -a terms $arg
+    end
+
+    # --complete-raw prints "id <tab> title <tab> url"; fish wants
+    # "value <tab> description", so complete to the url and describe it with
+    # the folder and title
+    booker --complete-raw $terms 2>/dev/null | while read -l -d \t id title url
+        printf '%s\t%s\n' $url $title
+    end
+end
+
+complete -c booker -f -a '(__booker_bookmarks)'
+
+complete -c booker -s b -l bookmark -d 'explicitly open bookmark'
+complete -c booker -s s -l search -d 'explicitly search arguments'
+complete -c booker -s l -l list -d 'print the bookmark table, skipping the picker'
+complete -c booker -s c -l complete -d 'show tab completions'
+complete -c booker -l complete-raw -d 'tab completions, tab separated (for shell scripts)'
+complete -c booker -s v -l version -d 'print version'
+complete -c booker -s h -l help -d 'show help'
+# the shell names here mirror SHELLS in lib/booker/installer.rb, which is the source of
+# truth - add a shell there and it needs adding here too
+complete -c booker -s i -l install -x -d 'install booker support files' \
+    -a 'all bookmarks completion config safari zsh bash fish'

data/lib/booker/bookmarks.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# grab/parse bookmarks from every configured source, and the two value objects
+# the parsers hand back. Set needs no require - autoloaded since ruby 3.2, the
+# floor in the gemspec
+
+require_relative "output"
+
+using Booker::Colors
+
+module Booker
+  # Main Bookmarks facade class
+  class Bookmarks
+    # one row per browser: everything booker knows about a bookmark source
+    # lives here, so a fourth browser is an entry rather than a hunt through the
+    # parser lookup, the installer's labels and its colors. chrome's file has no
+    # extension, so it is the fallback rather than a row to match on
+    BROWSERS = {
+      firefox: {parser: Parsers::Firefox, ext: ".sqlite", label: "[Firefox]", color: :blu},
+      safari: {parser: Parsers::Safari, ext: ".plist", label: "[Safari]", color: :cyan},
+      chrome: {parser: Parsers::Chrome, ext: nil, label: "[Chrome]", color: :yel}
+    }.freeze
+
+    # which browser wrote this file, by name. the installer labels sources with
+    # it and the parse loop below picks a parser with it, so the two can never
+    # disagree about what a path is
+    def self.source_for(path)
+      BROWSERS.find { |_, b| b[:ext] && path&.end_with?(b[:ext]) }&.first || :chrome
+    end
+
+    attr_reader :allurls
+
+    def initialize(search_term = "")
+      @conf = Config.default
+      @allurls = []
+      seen = Set.new
+
+      # stat each configured path once, not once to count them and again to
+      # read them. the index is kept: it is the source half of every id
+      sources = @conf.bookmarks.each_with_index.select { |p, _| p && File.exist?(p) }
+      @multi_source = sources.length > 1
+
+      sources.each do |file_path, source_index|
+        source = self.class.source_for(file_path)
+        parser = BROWSERS.fetch(source)[:parser].new(file_path, search_term)
+        parser.parse
+
+        parser.results.each do |bookmark|
+          # add? is nil when the key was already there, so the dedupe check and
+          # the record of having seen it are the same call
+          next unless seen.add?([bookmark.title, bookmark.url])
+
+          @allurls << Bookmark.new(
+            folder: bookmark.folder,
+            title: bookmark.title,
+            url: bookmark.url,
+            id: "#{source_index}_#{bookmark.id}",
+            source: source
+          )
+        end
+      end
+    end
+
+    # output for zsh autocompetion, print out id, title and cleaned url
+    def autocomplete
+      @allurls.each do |url|
+        name = clean_name(url)
+        link = clean_link(url)
+        puts url.id + ":" + name + ":" + link
+      end
+    end
+
+    # one tab separated id/title/url triple per bookmark, shared by the shell
+    # completion feed and the picker. never truncated or padded, unlike
+    # #autocomplete: `tput cols` is unreliable in a completion subshell and a
+    # truncated url opens a broken link. tabs and newlines go from every field,
+    # not just the url - one surviving in a folder name splits that bookmark
+    # into two candidates the picker offers separately, neither openable
+    def rows
+      @allurls.map do |url|
+        [url.id, display_name(url), url.url].map { |f| f.to_s.delete("\t\n") }.join("\t")
+      end
+    end
+
+    # machine readable feed for the shell completion scripts
+    def autocomplete_raw
+      rows.each { |row| puts row }
+    end
+
+    # clean title for completion, delete anything not allowed in linktitle
+    def clean_name(url)
+      # Use half terminal width for name to leave room for URL
+      display_name(url).window((Term.width / 2).clamp(..50))
+    end
+
+    # "[source] folder | title", with no width applied
+    def display_name(url)
+      # Format: [source] folder | title (source only when multi-source)
+      prefix = (@multi_source && url.source) ? "[#{url.source}] " : ""
+      name = prefix + url.display_folder + " | " + url.title.gsub(/[^a-z0-9\-\/_ ]/i, "")
+      name.squeeze!("-")
+      name.squeeze!(" ")
+      # a top level bookmark has no folder text, which would otherwise leave a
+      # leading space - invisible in the padded #clean_name output, but not in
+      # the raw feed the completion scripts read
+      name.strip
+    end
+
+    # clean link for completion, remove strange things from any linkurls
+    def clean_link(url)
+      link = url.url.gsub(/[,'"&?].*/, "")
+      link.gsub!(/.*:\/+/, "")
+      link.delete!(" ")
+      # Use half terminal width for URL
+      max_width = (Term.width / 2 - CODEWIDTH).clamp(..50)
+      link[0..max_width]
+    end
+
+    # get link (from id number). #each returned @allurls itself when nothing
+    # matched, so a bad id reached open_bookmark as an Array and blew up with a
+    # TypeError instead of the "bookmark not found" message
+    def bookmark_url(id)
+      @allurls.find { |url| id == url.id }&.url
+    end
+  end
+
+  # for recursively parsing bookmarks
+  class Folder
+    attr_reader :json, :title
+
+    # the browsers disagree about what punctuation belongs in a folder name, so
+    # every parser normalizes through here rather than carrying its own copy of
+    # the rule for the levels it builds itself
+    def self.normalize(title) = title.gsub(/[:,'"]/, "-").downcase
+
+    def initialize(json, title = "|")
+      @title = Folder.normalize(title)
+      @json = json
+    end
+  end
+
+  # one parsed bookmark. the three browsers disagree about what punctuation
+  # belongs in a title, so cleaning happens here rather than in each parser.
+  # Data.new still accepts positional args, so the parsers could pass either
+  Bookmark = Data.define(:folder, :title, :url, :id, :source) do
+    def initialize(folder:, title:, url:, id:, source: nil)
+      super(folder:, title: title.gsub(/[:'"+]/, " ").downcase, url:, id:, source:)
+    end
+
+    # the folder as a reader sees it: no leading marker, no trailing slash, a
+    # name for the top level - which "|" and "|/" both mean, both leaving
+    # nothing behind once stripped. shared by the picker feed and the --list
+    # table, which each used to decide for itself what "top" looked like
+    def display_folder
+      stripped = folder.gsub(/^\|/, "").chomp("/")
+      stripped.empty? ? "[root]" : stripped
+    end
+
+    # ruby 3.2's Data#with copies members straight across instead of going back
+    # through #initialize, so a title replaced there would keep its punctuation
+    # and case. 3.3 fixed it; spelling it out keeps the gemspec's ">= 3.2" true
+    def with(**changes) = self.class.new(**to_h.merge(changes))
+  end
+end

data/lib/booker/cli.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+# parse booker's command line args and act on them
+
+require_relative "output"
+
+using Booker::Colors
+
+module Booker
+  class CLI
+    include Browser
+    include Output
+
+    # a bookmark id is "<source index>_<browser id>". safari uses a uuid where
+    # chrome and firefox number theirs, so the second half is anything id-shaped
+    # rather than digits; bare digits stay valid for single-source configs
+    # written before the prefix existed. completion inserts urls now, but ids
+    # are still first class - --bookmark takes them, the picker returns them
+    BOOKMARK_ID = /\A(?:\d+_[a-z0-9-]+|[0-9_]+)\z/i
+
+    def initialize(args)
+      parse args
+    end
+
+    def parse(args)
+      show_bookmarks if args.none?
+
+      if args.first&.start_with?("-")
+        dispatch_option(args)
+        exit 0
+      end
+
+      bookmark_ids, other_args = args.partition { |a| BOOKMARK_ID.match?(a) }
+      open_bookmark(bookmark_ids) unless bookmark_ids.empty?
+
+      unless other_args.empty?
+        # every argument being a url means they all came from tab completion,
+        # which inserts one per bookmark - open the lot. one non-url word makes
+        # the whole line a search, so a phrase containing a domain still is one
+        if other_args.all? { |arg| domain.match?(arg) }
+          other_args.each do |site|
+            puts "opening website: ".grn + site
+            openweb(prep(site))
+          end
+        else
+          pick_or_search(other_args.join(" ").strip)
+        end
+      end
+    end
+
+    def option_parser
+      # required here rather than at the top of the file: optparse is only
+      # reachable through an argument starting with "-", so `booker <term>` and
+      # every tab press paid to load it without ever building one
+      require "optparse"
+
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: booker [options] [arguments]"
+        opts.separator ""
+        opts.separator "Main options:"
+        opts.on("-b", "--bookmark", "explicitly open bookmark") { @mode = :bookmark }
+        opts.on("-i", "--install", "install: all|bookmarks|completion|config|safari") { @mode = :install }
+        opts.on("-s", "--search", "explicitly search arguments") { @mode = :search }
+        opts.on("-l", "--list", "print the bookmark table, skipping the picker") { @mode = :list }
+        opts.separator ""
+        opts.separator "Other options:"
+        opts.on("-c", "--complete", "show tab completions") { @mode = :complete }
+        opts.on("--complete-raw", "tab completions, tab separated (for shell scripts)") { @mode = :complete_raw }
+        opts.on("-v", "--version", "print version") {
+          puts VERSION
+          exit 0
+        }
+        opts.on_tail("-h", "--help", "show help") {
+          puts opts
+          exit 0
+        }
+      end
+    end
+
+    def dispatch_option(args)
+      option_parser.parse!(args)
+
+      case @mode
+      when :bookmark
+        pexit "Error: ".red + "booker --bookmark expects bookmark id" if args.empty?
+        open_bookmark(args)
+      when :install
+        installer.install(args.empty? ? %w[completion config bookmarks] : args)
+      when :search
+        pexit "Error: ".red + "--search requires an argument" if args.empty?
+        open_search(args.join(" "))
+      when :list
+        # `booker --list github` narrows the table, rather than silently
+        # dropping the term and printing everything
+        show_bookmarks(args.join(" "), force_table: true)
+      when :complete
+        Bookmarks.new(args.join(" ")).autocomplete
+      when :complete_raw
+        Bookmarks.new(args.join(" ")).autocomplete_raw
+      end
+    rescue OptionParser::InvalidOption => e
+      pexit "Error: ".red + e.message
+    end
+
+    def installer
+      # the installer pulls in find, fileutils and open3 and is reachable only
+      # through --install, so a plain search - and every completion subshell -
+      # loaded all of it to never call any of it
+      require_relative "installer"
+
+      @installer ||= Installer.new
+    end
+
+    def openweb(url)
+      # Pass URL directly to browser without invoking shell
+      # This avoids issues with special characters like parentheses
+      browser_cmd = browse.strip
+
+      # Redirect stdout/stderr to suppress GTK warnings
+      success = system(browser_cmd, url, out: File::NULL, err: File::NULL)
+
+      unless success
+        # system reports a missing binary as nil rather than false, but the
+        # forked child still exited - with 127, the shell convention for execvp
+        # failures - so there is a status either way. the &. is only for nothing
+        # in this process having spawned a child yet
+        code = Process.last_status&.exitstatus
+        puts "Warning: ".yel + "Failed to open URL (exit code: #{code})"
+      end
+    end
+
+    # bookmark ids, opened in order. parsing every source costs hundreds of
+    # milliseconds, so a caller that already has the set - the picker does -
+    # passes it in, and it is searched once for the list rather than once per id
+    def open_bookmark(bm, store = nil)
+      store ||= Bookmarks.new
+
+      bm.each do |id|
+        url = store.bookmark_url(id)
+        pexit "Failure:".red + " bookmark #{id} not found" if url.nil?
+        puts "opening bookmark ".grn + url
+        openweb(url)  # no shell quoting needed - system() handles it
+      end
+    end
+
+    def open_search(term)
+      puts "searching ".grn + term
+      search = Config.default.searcher
+      term = term.tr(" ", "+")
+      openweb(search + term)  # No shell escape needed - it's a URL
+    end
+
+    # a term matching bookmarks is offered as a choice; one matching nothing is
+    # a search, exactly as it always was. cancelling the picker is a decision
+    # rather than a fallthrough, and `booker -s <term>` still demands a search
+    def pick_or_search(term)
+      if Picker.enabled?
+        bookmarks = Bookmarks.new(term)
+        pick_and_open(bookmarks) unless bookmarks.allurls.empty?
+      end
+
+      open_search(term)
+    end
+
+    # offer the bookmarks as a choice and open what comes back. either way this
+    # ends the run: cancelling the picker is a decision, not a fallthrough to
+    # whatever the caller would have done instead
+    def pick_and_open(bookmarks)
+      id = Picker.select(bookmarks.rows)
+      exit 0 if id.nil?
+      open_bookmark([id], bookmarks)
+      exit 0
+    end
+
+    def show_bookmarks(term = "", force_table: false)
+      bookmarks = Bookmarks.new(term)
+      allurls = bookmarks.allurls
+
+      if allurls.empty?
+        puts "No bookmarks found.".red
+        puts "Run: ".yel + "booker --install bookmarks".cyan
+        exit 0
+      end
+
+      # the picker owns the screen when there is one, so nothing is printed
+      # above it. --list forces the table back for anyone who wants it
+      pick_and_open(bookmarks) if !force_table && Picker.enabled?
+
+      puts "Bookmarks:".grn + " (usage: booker <id> or booker <search>)"
+      puts ""
+
+      widths = column_widths
+      allurls.each { |bookmark| puts row(bookmark, widths) }
+
+      puts ""
+      puts "Found #{allurls.length} bookmarks".grn
+      puts ""
+      puts "Examples:".yel
+      puts "  #{"booker #{allurls.first.id}".ljust(20).cyan}  # Open first bookmark"
+      puts "  #{"booker github".ljust(20).cyan}  # Search bookmarks for 'github'"
+      puts "  #{"booker --help".ljust(20).cyan}  # Show help"
+
+      exit 0
+    end
+
+    # what is left of the terminal once the id column and the single spaces
+    # between columns are spoken for, shared out by proportion with a floor
+    # apiece so a narrow window still shows something of every field
+    ID_WIDTH = 10
+    SHARES = {folder: [0.20, 15], title: [0.30, 20], url: [0.50, 30]}.freeze
+
+    def column_widths
+      remaining = Term.width - ID_WIDTH - 3
+      SHARES.transform_values { |share, floor| (remaining * share).clamp(floor..).to_i }
+    end
+
+    def row(bookmark, widths)
+      [
+        bookmark.id.to_s.window(ID_WIDTH).grn,
+        bookmark.display_folder.window(widths[:folder]).blu,
+        bookmark.title.window(widths[:title]).yel,
+        bookmark.url.window(widths[:url])
+      ].join(" ")
+    end
+  end
+end