Update own dogfood

mkit.ini

@@ -1,3 +1,4 @@
+#mkit version=0.0.14
 
 [project]
 
@@ -9,31 +10,24 @@
     relsrc      = master
     reldst      = last
 
-[ENV]
-
-    PREFIX = utils
-
 [lists]
+    tarball = Makefile
+    tarball = mkit.ini
+    tarball = README.md
+    tarball = src
+    tarball = utils
 
-    group = bin
-    group = rest
-
-    dist = Makefile
-    dist = mkit.ini
-    dist = README.md
-    dist = src
-    dist = utils
-
-[modes]
-    bin = 755
+[ENV]
+    PREFIX = utils
 
 [roots]
     bin  = [ENV:PREFIX]/mkit
     rest = [ENV:PREFIX]/mkit
 
-[files:bin]
-    src/make     = make
+[modes]
+    bin = 755
 
-[files:rest]
-    src/include  = include
-    src/mkit.mk  = mkit.mk
+[files]
+    bin = src/make
+    rest = src/include
+    rest = src/mkit.mk

utils/mkit/include/build.sh

@@ -1,21 +1,10 @@
 #!/bin/bash
 
-. "$MKIT_DIR/include/ini.sh" || die "cannot import ini.sh"
+. "$MKIT_DIR/include/ini.sh"   || die "cannot import ini.sh"
+. "$MKIT_DIR/include/facts.sh" || die "cannot import facts.sh"
 
 
-build() {
-    #
-    # Add meat to all skeletons
-    #
-    local srcpath
-    find src -type f -name '*.skel' \
-     | while read srcpath;
-       do
-           build1 "$srcpath"
-       done
-}
-
-build1() {
+_build1() {
     #
     # Process one skeleton
     #
@@ -23,14 +12,84 @@ build1() {
     local dstpath="$2"
     local ftype="$3"
     test -n "$dstpath"  || dstpath=${srcpath%.skel}
-    test -n "$ftype"    || ftype=$(guess_ftype "$dstpath")
+    test -n "$ftype"    || ftype=$(_guess_ftype "$dstpath")
     debug_var srcpath dstpath ftype
-    <"$srcpath" build1_ftype "$ftype" >"$dstpath"
+    <"$srcpath" _build1_ftype "$ftype" >"$dstpath"
     mkdir -p "$MKIT_LOCAL"
     echo "$dstpath" >> "$MKIT_LOCAL/built.lst"
 }
 
-guess_ftype() {
+_build1_ftype() {
+    #
+    # Build a file of type $1
+    #
+    local ftype="$1"
+    case $ftype in
+        MKIT_COMMON)    _expand_tokens "tokens" ;;
+        markdown)       _expand_includes | _expand_tokens "tokens" ;;
+        rpmstuff)       _expand_tokens "tokens" "rpmstuff:tokens" ;;
+        *)              die "unknown file type: $ftype" ;;
+    esac
+}
+
+_expand_includes() {
+    #
+    # Expand include directives
+    #
+    # Expand e.g. `<!-- include4: foo.sh -->` to include code of foo.sh
+    #
+    perl -we '
+        use strict;
+        my $text;
+        while (<>) {
+            chomp;
+            if (m/<!-- include4: (\S+) -->/) {
+                open my $fh, $1 or warn "cannot find: $1";
+                my $text = do { local($/); <$fh> };
+                close $fh;
+                $text =~ s/^(.)/    $1/gm;
+                chomp $text;
+                print "$text\n";
+            } else {
+                print "$_\n";
+            }
+        }
+    '
+}
+
+_expand_tokens() {
+    #
+    # Expand tokens from sections $@
+    #
+    local script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
+    local section varname varvalue
+    {
+        for section in "$@";
+        do
+            debug_var section
+            ini lskeys "$section" \
+              | while read varname;
+                do
+                    varvalue="$(ini 1value "$section:$varname" | _qfs )"
+                    echo "s|$varname|$varvalue|g;"
+                    debug_var varname varvalue
+                done
+        done
+        echo "s|__MKIT_PROJ_NAME__|$(ini 1value project:name | _qfs)|g;"
+        echo "s|__MKIT_PROJ_CODENAME__|$(ini 1value project:codename | _qfs)|g;"
+        echo "s|__MKIT_PROJ_PKGNAME__|$(ini 1value project:pkgname | _qfs)|g;"
+        echo "s|__MKIT_PROJ_TAGLINE__|$(ini 1value project:tagline | _qfs)|g;"
+        echo "s|__MKIT_PROJ_MAINTAINER__|$(ini 1value project:maintainer | _qfs)|g;"
+        echo "s|__MKIT_PROJ_VCS_BROWSER__|$(ini 1value project:vcs_browser | _qfs)|g;"
+        echo "s|__MKIT_PROJ_GIT_LASTHASH__|$(git_lasthash | _qfs)|g;"
+        echo "s|__MKIT_PROJ_VERSION__|$(semver | _qfs)|g;"
+        echo "s|__MKIT_SELF_VERSION__|$MKIT_VERSION|g;"
+    } >> "$script"
+    sed -f "$script" || die "_expand_tokens failed"
+    rm "$script"
+}
+
+_guess_ftype() {
     #
     # Guess file type from destination path $1
     #
@@ -41,17 +100,26 @@ guess_ftype() {
     esac
 }
 
-build1_ftype() {
+_qfs() {
     #
-    # Build a file of type $1
+    # Quote for our sed scipt's RHS
     #
-    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
+    sed '
+        s:\\:\\\\:g
+        s:|:\\|:g
+    '
+}
+
+build() {
+    #
+    # Add meat to all skeletons
+    #
+    local srcpath
+    find src -type f -name '*.skel' \
+     | while read srcpath;
+       do
+           _build1 "$srcpath"
+       done
 }
 
 build_manpages() {
@@ -85,30 +153,11 @@ clean() {
     true
 }
 
-dist() {
-    #
-    # 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_PROJ_PKGNAME-$version
-    mkdir -p "$dirname"
-    ini values "lists:dist" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
-    update_version "$version" "$dirname/mkit.ini"
-    tar -cf "$dirname.tar" "$dirname"
-    gzip -f "$dirname.tar"      # see above FIXME
-    mkdir -p "$MKIT_LOCAL"
-    echo "$dirname.tar.gz" >> "$MKIT_LOCAL/built.lst"
-    rm -rf "$dirname"
-}
-
 debstuff() {
     #
     # Build Debian stuff (eamed tarball, debian dir)
     #
-    local version="$(get_version)"
+    local version="$(semver)"
 
     # tarball - we should already have by means of 'dist'
     #
@@ -119,8 +168,8 @@ debstuff() {
 
     # read content of each mandatory file from debian_skel
     #
-    local debian_skel=$(ini 1value debstuff:debian_skel)
-    test -n "$debian_skel" || die "debstuff:debian_skel not specified"
+    local debian_skel=$(ini 1value dist:debstuff)
+    test -n "$debian_skel" || die "dist:debstuff not specified"
     test -d "$debian_skel" || die "debian directory template found: $debian_skel"
     mkdir -p debian/source
     local dfsrc dftgt
@@ -129,154 +178,40 @@ debstuff() {
         do
             dftgt="debian/${dfsrc#$debian_skel}"
             mkdir -p "$(dirname "$dftgt")"
-            build1 "$dfsrc" "$dftgt"
+            _build1 "$dfsrc" "$dftgt"
         done
     echo debian >> "$MKIT_LOCAL/built.lst"
 }
 
-rpmstuff() {
-    #
-    # Build specfile
-    #
-    local specname="$MKIT_PROJ_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 e.g. `<!-- include4: foo.sh -->` to include code of foo.sh
+dist() {
     #
-    perl -we '
-        use strict;
-        my $text;
-        while (<>) {
-            chomp;
-            if (m/<!-- include4: (\S+) -->/) {
-                open my $fh, $1 or warn "cannot find: $1";
-                my $text = do { local($/); <$fh> };
-                close $fh;
-                $text =~ s/^(.)/    $1/gm;
-                chomp $text;
-                print "$text\n";
-            } else {
-                print "$_\n";
-            }
-        }
-    '
-}
-
-expand_variables() {
+    # Create distributable tarball
     #
-    # Expand variables from sections $@
+    #FIXME: lacking Makefile skills, we do this step twice fot
+    #       rpmstuff, hence -f hack for gzip
     #
-    local script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
-    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|;"
-                    debug_var varname varvalue
-                done
-        done
-        echo "s|__MKIT_PROJ_NAME__|$(ini 1value project:name)|;"
-        echo "s|__MKIT_PROJ_CODENAME__|$(ini 1value project:codename)|;"
-        echo "s|__MKIT_PROJ_PKGNAME__|$(ini 1value project:pkgname)|;"
-        echo "s|__MKIT_PROJ_TAGLINE__|$(ini 1value project:tagline)|;"
-        echo "s|__MKIT_PROJ_VERSION__|$(get_version)|;"
-        echo "s|__MKIT_SELF_VERSION__|$MKIT_VERSION|;"
-    } >> "$script"
-    perl -wp "$script" || die "expand_variables failed"
-    rm "$script"
+    local version=$(semver)
+    local git_lasthash=$(git_lasthash)
+    local dirname=$MKIT_PROJ_PKGNAME-$version
+    mkdir -p "$dirname"
+    ini values "dist:tarball" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
+    update_version "$version" "$dirname/mkit.ini"
+    mkdir -p "$dirname/.mkit"
+    echo -n "$git_lasthash" > "$dirname/.mkit/git_lasthash"
+    tar -cf "$dirname.tar" "$dirname"
+    gzip -f "$dirname.tar"      # see above FIXME
+    mkdir -p "$MKIT_LOCAL"
+    echo "$dirname.tar.gz" >> "$MKIT_LOCAL/built.lst"
+    rm -rf "$dirname"
 }
 
-get_version() {
-    #
-    # Build semver version string with build metadata
-    #
-    # Build version string from available info using following
-    # logic:
-    #
-    #  1. use project.version (from mkit.ini)
-    #  2. if we are in git, override the version with last tag
-    #  3. if set, add project:prerl (from mkit.ini) as pre-release ID
-    #     (afer dash)
-    #  4. if we are at a later commit than the last tag, add branch
-    #     name and commit sha1 to build metadata (after plus sign)
-    #  5. if the tree is "dirty", i.e. has uncommited changes,
-    #     add "dirty" to build metadata
-    #
-    # The version is compatible with SemVer 2.0.0.
-    #
-    # Examples:
-    #
-    #     myprog v1.0.7                         # all clear
-    #     myprog v1.0.7-alpha                   # mkit.ini: project:prerl="alpha"
-    #     myprog v1.0.7-alpha+g1aef811.master   # ^^ + some commits after
-    #     myprog v1.0.7-alpha+gf14fc4f.api2     # ^^ + on a feature branch
-    #     myprog v1.0.7-alpha+gf14fc4f.api2.dirty  # ^^ + tree edited
-    #     myprog v1.0.7-alpha+dirty             # tag OK but tree edited
-    #     myprog v1.0.7+dirty                   # ^^ but no pre-release id
-    #
-    # Note that versions with "dirty" should be perceived as kind of
-    # dangerous outside developer's own machine.  Versions with sha1 are
-    # safer but must not be released.
-    #
-    # I have considered decorating the git commit refs to make them
-    # sort of sortable (e.g. "r1.g1aef811"), but on second thought,
-    # I don't think it's good idea to give *any* semantics to meta-data
-    # at all.  First, there is no rule that r1<r2<r3; a commit can be
-    # removing what other just added and one change can be split to
-    # multiple commits.  Also, the whole thing breaks anyway once you
-    # rebase your branch (no, it's not a sin).  The sole purpose of
-    # meta-data is to *identify* the code, and provide safe path back
-    # to tree; commit refs are already perfect for that.
+rpmstuff() {
     #
-    # FIXME:  Using project:prerl for release IDs may not be compatible with
-    #         release strategy implemented in release.sh
+    # Build specfile
     #
-    local version=$(ini 1value project:version)
-    local prerl=$(ini 1value project:prerl)
-    grep ":" <<<"$prerl" && warn "colon in project:prerl may corrupt version data: $prerl"
-    if git rev-parse HEAD >&/dev/null;
-    then    # we are in git repo... so we can get smart
-        local latest_tag=$(
-            git log --format="%D" \
-              | sed 's/,/\n/g' \
-              | sed 's/^[[:blank:]]*//; ' \
-              | grep -E '^tag: v[[:digit:]]+\.' \
-              | cut -d' ' -f2 \
-              | head -1
-        )
-        if ! git describe --tags --exact-match HEAD >&/dev/null;
-        then    # we are at a later commit than the last tag
-            local sha=g$(git log -1 --pretty=format:%h HEAD)
-            local curbranch=$(git rev-parse --abbrev-ref HEAD)
-            local commit="$curbranch.$sha"
-        fi
-        if test "$(git diff --shortstat 2>/dev/null)" != "";
-        then    # the tree is "dirty", i.e. has been edited
-            local dirty=dirty
-        fi
-        test -n "$latest_tag" && version=${latest_tag:1}
-        local suffix=""
-        case "$commit:$dirty" in
-            :)       suffix=""                ;;
-            :dirty)  suffix="+$dirty"         ;;
-            *:)      suffix="+$commit"        ;;
-            *:dirty) suffix="+$commit.$dirty" ;;
-        esac
-        test -b "$prerl" && suffix="-$prerl$suffix"
-        version="$version$suffix"
-    fi
-    echo "$version"
+    local specname="$MKIT_PROJ_PKGNAME.spec"
+    local specsrc="$(ini 1value "dist:rpmstuff")"
+    test -n "$specsrc" || die "dist:rpmstuff not specified"
+    test -f "$specsrc" || die "specfile template not found: $specsrc"
+    _build1 "$specsrc" "$specname"
 }

utils/mkit/include/deploy.sh

@@ -1,24 +1,10 @@
 #!/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
-}
-
-deploy_item() {
+_deploy_item() {
     #
     # Deploy item and make it look like wanted
     #
-    # usage: deploy_item src dst [mode]
+    # 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
@@ -54,18 +40,20 @@ deploy_item() {
     fi
 }
 
-get_dst() {
+_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")"
+    local dst=$3
+    test -n "$dst" || dst=${src##*/}
+    echo "$(_get_root "$grp")/$dst"
 }
 
-get_root() {
+_get_root() {
     #
-    # Find out target rooot for group $1
+    # Find out target root for group $1
     #
     local grp="$1"
     local root=$(ini 1value "roots:$grp")
@@ -78,20 +66,36 @@ get_root() {
     esac
 }
 
+_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
+}
+
 install() {
     #
     # Install product
     #
     local dst group mode src
-    ini values "lists:group" \
+    ini lskeys "files" \
+      | sort \
+      | uniq \
       | while read group;
         do
             mode=$(ini 1value "modes:$group")
-            ini lskeys "files:$group" \
-              | while read src;
+            ini values "files:$group" \
+              | while read src dst;
                 do
-                    dst=$(get_dst "$group" "$src")
-                    deploy_item "$src" "$dst" "$mode"
+                    dst=$(_get_dst "$group" "$src" "$dst")
+                    _deploy_item "$src" "$dst" "$mode"
                 done
         done
     test -f "$MKIT_LOCAL/autoclean" && clean
@@ -103,13 +107,15 @@ uninstall() {
     # Uninstall product
     #
     local dst group src
-    ini values "lists:group" \
+    ini lskeys "files" \
+      | sort \
+      | uniq \
       | while read group;
         do
-            ini lskeys "files:$group" \
-              | while read src;
+            ini values "files:$group" \
+              | while read src dst;
                 do
-                    dst=$(get_dst "$group" "$src")
+                    dst=$(_get_dst "$group" "$src" "$dst")
                     _maybe rm -vrf "$dst"
                 done
         done

utils/mkit/include/facts.sh

@@ -0,0 +1,175 @@
+#!/bin/bash
+
+. "$MKIT_DIR/include/ini.sh" || die "cannot import ini.sh"
+
+git_bool() {
+    #
+    # Get git bool (ie. exit status counts) $1
+    #
+    local bool_name="$1"
+    git_present || warn "can't give bool outside git repo: $bool_name"
+    case "$bool_name" in
+        dirty_files)
+            git diff-files | grep -qm 1 .
+            ;;
+        dirty_index)
+            git diff-index HEAD | grep -qm 1 .
+            ;;
+        dirty)
+            git_bool dirty_files || git_bool dirty_index
+            ;;
+        *)
+            warn "unknown git bool asked: $bool_name"
+            return 2
+            ;;
+    esac
+}
+
+git_fact() {
+    #
+    # Get git fact $1
+    #
+    local fact_name="$1"
+    git_present || warn "can't give fact outside git repo: $fact_name"
+    case "$fact_name" in
+        latest_tag)
+            git log --format="%d" \
+              | sed 's/,/\n/g' \
+              | sed 's/^[[:blank:]]*//' \
+              | grep -E '^\(?tag' \
+              | tr -cd '[[:digit:]].v\n' \
+              | grep . -m 1
+            ;;
+        latest_version)
+            git_fact latest_tag | git_tag2ver
+            ;;
+        current_branch)
+            git rev-parse --abbrev-ref HEAD
+            ;;
+        reldiff)
+            git log --oneline "$(git_fact latest_tag)..HEAD" --name-only
+            ;;
+        latest_sha)
+            git log -1 --pretty=format:%h HEAD
+            ;;
+        *)
+            warn "unknown git fact asked: $fact_name"
+            ;;
+    esac
+}
+
+git_present() {
+    #
+    # True if we're in a git repo
+    #
+    git rev-parse HEAD >&/dev/null
+}
+
+git_tag2ver() {
+    #
+    # Convert tag to version
+    #
+    sed s/^v//
+}
+
+git_ver2tag() {
+    #
+    # Convert version to tag
+    #
+    sed s/^/v/
+}
+
+git_lasthash() {
+    #
+    # Show last commit hash (with .dirty suffix if needed)
+    #
+    # If outside git repo, get it from .mkit/git_lasthash, which
+    # should have been put there by dist target.  (I.e., this won't
+    # work if you got outside the git repo in other way than dist
+    # target, but that's actually expected.)
+    #
+    if git_present;
+    then    # we are in git repo
+        local last_hash=$(git rev-parse HEAD)
+        echo -n "$last_hash"
+        git_bool dirty && echo -n ".dirty"
+    else    # we are outside (eg. distributor's build dir')
+        grep . .mkit/git_lasthash || {
+            echo UNKNOWN
+            warn "malformed source, could not determine git hash"
+        }
+    fi
+}
+
+semver() {
+    #
+    # Build semver version string with build metadata
+    #
+    # Build version string from available info using following
+    # logic:
+    #
+    #  1. use project.version (from mkit.ini)
+    #  2. if we are in git, override the version with last tag
+    #  3. if set, add project:prerl (from mkit.ini) as pre-release ID
+    #     (afer dash)
+    #  4. if we are at a later commit than the last tag, add branch
+    #     name and commit sha1 to build metadata (after plus sign)
+    #  5. if the tree is "dirty", i.e. has uncommited changes,
+    #     add "dirty" to build metadata
+    #
+    # The version is compatible with SemVer 2.0.0.
+    #
+    # Examples:
+    #
+    #     myprog v1.0.7                         # all clear
+    #     myprog v1.0.7-alpha                   # mkit.ini: project:prerl="alpha"
+    #     myprog v1.0.7-alpha+g1aef811.master   # ^^ + some commits after
+    #     myprog v1.0.7-alpha+gf14fc4f.api2     # ^^ + on a feature branch
+    #     myprog v1.0.7-alpha+gf14fc4f.api2.dirty  # ^^ + tree edited
+    #     myprog v1.0.7-alpha+dirty             # tag OK but tree edited
+    #     myprog v1.0.7+dirty                   # ^^ but no pre-release id
+    #
+    # Note that versions with "dirty" should be perceived as kind of
+    # dangerous outside developer's own machine.  Versions with sha1 are
+    # safer but must not be released.
+    #
+    # I have considered decorating the git commit refs to make them
+    # sort of sortable (e.g. "r1.g1aef811"), but on second thought,
+    # I don't think it's good idea to give *any* semantics to meta-data
+    # at all.  First, there is no rule that r1<r2<r3; a commit can be
+    # removing what other just added and one change can be split to
+    # multiple commits.  Also, the whole thing breaks anyway once you
+    # rebase your branch (no, it's not a sin).  The sole purpose of
+    # meta-data is to *identify* the code, and provide safe path back
+    # to tree; commit refs are already perfect for that.
+    #
+    # FIXME:  Using project:prerl for release IDs may not be compatible with
+    #         release strategy implemented in release.sh
+    #
+    local version=$(ini 1value project:version)
+    local prerl=$(ini 1value project:prerl)
+    grep ":" <<<"$prerl" && warn "colon in project:prerl may corrupt version data: $prerl"
+    if git_present;
+    then    # we are in git repo... so we can get smart
+        local latest_tag=$(git_fact latest_tag)
+        if ! git describe --tags --exact-match HEAD >&/dev/null;
+        then    # we are at a later commit than the last tag
+            local commit="$(git_fact current_branch).g$(git_fact latest_sha)"
+        fi
+        local dirty=""
+        local suffix=""
+        git_bool dirty; dirty=$?
+        test -n "$latest_tag" && version=${latest_tag:1}
+        case "$dirty:$commit" in
+            1:)  suffix=""               ;;
+            0:)  suffix="+dirty"         ;;
+            1:*) suffix="+$commit"       ;;
+            0:*) suffix="+$commit.dirty" ;;
+            *)   suffix=MKIT_BUG;
+                 warn "MKIT_BUG: bad dirt/commit detection" ;;
+        esac
+        test -n "$prerl" && suffix="-$prerl$suffix"
+        version="$version$suffix"
+    fi
+    echo "$version"
+}

utils/mkit/include/ini.sh

@@ -1,24 +1,5 @@
 #!/bin/bash
 
-ini() {
-    #
-    # do ini operation
-    #
-    local op=$1
-    local arg=$2
-    local fn
-    local limit=_ini_cat
-    debug_var op arg
-    case $op in
-        lskeys) fn=_ini_lskeys   ;;
-        sec)    fn=_ini_grepsec  ;;
-        values) fn=_ini_greppath ;;
-        1value) fn=_ini_greppath; limit="tail -1" ;;
-        *)      die "incorrect use of \`ini()\`"
-    esac
-    <"$MKIT_INI" $fn "$arg" | $limit
-}
-
 _ini_cat() {
     #
     # A no-op for text stream
@@ -121,3 +102,42 @@ _ini_maybe_expand() {
         _ini_cat
     fi
 }
+
+ini() {
+    #
+    # do ini operation
+    #
+    local op=$1
+    local arg=$2
+    local fn
+    local limit=_ini_cat
+    case $op in
+        lskeys) fn=_ini_lskeys   ;;
+        sec)    fn=_ini_grepsec  ;;
+        values) fn=_ini_greppath ;;
+        1value) fn=_ini_greppath; limit="tail -1" ;;
+        *)      die "incorrect use of \`ini()\`"
+    esac
+    <"$MKIT_INI" $fn "$arg" | $limit
+}
+
+update_version() {
+    #
+    # Change project.version in mkit.ini at path $2 to version $1
+    #
+    local version="$1"
+    local inifile="$2"
+    local tmp=$(mktemp -t mkit.update_version.XXXXXXXX)
+    <"$inifile" perl -e '
+        my $hit = 0;
+        my $done = 0;
+        foreach (<STDIN>) {
+            if      ($done) { print; next; }
+            elsif   (m/\[project\]/) { $hit++; print; next; }
+            elsif   (m/\[/) { $hit = 0; print; next; }
+            elsif   ($hit) { s/\bversion\b( *)=( *).*/version$1=$2$ARGV[0]/ and $done++; print; }
+            else { print; next; }
+        }
+    ' "$version" >"$tmp" || die "failed to update version in mkit.ini"
+    mv "$tmp" "$inifile"
+}

utils/mkit/include/mkit.sh

@@ -5,6 +5,26 @@
 . "$MKIT_DIR/include/release.sh" || die "cannot import release.sh"
 . "$MKIT_DIR/include/ini.sh"    || die "cannot import ini.sh"
 
+_valid_targets() {
+    #
+    # List valid routes
+    #
+    echo build
+    echo build_manpages
+    echo clean
+    echo debstuff
+    echo dist
+    echo install
+    echo release_x
+    echo release_y
+    echo release_z
+    echo rpmstuff
+    echo uninstall
+    echo vbump_x
+    echo vbump_y
+    echo vbump_z
+}
+
 debug() {
     #
     # Print debug message
@@ -30,23 +50,6 @@ debug_var() {
     done
 }
 
-MKIT_INI=${MKIT_INI:-mkit.ini}
-MKIT_INI_EXPAND=2
-MKIT_PROJ_NAME=$(ini 1value "project:name")
-MKIT_PROJ_PKGNAME=$(ini 1value "project:pkgname")
-MKIT_DEFAULT_MODE="644"
-
-mkit_init() {
-    #
-    # Do basic initialization
-    #
-    # Check for ini file and some variables
-    #
-    test -f "$MKIT_INI" || die "cannot find mkit.ini: $MKIT_INI"
-    test -n "$(tr -d '[:space:]' <<<"$MKIT_LOCAL")" \
-     || die "MKIT_LOCAL must be non-blank: '$MKIT_LOCAL'"
-}
-
 die() {
     #
     # Exit with message and non-zero exit status
@@ -55,39 +58,71 @@ die() {
     exit 4
 }
 
-warn() {
+_compver() {
+    #
+    # True if version $1 matches our version
+    #
+    # If our x is 0, check first two fragments, otherwise check just
+    # the x.  Fragments must equal.
+    #
+    local their_ver our_x our_y their_x their_y
+    their_ver="$1"
+    their_x=${their_ver%%.*}
+    their_y=${their_ver##$their_x.}
+    their_y=${their_y%%.*}
+    our_x=${MKIT_VERSION%%.*}
+    our_y=${MKIT_VERSION##$our_x.}
+    our_y=${our_y%%.*}
+    debug_var MKIT_VERSION our_x our_y their_ver their_x their_y
+    test "$their_x" -eq "$our_x" || return 1
+    test "$our_x" -eq 0 && {
+        test "$their_y" = "$our_y"
+        return $?
+    }
+    return 0
+}
+
+_chkiniversion() {
     #
-    # Print warning message
+    # Check if ini version is supported
     #
-    echo "$@" >&2
+    # Look for "#mkit version=0.0.0" or similar in first or last
+    # 3 lines of the file; then check if the version is supported.
+    #
+    local ver_line
+    local their_ver
+    ver_line=$(
+        {
+            head -3 "$MKIT_INI"
+            tac "$MKIT_INI" | tail -3
+        } | grep -m 1 -E '^# *mkit +version *= *v?[0-9]+\.[0-9]+\.[0-9]+'
+    )
+    test -n "$ver_line" \
+     || die "version mark ('#mkit version=x.y.z') not found in: $MKIT_INI"
+    their_ver="$(tr -d '[:blank:]v' <<<"${ver_line##*=}")"
+    _compver "$their_ver" \
+     || die "bad mkit.ini version: $their_ver does not match $MKIT_VERSION"
 }
 
-update_version() {
-    #
-    # Change project.version in mkit.ini at path $2 to version $1
-    #
-    local version="$1"
-    local inifile="$2"
-    local tmp=$(mktemp -t mkit.update_version.XXXXXXXX)
-    <"$inifile" perl -e '
-        my $hit = 0;
-        my $done = 0;
-        foreach (<STDIN>) {
-            if      ($done) { print; next; }
-            elsif   (m/\[project\]/) { $hit++; print; next; }
-            elsif   (m/\[/) { $hit = 0; print; next; }
-            elsif   ($hit) { s/\bversion\b *=.*/version = $ARGV[0]/ and $done++; print; }
-            else { print; next; }
-        }
-    ' "$version" >"$tmp" || die "failed to update version in mkit.ini"
-    mv "$tmp" "$inifile"
+mkit_init() {
+    #
+    # Do basic initialization
+    #
+    # Check for ini file and some variables
+    #
+    $MKIT_DRY && MKIT_DEBUG=true
+    MKIT_PROJ_PKGNAME=$(ini 1value "project:pkgname")
+    test -f "$MKIT_INI" || die "cannot find mkit.ini: $MKIT_INI"
+    _chkiniversion
+    test -n "$(tr -d '[:space:]' <<<"$MKIT_LOCAL")" \
+     || die "MKIT_LOCAL must be non-blank: '$MKIT_LOCAL'"
 }
 
 route() {
     #
     # Call correct function based on $1
     #
-    if valid_targets | grep -qwx "^$1";
+    if _valid_targets | grep -qwx "^$1";
     then
         "$1"
     else
@@ -95,27 +130,14 @@ route() {
             echo "usage: $(basename "$0") TARGET"
             echo
             echo "valid targets:"
-            valid_targets | sed 's/^/    /'
+            _valid_targets | sed 's/^/    /'
         } >&2
     fi
 }
 
-valid_targets() {
+warn() {
     #
-    # List valid routes
+    # Print warning message
     #
-    echo build
-    echo build_manpages
-    echo clean
-    echo debstuff
-    echo dist
-    echo install
-    echo release_x
-    echo release_y
-    echo release_z
-    echo rpmstuff
-    echo uninstall
-    echo vbump_x
-    echo vbump_y
-    echo vbump_z
+    echo "$@" >&2
 }

utils/mkit/include/release.sh

@@ -1,172 +1,164 @@
 #!/bin/bash
 
-__die_if() {
+. "$MKIT_DIR/include/ini.sh"   || die "cannot import ini.sh"
+. "$MKIT_DIR/include/facts.sh" || die "cannot import facts.sh"
+
+_bump_version() {
+    #
+    # Bump version on stdin by level $1 (x, y or z)
+    #
+    local rlevel=$1
+    local old
+    read -r old
+    local oldx=${old%.*.*}
+    local oldz=${old#*.*.}
+    local tmpy=${old%.*}
+    local oldy=${tmpy#*.}
+    local new=""
+    case $rlevel in
+        x) new="$((oldx+1)).0.0"            ;;
+        y) new="$oldx.$((oldy+1)).0"        ;;
+        z) new="$oldx.$oldy.$((oldz+1))"    ;;
+        *) die "invalid release level: $1"  ;;
+    esac
+    echo "$new"
+}
+
+_relck() {
     #
     # Die if blocking condition $1 is detected
     #
     local condition="$1"
     local x
     case "$condition" in
-        nogit)
+        git_present)
             git rev-parse HEAD >&/dev/null\
              || die "cannot do this outside git repo"
             ;;
-        norelbr)
+        at_relsrc)
             local relsrc=$(ini 1value project:relsrc)
-            __git_info curbranch \
+            git_fact current_branch \
               | grep -qFx "$relsrc" \
              || die "you are not on release source branch: $relsrc"
             ;;
-        dirty)
+        not_dirty)
             git diff --shortstat 2>/dev/null \
               | grep -q . \
              && die "tree is dirty: $dirt"
             ;;
-        novertag)
-            __git_info lasttag \
+        tags_ok)
+            git_fact latest_tag \
               | grep -q . \
-             || die "cannot find last tag"
+             || die "cannot find latest tag"
             ;;
-        nobump)
+        vbump_hot)
             git diff-tree --no-commit-id --name-only -r HEAD \
               | grep -qFx mkit.ini \
              || die "last change must be version bump in mkit.ini"
             ;;
-        wip)
-            __git_info reldiff \
+        no_wip)
+            git_fact reldiff \
               | grep '^....... WIP ' \
-             && die "WIP commit since $(__git_info lasttag)"
+             && die "WIP commit since $(git_fact latest_tag)"
             ;;
-        old_c)
-            x=$(__ver_info nextver_g)
-            __ver_info currver_c \
-              | grep -qFx "$x" \
-             || die "new version not in mkit.ini: $x"
+        ini_version)
+            local oracle=$(git_fact latest_version | _bump_version "$rlevel")
+            ini 1value project:version  \
+              | grep -qFx "$oracle" \
+             || die "new version not in mkit.ini: $oracle"
+            ;;
+        *)
+            die "unknown release check: $condition"
             ;;
     esac
 }
 
-__git_info() {
-    #
-    # Get git info $1
-    #
-    local info="$1"
-    case "$info" in
-        lasttag)    git tag | grep ^v | sort -V | tail -n1  ;;
-        curbranch)  git rev-parse --abbrev-ref HEAD         ;;
-        reldiff)    git log --oneline "$(__git_info lasttag)..HEAD" --name-only ;;
-    esac
-}
-
-__ver_info() {
-    #
-    # Get git info $1
-    #
-    local info="$1"
-    case "$info" in
-        lastver_g)  __git_info lasttag | sed s/^v// ;;
-        nextver_g)  __make_ver "$level" "$(__ver_info lastver_g)" ;;
-        currver_c)  ini 1value project:version ;;
-        nextver_c)  __make_ver "$level" "$(__ver_info currver_c)" ;;
-    esac
-}
-
-__make_ver() {
-    local level=$1
-    local old=$2
-    local oldx=${old%.*.*}
-    local oldz=${old#*.*.}
-    local tmpy=${old%.*}
-    local oldy=${tmpy#*.}
-    case $level in
-        x) new="$((oldx+1)).0.0"            ;;
-        y) new="$oldx.$((oldy+1)).0"        ;;
-        z) new="$oldx.$oldy.$((oldz+1))"    ;;
-        *) die "invalid release level: $1"  ;;
-    esac
-    echo "$new"
-}
-
-__release() {
+_release() {
     #
     # Prepare release
     #
     # Span release routines: make a signed tag, check branch
     # and update release branch
     #
-    # FIXME: Using project:prerl as build.sh:get_version() does may not be
+    # FIXME: Using project:prerl as build.sh:semver() does may not be
     #        compatible with this release strategy
     #
-    local level=$1
+    local rlevel=$1
     local newtag
+    local reldst
 
-    __die_if nogit
-    __die_if norelbr
-    __die_if dirty
-    __die_if novertag
-    __die_if nobump
-    __die_if wip
-    __die_if old_c
+    _relck git_present
+    _relck at_relsrc
+    _relck not_dirty
+    _relck tags_ok
+    _relck vbump_hot
+    _relck no_wip
+    _relck ini_version
 
-    newtag=v$(__ver_info nextver_g)
+    newtag=$(git_fact latest_version | _bump_version "$rlevel" | git_ver2tag )
     set -e
     debug_var newtag
     $MKIT_DRY && return
-    git tag -m "$MKIT_PROJ_NAME $newtag - $CODENAME" "$newtag"
-    git branch -f "$(ini 1value project:reldst)" "$newtag"
-}
+    git tag -m "$(ini 1value project:name) $newtag - $CODENAME" "$newtag"
 
-__git_msg_vbump() {
-    echo "Bump version"
-    echo ""
-    echo "Overview of changes:"
-    echo ""
-    __git_info reldiff \
-      | sed '
-            s/^[a-f0-9]\{7\} / *  &/; t PATHS
-            s/^/        /
-            :PATHS
-        '
+    reldst=$(ini 1value project:reldst)
+    debug_var reldst
+    if test -n "$reldst";
+    then
+        git branch -f "$reldst" "$newtag"
+    fi
 }
 
-__vbump() {
-    local level="$1"
+_vbump() {
+    local rlevel="$1"
     local lastver   # current from mkit.ini
     local nextver   # after the bump
-    __die_if nogit
-    __die_if norelbr
-    __die_if dirty
-    lastver=$(__ver_info currver_c)
-    nextver=$(__ver_info nextver_c)
+    _relck git_present
+    _relck at_relsrc
+    _relck not_dirty
+    nextver=$(ini 1value project:version | _bump_version "$rlevel")
     debug_var lastver nextver
     $MKIT_DRY && return
     update_version "$nextver" mkit.ini \
       || die "failed to update version in mkit.ini"
     git add mkit.ini \
       || die "failed to add mkit.ini to the index"
-    git commit -e -m "$(__git_msg_vbump)"
+    git commit -e -m "$(_vbump_gitmsg)"
 }
 
-vbump_x() {
-    __vbump x
+_vbump_gitmsg() {
+    echo "Bump version"
+    echo ""
+    echo "Overview of changes:"
+    echo ""
+    git_fact reldiff \
+      | sed '
+            s/^[a-f0-9]\{7\} / *  &/; t PATHS
+            s/^/        /
+            :PATHS
+        '
 }
 
-vbump_y() {
-    __vbump y
+release_x() {
+    _release x
 }
 
-vbump_z() {
-    __vbump z
+release_y() {
+    _release y
 }
 
-release_x() {
-    __release x
+release_z() {
+    _release z
 }
 
-release_y() {
-    __release y
+vbump_x() {
+    _vbump x
 }
 
-release_z() {
-    __release z
+vbump_y() {
+    _vbump y
+}
+
+vbump_z() {
+    _vbump z
 }

utils/mkit/make

@@ -6,12 +6,63 @@ die() {
     echo "$@" && exit 9
 }
 
-export MKIT_VERSION=0.0.11+devel.gda0869d
 
-export MKIT_DIR=${MKIT_DIR:-$(dirname "$0")}
-export MKIT_LOCAL=${MKIT_LOCAL:-.mkit}
-export MKIT_DRY=${MKIT_DRY:-false}
-export MKIT_DEBUG=${MKIT_DEBUG:-false}
+#
+# Debug mode (true|false)
+#
+MKIT_DEBUG=${MKIT_DEBUG:-false}
+
+#
+# Default deploy mode for files
+#
+MKIT_DEFAULT_MODE="644"
+
+#
+# Path to MKit dir (where 'include' is)
+#
+MKIT_DIR=${MKIT_DIR:-$(dirname "$0")}
+
+#
+# Dry mode (true|false)
+#
+# Set to true to not install anything. Implies MKIT_DEBUG.
+#
+MKIT_DRY=${MKIT_DRY:-false}
+
+#
+# Path to mkit.ini
+#
+MKIT_INI=${MKIT_INI:-mkit.ini}
+
+#
+# Limit ini expansion depth
+#
+# To avoid endless loops, this value is subtracted each
+# time ini() expands a reference; when zero is reached,
+# no more expansions happen.
+#
+MKIT_INI_EXPAND=2
+
+#
+# Path to MKit local config and temp
+#
+# Typically hidden in project root, here MKit can
+# save its temporary lists.
+#
+MKIT_LOCAL=${MKIT_LOCAL:-.mkit}
+
+#
+# Package name
+#
+# Used as base for tarball and in some default tokens.
+#
+MKIT_PROJ_PKGNAME=""
+
+#
+# This MKit version
+#
+MKIT_VERSION=0.0.13+devel.gec1f180
+
 
 . "$MKIT_DIR/include/mkit.sh" || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"