split off bmo: Remove libexec et al

src/ffoo/saturnin_urimagic.sh

@@ -1,134 +0,0 @@
-#!/bin/bash
-
-ffoo import inigrep
-ffoo import pretty
-
-
-#
-# Prefix for inigrep path for 1 and 2-arg queries
-#
-saturnin_urimagic__inipfx0="${saturnin_urimagic__inipfx0:-}"
-saturnin_urimagic__inipfxN="${saturnin_urimagic__inipfxN:-}"
-
-
-saturnin_urimagic__scan() {
-    #
-    # Scan stdin for what looks like URI, ID or keyword
-    #
-    # Output URIs: first what were apparent uris, then IDs converted to
-    # URIs, then equal sign expressions, then "tags" like bug1234 (i.e.
-    # letters+nubmbers, no spaces), then things that looked like
-    # kw expressions, converted to URIs.
-    #
-    # Note that kw expressions (e.g. "bug 123") work only if they start
-    # the line.
-    #
-    # Apply this filter to args or clipboard, and either use head -1 or
-    # if you are brave, open all URIs.
-    #
-    local d=$(mktemp -d -t saturnin_urimagic.XXXXXXXX)
-    local p=__saturnin_urimagic__
-    pushd "$d" >&/dev/null
-        ##
-        # heat up and fill pipes
-        #
-        mkfifo maybe_uris maybe_ids maybe_exps maybe_tags maybe_kws \
-               uris uris_from_ids uris_from_exps uris_from_tags uris_from_kws
-        cat | tee maybe_uris maybe_ids maybe_exps maybe_tags maybe_kws \
-            >/dev/null &
-        ##
-        # process each pipe *async* by different filter
-        #
-        < maybe_uris ${p}flt_uris             > uris &
-        < maybe_ids  ${p}flt_ids  | ${p}deref > uris_from_ids &
-        < maybe_exps ${p}flt_exps | ${p}deref > uris_from_exps &
-        < maybe_tags ${p}flt_tags | ${p}deref > uris_from_tags &
-        < maybe_kws  ${p}flt_kws  | ${p}deref > uris_from_kws &
-        ##
-        # print result *sync* in correct order
-        #
-        {
-            cat uris
-            cat uris_from_ids
-            cat uris_from_exps
-            cat uris_from_tags
-            cat uris_from_kws
-        } | grep .  # throw away empties; add missing LF
-    popd >&/dev/null
-    rm -rf "$d"
-}
-
-__saturnin_urimagic__deref() {
-    #
-    # Turn keyword or query (like "g hello" for google) to URI
-    #
-    local line      # input line,   eg. "g hello dolly" or "bug 1234"
-    local kw        # keyword part, eg. "g"             or "bug"
-    local query     # query part,   eg. "hello dolly"   or "1234"
-    local pfx0=$saturnin_urimagic__inipfx0
-    local pfxN=$saturnin_urimagic__inipfxN
-    while read kw query;
-    do
-        debug -v kw query
-        if test -n "$query";
-        then
-            local fmt=$(inigrep -j -1 -p "$pfxN.${kw,,}")
-            debug -v fmt
-            printf "$fmt\n" "$query"
-        else
-            inigrep -j -1 -p "$pfx0.$kw"
-        fi
-    done
-}
-
-__saturnin_urimagic__flt_exps() {
-    #
-    # Hack expressions like bug = 123 out of the text
-    #
-    sed -e 's/(\d)\</\n/;' \
-      | perl -CS -ne '
-            next unless m/\b([a-zA-Z]\w*\s*=\s*\w+)\b/;
-            print "$1\n";
-        ' \
-      | sed -re 's/\s*=\s*/ /' \
-      | tr '[:upper:]' '[:lower:]'
-}
-
-__saturnin_urimagic__flt_ids() {
-    #
-    # Hack doer-like id's (ID#123) out of the text
-    #
-    tr ' ' '\n' \
-      | perl -CS -ne '
-            next unless m/\b([a-zA-Z]\w*#\w+)\b/;
-            print "$1\n";
-        ' \
-      | tr '#' ' '
-}
-
-__saturnin_urimagic__flt_kws() {
-    #
-    # Hack out lines that look like kw expressions
-    #
-    grep -Ee '^\s*[a-zA-Z]\w*\s+[^=]' -e '^\s*[a-zA-Z]\w*$'
-}
-
-__saturnin_urimagic__flt_tags() {
-    #
-    # Hack "tags" like bug123 out of the text
-    #
-    tr ' ' '\n' \
-      | grep -E '^[a-zA-Z]+[0-9]+$' \
-      | sed -r 's/([a-zA-Z]+)([0-9])/\1 \2/'
-}
-
-__saturnin_urimagic__flt_uris() {
-    #
-    # Hack URIs out of the text.
-    #
-    tr ' ' '\n' \
-      | perl -CS -ne '
-            next unless m|(\bhttps?://[[:alnum:]_:/.?#&+,%@=;~-]+)\b|u;
-            print "$1\n";
-        '
-}

src/ffoo/saturnin_zleep.sh

@@ -1,94 +0,0 @@
-#!/bin/bash
-
-ffoo import inigrep
-ffoo import pretty
-ffoo import sync
-
-__zleep_user_part() {
-    saturnin iam undocking
-    slock &
-}
-
-__zleep_try_umount() {
-    local mp=$1
-    mountpoint -q "$mp" || return 0
-    umount        "$mp" || return 1
-    mount | grep  "$mp" && return 1
-    return 0
-}
-
-__zleep_try_umount_all() {
-    local mp
-    for mp in $(inigrep -p iam.mounting.point);
-    do
-        __zleep_try_umount "$mp" || return 1
-    done
-    return 0
-}
-
-__zleep_sudo_part() {
-    wait_until -d 5 -t 30 __zleep_try_umount_all || die "unable to unmount drives"
-    pm-suspend
-}
-
-__zleep_sudo_part_started() {
-    # i.e. password prompt went ok
-    test -e "$ZLEEP_ON_ROOT"
-    rv=$?
-    debug -v rv
-    return $rv
-}
-
-__zleep_user_part_done() {
-    ! test -e "$ZLEEP_ON_USER"
-    rv=$?
-    debug -v rv
-    return $rv
-}
-
-__zleep_min_path() {
-    echo -n "$(sudo env | grep ^PATH)"
-    echo -n :
-    echo -n "$(dirname "$(which ffoom)")"
-    echo -n :
-    echo -n "$(dirname "$(which saturnin)")"
-}
-
-zleep() {
-    #
-    # Put the host on sleep
-    #
-    # We need to
-    #
-    #  1. authenticate
-    #  2. start user's part in the background -- mainly slock
-    #  3. start root's part -- put system on sleep (unmount, suspend)
-    #
-    # This is solved by forking with sudo, and waiting for user part to indicate
-    # it has finished.  That way, we can ensure that suspend happens *after* the
-    # screen has been locked, and at the same time we leave authentication part
-    # on sudo.
-    #
-    if test -z "$ZLEEP_ON_USER";    ## we are parent (running as normal user)
-    then
-        ZLEEP_ON_USER=$(mktemp)
-        ZLEEP_ON_ROOT=$(mktemp -u)
-        SUDO_PATH=$(__zleep_min_path)   # needed while bins are still under local
-        debug -v ZLEEP_ON_USER ZLEEP_ON_ROOT SUDO_PATH
-        sudo env \
-            ZLEEP_ON_ROOT="$ZLEEP_ON_ROOT" \
-            ZLEEP_ON_USER="$ZLEEP_ON_USER" \
-            PATH="$SUDO_PATH" \
-            saturnin iam zleeping &
-        wait_until -t 60 __zleep_sudo_part_started    # i.e. password prompt done
-        __zleep_user_part
-        rm -f "$ZLEEP_ON_USER"
-    else                            ## we are child (running as root)
-        touch "$ZLEEP_ON_ROOT"
-        test "$(id -u)" -eq 0               || die "must be root"
-        wait_until __zleep_user_part_done   || die "timeout waiting for parent"
-        __zleep_sudo_part
-        rm -f "$ZLEEP_ON_ROOT"
-        return $?
-    fi
-}

src/libexec/saturnin-au

@@ -1,110 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import pretty
-
-ffoo import saturnin_meta
-
-
-usage() {
-    mkusage "up"     \
-            "down"   \
-            "flip"   \
-            "mute"   \
-            "query is_muted" \
-            "unmute"
-}
-
-
-sound_is_muted() {
-    #
-    # At least one playback channel is muted
-    #
-    local master_status="$(amixer get Master)"
-    echo "$master_status" \
-      | grep "Playback channels" \
-      | sed -e 's/.*: //; s/ - /\n/' \
-      | while read chname
-        do
-            grep -e "^ *$chname" <<<"$master_status"
-        done \
-      | grep -qse '\[off\]$'
-}
-
-do_down() {
-    #
-    # turn volume down
-    #
-    amixer -q sset Master 5%-
-}
-
-do_flip() {
-    #
-    # mute or unmute
-    #
-    if sound_is_muted;
-    then
-        amixer -q sset Master unmute;
-    else
-        amixer -q sset Master mute;
-    fi
-}
-
-do_mute() {
-    #
-    # mute
-    #
-    amixer -q sset Master mute
-}
-
-do_query() {
-    #
-    # Query properties
-    #
-    local query="$1"
-    debug -v query
-    case "$query" in
-        is_muted) sound_is_muted; return $? ;;
-        *)        usage                     ;;
-    esac
-}
-
-do_up() {
-    #
-    # turn volume up
-    #
-    amixer -q sset Master 5%+
-}
-
-do_unmute() {
-    #
-    # mute
-    #
-    amixer -q sset Master unmute
-}
-
-
-action=
-while true; do case "$1" in
-    up)     action=up;     shift ;;
-    down)   action=down;   shift ;;
-    flip)   action=flip;   shift ;;
-    mute)   action=mute;   shift ;;
-    query)  action=query;  shift ; break ;;
-    unmute) action=unmute; shift ;;
-    "")     break                ;;
-    *)      usage                ;;
-esac done
-
-debug "\$*='$*'"
-debug -v action
-
-case $action in
-    up|down|flip|mute|query|unmute)
-        saturnin_wraphook "do_$action" "$@"
-        ;;
-    *)
-        usage
-        ;;
-esac

src/libexec/saturnin-clip

@@ -1,140 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-
-
-#
-# Where to store clips
-#
-STORAGE_DIR="$SATURNIN_CACHE_HOME/clips"
-
-usage() {
-    mkusage "[ls]" \
-            "save [-1|-2|-c]" \
-            "load [-1|-2|-c]" \
-            "rm" \
-            "clean"
-}
-
-clipln() {
-    #
-    # Print desired clipboard(s) and \n
-    #
-    case $1 in
-        primary|secondary|clipboard)
-            xclip -o -selection "$1"   2>/dev/null
-            ;;
-        ALL)
-            xclip -o -selection primary   2>/dev/null
-            xclip -o -selection secondary 2>/dev/null
-            xclip -o -selection clipboard 2>/dev/null
-            ;;
-    esac
-    echo ""
-}
-
-save_clip() {
-    #
-    # Save single clip
-    #
-    local clipname=$1
-    mkdir -p "$STORAGE_DIR" || die "could not create directory for saving"
-    local path="$STORAGE_DIR/$(date +%Y%m%d-%H%M%S.clip)"
-    clipln "$clipname" > "$path"
-}
-
-lsclips() {
-    #
-    # List clips with MIME types and hints
-    #
-    local ft hint name
-    test -d "$STORAGE_DIR" || return 0
-    find "$STORAGE_DIR" -name "*.clip" 2>/dev/null \
-      | while read name;
-        do
-            ft=$(file -b -i "$name" | cut -d\; -f1)
-            case $ft in
-                text/*)
-                    hint=$(head -c 80 "$name" | tr '\n' '↵')
-                    ;;
-                *)
-                    hint=$(head -c 16 "$name" | hexdump -C | head -1)
-                    ;;
-            esac
-            echos "$(basename "$name") || $ft || $hint"
-        done
-}
-
-lspaths() {
-    #
-    # List only clip paths
-    #
-    ls "$STORAGE_DIR/"*.clip
-}
-
-load_clip() {
-    #
-    # Load single clip of choice
-    #
-    local clipname=$1
-    local name=$(pick_clip)
-    test -n "$name" || return 1
-    < "$STORAGE_DIR/$name" xclip -i -selection "$clipname"
-}
-
-rm_clip() {
-    #
-    # Remove single clip of choice
-    #
-    local name=$(pick_clip)
-    test -n "$name" || return 1
-    rm -f "$STORAGE_DIR/$name"
-}
-
-rm_all() {
-    #
-    # Drop all clips
-    #
-    test -n "$STORAGE_DIR" || die "storage directory is unset, aborting"
-    test -d "$STORAGE_DIR" || return 0
-    find "$STORAGE_DIR" -name "*.clip" -print0 | xargs -0 rm -f
-    rmdir "$STORAGE_DIR" 2>/dev/null | :
-}
-
-pick_clip() {
-    saturnin clip ls \
-      | saturnin dmenu \
-      | cut -d\   -f 1
-}
-
-
-clipname=primary
-action=list_nice
-while true; do case "$1" in
-    save)   action=save;        shift ;;
-    load)   action=load;        shift ;;
-    ls)     action=list;        shift ;;
-    lsh)    action=list_nice    shift ;;
-    rm)     action=remove;      shift ;;
-    clean)  action=clean;       shift ;;
-    -1)     clipname=primary;   shift ;;
-    -2)     clipname=secondary; shift ;;
-    -c)     clipname=clipboard; shift ;;
-    "")     break                     ;;
-    *)      usage                     ;;
-esac done
-
-debug "\$*='$*'"
-debug -v clipname action
-
-case $action in
-    save)       save_clip $clipname ;;
-    load)       load_clip $clipname ;;
-    remove)     rm_clip ;;
-    clean)      rm_all ;;
-    list)       lspaths ;;
-    list_nice)  lsclips ;;
-esac

src/libexec/saturnin-dmenu

@@ -1,46 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-
-usage() {
-    mkusage "[-l|--lines NUM] [--split CHAR] ARGS..."
-}
-
-lines=10
-maybe_split=cat
-delim=" "
-field=2-
-
-while true; do case $1 in
-    -l|--lines)     lines=$2; shift 2 || usage ;;
-    --split)        delim=$2; maybe_split=do_split; shift 2 || usage ;;
-    --split-field)  field=$2; maybe_split=do_split; shift 2 || usage ;;
-    --help|--usage) usage             ;;
-    *)              break             ;;
-esac done
-
-nb="$(inigrep -1 -p style.color.nbg)"
-nf="$(inigrep -1 -p style.color.nfg)"
-sb="$(inigrep -1 -p style.color.sbg)"
-sf="$(inigrep -1 -p style.color.sfg)"
-fn="$(inigrep -1 -p style.font)"
-fn=${fn:--*-terminus-medium-r-*-*-16-*-*-*-*-*-*-*}
-
-debug -v nb nf sb sf fn lines maybe_split delim
-
-style() {
-    test -n "$nb" && echo -n "-nb $nb "
-    test -n "$nf" && echo -n "-nf $nf "
-    test -n "$sb" && echo -n "-sb $sb "
-    test -n "$sf" && echo -n "-sf $sf "
-    test -n "$fn" && echo -n "-fn $fn "
-}
-
-do_split() {
-    cut "-d$delim" -f"$field"
-}
-
-dmenu -b -i -l "$lines" $(style) "$@" | $maybe_split

src/libexec/saturnin-iam

@@ -1,126 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-ffoo import sync
-
-ffoo import saturnin_meta
-ffoo import saturnin_zleep
-
-
-#
-# self help
-#
-
-available_commands="afk at back gone ooo wfh undocking zleeping"
-
-usage() {
-    mkusage "$available_commands"
-}
-
-
-#
-# querying
-#
-
-where_i_am() {
-    #
-    # what is my physical location?
-    #
-    if=$(inigrep -p iam.using.if)
-    gwmac=$(arp | grep "^gateway\\>.*\\<$if\$" | tr ' ' '\n' | grep :)
-    inigrep -p "iam.seeing.gw.$gwmac" || echo OUT
-}
-
-set_status() {
-    #
-    # set public status $1 by command in conf file
-    #
-    local what=$1
-    saturnin_runhook "say_$what"
-    saturnin_runhook "log_$what"
-}
-
-
-#
-# subcommand handlers
-#
-
-i_am_afk() {
-    #
-    # away from keyboard; blocks until i'm back again
-    #
-    saturnin_runhook "afk"
-    set_status "afk"
-    saturnin kb home    # make sure to set lang to default before locking
-    slock
-    set_status "atk"
-}
-
-i_am_at() {
-    #
-    # Just say where I am
-    #
-    where_i_am
-}
-
-i_am_back() {
-    #
-    # returning to work (should be called by other subcommands)
-    #
-    set_status "back"
-    klist -s || urxvt -e kinit
-}
-
-i_am_gone() {
-    #
-    # gone fishin'
-    #
-    kdestroy
-    ssh-add -D
-    set_status "gone"
-    i_am_afk
-    i_am_back
-}
-
-i_am_ooo() {
-    #
-    # too dangerous to implement
-    #
-    die "not implemented"
-}
-
-i_am_wfh() {
-    #
-    # too dangerous to implement
-    #
-    die "not implemented"
-}
-
-i_am_undocking() {
-    #
-    # i.e. hibernated
-    #
-    inigrep -p iam.undocking.like | bash -
-}
-
-i_am_zleeping() {
-    #
-    # i.e. hibernated
-    #
-    set_status "zleeping"
-    zleep
-    i_am_back
-}
-
-cmd=$1
-
-test -n "$cmd" || usage
-
-echo "$available_commands" | grep -qw "$cmd" || usage
-
-shift
-
-"i_am_$cmd" "$1"

src/libexec/saturnin-kb

@@ -1,59 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-
-
-usage() {
-    mkusage "[show]" \
-            "next" \
-            "home" \
-            "layout LAYOUT"
-}
-
-next_layout() {
-    #
-    # change layout to the next one in row
-    #
-    local cur="$current_layout"
-    local all="$(inigrep -p kb.layout)"
-    local def="$default_layout"
-    local nxt=$(
-        echo -e "$all\n$all" \
-          | grep -m 1 -A 1 "$cur" \
-          | tail -1
-    )
-    test -z "$nxt" && nxt=$def
-    test -z "$nxt" && nxt=us
-    debug -v all def cur nxt
-    echo "$nxt"
-}
-
-default_layout="$(inigrep -1 -p kb.layout)"
-current_layout="$(setxkbmap -v | grep '^symbols: ' | cut -d+ -f2)"
-
-layout=""
-action=show
-case "$1" in
-    home)     action=set; layout="$default_layout" ;;
-    next)     action=set; layout="$(next_layout)"  ;;
-    layout)   action=set; layout="$2"              ;;
-    ""|show)  true                                 ;;
-    *)        usage                                ;;
-esac
-
-
-debug -v layout current_layout default_layout
-
-case "$action" in
-    show)
-        echo "$current_layout"
-        exit
-        ;;
-    set)
-        test -n "$layout" || usage
-        setxkbmap "$layout"
-        ;;
-esac

src/libexec/saturnin-ln

@@ -1,48 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-
-DEFAULT_TARGET=$HOME
-
-usage() {
-    mkusage "[-t|--target TARGET] [SOURCE] [NAME]"
-}
-
-expand_tilde() {
-    #
-    # Exchange "~" for home
-    #
-    perl -pe "s|^[[:space:]]*~|$HOME|"
-}
-
-link() {
-    local src=$1
-    local dst=$2
-    think "linking $src to $dst"
-    rm -f "$dst"
-    ln -sr "$src" "$dst"
-}
-
-load() {
-    inigrep -p "ln.dir.$1" | expand_tilde
-}
-
-while true; do case $1 in
-    -t|--target)        target=$2           shift 2 || usage ;;
-    --help)             usage                       ;;
-    -*)                 usage                       ;;
-    *)                  src=$1; name=$2;    break   ;;
-esac done
-
-test -z "$target"               && target=$(load target)
-test -z "$target"               && target=$DEFAULT_TARGET
-test -z "$name"                 && name="$(basename "$PWD")"
-test -z "$src"                  && src="."
-
-debug -v src name target
-
-mkdir -p "$target"
-link "$src" "$target/$name"

src/libexec/saturnin-menu

@@ -1,156 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-
-usage() {
-    mkusage "[-g generator_cmd] [-s selector_cmd] [-c consumer_cmd] [name]"
-}
-
-SATURNIN_MENU_MNAME=""
-SATURNIN_MENU_GENERATOR=""
-SATURNIN_MENU_SELECTOR=""
-SATURNIN_MENU_SELECT_ARGS=""
-SATURNIN_MENU_CONSUMER=""
-
-load_parts() {
-    #
-    # Load mandatory parts for menu name $1
-    #
-    local mname
-
-    # last chance to get mname
-    test -n "$SATURNIN_MENU_MNAME" \
-     || SATURNIN_MENU_MNAME="$(get_mname)" \
-     || usage
-    mname="$SATURNIN_MENU_MNAME"
-
-    # check that menu item exists
-    inigrep -s "menu.$mname" | grep -q . \
-     || die "no such menu: $mname"
-
-    test -n "$SATURNIN_MENU_GENERATOR" \
-     || SATURNIN_MENU_GENERATOR="$(get_generator)"  \
-     || die "cannot find generator for menu: $mname"
-
-    test -n "$SATURNIN_MENU_SELECTOR" \
-     || SATURNIN_MENU_SELECTOR="$(get_selector)" \
-     || die "cannot find selector for menu: $mname"
-
-    test -n "$SATURNIN_MENU_SELECT_ARGS" \
-     || SATURNIN_MENU_SELECT_ARGS="$(get_select_args)"
-
-    test -n "$SATURNIN_MENU_CONSUMER" \
-     || SATURNIN_MENU_CONSUMER="$(get_consumer)" \
-     || die "cannot find consumer for menu: $mname"
-}
-
-get_mname() {
-    #
-    # Take from global INI default
-    #
-    inigrep -1 -p menu._default_.name | grep .
-}
-
-get_generator() {
-    #
-    # Obtain and echo generator for menu $mname
-    #
-    # First, look for 'generator' key in menu definition,
-    # then for items as 'item' keys at the same place,
-    # finally default 'generator'.
-    #
-    inigrep -1 -p "menu.$mname.generator" | grep . \
-     && return 0
-    inigrep -p "menu.$mname.item" | grep -m 1 -q . \
-     && echo "inigrep -p menu.$mname.item" \
-     && return 0
-    inigrep -1 -p "menu._default_.generator" | grep . \
-     && return 0
-    return 1
-}
-
-get_selector() {
-    #
-    # Obtain and echo selector for menu $mname
-    #
-    # First, look for 'selector' key in menu definition,
-    # then a default 'selector'.
-    #
-    inigrep -1 -p "menu.$mname.selector" | grep . \
-     && return 0
-    inigrep -1 -p "menu._default_.selector" | grep .
-}
-
-get_select_args() {
-    #
-    # Obtain and echo selector args for menu $mname
-    #
-    # First, look for 'select_args' key in menu definition,
-    # then a default 'select_args'.
-    #
-    inigrep -1 -p "menu.$mname.select_args" | grep . \
-     && return 0
-    inigrep -1 -p "menu._default_.select_args"
-}
-
-get_consumer() {
-    #
-    # Obtain and echo consumer args for menu $mname
-    #
-    # First, look for 'consumer' key in menu definition,
-    # then a default 'consumer'.
-    #
-    inigrep -1 -p "menu.$mname.consumer" | grep . \
-     && return 0
-    inigrep -1 -p "menu._default_.consumer" | grep .
-}
-
-do_generate() {
-    #
-    # Generate menu items
-    #
-    bash -n <<<"$SATURNIN_MENU_GENERATOR" \
-     || die "syntax errors in generator: $SATURNIN_MENU_GENERATOR"
-    eval "$SATURNIN_MENU_GENERATOR"
-}
-
-do_select() {
-    #
-    # Bring up selection UI
-    #
-    bash -n <<<"$SATURNIN_MENU_SELECTOR" \
-     || die "syntax errors in selector: $SATURNIN_MENU_SELECTOR"
-    eval "$SATURNIN_MENU_SELECTOR $SATURNIN_MENU_SELECT_ARGS"
-}
-
-
-do_consume() {
-    #
-    # Process the selected item(s)
-    #
-    bash -n <<<"$SATURNIN_MENU_CONSUMER" \
-     || die "syntax errors in consumer: $SATURNIN_MENU_CONSUMER"
-    eval "$SATURNIN_MENU_CONSUMER"
-}
-
-while true; do case "$1" in
-    -g) SATURNIN_MENU_GENERATOR="$2"; shift; shift ;;
-    -s) SATURNIN_MENU_SELECTOR="$2"; shift; shift ;;
-    -c) SATURNIN_MENU_CONSUMER="$2"; shift; shift ;;
-    -*) usage ;;
-    "") usage ;;
-    *)  SATURNIN_MENU_MNAME="$1"; shift; break ;;
-esac done
-
-load_parts
-
-debug -v SATURNIN_MENU_MNAME \
-         SATURNIN_MENU_GENERATOR \
-         SATURNIN_MENU_SELECTOR \
-         SATURNIN_MENU_SELECT_ARGS \
-         SATURNIN_MENU_CONSUMER
-
-do_generate | do_select | do_consume

src/libexec/saturnin-uris

@@ -1,72 +0,0 @@
-#!/bin/bash
-
-. "$(ffoom path)" || exit 3
-
-ffoo import inigrep
-ffoo import pretty
-
-ffoo import saturnin_urimagic
-
-saturnin_urimagic__inipfx0="uris.bookmark"
-saturnin_urimagic__inipfxN="uris.query"
-
-#
-# On clipboards:
-#
-#   *  primary is for selection/middle mouse click (X power users)
-#   *  clipboard is for Win/Mac-like explicit Copy/Cut/Paste
-#   *  nobody uses secondary
-#
-# see http://standards.freedesktop.org/clipboards-spec/clipboards-latest.txt
-# for more details
-#
-
-usage() {
-    mkusage "word..."      \
-            "-f file"      \
-            "-1|-2|-c|-C"
-}
-
-clipln() {
-    #
-    # Print primary clipboard and \n
-    #
-    case $1 in
-        pri) s=primary   ;;
-        sec) s=secondary ;;
-        clp) s=clipboard ;;
-    esac
-    xclip -o -selection $s 2>/dev/null
-    echo ""
-}
-
-src=args
-while true; do case "$1" in
-    -f) src=file; file=$2; shift 2 || usage ;;
-    -1) src=xpri;          shift   ;;
-    -2) src=xsec;          shift   ;;
-    -c) src=xclp;          shift   ;;
-    -C) src=xall;          shift   ;;
-    -*) usage                      ;;
-    *)  break ;;
-esac done
-
-debug "\$*='$*'"
-debug -v src
-
-case "$src" in
-    args) uri="$(echo "$@" | saturnin_urimagic__scan)" ;;
-    file) uri="$(cat "$file" | saturnin_urimagic__scan)" ;;
-    xpri) uri="$(clipln pri | saturnin_urimagic__scan)" ;;
-    xsec) uri="$(clipln sec | saturnin_urimagic__scan)" ;;
-    xclp) uri="$(clipln clp | saturnin_urimagic__scan)" ;;
-    xall) uri="$(clipln pri | saturnin_urimagic__scan)"
-          uri="$(clipln sec | saturnin_urimagic__scan)"
-          uri="$(clipln clp | saturnin_urimagic__scan)"
-          ;;
-esac
-debug -v uri
-
-test -z "$uri" && uri="$(inigrep -p uris.bookmark.default)"
-
-echo "$uri"

src/libexec/saturnin-xuris

@@ -1,80 +0,0 @@
-#!/bin/bash
-
-# launch Uzbl once per each URI in stdin
-
-. "$(ffoom path)" || exit 3
-ffoo import pretty
-ffoo import inigrep
-
-SATURNIN_XURIS_NOTIFICATIONS=true
-SATURNIN_XURIS_LIMIT=100
-SATURNIN_XURIS_ALWAYS_RUN=false
-SATURNIN_XURIS_UNIQ=true
-SATURNIN_XURIS_CHOICE="${SATURNIN_XURIS_CHOICE:-false}"
-
-usage() {
-    mkusage "[-u|--uniq] [-a|--always-run] [-l|--limit N] [-c|--choose] [-C|--choice-cmd COMMAND]"
-}
-
-maybe_uniq() {
-    $SATURNIN_XURIS_UNIQ || { cat; return; }
-    sort | uniq
-}
-
-notify() {
-    $SATURNIN_XURIS_NOTIFICATIONS || return 0
-    local summary="saturnin-xuris"
-    local body="$1"
-    notify-send -a saturnin-xuris "$summary" "$body"
-}
-
-open_from() {
-    local list="$1"
-    local count=$(wc -l <"$list")
-
-    test "$count" -gt $SATURNIN_XURIS_LIMIT && {
-        notify "too much URIs; giving up: $count > $SATURNIN_XURIS_LIMIT"
-        return 1
-    }
-
-    test "$count" -eq 0 && {
-        $SATURNIN_XURIS_ALWAYS_RUN && $SATURNIN_XURIS_BIN &
-        return 0
-    }
-
-    while read uri;
-    do
-        $SATURNIN_XURIS_BIN "$uri" &
-    done < "$list"
-}
-
-while true; do case $1 in
-    -a|--always-run) SATURNIN_XURIS_ALWAYS_RUN=true; shift ;;
-    -b|--bin)        SATURNIN_XURIS_BIN="$2"; shift; shift ;;
-    -c|--choose)     SATURNIN_XURIS_CHOICE="inigrep -j -p xuris.browsers | saturnin dmenu"; shift ;;
-    -C|--choice-cmd) SATURNIN_XURIS_CHOICE="$2"; shift; shift ;;
-    -l|--limit)      SATURNIN_XURIS_LIMIT=$2; shift; shift ;;
-    -u|--uniq)       SATURNIN_XURIS_UNIQ=true;       shift ;;
-    -U|--no-uniq)    SATURNIN_XURIS_UNIQ=false;      shift ;;
-    -*)       usage ;;
-    "")       break ;;
-    *)        usage ;;
-esac done
-
-debug -v SATURNIN_XURIS_ALWAYS_RUN \
-         SATURNIN_XURIS_CHOICE \
-         SATURNIN_XURIS_LIMIT \
-         SATURNIN_XURIS_UNIQ
-
-SATURNIN_XURIS_URI_LIST=$(mktemp -t saturnin-xuris.XXXXXXXX)
-cat | maybe_uniq | grep . >"$SATURNIN_XURIS_URI_LIST"
-
-# choice of URI has been made; we may try to use dmenu
-bash -n <<<"$SATURNIN_XURIS_CHOICE"
-SATURNIN_XURIS_BIN=$(eval "$SATURNIN_XURIS_CHOICE")
-SATURNIN_XURIS_BIN="${SATURNIN_XURIS_BIN:-$(inigrep -j -1 -p xuris.default_browser)}"
-
-debug -v SATURNIN_XURIS_BIN
-
-open_from "$SATURNIN_XURIS_URI_LIST"
-rm "$SATURNIN_XURIS_URI_LIST"