Update mkit to version from fastfoo 0.7.0+master.g7e6e358

utils/mkit/include/build.sh

 #!/bin/bash
 
-. $MKIT_DIR/include/ini.sh || die "cannot import ini.sh"
+. "$MKIT_DIR/include/ini.sh" || die "cannot import ini.sh"
 
 
 build() {
     srcpath=$1
     dstpath=${srcpath%.skel}
     case $dstpath in
-        *.md)   cat $srcpath \
-                  | expand_includes \
-                  | expand_variables \
-                > $dstpath ;;
-        *)      cat $srcpath \
-                  | expand_variables \
-                > $dstpath ;;
+        *.md) <"$srcpath" expand_includes | expand_variables >"$dstpath" ;;
+        *)    <"$srcpath"                   expand_variables >"$dstpath" ;;
     esac
-    echo $dstpath >> built.list
+    echo "$dstpath" >> built.list
 }
 
 build_manpages() {
         ini lskeys "files:man" \
           | while read manfile;
             do
-                mdfile=$manfile.md
-                ronn -r $mdfile
-                echo $manfile >> built.list
+                mdfile="$manfile.md"
+                ronn -r "$mdfile"
+                echo "$manfile" >> built.list
             done
     else
         echo "ronn is not installed"
     # Clean up tree after building
     #
     test -f built.list && {
-        cat built.list | xargs rm -f
+        <built.list xargs rm -f
         rm -f built.list
-    } || :
+    }
+    true
 }
 
 dist() {
     #
     local version=$(get_version)
     local dirname=$MKIT_PKGNAME-$version
-    mkdir -p $dirname
+    mkdir -p "$dirname"
     local item
-    cp -R $(ini values "lists:dist") $dirname
-    sed -i -e "s/^VERSION = .*/VERSION = $version/" $dirname/config.mk
-    tar -cf $dirname.tar $dirname
-    gzip $dirname.tar
-    rm -rf $dirname
+    cp -R "$(ini values "lists:dist")" "$dirname"
+    sed -i -e "s/^VERSION = .*/VERSION = $version/" "$dirname/config.mk"
+    tar -cf "$dirname.tar" "$dirname"
+    gzip "$dirname.tar"
+    rm -rf "$dirname"
 }
 
 expand_includes() {
       | while read varname;
         do
             varvalue="$(ini 1value "vars:$varname" | sed -e 's/\$/\\$/' )"
-            echo "s|$varname|$varvalue|;" >> $script
+            echo "s|$varname|$varvalue|;" >> "$script"
         done
-    echo "s|__CODENAME__|$CODENAME|;"     >> $script
-    echo "s|__VERSION__|$(get_version)|;" >> $script
-    perl -wp $script
-    rm $script
+    echo "s|__CODENAME__|$CODENAME|;"     >> "$script"
+    echo "s|__VERSION__|$(get_version)|;" >> "$script"
+    perl -wp "$script"
+    rm "$script"
 }
 
 get_version() {
     # meta-data is to *identify* the code, and provide safe path back
     # to tree; commit refs are already perfect for that.
     #
-    # FIXME:  The assumpton "if we are in git repo, we can read version
-    #         from tags" fails if we are in shallow clone made from
-    #         other than a tagged commit.
-    #
     # FIXME:  Using PRERELEASE for release IDs may not be compatible with
     #         release strategy implemented in release.sh
     #
         then    # the tree is "dirty", i.e. has been edited
             local dirty=dirty
         fi
-        version=${lasttag:1}
+        test -n "$lasttag" && version=${lasttag:1}
         local suffix=""
-        case $prerl:$commit:$dirty in
-            ::)        suffix=""                       ;;
-            ::dirty)   suffix="+$dirty"                ;;
-            :*:)       suffix="+$commit"               ;;
-            :*:dirty)  suffix="+$commit"               ;;
-            *::)       suffix="-$prerl"                ;;
-            *::dirty)  suffix="-$prerl+$dirty"         ;;
-            *:*:)      suffix="-$prerl+$commit"        ;;
-            *:*:dirty) suffix="-$prerl+$commit.$dirty" ;;
+        case "$commit:$dirty" in
+            :)       suffix=""                ;;
+            :dirty)  suffix="+$dirty"         ;;
+            *:)      suffix="+$commit"        ;;
+            *:dirty) suffix="+$commit.$dirty" ;;
         esac
-        version=$version$suffix
+        test -b "$prerl" && suffix="-$prerl$suffix"
+        version="$version$suffix"
     fi
-    echo $version
+    echo "$version"
 }

utils/mkit/include/deploy.sh

 #!/bin/bash
 
 
+check_env() {
+    #
+    # Check that environment variables have been set properly
+    #
+    PREFIX="$(readlink -m "$PREFIX")"
+    test -d "$PREFIX" || die "PREFIX points to non-existent directory: $PREFIX"
+}
+
+deploy_item() {
+    #
+    # Deploy item and make it look like wanted
+    #
+    # usage: deploy_item src dst [mode]
+    #
+    # Both src and dst must be names of actual items[1],
+    # whereas dst must not exist.  On update, dst is
+    # usually to be replaced but that is uninstall's
+    # job!
+    #
+    #  [1] Ie. src=foo and dst=/foo/bar does *always*
+    #      mean that foo will become 'bar'.  This is
+    #      different than traditional `cp` behavior,
+    #      when this depends if 'bar' already exists
+    #      as a directory.
+    #
+    # If mode is omitted or empty, MKIT_DEFAULT_MODE is
+    # used instead.
+    #
+    # Directories are copied recursively, and mode is
+    # applied only to files.
+    #
+    local src="$1"
+    local dst="$2"
+    local mode="${3:-$MKIT_DEFAULT_MODE}"
+    if test -d "$src";
+    then
+        cp -Tvr "$src" "$dst"
+        find "$dst" -type f -print0 | xargs -0 chmod -c "$mode"
+    else
+        command -p install -DTvm "$mode" "$src" "$dst"
+    fi
+}
+
 get_dst() {
     #
     # Find out target path for src file $2 of group $1
     #
     local grp=$1
     local src=$2
-    echo "$(get_root $grp)/$(ini 1value "files:$grp:$src")"
+    echo "$(get_root "$grp")/$(ini 1value "files:$grp:$src")"
 }
 
 get_root() {
     #
     # Install product
     #
+    check_env
     local dst group mode src
     ini values "lists:group" \
       | while read group;
         do
             mode=$(ini 1value "modes:$group")
-            mode=${mode:-$MKIT_DEFAULT_MODE}
             ini lskeys "files:$group" \
               | while read src;
                 do
                     dst=$(get_dst "$group" "$src")
-                    command -p install -DTvm $mode $src "$dst"
+                    deploy_item "$src" "$dst" "$mode"
                 done
         done
-    test -f .autoclean && clean || :
+    test -f .autoclean && clean
+    true
 }
 
 uninstall() {
     #
     # Uninstall product
     #
+    check_env
     local dst group src
     ini values "lists:group" \
       | while read group;
               | while read src;
                 do
                     dst=$(get_dst "$group" "$src")
-                    rm -vf "$dst"
+                    rm -vrf "$dst"
                 done
         done
 }

utils/mkit/include/ini.sh

         1value) fn=_ini_greppath; limit="tail -1" ;;
         *)      die "incorrect use of \`ini()\`"
     esac
-    cat $MKIT_INI | $fn $arg | $limit
+    <"$MKIT_INI" $fn "$arg" | $limit
 }
 
 _ini_cat() {
     #     [files:share]
     #         my/lib.sh   = proj/my/lib.sh
     #
-    local wnt=$1
-    local wntkey=${wnt##*:}
-    local wntsec=${wnt%:$wntkey}
+    local wnt="$1"
+    local wntkey="${wnt##*:}"
+    local wntsec="${wnt%:$wntkey}"
     if test "$wntsec" = 'ENV';
     then
         local override="${!wntkey}"
             return
         fi
     fi
-    _ini_grepsec $wntsec | _ini_grepkey $wntkey
+    _ini_grepsec "$wntsec" | _ini_grepkey "$wntkey"
 }
 
 _ini_grepsec() {
     #
     # Read one INI section
     #
-    local wnt=$1
+    local wnt="$1"
     local ok=false
     grep '.' \
       | grep -v '\s*#' \
     #
     # List keys from a section
     #
-    local sct=$1
-    _ini_grepsec $sct | cut -d= -f1 | sort | uniq
+    local sct="$1"
+    _ini_grepsec "$sct" | cut -d= -f1 | sort | uniq
 }
 
 _ini_maybe_expand() {
     #
     # Decide whether or not to expand
     #
-    if test $MKIT_INI_EXPAND -gt 0;
+    if test "$MKIT_INI_EXPAND" -gt 0;
     then
-        MKIT_INI_EXPAND=$(( $MKIT_INI_EXPAND - 1 )) _ini_expand
+        MKIT_INI_EXPAND=$(( --MKIT_INI_EXPAND )) _ini_expand
     else
         _ini_cat
     fi

utils/mkit/include/mkit.sh

 #!/bin/bash
 
-. $MKIT_DIR/include/build.sh  || die "cannot import build.sh"
-. $MKIT_DIR/include/deploy.sh || die "cannot import deploy.sh"
-. $MKIT_DIR/include/release.sh || die "cannot import release.sh"
-. $MKIT_DIR/include/ini.sh    || die "cannot import ini.sh"
+. "$MKIT_DIR/include/build.sh"  || die "cannot import build.sh"
+. "$MKIT_DIR/include/deploy.sh" || die "cannot import deploy.sh"
+. "$MKIT_DIR/include/release.sh" || die "cannot import release.sh"
+. "$MKIT_DIR/include/ini.sh"    || die "cannot import ini.sh"
 
 MKIT_INI=${MKIT_INI:-mkit.ini}
 MKIT_INI_EXPAND=2
     #
     # Do basic initialization
     #
-    # Check for ini file, load variables from config.mk, resolve
-    # and check for PREFIX
+    # Check for ini file, load variables from config.mk
     #
     test -f "$MKIT_INI" || die "cannot find mkit.ini: $MKIT_INI"
     tmp=$(mktemp)
-    sed -e 's/ = /=/' < config.mk > $tmp
-    . $tmp
-    rm -f $tmp
-    PREFIX="$(readlink -f "$PREFIX")"
-    test -d "$PREFIX" || die "PREFIX points to bad directory: $PREFIX"
+    sed -e 's/ = /=/' < config.mk > "$tmp"
+    . "$tmp"
+    rm -f "$tmp"
 }
 
 die() {
     #
     # Exit with message and non-zero exit status
     #
-    echo "fatal: $@" >&2
+    echo "fatal: $*" >&2
     exit 4
 }
 
             $1
             ;;
         *)
-            echo "usage: $(basename $0) build|clean|dist|install|uninstall" >&2
+            echo "usage: $(basename "$0") build|clean|dist|install|uninstall" >&2
     esac
 }

utils/mkit/include/release.sh

         z) new="$oldx.$oldy.$((oldz+1))"    ;;
         *) die "invalid release level: $1"  ;;
     esac
-    echo $new
+    echo "$new"
 }
 
 __release() {
     git rev-parse HEAD >&/dev/null || die "cannot release outside git repo"
     local lastfile=$(git diff-tree --no-commit-id --name-only -r HEAD)
     local lasttag=$(git tag | grep ^v | sort -V | tail -n1)
-    local changelog="$(git log --oneline $lasttag..HEAD)"
+    local changelog="$(git log --oneline "$lasttag..HEAD")"
     local curbranch=$(git rev-parse --abbrev-ref HEAD)
     local dirt="$(git diff --shortstat 2>/dev/null)"
 
-    local newver=$(__make_ver $level ${lasttag#v})
+    local newver=$(__make_ver "$level" "${lasttag#v}")
     local newtag=v$newver
     local higher=$(echo -e "$oldtag\n$newtag" | sort -V | tail -n1)
 
+    test "$lastfile" = config.mk \
+     || die "last change must be version bump in config.mk"
+
+    test -n "$lasttag" \
+     || die "cannot find last tag"
+
     test "$newtag" = "$higher" \
      || die "generated tag looks older: $oldtag<$newtag"
 
     grep -qw "$newver" config.mk \
      || die "new version not in config.mk: $newver"
 
-    test -n "$lasttag" \
-     || die "cannot find last tag"
-
     grep '^....... WIP ' <<<"$changelog" \
      && die "WIP commit since $lasttag"
 
     # FIXME: Have user prepare proper message with changelog
 
     set -e
-    git tag -m "$MKIT_PROJNAME $newtag - $CODENAME" $newtag
-    git branch -f $RELDST $newtag
+    git tag -m "$MKIT_PROJNAME $newtag - $CODENAME" "$newtag"
+    git branch -f "$RELDST" "$newtag"
 }
 
 release_x() {

utils/mkit/make

 
 export MKIT_DIR=${MKIT_DIR:-mkit}
 
-. $MKIT_DIR/include/mkit.sh || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"
+. "$MKIT_DIR/include/mkit.sh" || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"
 
 mkit_init