Drop d; this is not a daemon

Makefile

-# ffood - Fast Food - a Bash Library
+# ffoo - Fast Foo - a Bash Library
 # See LICENSE file for copyright and license details.
 
 include config.mk
 
-all: options doc ffood
+all: options doc ffoo
 
 options:
-	@echo ffood build options:
+	@echo ffoo build options:
 	@echo "VERSION  = ${VERSION}"
 	@echo "PREFIX   = ${PREFIX}"
 
 manpages:
 	@setup/mk.sh manpages
 
-ffood:
-	@setup/mk.sh ffood
+ffoo:
+	@setup/mk.sh ffoo
 
 test: install
 	@setup/mk.sh test

README

-Fast Food Bash library
-======================
+Fast Foo Bash library
+=====================
 
-ffood - Fast Food - a Bash Library
+ffoo - Fast Foo - a Bash Library
 
 
 NOTES
     This is "fixed" by adding at least one all-matching `grep`
     command before the while loop.
 
- *  iniread: when same key is found in eg. /etc/ffood/ffood.ini
-    and ~/.ffood.ffood.ini, output is concatenated.  If you
+ *  iniread: when same key is found in eg. /etc/ffoo/ffoo.ini
+    and ~/.ffoo.ffoo.ini, output is concatenated.  If you
     want the value be rather overriden, you can simply add
     `-1` to limit output to the last one.
 

bin/ffdoc.in

 #!/bin/bash
 
-. __FFOOD_DIR__/ffood.sh
+. __FFOO_DIR__/ffoo.sh
 
-ffood import core
+ffoo import core
 
 
 usage() {
 
 target=$1
 test -n "$target" || usage
-ffood doc "$target"
+ffoo doc "$target"

bin/fff.in

 #!/bin/bash
 
-. __FFOOD_DIR__/ffood.sh
+. __FFOO_DIR__/ffoo.sh
 
-ffood import core
+ffoo import core
 
 
 usage() {
 while true; do
     case $1 in
         -d|--debug)
-            FFOOD_DEBUG=true
+            FFOO_DEBUG=true
             shift 1
             ;;
         -v|--verbose)
-            FFOOD_VERBOSE=true
+            FFOO_VERBOSE=true
             shift 1
             ;;
         -I|--include)
 done
 
 for i in $(tr ":" " " <<<"$includes"); do
-    ffood import $i
+    ffoo import $i
 done
 
 "$@"

bin/ffmanage.in

 #!/bin/bash
 
-. __FFOOD_DIR__/ffood.sh
+. __FFOO_DIR__/ffoo.sh
 
-ffood import core
+ffoo import core
 
 
 usage() {
 }
 
 version_info() {
-    echo "$(basename $0) (Fast Food bash library) $FFOOD_VERSION"
+    echo "$(basename $0) (Fast Foo bash library) $FFOO_VERSION"
     echo
-    echo "install path: __FFOOD_DIR__"
-    echo "data path: $FFOOD_DATA_DIR"
+    echo "install path: __FFOO_DIR__"
+    echo "data path: $FFOO_DATA_DIR"
 }
 
 while true; do case $1 in
         -d|--debug)
-            FFOOD_DEBUG=true;
+            FFOO_DEBUG=true;
             shift;
             ;;
         --library-init)
-            echo "__FFOOD_DIR__/ffood.sh"
+            echo "__FFOO_DIR__/ffoo.sh"
             exit 0
             ;;
         --list-modules)
-            ffood _list_all_modules
+            ffoo _list_all_modules
             exit $?
             ;;
         --list-functions)
             if test -n "$2";
             then
-                ffood _list_functions_in_mfile $(ffood _list_mfiles_like $2)
+                ffoo _list_functions_in_mfile $(ffoo _list_mfiles_like $2)
                 exit $?
             else
-                ffood _list_all_functions
+                ffoo _list_all_functions
                 exit $?
             fi
             ;;

doc/examples/template.sh.in

 #!/bin/bash
 
-. __FFOOD_DIR__/ffood.sh
+. __FFOO_DIR__/ffoo.sh
 
-ffood import core
+ffoo import core
 
-FFOOD_VERBOSE=true
-FFOOD_DEBUG=true
+FFOO_VERBOSE=true
+FFOO_DEBUG=true

doc/ffood.3.md → doc/ffoo.3.md

-FFOOD
-=====
+FFOO
+====
 
 SYNOPSIS
 --------
 
     #!/bin/bash
     # ~/bin/example
-    source /usr/share/lib/ffood/ffood.sh
-    ffood import core
+    source /usr/share/lib/ffoo/ffoo.sh
+    ffoo import core
 
     # basic echo helpers
-    think "about saying something..."   # like echo if FFOOD_VERBOSE
+    think "about saying something..."   # like echo if FFOO_VERBOSE
     warn "this is just an example"      # obvious :)
     false || die "false was true!"      # Perlism :)
     x=1; y=2; z=3
     echo "hello" | debug_pipe mypipe    # debug:PIPE mypipe: hello
 
     # more advanced functions
-    FFOOD_DATADIR=$HOME/.example
-    cat >$FFOOD_DATADIR/main.ini <<EOF
+    FFOO_DATADIR=$HOME/.example
+    cat >$FFOO_DATADIR/main.ini <<EOF
     # a sample ini file
     [mysection]
         key = something
     python sample.py                        # "will work!" due to the -S
 
     # even more
-    ffood import recon
+    ffoo import recon
     wait_until -e ! test -e badfile         # -e means use eval (make "!" work)
     think "the badfile is away..."
     bad_file_away() {                       # but you can avoid eval
     wait_until bad_file_away
 
     # ... and more
-    ffood import recon
+    ffoo import recon
     register_artifact this_file_will_exist.log
     some_important_program > this_file_will_exist.log
     collect_artifacts                       # will preserve tree from /
 
     # ...AND MORE!
-    ffood import sw
+    ffoo import sw
     cat > dependencies.ini <<EOF
     [needs/now]
         yum = ronn

ffoo.sh.in

+#!/bin/bash
+
+FFOO_DATA_DIR=${FFOO_DATA_DIR:-$HOME/.ffoo}
+FFOO_DIR=${FFOO_DIR:-__FFOO_DIR__}
+FFOO_ARTIFACTS_DIR=${FFOO_ARTIFACTS_DIR:-artifacts}
+FFOO_DEBUG=${FFOO_DEBUG:-false}
+FFOO_DEBUGINIT=${FFOO_DEBUGINIT:-false}
+FFOO_INCLUDE=${FFOO_INCLUDE:-$FFOO_DIR/include}
+FFOO_MKPRETTY=${FFOO_MKPRETTY:-plain}
+FFOO_VERBOSE=${FFOO_VERBOSE:-false}
+FFOO_VERSION=__VERSION__
+
+ffoo() {
+    case $1 in
+        __debug)
+            $FFOO_DEBUGINIT || return 0
+            shift
+            echo "debug: $@" >&2
+            ;;
+        __die)
+            shift
+            echo "$@" >&2
+            exit 1
+            ;;
+        doc)
+            ffoo __die "not implemented (sorry...)"
+            ;;
+        import)
+            ffoo __debug "importing module $2"
+            local mfile=$(ffoo _list_mfiles_like $2 | head -1)
+            test -n "$mfile" || ffoo __die "cannot find module $2"
+            ffoo __debug "found module file: $mfile"
+            . $mfile
+            return $?
+            ;;
+        _list_all_functions)
+            local mfile
+            ffoo _list_all_mfiles | while read mfile;
+            do
+                ffoo _list_functions_in_mfile "$mfile"
+            done
+            ;;
+        _list_all_modules)
+            local mp mfn;
+            ffoo _list_all_mfiles | while read mp;
+            do
+                mfn="${mp##*/}"
+                echo "${mfn%%.sh}"
+            done
+            ;;
+        _list_all_mfiles)
+            {
+                echo $FFOO_INCLUDE/*.sh | tr ' ' '\n'
+                test -n "$FFOO_PATH" && echo $FFOO_PATH/*.sh
+            } | tr ' ' '\n'
+            ;;
+        _list_mfiles_like)
+            test -f "$FFOO_INCLUDE/$2.sh"                  && echo "$FFOO_INCLUDE/$2.sh"
+            test -n "$FFOO_PATH" -a -f "$FFOO_PATH/$2.sh" && echo "$FFOO_PATH/$2.sh"
+            ;;
+        _list_functions_in_mfile)
+            local mfile="$2"
+            grep -HE '^[[:alnum:]_]+\(\) \{' "$mfile" \
+              | sed -e 's/^.*\///; s/\.sh:/./; s/(.*//'
+            ;;
+        *)
+            ffoo __die "unknown ffoo command: $1"
+            ;;
+    esac
+}
+
+ffoo __debug "FFOO_DATA_DIR='$FFOO_DATA_DIR'"
+ffoo __debug "FFOO_DIR='$FFOO_DIR'"
+ffoo __debug "FFOO_ARTIFACTS_DIR='$FFOO_ARTIFACTS_DIR'"
+ffoo __debug "FFOO_DEBUG='$FFOO_DEBUG'"
+ffoo __debug "FFOO_DEBUGINIT='$FFOO_DEBUGINIT'"
+ffoo __debug "FFOO_INCLUDE='$FFOO_INCLUDE'"
+ffoo __debug "FFOO_INIPATH='$FFOO_INIPATH'"
+ffoo __debug "FFOO_MKPRETTY='$FFOO_MKPRETTY'"
+ffoo __debug "FFOO_VERBOSE='$FFOO_VERBOSE'"
+ffoo __debug "FFOO_VERSION='$FFOO_VERSION'"

ffood.sh.in

-#!/bin/bash
-
-FFOOD_DATA_DIR=${FFOOD_DATA_DIR:-$HOME/.ffood}
-FFOOD_DIR=${FFOOD_DIR:-__FFOOD_DIR__}
-FFOOD_ARTIFACTS_DIR=${FFOOD_ARTIFACTS_DIR:-artifacts}
-FFOOD_DEBUG=${FFOOD_DEBUG:-false}
-FFOOD_DEBUGINIT=${FFOOD_DEBUGINIT:-false}
-FFOOD_INCLUDE=${FFOOD_INCLUDE:-$FFOOD_DIR/include}
-FFOOD_MKPRETTY=${FFOOD_MKPRETTY:-plain}
-FFOOD_VERBOSE=${FFOOD_VERBOSE:-false}
-FFOOD_VERSION=__VERSION__
-
-ffood() {
-    case $1 in
-        __debug)
-            $FFOOD_DEBUGINIT || return 0
-            shift
-            echo "debug: $@" >&2
-            ;;
-        __die)
-            shift
-            echo "$@" >&2
-            exit 1
-            ;;
-        doc)
-            ffood __die "not implemented (sorry...)"
-            ;;
-        import)
-            ffood __debug "importing module $2"
-            local mfile=$(ffood _list_mfiles_like $2 | head -1)
-            test -n "$mfile" || ffood __die "cannot find module $2"
-            ffood __debug "found module file: $mfile"
-            . $mfile
-            return $?
-            ;;
-        _list_all_functions)
-            local mfile
-            ffood _list_all_mfiles | while read mfile;
-            do
-                ffood _list_functions_in_mfile "$mfile"
-            done
-            ;;
-        _list_all_modules)
-            local mp mfn;
-            ffood _list_all_mfiles | while read mp;
-            do
-                mfn="${mp##*/}"
-                echo "${mfn%%.sh}"
-            done
-            ;;
-        _list_all_mfiles)
-            {
-                echo $FFOOD_INCLUDE/*.sh | tr ' ' '\n'
-                test -n "$FFOOD_PATH" && echo $FFOOD_PATH/*.sh
-            } | tr ' ' '\n'
-            ;;
-        _list_mfiles_like)
-            test -f "$FFOOD_INCLUDE/$2.sh"                  && echo "$FFOOD_INCLUDE/$2.sh"
-            test -n "$FFOOD_PATH" -a -f "$FFOOD_PATH/$2.sh" && echo "$FFOOD_PATH/$2.sh"
-            ;;
-        _list_functions_in_mfile)
-            local mfile="$2"
-            grep -HE '^[[:alnum:]_]+\(\) \{' "$mfile" \
-              | sed -e 's/^.*\///; s/\.sh:/./; s/(.*//'
-            ;;
-        *)
-            ffood __die "unknown ffood command: $1"
-            ;;
-    esac
-}
-
-ffood __debug "FFOOD_DATA_DIR='$FFOOD_DATA_DIR'"
-ffood __debug "FFOOD_DIR='$FFOOD_DIR'"
-ffood __debug "FFOOD_ARTIFACTS_DIR='$FFOOD_ARTIFACTS_DIR'"
-ffood __debug "FFOOD_DEBUG='$FFOOD_DEBUG'"
-ffood __debug "FFOOD_DEBUGINIT='$FFOOD_DEBUGINIT'"
-ffood __debug "FFOOD_INCLUDE='$FFOOD_INCLUDE'"
-ffood __debug "FFOOD_INIPATH='$FFOOD_INIPATH'"
-ffood __debug "FFOOD_MKPRETTY='$FFOOD_MKPRETTY'"
-ffood __debug "FFOOD_VERBOSE='$FFOOD_VERBOSE'"
-ffood __debug "FFOOD_VERSION='$FFOOD_VERSION'"

include/core.sh

     #     debug -v var1 var2 result
     #     debug -v "var@ result"
     #
-    $FFOOD_DEBUG || return 0
+    $FFOO_DEBUG || return 0
     __echo "$@"
 }
 
     # Use "-l" to split every parameter to separate line, (useful
     # or longer warnings)
     #
-    $FFOOD_VERBOSE || return 0
+    $FFOO_VERBOSE || return 0
     __echo "$@"
 }
 
     #               that called __echo and each argument
     #               given
     #
-    ffood import mkpretty_${FFOOD_MKPRETTY}
+    ffoo import mkpretty_${FFOO_MKPRETTY}
     local caller=${FUNCNAME[2]}
     local front=${FUNCNAME[1]}
     case "$caller" in
 }
 
 __echo_trace() {
-    $FFOOD_DEBUG || return 0
+    $FFOO_DEBUG || return 0
     local -a tr=(${FUNCNAME[@]})
     unset tr[0]; unset tr[1]; unset tr[2];
     local tmp=$(echo "${tr[*]}" | tr '  ' '\n' | tac )
                 cat $arg
             ;;
         *)              # name given, find all its incarnations
-            debug -v FFOOD_INIPATH
-            echo "$FFOOD_INIPATH" \
+            debug -v FFOO_INIPATH
+            echo "$FFOO_INIPATH" \
               | tr ':' '\n' \
               | while read trydir;
                 do

include/mkpretty_color.sh

 #!/bin/bash
 
-ffood import termcolors
+ffoo import termcolors
 
 mkpretty_debug() {
     while IFS= read line;
-    do echo -ne "${FFOOD_TERMCOLORS_LBLUE}debug:$caller:$FFOOD_TERMCOLORS_NONE"
+    do echo -ne "${FFOO_TERMCOLORS_LBLUE}debug:$caller:$FFOO_TERMCOLORS_NONE"
        echo "$line"; done
 }
 
 mkpretty_die() {
-    echo -ne "$FFOOD_TERMCOLORS_LRED"
+    echo -ne "$FFOO_TERMCOLORS_LRED"
     while IFS= read line;
     do echo "$line"; done
-    echo -ne "$FFOOD_TERMCOLORS_NONE"
+    echo -ne "$FFOO_TERMCOLORS_NONE"
 }
 
 mkpretty_usage_is() {
-    echo -ne "$FFOOD_TERMCOLORS_YELLOW"
+    echo -ne "$FFOO_TERMCOLORS_YELLOW"
     while IFS= read line;
     do echo -e "$line"; done
-    echo -ne "$FFOOD_TERMCOLORS_NONE"
+    echo -ne "$FFOO_TERMCOLORS_NONE"
 }
 
 mkpretty_think() {
 }
 
 mkpretty_warn() {
-    echo -ne "$FFOOD_TERMCOLORS_LRED"
+    echo -ne "$FFOO_TERMCOLORS_LRED"
     while IFS= read line;
     do echo "$line"; done
-    echo -ne "$FFOOD_TERMCOLORS_NONE"
+    echo -ne "$FFOO_TERMCOLORS_NONE"
 }

include/proj_ol.sh

 #!/bin/bash
 
-ffood import core
-ffood import recon
-ffood import testing
-ffood import yummy
+ffoo import core
+ffoo import recon
+ffoo import testing
+ffoo import yummy
 
 
 OLCS_RUNHOW=$(iniread -s mk.run.how mk-ol.ini)

include/recon.sh

 #!/bin/bash
 
-ffood import core
+ffoo import core
 
 
 age_of_leaf() {

include/sw.sh

 #!/bin/bash
 
-ffood import core
-ffood import yummy
+ffoo import core
+ffoo import yummy
 
 any_install() {
     local tool pkg

include/termcolors.sh

-FFOOD_TERMCOLORS_BLACK="\033[0;30m"
-FFOOD_TERMCOLORS_RED="\033[0;31m"
-FFOOD_TERMCOLORS_GREEN="\033[0;32m"
-FFOOD_TERMCOLORS_YELLOW="\033[0;33m"
-FFOOD_TERMCOLORS_BLUE="\033[0;34m"
-FFOOD_TERMCOLORS_MAGENTA="\033[0;35m"
-FFOOD_TERMCOLORS_CYAN="\033[0;36m"
-FFOOD_TERMCOLORS_WHITE="\033[0;37m"
-FFOOD_TERMCOLORS_LBLACK="\033[1;30m"
-FFOOD_TERMCOLORS_LRED="\033[1;31m"
-FFOOD_TERMCOLORS_LGREEN="\033[1;32m"
-FFOOD_TERMCOLORS_LYELLOW="\033[1;33m"
-FFOOD_TERMCOLORS_LBLUE="\033[1;34m"
-FFOOD_TERMCOLORS_LMAGENTA="\033[1;35m"
-FFOOD_TERMCOLORS_LCYAN="\033[1;36m"
-FFOOD_TERMCOLORS_LWHITE="\033[1;37m"
-FFOOD_TERMCOLORS_NONE="\033[1;0m"
+FFOO_TERMCOLORS_BLACK="\033[0;30m"
+FFOO_TERMCOLORS_RED="\033[0;31m"
+FFOO_TERMCOLORS_GREEN="\033[0;32m"
+FFOO_TERMCOLORS_YELLOW="\033[0;33m"
+FFOO_TERMCOLORS_BLUE="\033[0;34m"
+FFOO_TERMCOLORS_MAGENTA="\033[0;35m"
+FFOO_TERMCOLORS_CYAN="\033[0;36m"
+FFOO_TERMCOLORS_WHITE="\033[0;37m"
+FFOO_TERMCOLORS_LBLACK="\033[1;30m"
+FFOO_TERMCOLORS_LRED="\033[1;31m"
+FFOO_TERMCOLORS_LGREEN="\033[1;32m"
+FFOO_TERMCOLORS_LYELLOW="\033[1;33m"
+FFOO_TERMCOLORS_LBLUE="\033[1;34m"
+FFOO_TERMCOLORS_LMAGENTA="\033[1;35m"
+FFOO_TERMCOLORS_LCYAN="\033[1;36m"
+FFOO_TERMCOLORS_LWHITE="\033[1;37m"
+FFOO_TERMCOLORS_NONE="\033[1;0m"

include/testing.sh

 #!/bin/bash
 
-ffood import core
+ffoo import core
 
 collect_artifacts() {
     local aroot="$1"
     test -n "$aroot" || usagef "target_root"
-    test -f $FFOOD_TMP/artifact_list || return 0
+    test -f $FFOO_TMP/artifact_list || return 0
     local tgt
     think "collecting artifacts to $aroot"
-    cat $FFOOD_TMP/artifact_list \
+    cat $FFOO_TMP/artifact_list \
         | while read path;
           do
               tgt=$aroot/$(dirname $path)
 }
 
 register_artifact() {
-    test -n "$FFOOD_TMP" && FFOOD_TMP=$(mktemp -d)
-    local list=$FFOOD_TMP/artifact_list
+    test -n "$FFOO_TMP" && FFOO_TMP=$(mktemp -d)
+    local list=$FFOO_TMP/artifact_list
     local a
     for a in "$@";
     do

include/www.sh

 #!/bin/bash
 
-ffood import core
+ffoo import core
 
 filter_exprs() {
     #

include/xorg.sh

 #!/bin/bash
 
-ffood import core
+ffoo import core
 
 clipln() {
     xclip -o -selection primary 2>/dev/null

notes/TODO.md

 *   `__echo` -- add --source, i.e. print source of a
     particular function at runtime
 
-*   fix up `ffood --list-*`, current implementation is
+*   fix up `ffoo --list-*`, current implementation is
     scratching right ear with left hand
 
-*   support conflict checking in `ffood`. i.e. for TI and the likes
+*   support conflict checking in `ffoo`. i.e. for TI and the likes
 
 *   doc - finish `ffdoc`, add first line to function lists
 

setup/mk.sh

 #!/bin/bash
-# ffood - Fast Food - a Bash Library
+# ffoo - Fast Foo - a Bash Library
 # See LICENSE file for copyright and license details.
 
 tmp=$(mktemp)
 
 bindir=${DESTDIR}${PREFIX}/bin
 mandir=${DESTDIR}${MANPREFIX}
-docdir=${DESTDIR}${PREFIX}/share/doc/ffood
-shrdir=${DESTDIR}${PREFIX}/share/ffood
+docdir=${DESTDIR}${PREFIX}/share/doc/ffoo
+shrdir=${DESTDIR}${PREFIX}/share/ffoo
 
 list_of_bins() {
     echo bin/ffdoc
 
 list_of_docs() {
     echo doc/fff.1.md
-    echo doc/ffood.3.md
+    echo doc/ffoo.3.md
 }
 
 list_of_shrs() {
-    echo ffood.sh
+    echo ffoo.sh
     echo include
 }
 
 }
 
 dist() {
-    local dirname=ffood-${VERSION}
+    local dirname=ffoo-${VERSION}
     mkdir -p $dirname
     cp -R   bin \
             config.mk \
             doc \
             include \
             Makefile \
-            ffood.sh.in \
+            ffoo.sh.in \
             README \
             LICENSE \
             setup \
     test -f .autoclean && clean || :
 }
 
-ffood() {
+ffoo() {
     local srcpath dstpath
     find -type f -name '*.in' \
         | while read srcpath;
           do
               dstpath=${srcpath%.in}
-              perl -pe "s|__FFOOD_DIR__|$shrdir|;
+              perl -pe "s|__FFOO_DIR__|$shrdir|;
                         s|__VERSION__|$VERSION|;" < $srcpath > $dstpath
               echo $dstpath >> built.list
           done
 
 uninstall() {
     list_of_installed_bins | xargs rm -f
-    rm -rf $shrdir/ffood
-    rm -rf $docdir/ffood
+    rm -rf $shrdir/ffoo
+    rm -rf $docdir/ffoo
     rm -f $mandir/man1/fff.1
-    rm -f $mandir/man3/ffood.3
+    rm -f $mandir/man3/ffoo.3
 }
 
 case $1 in
-    clean|dist|install|install_manpages|manpages|ffood|uninstall)
+    clean|dist|install|install_manpages|manpages|ffoo|uninstall)
         $1
         ;;
     test)
         run_test
         ;;
     *)
-        echo "usage: $(basename $0) clean|dist|install|ffood|test|uninstall" >&2
+        echo "usage: $(basename $0) clean|dist|install|ffoo|test|uninstall" >&2
 esac

test/iniread.in

 
 . /usr/share/beakerlib/beakerlib.sh
 
-. __FFOOD_DIR__/qecc.sh
-ffood import core
+. __FFOO_DIR__/ffoo.sh
+ffoo import core
 
 
 do_test() {