Update MKit to v0.0.34

mkit.ini

     etc_bc  = /etc/bash_completion.d
     sfincb  = [ENV:PREFIX]/share/shellfu/include-bash
 
-[tokens]
+[macros]
     __SATURNIN_DATA_HOME__    = [ENV:XDG_DATA_HOME]/saturnin-demo
     __SATURNIN_CACHE_HOME__   = [ENV:XDG_CACHE_HOME]/saturnin-demo
     __SATURNIN_CONFIG_HOME__  = [ENV:XDG_CONFIG_HOME]/saturnin-demo
     share   = src/help
     share   = src/ini.d
 
-#mkit version=0.0.24
+#mkit version=0.0.34

utils/mkit/include/build.sh

     test -n "$ftype"    || ftype=$(__guess_ftype "$dstpath")
     debug_var srcpath dstpath ftype
     <"$srcpath" __build1_ftype "$ftype" >"$dstpath"
-    rec_built "$dstpath"
+    __rec_built "$dstpath"
 }
 
 __build1_ftype() {
     #
     local ftype=$1      # file/builder type
     case $ftype in
-        MKIT_COMMON)    __expand_tokens "tokens" ;;
-        rpmstuff)       __expand_tokens "tokens" "rpmstuff:tokens" ;;
-        debstuff)       __expand_tokens "tokens" "debstuff:tokens" ;;
+        MKIT_COMMON)    __expand_macros "macros" ;;
+        rpmstuff)       __expand_macros "macros" "rpmstuff:macros" ;;
+        debstuff)       __expand_macros "macros" "debstuff:macros" ;;
         *)              die "unknown file type: $ftype" ;;
     esac
 }
 
-__expand_tokens() {
+__expand_line() {
     #
-    # Read stdin, expanding tokens from sections $@
+    # Expand macro from $MacroMap in single line $1
     #
-    local script        # sed script cache
-    local section       # each section to expand tokens from
-    local varname       # each token name
-    local varvalue      # each token value
-    script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
-    {
-        for section in "$@"; do
-            debug_var section
-            ini lskeys "$section" \
-              | while read -r varname; do
-                    varvalue="$(ini 1value "$section:$varname" | __qfs )"
-                    echo "s|$varname|$varvalue|g;"
-                    debug_var varname varvalue
-                done
+    # If macro value has multiple lines, repeat original line with
+    # different substitution.
+    #
+    # E.g. if macro value is "foo\nbar" and macro name is __FOO__,
+    # line `see: "__FOO__"` will expand to two lines: `see: "foo"`
+    # and `see: "bar"`.
+    #
+    local line=$1   # line to process
+    local mname     # macro name
+    local mvline    # line of macro value
+    local xline     # expanded line
+    xline=$line
+    for mname in "${!MacroMap[@]}"; do
+        if ! test "${line//$mname}" == "$line"; then
+            xline=$(
+                while IFS= read -r mvline; do
+                    echo "${line//$mname/$mvline}"
+                done <<<"${MacroMap[$mname]}"
+            )
+        fi
+        line=$xline
+    done
+    echo "$xline"
+    return 1
+}
+
+__expand_macros() {
+    #
+    # Read stdin, expanding macros from sections $@
+    #
+    local section       # each section to expand macros from
+    local line          # each line on stdin
+    local mname         # each macro name
+    local -A MacroMap   # macro value map
+    MacroMap[__MKIT_PROJ_NAME__]=$(ini 1value project:name)
+    MacroMap[__MKIT_PROJ_CODENAME__]=$(ini 1value project:codename)
+    MacroMap[__MKIT_PROJ_LICENSE__]=$(ini 1value project:license)
+    MacroMap[__MKIT_PROJ_PKGNAME__]=$(ini 1value project:pkgname)
+    MacroMap[__MKIT_PROJ_TAGLINE__]=$(ini 1value project:tagline)
+    MacroMap[__MKIT_PROJ_MAINTAINER__]=$(ini 1value project:maintainer)
+    MacroMap[__MKIT_PROJ_VCS_BROWSER__]=$(ini 1value project:vcs_browser)
+    MacroMap[__MKIT_PROJ_GIT_LASTHASH__]=$(__cached git_lasthash)
+    MacroMap[__MKIT_PROJ_VERSION__]=$(__cached semver)
+    MacroMap[__MKIT_SELF_VERSION__]=$MKIT_VERSION
+    for section in "$@"; do
+        for mname in $(ini lskeys "$section"); do
+            MacroMap[$mname]=$(ini values "$section:$mname")
         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_LICENSE__|$(ini 1value project:license | __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"
+    done
+    debug_var MacroMap
+    while IFS= read -r line; do
+        __expand_line "$line"
+    done
 }
 
 __guess_ftype() {
     '
 }
 
+__cached() {
+    #
+    # Cached value $1 of function $1()
+    #
+    # In order to support git-less builds, some values might be cached
+    # in $MKIT_LOCAL.  This function gets file $1 from that cache (cache
+    # hit) or re-creates it (cache miss), but prints its body in either
+    # case.
+    #
+    # The command to re-create file is the same as the key (ie. no
+    # arguments).
+    #
+    local name=$1
+    __local_get "$name" && return 0
+    "$name" | __local_putb "$name"
+    __local_get "$name"
+}
+
+__local_putb() {
+    #
+    # Make file $1 in $MKIT_LOCAL from stdin and mark as built
+    #
+    local fpath=$1
+    __local_put "$fpath" && __rec_built "$MKIT_LOCAL/$fpath"
+}
+
+__local_put() {
+    #
+    # Make file $1 in $MKIT_LOCAL from stdin
+    #
+    local fpath="$MKIT_LOCAL/$1"
+    { mkdir -p "${fpath%/*}" && cat >"$fpath"; } \
+     || die "cannot write to local cache: $fpath"
+}
+
+__local_get() {
+    #
+    # Read file $1 in $MKIT_LOCAL
+    #
+    local fpath="$MKIT_LOCAL/$1"
+    cat "$fpath" 2>/dev/null
+}
+
+__rec_built() {
+    #
+    # Record file $1 for deletion on `clean`
+    #
+    local file=$1
+    mkdir -p "$MKIT_LOCAL"
+    echo "$file" >> "$MKIT_LOCAL/built.lst"
+}
+
 _mkit_data() {
     #
-    # Build sampler showing all token values
+    # Build sampler showing all macro values
     #
-    local token
+    local macro
     local section
     local sections
     sections=()
-    ini lskeys tokens | grep -q . && sections=(tokens)
-    sections+=( $(ini lssect | grep ':tokens$') )
+    ini lskeys macros | grep -q . && sections=(macros)
+    sections+=( $(ini lssect | grep ':macros$') )
     {
         echo "(builtin):"
         echo "  x_MKIT_PROJ_NAME__ => '__MKIT_PROJ_NAME__'"
         echo "  x_MKIT_SELF_VERSION__ => '__MKIT_SELF_VERSION__'"
         for section in "${sections[@]}"; do
             echo "$section:"
-            for token in $(ini lskeys "$section"); do
-                echo "  x${token:1} => '$token'"
+            for macro in $(ini lskeys "$section"); do
+                echo "  x${macro:1} => '$macro'"
             done
         done
     } \
-      | __expand_tokens "MKIT_BUILTIN" "${sections[@]}" \
+      | __expand_macros "MKIT_BUILTIN" "${sections[@]}" \
       | sed '/^  x/ s|x|_|'
 }
 
     # Add meat to all skeletons
     #
     local srcpath   # each source path
-    semver >/dev/null
     find . -type f -name '*.skel' \
      | while read -r srcpath; do
            __build1 "$srcpath"
     local debian_skel   # 'debian' folder skeleton
     local dfsrc         # each source file from ^^
     local dftgt         # each built packaging file
-    version=$(semver)
+    version=$(__cached semver)
 
     # tarball - we should already have by means of 'dist'
     #
     mv "${MKIT_PROJ_PKGNAME}-$version.tar.gz" \
        "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz" \
      || die "could not rename tarball"
-    rec_built "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz"
+    __rec_built "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz"
 
     # read content of each mandatory file from debian_skel
     #
             mkdir -p "$(dirname "$dftgt")"
             __build1 "$dfsrc" "$dftgt" debstuff
         done
-    rec_built debian
+    __rec_built debian
 }
 
 dist() {
     git_lasthash=$(git_lasthash)
     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 "$version" > "$dirname/.mkit/semver"
     echo -n "$git_lasthash" > "$dirname/.mkit/git_lasthash"
     tar -cf "$dirname.tar" "$dirname"
     gzip -f "$dirname.tar"      # see above FIXME
-    rec_built "$dirname.tar.gz"
+    __rec_built "$dirname.tar.gz"
     rm -rf "$dirname"
 }
 

utils/mkit/include/facts.sh

         latest_sha)
             git log -1 --pretty=format:%h HEAD
             ;;
+        latest_cdate)
+            git log -1 --format=%cd --date=unix HEAD
+            ;;
         *)
             warn "unknown git fact asked: $fact_name"
             ;;
     #
     # 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.)
+    # We can't do it outside git repo (or without git) but we should
+    # not be asked to; targets that don't require git should make use
+    # of cache built by dist target.
     #
     local last_hash     # last commit hash
-    if git_present; then    # we are in git repo
-        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
+    git_present || {
+        echo UNKNOWN_HASH
+        warn "no git present; could not determine last hash"
+        return 3
+    }
+    last_hash=$(git rev-parse HEAD)
+    echo -n "$last_hash"
+    git_bool dirty && echo -n ".dirty"
 }
 
 semver() {
     #
-    # Build semver version string with build metadata
+    # Build proper SemVer version string
     #
     # 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
+    #  1. Use version from last git tag (or mkit.ini if there is no
+    #     tag, which is possible on new project)
+    #  2. 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
+    #  3. 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,
+    #  4. 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
+    #     foo v1.0.7                            # all clear; proper release
+    #     foo v1.0.7-beta                       # mkit.ini: project:prerl="beta"
+    #     foo v1.0.7-beta+g1aef811.master       # ^^ + some commits after
+    #     foo v1.0.7-beta+gf14fc4f.api2         # ^^ + on a feature branch
+    #     foo v1.0.7-beta+gf14fc4f.api2.dirty   # ^^ + tree edited
+    #     foo v1.0.7-beta+dirty                 # tag OK but tree edited
+    #     foo 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       # version string (final result)
-    local prerl         # pre-release keyword (from mkit.ini, eg. 'alpha')
+    local xyz           # base version string
+    local prerl         # pre-release keyword (from mkit.ini, eg. 'beta')
     local latest_tag    # latest git tag
     local commit        # commit indicator (CURRENT_BRANCH.gHASH)
-    local dirty         # 0 if dirty, 1 if clean
+    local dirty=F       # F if dirty, T if clean
+    local btime         # timestamp or nothing (see $MKIT_TTAG)
     local suffix        # version suffix
-    local_get semver && return 0
-    version=$(ini 1value project:version)
     prerl=$(ini 1value project:prerl)
+    case $MKIT_TTAG in
+        none)   btime= ;;
+        btime)  btime=$(date -u +%Y%m%d%H%M%S) ;;
+        ctime)  btime=$(date -d @"$(git_fact latest_cdate)" -u +%Y%m%d%H%M%S) ;;
+    esac
     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
-        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
-            commit="$(git_fact current_branch).g$(git_fact latest_sha)"
-        fi
-        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"
+    git_present || {
+        echo UNKNOWN_VERSION
+        warn "no git present; could not determine SemVer"
+        return 3
+    }
+    latest_tag=$(git_fact latest_tag)
+    case $latest_tag in
+        v*) xyz=${latest_tag:1} ;;
+        "") warn "no tags, using base version from mkit.ini (ok for new project)"
+            xyz=$(ini 1value project:version) ;;
+        *)  warn "bad form of last tag, using base version from mkit.ini: tag is '$latest_tag'"
+            xyz=$(ini 1value project:version) ;;
+    esac
+    if ! git describe --tags --exact-match HEAD >&/dev/null;
+    then    # we are at a later commit than the last tag
+        commit="$(git_fact current_branch).g$(git_fact latest_sha)"
     fi
-    local_putb semver <<<"$version"
-    echo "$version"
+    git_bool dirty && dirty=T
+    case "$dirty:$btime:$commit" in
+        F:*:)   suffix=""                       ;;
+        T::)    suffix="+dirty"                 ;;
+        T:*:)   suffix="+t$btime.dirty"           ;;
+        F::*)   suffix="+$commit"               ;;
+        F:*:*)  suffix="+t$btime.$commit"         ;;
+        T::*)   suffix="+$commit.dirty"         ;;
+        T:*:*)  suffix="+t$btime.$commit.dirty"   ;;
+        *)      suffix=MKIT_BUG
+                warn "MKIT_BUG: bad dirt/commit detection" ;;
+    esac
+    test -n "$prerl" && suffix="-$prerl$suffix"
+    echo "$xyz$suffix"
 }

utils/mkit/include/ini.sh

     done
 }
 
+__ini_grepcmt() {
+    #
+    # Remove comments from INI file on stdin
+    #
+    grep -v '^[[:space:]]*#'
+}
+
 __ini_grepkey() {
     #
     # Read key from a section
     #
     local wnt=$1    # wanted key
     grep '.' \
-      | grep -v '\s*#' \
       | sed -e 's/ *= */=/; s/ +$//; s/^//;' \
       | grep -e "^$wnt=" \
       | cut -d= -f2- \
     local ok=false      # are we in the section?
     local line          # each input line
     grep '.' \
-      | grep -v '\s*#' \
       | while read -r line; do
             case "$line" in
                 \[$wnt\]) ok=true;  continue ;;
     fi
 }
 
+__ini_body() {
+    #
+    # Produce mkit.ini body including INCLUDE
+    #
+    # Note: recursive includes are not supported.
+    #
+    local inc                       # file to include
+    local incre='\[INCLUDE:.*\]'    # include directive regex
+    local iline                     # include directive line
+    if iline=$(grep -m1 -x "$incre" "$MKIT_INI"); then
+        inc=${iline#*:}; inc=${inc%]}
+        grep -vx "$incre" "$inc"
+        grep -vx "$incre" "$MKIT_INI"
+    else
+        cat "$MKIT_INI"
+    fi | __ini_grepcmt
+}
+
 ini() {
     #
     # do ini operation
         1value) fn=__ini_greppath; limit="tail -1" ;;
         *)      die "incorrect use of \`ini()\`"
     esac
-    <"$MKIT_INI" $fn "$arg" | $limit
+    __ini_body | $fn "$arg" | $limit
 }
 
 update_version() {

utils/mkit/include/mkit.sh

     #
     $MKIT_DEBUG || return 0
     local __mkit_debug_var_name__       # variable name to debug
+    local decl                          # declare string
     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
+            decl=$(declare -p "$__mkit_debug_var_name__")
+            decl=${decl#declare ?? }
+            echo "MKIT_DEBUG: ${FUNCNAME[1]}(): $decl"
         } >&2
     done
 }
      || die "bad mkit.ini version: $their_ver does not match $MKIT_VERSION"
 }
 
-local_putb() {
-    #
-    # Make file $1 in $MKIT_LOCAL from stdin and mark as built
-    #
-    local fpath=$1
-    local_put "$fpath" && rec_built "$MKIT_LOCAL/$fpath"
-}
-
-local_put() {
-    #
-    # Make file $1 in $MKIT_LOCAL from stdin
-    #
-    local fpath="$MKIT_LOCAL/$1"
-    { mkdir -p "${fpath%/*}" && cat >"$fpath"; } \
-     || die "cannot write to local cache: $fpath"
-}
-
-local_get() {
-    #
-    # Read file $1 in $MKIT_LOCAL
-    #
-    local fpath="$MKIT_LOCAL/$1"
-    cat "$fpath" 2>/dev/null
-}
-
 mkit_init() {
     #
     # Do basic initialization
     __chkiniversion
 }
 
-rec_built() {
-    #
-    # Record file $1 for deletion on `clean`
-    #
-    local file=$1
-    mkdir -p "$MKIT_LOCAL"
-    echo "$file" >> "$MKIT_LOCAL/built.lst"
-}
-
 route() {
     #
     # Call correct function based on $1

utils/mkit/include/vars.sh

 #
 # Package name
 #
-# Used as base for tarball and in some default tokens.
+# Used as base for tarball and in some default macros.
 #
 MKIT_PROJ_PKGNAME=""
 
+#
+# Add time-based ordinal tag to SemVer build data?
+#
+# Can be 'none', 'ctime' or 'btime'.
+#
+# If 'ctime', devel builds have also timestamp-based tag in format of
+# `t%Y%m%d%H%M%S`, that is, a small character 't' followed by timestamp
+# without non-digit characters.  The timestamps are in UTC, ie. timezones
+# need not apply.  'btime' has the same format, except that it's derived
+# from build time, while 'ctime' is from last commit's commit date.
+#
+# This helps with deploying development builds where packaging system
+# is not SemVer-compliant and makes it hard to install arbitrary version.
+# For example, old yum version (as of RHEL-6) will not let you install
+# version that it deems older than is installed, making it hard to
+# continually upgrade during active development.  While packaging
+# systems have their own rukes (and SemVer says both versions should be
+# considered same) this tag will make it more likely to "win" the build
+# you made later.
+#
+# Note that this does not affect clean builds (ie. builds from clean
+# repo with HEAD corresponding to latest version tag.).
+#
+# Also note that 'btime' makes the version non-deterministic: merely
+# initiating the build a second later will result in different version.
+#
+MKIT_TTAG=${MKIT_TTAG:-ctime}
+
 #
 # This MKit version
 #
-MKIT_VERSION=0.0.28
+MKIT_VERSION=0.0.34

utils/mkit/stub

                 remake_section dist
                 remake_section ENV
                 remake_section roots
-                remake_section tokens
+                remake_section macros
                 remake_section modes
                 remake_section files
             else
                     echo "doc = [ENV:PREFIX]/share/doc/$PackageName"
                 } | reformat_section
                 echo ""
-                echo "[tokens]"
+                echo "[macros]"
                 {
                     echo "__${PackageName^^}_FOO__ = Barr.."
                 } | reformat_section
             echo 'Summary:    __MKIT_PROJ_NAME__ - __MKIT_PROJ_TAGLINE__'
             test -n "$VcsBrowser" && echo 'URL:        __MKIT_PROJ_VCS_BROWSER__'
             $MkLicense && echo "License:    $License"
-            echo ''
             echo 'Source0:    %{name}-%{version}.tar.gz'
             echo 'BuildArch:  noarch'
             echo ''
             echo 'Section: misc'
             echo 'Priority: extra'
             echo 'Standards-Version: 3.9.2'
-            echo 'Build-Depends: debhelper (>= 9)'
+            echo 'Build-Depends:'
+            echo ' debhelper (>= 9),'
             echo ''
             echo 'Package: __MKIT_PROJ_PKGNAME__'
             echo 'Architecture: all'
             echo "everything, so few things still need to be done manually."
             echo "This document will guide you throught the rest of the"
             echo "process."
-
             echo ""
             echo ""
             echo "Structure"
             echo "    machine should be uder 'src'."
             echo ""
             echo "    Note that during build time, files named ending with"
-            echo "    '.skel' are subject to token expansion, see mkit.ini"
+            echo "    '.skel' are subject to macro expansion, see mkit.ini"
             echo "    section below for details."
             echo ""
             echo " *  *notes* directory - here you shall store notes"
             echo " *  *packaging* directory contains templates that enable"
             echo "    MKit create raw stuffs used to create DEB or RPM"
             echo "    packages.  Similar to '.skel' files in 'src', all files"
-            echo "    here are automatically considered for token expansion,"
+            echo "    here are automatically considered for macro expansion,"
             echo "    no matter how they are named (see mkit.ini section"
             echo "    below)."
             echo ""
             echo "    idea!), be prepared that you will need to follow their"
             echo "    guidelines.  This will most probably mean huge changes"
             echo "    to these packages or even changes to your workflow."
-
             echo ""
             echo ""
             echo "Placeholders"
             echo "    Typical example of a role is e.g. 'bin' for commands"
             echo "    (normally under '/usr/bin' or '/usr/local/bin'), 'doc'"
             echo "    for documents or 'lib' for libraries."
-
             echo ""
             echo " 2. Next, in \`[roots]\` section, you have to set target"
             echo "    root directory for each role.  However, in order to"
             echo "    environment variable.  For this reason, most paths"
             echo "    need to start with \`[ENV:PREFIX]\`."
             echo ""
-
             echo " 3. \`[files]\` section is where you assign actual files"
             echo "    from your repository to their final paths.  The format"
             echo "    is \`ROLE = REPOPATH [RENAMED]\`, where ROLE is file's"
             echo "    individually, if in your repo you have a directory with"
             echo "    100 files of the same role, you can add just path to the"
             echo "    directory itself."
-
             echo ""
             echo " 4. If some roles require special permissions on your files,"
             echo "    \`[modes]\` section is your friend.  Permissions here"
             echo "    should be in UNIX octal format."
-
             echo ""
-            echo " 5. Next, \`[tokens]\` section allows you to define own"
+            echo " 5. Next, \`[macros]\` section allows you to define own"
             echo "    placeholders that will be replaced when your scripts are"
             echo "    built.  Each file in 'src' directory that is named with"
             echo "    '.skel' suffix, and each file from 'packaging' directory"
-            echo "    (no matter its name), can contain one or more of tokens"
-            echo "    defined here, plus range of tokens automatically defined"
-            echo "    by MKit.  During build, these tokens are replaced with"
+            echo "    (no matter its name), can contain one or more of macros"
+            echo "    defined here, plus range of macros automatically defined"
+            echo "    by MKit.  During build, these macros are replaced with"
             echo "    their actual values."
-
             echo ""
             echo " 6. Less interesting, but important section is \`[dist]\`,"
             echo "    which lists files in your codebase that will be added"
             echo "    above).  Listing directory here will include all its"
             echo "    contents, and normally it's OK to be very inclusive, so"
             echo "    most of the time this section should be OK."
-
             echo ""
             echo " 7. Even less interesting is section \`[ENV]\`.  It is"
             echo "    special in that it provides *default* value for an"
             echo "    environment variable.  You almost never need to touch"
             echo "    this."
             echo ""
-
             echo " 8. Finally, the most interesting section!  \`[project]\`,"
             echo "    provides most general information for your project such"
             echo "    as name and version."
         echo "    -R            skip creating README.md"
         echo "    -M            skip creating Makefile"
         echo "    -P            skip creating packaging templates"
-        echo "    -L            list know licenses and exit"
+        echo "    -L            list known licenses and exit"
         echo ""
         echo "PKGNAME should be packaging-friendly name, ie. consist"
         echo "only of small letters, numbers, underscore and dash."