Update own dog food to v0.0.6

It looks .dirty as we had to update in 2 steps due to a bug in v0.0.5

utils/mkit/include/build.sh

     #
     # Process one skeleton
     #
-    local srcpath dstpath
-    srcpath=$1
-    dstpath=${srcpath%.skel}
-    case $dstpath in
-        *.md) <"$srcpath" expand_includes | expand_variables >"$dstpath" ;;
-        *)    <"$srcpath"                   expand_variables >"$dstpath" ;;
-    esac
+    local srcpath="$1"
+    local dstpath="$2"
+    local ftype="$3"
+    test -n "$dstpath"  || dstpath=${srcpath%.skel}
+    test -n "$ftype"    || ftype=$(guess_ftype "$dstpath")
+    debug_var srcpath dstpath ftype
+    <"$srcpath" build1_ftype "$ftype" >"$dstpath"
     mkdir -p "$MKIT_LOCAL"
     echo "$dstpath" >> "$MKIT_LOCAL/built.lst"
 }
 
+guess_ftype() {
+    #
+    # Guess file type from destination path $1
+    #
+    local dstpath="$1"
+    case $dstpath in
+        *.md) echo markdown    ;;
+        *)    echo MKIT_COMMON ;;
+    esac
+}
+
+build1_ftype() {
+    #
+    # Build a file of type $1
+    #
+    local ftype="$1"
+    case $ftype in
+        MKIT_COMMON)    expand_variables "vars" ;;
+        markdown)       expand_includes | expand_variables "vars" ;;
+        rpmstuff)       expand_variables "vars" "rpmstuff:vars" ;;
+        *)              die "unknown file type: $ftype" ;;
+    esac
+}
+
 build_manpages() {
     local manfile mdfile
     if command -v ronn >/dev/null;
     #
     # Create distributable tarball
     #
+    #FIXME: lacking Makefile skills, we do this step twice fot
+    #       rpmstuff, hence -f hack for gzip
+    #
     local version=$(get_version)
     local dirname=$MKIT_PKGNAME-$version
     mkdir -p "$dirname"
     ini values "lists:dist" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
     sed -i -e "s/^VERSION = .*/VERSION = $version/" "$dirname/config.mk"
     tar -cf "$dirname.tar" "$dirname"
-    gzip "$dirname.tar"
+    gzip -f "$dirname.tar"      # see above FIXME
+    mkdir -p "$MKIT_LOCAL"
+    echo "$dirname.tar.gz" >> "$MKIT_LOCAL/built.lst"
     rm -rf "$dirname"
 }
 
+rpmstuff() {
+    #
+    # Build specfile
+    #
+    local specname="$(ini 1value ENV:PKGNAME).spec"
+    local specsrc="$(ini 1value "rpmstuff:spec_skel")"
+    test -n "$specsrc" || die "rpmstuff:spec_skel not specified"
+    test -f "$specsrc" || die "specfile template not found: $specsrc"
+    build1 "$specsrc" "$specname"
+}
+
 expand_includes() {
     #
     # Expand include directives
 
 expand_variables() {
     #
-    # Expand variable values
+    # Expand variables from sections $@
     #
     local script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
-    local varname varvalue
-    ini lskeys "vars" \
-      | while read varname;
-        do
-            varvalue="$(ini 1value "vars:$varname" | sed -e 's/\$/\\$/' )"
-            echo "s|$varname|$varvalue|;" >> "$script"
-        done
+    local section varname varvalue
+    for section in "$@";
+    do
+        debug_var section
+        ini lskeys "$section" \
+          | while read varname;
+            do
+                varvalue="$(ini 1value "$section:$varname" | sed -e 's/\$/\\$/' )"
+                echo "s|$varname|$varvalue|;" >> "$script"
+                debug_var varname varvalue
+            done
+    done
     echo "s|__CODENAME__|$CODENAME|;"     >> "$script"
     echo "s|__VERSION__|$(get_version)|;" >> "$script"
-    perl -wp "$script"
+    perl -wp "$script" || die "expand_variables failed"
     rm "$script"
 }
 

utils/mkit/include/deploy.sh

 #!/bin/bash
 
+_maybe() {
+    #
+    # Call the deploy command $1 $@ unless in dry mode
+    #
+    debug "$@"
+    local cmd="$1"; shift
+    $MKIT_DRY && return
+    case "$cmd" in
+        cp|rm|rmdir|chmod|mkdir) $cmd "$@" ;;
+        install)                 command -p install "$@" ;;
+        *)                       die "bad command called";;
+    esac
+}
 
 check_env() {
     #
-    # Check that environment variables have been set properly
+    # Check that critical variables are set correctly
     #
-    PREFIX="$(readlink -m "$PREFIX")"
-    test -d "$PREFIX" || die "PREFIX points to non-existent directory: $PREFIX"
+    test -n "$destdir" || die "could not determine DESTDIR"
+    test -d "$destdir" || die "DESTDIR: no such directory: $destdir"
 }
 
 deploy_item() {
     local mode="${3:-$MKIT_DEFAULT_MODE}"
     if test -d "$src";
     then
-        mkdir -p "$(dirname "$dst")"
-        cp -Tvr "$src" "$dst"
+        _maybe mkdir -vp "$(dirname "$dst")"
+        _maybe cp -Tvr "$src" "$dst"
         find "$dst" -type f -print0 | xargs -0 chmod -c "$mode"
     else
-        command -p install -DTvm "$mode" "$src" "$dst"
+        _maybe install -DTvm "$mode" "$src" "$dst"
     fi
 }
 
+get_destdir() {
+    #
+    # Get DESTDIR: first from ENV:DESTDIR, then the default
+    #
+    {
+        ini 1value ENV:DESTDIR | grep . && return
+        echo "$MKIT_DEFAULT_DESTDIR"
+    } \
+      | xargs readlink -m \
+      | grep -m 1 .
+}
+
 get_dst() {
     #
     # Find out target path for src file $2 of group $1
     local grp="$1"
     local root=$(ini 1value "roots:$grp")
     test -n "$root" || die "missing in config.ini: roots:$grp"
-    echo "$root"
+    echo "$destdir/$root"
 }
 
 install() {
     #
     # Install product
     #
-    check_env
     local dst group mode src
+    local destdir=$(get_destdir)
+    check_env
     ini values "lists:group" \
       | while read group;
         do
     #
     # Uninstall product
     #
-    check_env
     local dst group src
+    local destdir=$(get_destdir)
+    check_env
     ini values "lists:group" \
       | while read group;
         do
               | while read src;
                 do
                     dst=$(get_dst "$group" "$src")
-                    rm -vrf "$dst"
+                    _maybe rm -vrf "$dst"
                 done
         done
 }

utils/mkit/include/mkit.sh

      || die "MKIT_LOCAL must be non-blank: '$MKIT_LOCAL'"
 }
 
+debug() {
+    #
+    # Print debug message
+    #
+    $MKIT_DEBUG || return 0
+    echo "MKIT_DEBUG: ${FUNCNAME[1]}()" "$@" >&2
+}
+
+debug_var() {
+    #
+    # Print debug message
+    #
+    $MKIT_DEBUG || return 0
+    local __mkit_debug_var_name__
+    for __mkit_debug_var_name__ in "$@";
+    do
+        {
+            echo -n "MKIT_DEBUG: ${FUNCNAME[1]}():"
+            echo -n " $__mkit_debug_var_name__"
+            echo -n "='${!__mkit_debug_var_name__}'"
+            echo
+        } >&2
+    done
+}
+
 die() {
     #
     # Exit with message and non-zero exit status
     # Call correct function based on $1
     #
     case $1 in
-        build|build_manpages|clean|dist|install|release_?|uninstall)
+        build|build_manpages|clean|dist|rpmstuff|install|release_?|uninstall)
             $1
             ;;
         *)
-            echo "usage: $(basename "$0") build|clean|dist|install|uninstall" >&2
+            echo "usage: $(basename "$0") build|clean|dist|rpmstuff|install|uninstall" >&2
     esac
 }

utils/mkit/make

     echo "$@" && exit 9
 }
 
-export MKIT_VERSION=0.0.4
+export MKIT_VERSION=0.0.6+dirty
 
 export MKIT_DIR=${MKIT_DIR:-$(dirname "$0")}
 export MKIT_LOCAL=${MKIT_LOCAL:-.mkit}
+export MKIT_DRY=${MKIT_DRY:-false}
+export MKIT_DEFAULT_DESTDIR=${MKIT_DEFAULT_DESTDIR:-/}
+export MKIT_DEBUG=${MKIT_DEBUG:-false}
 
 . "$MKIT_DIR/include/mkit.sh" || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"
 

utils/mkit/mkit.mk

 	@echo build options:
 	@echo "VERSION  = ${VERSION}"
 	@echo "PRERELEASE = ${PRERELEASE}"
+	@echo "DESTDIR   = ${DESTDIR}"
 	@echo "PREFIX   = ${PREFIX}"
 
 build:
 dist: clean
 	@$(MKIT_DIR)/make dist
 
+rpmstuff: dist
+	@$(MKIT_DIR)/make rpmstuff
+
 install: all
 	@$(MKIT_DIR)/make install
 
 uninstall:
 	@$(MKIT_DIR)/make uninstall
 
-.PHONY: all options clean dist install uninstall release_x release_y release_z
+.PHONY: all options clean dist rpmstuff install uninstall release_x release_y release_z