Update MKit to version v0.0.9

utils/mkit/include/build.sh

     #       rpmstuff, hence -f hack for gzip
     #
     local version=$(get_version)
-    local dirname=$MKIT_PKGNAME-$version
+    local dirname=$MKIT_PROJ_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"
+    update_version "$version" "$dirname/mkit.ini"
     tar -cf "$dirname.tar" "$dirname"
     gzip -f "$dirname.tar"      # see above FIXME
     mkdir -p "$MKIT_LOCAL"
     #
     # Build specfile
     #
-    local specname="$(ini 1value ENV:PKGNAME).spec"
+    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"
                 debug_var varname varvalue
             done
     done
-    echo "s|__CODENAME__|$CODENAME|;"     >> "$script"
-    echo "s|__VERSION__|$(get_version)|;" >> "$script"
+    echo "s|__MKIT_PROJ_CODENAME__|$(ini 1value project:codename)|;" >> "$script"
+    echo "s|__MKIT_PROJ_TAGLINE__|$(ini 1value project:tagline)|;" >> "$script"
+    echo "s|__MKIT_PROJ_VERSION__|$(get_version)|;" >> "$script"
     perl -wp "$script" || die "expand_variables failed"
     rm "$script"
 }
     # Build version string from available info using following
     # logic:
     #
-    #  1. use VERSION (from config.mk)
+    #  1. use project.version (from mkit.ini)
     #  2. if we are in git, override the version with last tag
-    #  3. if set, add PRERELEASE (from config.mk) as pre-release ID
+    #  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)
     # Examples:
     #
     #     myprog v1.0.7                         # all clear
-    #     myprog v1.0.7-alpha                   # PRERELEASE="alpha"
+    #     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
     # meta-data is to *identify* the code, and provide safe path back
     # to tree; commit refs are already perfect for that.
     #
-    # FIXME:  Using PRERELEASE for release IDs may not be compatible with
+    # FIXME:  Using project:prerl for release IDs may not be compatible with
     #         release strategy implemented in release.sh
     #
-    local version=$VERSION
-    local prerl=$PRERELEASE
-    grep ":" <<<"$prerl" && warn "colon in PRERELEASE may corrupt version data: $prerl"
+    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=$(

utils/mkit/include/mkit.sh

 
 MKIT_INI=${MKIT_INI:-mkit.ini}
 MKIT_INI_EXPAND=2
-MKIT_PKGNAME=$(ini 1value "ENV:PKGNAME")
-MKIT_PROJNAME=$(ini 1value "ENV:PROJNAME")
+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, load variables from config.mk
+    # Check for ini file and some variables
     #
     test -f "$MKIT_INI" || die "cannot find mkit.ini: $MKIT_INI"
-    tmp=$(mktemp)
-    sed -e 's/ = /=/' < config.mk > "$tmp"
-    . "$tmp"
-    rm -f "$tmp"
     test -n "$(tr -d '[:space:]' <<<"$MKIT_LOCAL")" \
      || die "MKIT_LOCAL must be non-blank: '$MKIT_LOCAL'"
 }
     echo "$@" >&2
 }
 
+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"
+}
+
 route() {
     #
     # Call correct function based on $1

utils/mkit/include/release.sh

              || die "cannot do this outside git repo"
             ;;
         norelbr)
+            local relsrc=$(ini 1value project:relsrc)
             __git_info curbranch \
-              | grep -qFx "$RELSRC" \
-             || die "you are not on RELSRC branch: $RELSRC"
+              | grep -qFx "$relsrc" \
+             || die "you are not on release source branch: $relsrc"
             ;;
         dirty)
             git diff --shortstat 2>/dev/null \
             ;;
         nobump)
             git diff-tree --no-commit-id --name-only -r HEAD \
-              | grep -qFx config.mk \
-             || die "last change must be version bump in config.mk"
+              | grep -qFx mkit.ini \
+             || die "last change must be version bump in mkit.ini"
             ;;
         wip)
             __git_info reldiff \
             x=$(__ver_info nextver_g)
             __ver_info currver_c \
               | grep -qFx "$x" \
-             || die "new version not in config.mk: $x"
+             || die "new version not in mkit.ini: $x"
             ;;
     esac
 }
     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" ;;
+        reldiff)    git log --oneline "$(__git_info lasttag)..HEAD" --name-only ;;
     esac
 }
 
     case "$info" in
         lastver_g)  __git_info lasttag | sed s/^v// ;;
         nextver_g)  __make_ver "$level" "$(__ver_info lastver_g)" ;;
-        currver_c)  grep -m 1 -w VERSION config.mk \
-                     | sed 's/ *= */=/' | cut -d = -f 2 | xargs echo ;;
+        currver_c)  ini 1value project:version ;;
         nextver_c)  __make_ver "$level" "$(__ver_info currver_c)" ;;
     esac
 }
     # Span release routines: make a signed tag, check branch
     # and update release branch
     #
-    # FIXME: Using PRERELEASE as build.sh:get_version() does may not be
+    # FIXME: Using project:prerl as build.sh:get_version() does may not be
     #        compatible with this release strategy
     #
     local level=$1
     set -e
     debug_var newtag
     $MKIT_DRY && return
-    git tag -m "$MKIT_PROJNAME $newtag - $CODENAME" "$newtag"
-    git branch -f "$RELDST" "$newtag"
+    git tag -m "$MKIT_PROJ_NAME $newtag - $CODENAME" "$newtag"
+    git branch -f "$(ini 1value project:reldst)" "$newtag"
 }
 
 __git_msg_vbump() {
     echo "Bump version"
     echo ""
-    __git_info reldiff | sed 's/^/ *  /'
+    echo "Overview of changes:"
+    echo ""
+    __git_info reldiff \
+      | sed '
+            s/^[a-f0-9]\{7\} / *  &/; t PATHS
+            s/^/        /
+            :PATHS
+        '
 }
 
 __vbump() {
     local level="$1"
-    local lastver   # current from config.mk
+    local lastver   # current from mkit.ini
     local nextver   # after the bump
     __die_if nogit
     __die_if norelbr
     nextver=$(__ver_info nextver_c)
     debug_var lastver nextver
     $MKIT_DRY && return
-    sed -i "s/$lastver/$nextver/" config.mk \
-      || die "failed to update config.mk"
-    git add config.mk \
-      || die "failed to add config.mk to the index"
+    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)"
 }
 

utils/mkit/make

     echo "$@" && exit 9
 }
 
-export MKIT_VERSION=0.0.8
+export MKIT_VERSION=0.0.9
 
 export MKIT_DIR=${MKIT_DIR:-$(dirname "$0")}
 export MKIT_LOCAL=${MKIT_LOCAL:-.mkit}

utils/mkit/mkit.mk

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