Add everything

.gitignore

@@ -0,0 +1,2 @@
+.mkit/autoclean
+imapdomo-*.tar.gz

LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

Makefile

@@ -0,0 +1,5 @@
+# imapdomo - imapfilter convenience wrapper
+# See LICENSE file for copyright and license details.
+
+MKIT_DIR=utils/mkit
+include $(MKIT_DIR)/mkit.mk

mkit.ini

@@ -0,0 +1,40 @@
+#mkit version=0.0.14
+
+[project]
+    version     = 0.0.0
+    name        = imapdomo
+    pkgname     = imapdomo
+    tagline     = imapfilter convenience wrapper
+    relsrc      = master
+
+[dist]
+    tarball = LICENSE
+    tarball = Makefile
+    tarball = README.md
+    tarball = mkit.ini
+    tarball = src
+    tarball = utils
+    rpmstuff = packaging/imapdomo.spec
+    debstuff = packaging/debian
+
+[ENV]
+    PREFIX = /usr
+
+[roots]
+    bin     = [ENV:PREFIX]/bin
+    share   = [ENV:PREFIX]/share/imapdomo
+    etc     = /etc/imapdomo
+
+[tokens]
+    __IMAPDOMO_CONFIG_USER__    = $HOME/.config/imapdomo
+    __IMAPDOMO_CONFIG_LOCAL__   = [roots:etc]
+    __IMAPDOMO_SHARE__          = [roots:share]
+    __IMAPDOMO_USER_CACHE__     = $HOME/.local/share/imapdomo
+
+[modes]
+    bin     = 755
+
+[files]
+    bin     = src/imapdomo
+    share   = src/main.lua
+    share   = src/common.lua

packaging/debian/changelog

@@ -0,0 +1,5 @@
+bmo (__MKIT_PROJ_VERSION__-1) UNRELEASED; urgency=medium
+
+  * Initial release. (Closes: #XXXXXX)
+
+ -- Alois Mahdal <netvor@vornet.cz>  Sat, 27 Feb 2016 01:38:03 +0100

packaging/debian/compat

@@ -0,0 +1 @@
+9

packaging/debian/control

@@ -0,0 +1,17 @@
+Source: __MKIT_PROJ_PKGNAME__
+Maintainer: Alois Mahdal <netvor@vornet.cz>
+Vcs-Browser: http://github.com/AloisMahdal/imapdomo
+Section: misc
+Priority: extra
+Standards-Version: 3.9.2
+Build-Depends: debhelper (>= 9)
+
+Package: __MKIT_PROJ_PKGNAME__
+Architecture: all
+Depends: bash, imapfilter, lua, shellfu-bash, shellfu-bash-core, shellfu-bash-extras
+Description: __MKIT_PROJ_TAGLINE__
+ imapdomo is simple convenience wrapper around imapfilter that
+ adds few more Lua functions and suggests some system to way how you can
+ organize your mail filtering and/or migrations, etc.
+
+# control file built with MKit __MKIT_SELF_VERSION__

packaging/debian/copyright

@@ -0,0 +1 @@
+

packaging/debian/imapdomo.install

@@ -0,0 +1,3 @@
+/usr/bin/imapdomo
+/usr/share/imapdomo/common.lua
+/usr/share/imapdomo/main.lua

packaging/debian/rules

@@ -0,0 +1,13 @@
+#!/usr/bin/make -f
+
+%:
+
+	dh $@
+
+override_dh_auto_install:
+
+	make install DESTDIR=debian/tmp
+
+override_dh_usrlocal:
+
+	@true

packaging/debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

packaging/imapdomo.spec

@@ -0,0 +1,40 @@
+Name:		__MKIT_PROJ_PKGNAME__
+Version:	__MKIT_PROJ_VERSION__
+Release:	1%{?dist}
+Summary:	__MKIT_PROJ_PKGNAME__ - __MKIT_PROJ_TAGLINE__
+
+License:	LGPLv2
+Source0:	%{name}-%{version}.tar.gz
+
+BuildArch:	noarch
+BuildRequires:	coreutils git
+Requires:	imapfilter
+Requires:	shellfu-bash
+Requires:	shellfu-bash-core
+Requires:	shellfu-bash-extras
+
+%description
+imapdomo is simple convenience wrapper around imapfilter that
+adds few more Lua functions and suggests some system to way how you can
+organize your mail filtering and/or migrations, etc.
+
+%prep
+%setup -q
+
+
+%build
+# %%configure
+make %{?_smp_mflags}
+
+%install
+%make_install
+
+%files
+%dir /usr/share/imapdomo
+/usr/bin/imapdomo
+/usr/share/imapdomo/common.lua
+/usr/share/imapdomo/main.lua
+
+%changelog
+
+# specfile built with MKit __MKIT_SELF_VERSION__

src/common.lua

@@ -0,0 +1,190 @@
+os = require "os"
+socket = require "socket"
+
+
+------------------------------------------------------------------------------
+-- config and handling                                                      --
+------------------------------------------------------------------------------
+
+function shortname()
+    --
+    -- Short hostname
+    --
+    local long = socket.dns.gethostname()
+    return string.gmatch(long, '[^.]+')()
+end
+
+function file_exists(name)
+    --
+    -- True if file *name* exists
+    --
+    local f = io.open(name,"r")
+    if f ~= nil then
+        io.close(f)
+        return true
+    else
+        return false
+    end
+end
+
+function init_host(session)
+    --
+    -- Do host-specific init, if exists
+    --
+    local init = session.dirs.host .. "/init.lua"
+    if file_exists(init) then
+        dofile(init)
+        return
+    end
+end
+
+function handle(session)
+    --
+    -- Look for action handler in session dirs; do first one that exists
+    --
+    local valid = {
+        newmail = true,
+        rewind = true,
+        cleanup = true,
+        migrate = true
+    }
+    if not valid[session.action] then
+        error("invalid action: " .. session.action)
+        return nil
+    end
+    init_host(session)
+    for k,v in ipairs({session.dirs.host, session.dirs.default}) do
+        attempt = v .. "/handlers/" .. session.action .. ".lua"
+        if file_exists(attempt) then
+            dofile(attempt)
+            return
+        end
+    end
+end
+
+
+------------------------------------------------------------------------------
+-- mail getters                                                             --
+------------------------------------------------------------------------------
+
+function get_queue(acct, mbox)
+    --
+    -- Get queue from *mbox* from *acct* or nil (no messages)
+    --
+    -- If mbox is not specified, "FILTER_QUEUE" is used
+    --
+    mbox = mbox or "FILTER_QUEUE"
+    local exist, unread, unseen, uidnext = acct[mbox]:check_status()
+    if exist > 0 then
+        return acct[mbox]:select_all()
+    end
+    return nil
+end
+
+function _notifirc1(subj, from, body)
+    --
+    -- notify about message using (pre-configured) notifirc
+    --
+    local fd = assert(io.popen('notifirc -c mail -f - "message preview:"', "w"))
+    local fmt = "> %s\n> %s\n> BODY: %s"
+    fd:write(fmt:format(subj, from, body))
+    fd:close()
+end
+
+function notifirc_all(seq)
+    --
+    -- Send notifications about all messages in *seq*
+    --
+    for _, mesg in ipairs(seq) do
+        mbox, uid = table.unpack(mesg)
+        subj = mbox[uid]:fetch_field('Subject')
+        from = mbox[uid]:fetch_field('From')
+        body = mbox[uid]:fetch_body()
+        _notifirc1(subj, from, body)
+    end
+end
+
+function _partinf_compare(a, b)
+    if not type(a) == type(b) then
+        return false
+    end
+    if type(a) == 'number' then
+        return a == b
+    elseif type(a) == 'string' then
+        return a:lower() == b:lower()
+    end
+end
+
+function has_part_like(query, structure)
+    --
+    -- True if structure has MIME part matching *query*
+    --
+    if structure == nil then
+        return false
+    end
+    for partid, partinf in pairs(structure) do
+        local part_answer = true
+        -- check all query parts
+        for qkey, qvalue in pairs(query) do
+            value = partinf[qkey]
+            if not _partinf_compare(value, qvalue) then
+                part_answer = false
+                break
+            end
+        end
+        if part_answer then
+            return true
+        end
+    end
+    return false
+end
+
+function save_header(mesg, name)
+    --
+    -- Append header from *mesg* to file named *name*
+    --
+    -- File will be placed under directory specified by IMAPDOMO_HEADERS
+    -- environment variable.
+    --
+    local dest = os.getenv("IMAPDOMO_HEADERS") .. '/' .. name
+    local cmd = ('cat >>"%q"'):format(dest)
+    mbox, uid = table.unpack(mesg)
+    header = mbox[uid]:fetch_header()
+    if pipe_to(cmd, header) == 0 then
+        return true
+    else
+        return false
+    end
+end
+
+function filter_header_saved(seq, name)
+    --
+    -- Save headers from sequence
+    --
+    -- Append header of each message in sequence *seq* to file names
+    -- *name* and return new sequence with those messages where save was
+    -- successful.
+    --
+    result = Set {}
+    for _, mesg in ipairs(seq) do
+        if save_header(mesg, name) then
+            table.insert(result, mesg)
+        end
+    end
+    return result
+end
+
+function filter_part_like(query, seq)
+    --
+    -- Run MIME part query on *seq* sequence of messages
+    --
+    result = Set {}
+    for _, mesg in ipairs(seq) do
+        mbox, uid = table.unpack(mesg)
+        structure = mbox[uid]:fetch_structure()
+        if has_part_like(query, structure) then
+            table.insert(result, mesg)
+        end
+    end
+    return result
+end

src/imapdomo.skel

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+. "$(shellfu-get path)" || exit 3
+
+shellfu import pretty
+
+IMAPDOMO_CFGDIR="__IMAPDOMO_CONFIG_USER__"
+IMAPDOMO_USER_CACHE="__IMAPDOMO_USER_CACHE__"
+
+
+usage() {
+    mkusage "[options] ACTION" \
+        -o                                                                    \
+            "-c DIR      change to DIR before doing anything"                 \
+            "-d          turn on debugging mode"                              \
+       --                                                                     \
+       "imapdomo will try to read .imapdomo/host/HOSTNAME/init.lua and"       \
+       ".imapdomo/host/HOSTNAME/handlers/ACTION.lua, where HOSTNAME is your"  \
+       "short hostname (eg. 'foo' in 'foo.example.com')."                     \
+       ""                                                                     \
+       "four valid actions are understood; since you must write handler for"  \
+       "each action you want to use, the meanings below are purely a guide:"  \
+       ""                                                                     \
+       "    newmail - check for and file new mail"                            \
+       "    rewind  - re-add messages from FILTER_FAIL back to FILTER_QUEUE"  \
+       "    cleanup - delete or archive old messages"                         \
+       "    migrate - move mail between mailboxes"                            \
+       ""                                                                     \
+       "See imapfilter_config(5)) for guide and API reference.  Few functions"\
+       "are also available in .imapdomo/common.lua"
+}
+
+mkcmd() {
+    #
+    # Compose imapfilter command
+    #
+    echo -n "IMAPDOMO_ACTION=$Action"
+    echo -n "  IMAPDOMO_HEADERS=$HeaderDir"
+    echo -n "  IMAPFILTER_HOME=$CfgDir"
+    echo -n "  imapfilter"
+    if $Debug
+    then
+        mkdir -p "$LogDir"
+        echo -n "  -d $LogDir/debug.log"
+        echo -n "  -v"
+    fi
+    echo -n "  -c $CfgDir/main.lua"
+}
+
+main() {
+    local Action    # what to do
+    local Debug     # true if debugging
+    local cmd       # imapfilter command
+    local CfgDir    # config directory
+    local LogDir    # directory to store logs
+    local HeaderDir # directory to store headers by save_header()
+    local CdTo      # change dir to this before running imapfilter
+    CfgDir="$IMAPDOMO_CFGDIR"
+    LogDir="$IMAPDOMO_USER_CACHE/logs"
+    HeaderDir="$IMAPDOMO_USER_CACHE/headers"
+    Debug=false
+    #shellcheck disable=SC2034
+    while true; do case $1 in
+        -c) CdTo="$2"; shift 2 || usage ;;
+        -d) Debug=true; PRETTY_DEBUG=true; shift ;;
+        -*) usage ;;
+        *)  break ;;
+    esac done
+    Action="$1"; shift
+    grep -qw "$Action" <<< "newmail|rewind|cleanup|migrate" || usage
+    cmd=$(mkcmd)
+    debug -v cmd
+    bash -n <<<"$cmd" || die
+    if test -n "$CdTo";
+    then
+        cd "$CdTo" || die
+    fi
+    mkdir -p "$HeaderDir" || die
+    eval "$cmd"
+}
+
+main "$@"

src/main.lua.skel

@@ -0,0 +1,11 @@
+#!/bin/lua
+
+dofile "__IMAPDOMO_SHARE__/common.lua"
+
+handle({
+    action = os.getenv("IMAPDOMO_ACTION"),
+    dirs = {
+        host = os.getenv("IMAPFILTER_HOME") .. "/host/" .. shortname(),
+        defhost = os.getenv("IMAPFILTER_HOME") .. "/default",
+    }
+})

utils/mkit/include/build.sh

@@ -0,0 +1,217 @@
+#!/bin/bash
+
+. "$MKIT_DIR/include/ini.sh"   || die "cannot import ini.sh"
+. "$MKIT_DIR/include/facts.sh" || die "cannot import facts.sh"
+
+
+_build1() {
+    #
+    # Process one skeleton
+    #
+    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"
+}
+
+_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
+    #
+    local dstpath="$1"
+    case $dstpath in
+        *.md) echo markdown    ;;
+        *)    echo MKIT_COMMON ;;
+    esac
+}
+
+_qfs() {
+    #
+    # Quote for our sed scipt's RHS
+    #
+    sed '
+        s:\\:\\\\:g
+        s:|:\\|:g
+    '
+}
+
+build() {
+    #
+    # Add meat to all skeletons
+    #
+    local srcpath
+    find -type f -name '*.skel' \
+     | while read srcpath;
+       do
+           _build1 "$srcpath"
+       done
+}
+
+build_manpages() {
+    local manfile mdfile
+    if command -v ronn >/dev/null;
+    then
+        ini lskeys "files:man" \
+          | while read manfile;
+            do
+                mdfile="$manfile.md"
+                ronn -r "$mdfile"
+                mkdir -p "$MKIT_LOCAL"
+                echo "$manfile" >> "$MKIT_LOCAL/built.lst"
+            done
+    else
+        echo "ronn is not installed"
+        return 1
+    fi
+}
+
+clean() {
+    #
+    # Clean up tree after building
+    #
+    test -f "$MKIT_LOCAL/built.lst" && {
+        <"$MKIT_LOCAL/built.lst" grep -v -e '\.\.' -e ^/ \
+          | xargs -r rm -rf
+        rm -f "$MKIT_LOCAL/built.lst"
+        rmdir --ignore-fail-on-non-empty "$MKIT_LOCAL"
+    }
+    true
+}
+
+debstuff() {
+    #
+    # Build Debian stuff (eamed tarball, debian dir)
+    #
+    local version="$(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"
+    echo "${MKIT_PROJ_PKGNAME}_$version.orig.tar.gz" >> "$MKIT_LOCAL/built.lst"
+
+    # read content of each mandatory file from debian_skel
+    #
+    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
+    find "$debian_skel" -type f \
+      | while read dfsrc;
+        do
+            dftgt="debian/${dfsrc#$debian_skel}"
+            mkdir -p "$(dirname "$dftgt")"
+            _build1 "$dfsrc" "$dftgt"
+        done
+    echo debian >> "$MKIT_LOCAL/built.lst"
+}
+
+dist() {
+    #
+    # Create distributable tarball
+    #
+    #FIXME: lacking Makefile skills, we do this step twice fot
+    #       rpmstuff, hence -f hack for gzip
+    #
+    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"
+}
+
+rpmstuff() {
+    #
+    # Build specfile
+    #
+    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

@@ -0,0 +1,122 @@
+#!/bin/bash
+
+_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
+        _maybe mkdir -vp "$(dirname "$dst")"
+        _maybe cp -Tvr "$src" "$dst"
+        find "$dst" -type f \
+          | while read chmod_item;
+            do
+                _maybe chmod "$mode" "$chmod_item"
+            done
+    else
+        _maybe 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
+    local dst=$3
+    test -n "$dst" || dst=${src##*/}
+    echo "$(_get_root "$grp")/$dst"
+}
+
+_get_root() {
+    #
+    # Find out target root for group $1
+    #
+    local grp="$1"
+    local root=$(ini 1value "roots:$grp")
+    local destdir=$(ini 1value ENV:DESTDIR)
+    destdir=${destdir%/}
+    case $destdir:$root in
+        *:)     die "missing in config.ini: roots:$grp" ;;
+        :*)     echo "$root" ;;
+        *:*)    echo "$destdir/$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 lskeys "files" \
+      | sort \
+      | uniq \
+      | while read group;
+        do
+            mode=$(ini 1value "modes:$group")
+            ini values "files:$group" \
+              | while read src dst;
+                do
+                    dst=$(_get_dst "$group" "$src" "$dst")
+                    _deploy_item "$src" "$dst" "$mode"
+                done
+        done
+    test -f "$MKIT_LOCAL/autoclean" && clean
+    true
+}
+
+uninstall() {
+    #
+    # Uninstall product
+    #
+    local dst group src
+    ini lskeys "files" \
+      | sort \
+      | uniq \
+      | while read group;
+        do
+            ini values "files:$group" \
+              | while read src dst;
+                do
+                    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

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+_ini_cat() {
+    #
+    # A no-op for text stream
+    #
+    while read line;
+    do
+        printf -- "%s\n" "$line"
+    done
+}
+
+_ini_expand() {
+    #
+    # Expand reference value (prefix only)
+    #
+    local line suffix ref value
+    while read line;                        # [foo:bar]/path
+    do
+        suffix="${line#\[*\]}"              # /path
+        ref="${line%$suffix}"               # [foo:bar]
+        ref="${ref%\]}"                     # [foo:bar
+        ref="${ref#\[}"                     # foo:bar
+        value="$(ini 1value "$ref")"        # foo_bar_value
+        printf -- "%s\n" "$value$suffix"    # foo_bar_value/path
+    done
+}
+
+_ini_grepkey() {
+    #
+    # Read key from a section
+    #
+    local wnt=$1
+    grep '.' \
+      | grep -v '\s*#' \
+      | sed -e 's/ *= */=/; s/ +$//; s/^//;' \
+      | grep -e "^$wnt=" \
+      | cut -d= -f2- \
+      | _ini_maybe_expand
+}
+
+_ini_greppath() {
+    #
+    # Read key from the right section
+    #
+    # E.g. `files:share:my/lib.sh` should read
+    #
+    #     [files:share]
+    #         my/lib.sh   = proj/my/lib.sh
+    #
+    local wnt="$1"
+    local wntkey="${wnt##*:}"
+    local wntsec="${wnt%:$wntkey}"
+    if test "$wntsec" = 'ENV';
+    then
+        local override="${!wntkey}"
+        if test -n "$override";
+        then
+            echo "$override"
+            return
+        fi
+    fi
+    _ini_grepsec "$wntsec" | _ini_grepkey "$wntkey"
+}
+
+_ini_grepsec() {
+    #
+    # Read one INI section
+    #
+    local wnt="$1"
+    local ok=false
+    grep '.' \
+      | grep -v '\s*#' \
+      | while read line;
+        do
+            case "$line" in
+                \[$wnt\]) ok=true;  continue ;;
+                \[*\])    ok=false; continue ;;
+            esac
+            $ok || continue
+            printf -- "%s\n" "$line"
+        done \
+      | sed -e 's/ *= */=/; s/ +$//; s/^//;'
+}
+
+_ini_lskeys() {
+    #
+    # List keys from a section
+    #
+    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;
+    then
+        MKIT_INI_EXPAND=$(( --MKIT_INI_EXPAND )) _ini_expand
+    else
+        _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

@@ -0,0 +1,143 @@
+#!/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"
+
+_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
+    #
+    $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
+    #
+    echo "fatal: $*" >&2
+    exit 4
+}
+
+_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() {
+    #
+    # Check if ini version is supported
+    #
+    # 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"
+}
+
+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";
+    then
+        "$1"
+    else
+        {
+            echo "usage: $(basename "$0") TARGET"
+            echo
+            echo "valid targets:"
+            _valid_targets | sed 's/^/    /'
+        } >&2
+    fi
+}
+
+warn() {
+    #
+    # Print warning message
+    #
+    echo "$@" >&2
+}

utils/mkit/include/release.sh

@@ -0,0 +1,163 @@
+#!/bin/bash
+
+. "$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+MKIT_BUMPSIZE)).0.0"            ;;
+        y) new="$oldx.$((oldy+MKIT_BUMPSIZE)).0"        ;;
+        z) new="$oldx.$oldy.$((oldz+MKIT_BUMPSIZE))"    ;;
+        *) die "invalid release level: $1"  ;;
+    esac
+    echo "$new"
+}
+
+_relck() {
+    #
+    # Die if blocking condition $1 is detected
+    #
+    local condition="$1"
+    local x
+    case "$condition" in
+        git_present)
+            git rev-parse HEAD >&/dev/null\
+             || die "cannot do this outside git repo"
+            ;;
+        at_relsrc)
+            local relsrc=$(ini 1value project:relsrc)
+            git_fact current_branch \
+              | grep -qFx "$relsrc" \
+             || die "you are not on release source branch: $relsrc"
+            ;;
+        not_dirty)
+            git diff --shortstat 2>/dev/null \
+              | grep -q . \
+             && die "tree is dirty: $dirt"
+            ;;
+        tags_ok)
+            git_fact latest_tag \
+              | grep -q . \
+             || die "cannot find latest tag"
+            ;;
+        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"
+            ;;
+        no_wip)
+            git_fact reldiff \
+              | grep '^....... WIP ' \
+             && die "WIP commit since $(git_fact latest_tag)"
+            ;;
+        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
+}
+
+_release() {
+    #
+    # Prepare release
+    #
+    # Span release routines: make a signed tag, check branch
+    # and update release branch
+    #
+    # FIXME: Using project:prerl as build.sh:semver() does may not be
+    #        compatible with this release strategy
+    #
+    local rlevel=$1
+    local newtag
+    local reldst
+
+    _relck git_present
+    _relck at_relsrc
+    _relck not_dirty
+    _relck tags_ok
+    _relck vbump_hot
+    _relck no_wip
+    _relck ini_version
+
+    newtag=$(git_fact latest_version | _bump_version "$rlevel" | git_ver2tag )
+    set -e
+    debug_var newtag
+    $MKIT_DRY && return
+    git tag -m "$(ini 1value project:name) $newtag - $(ini 1value project:codename)" "$newtag"
+
+    reldst=$(ini 1value project:reldst)
+    debug_var reldst
+    if test -n "$reldst";
+    then
+        git branch -f "$reldst" "$newtag"
+    fi
+}
+
+_vbump() {
+    local rlevel="$1"
+    local nextver   # after the bump
+    _relck git_present
+    _relck at_relsrc
+    _relck not_dirty
+    nextver=$(ini 1value project:version | _bump_version "$rlevel")
+    debug_var 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 "$(_vbump_gitmsg)"
+}
+
+_vbump_gitmsg() {
+    echo "Bump version"
+    echo ""
+    echo "Overview of changes:"
+    echo ""
+    git_fact reldiff \
+      | sed '
+            s/^[a-f0-9]\{7\} / *  &/; t PATHS
+            s/^/        /
+            :PATHS
+        '
+}
+
+release_x() {
+    _release x
+}
+
+release_y() {
+    _release y
+}
+
+release_z() {
+    _release z
+}
+
+vbump_x() {
+    _vbump x
+}
+
+vbump_y() {
+    _vbump y
+}
+
+vbump_z() {
+    _vbump z
+}

utils/mkit/make

@@ -0,0 +1,82 @@
+#!/bin/bash
+# mkit - simple install helper
+# See LICENSE file for copyright and license details.
+
+die() {
+    echo "$@" && exit 9
+}
+
+
+#
+# Bump size (for vbump_? and release_?)
+#
+MKIT_BUMPSIZE=${MKIT_BUMPSIZE:-1}
+
+#
+# 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.17
+
+
+. "$MKIT_DIR/include/mkit.sh" || die "failed to init; check if MKIT_DIR is set properly: $MKIT_DIR"
+
+case "$1" in
+    --version-semver) echo "$MKIT_VERSION"; exit 0 ;;
+    --version)        echo "Mkit (Simple Makefile target helper) $MKIT_VERSION"
+                      exit 0 ;;
+esac
+
+mkit_init
+
+route "$@"

utils/mkit/mkit.mk

@@ -0,0 +1,50 @@
+# mkit - Simple Makefile target helper
+# See LICENSE file for copyright and license details.
+
+export MKIT_DIR
+
+all: build
+
+build:
+	@$(MKIT_DIR)/make build
+
+manpages: build
+	@$(MKIT_DIR)/make build_manpages
+
+clean:
+	@$(MKIT_DIR)/make clean
+
+debstuff: dist
+	@$(MKIT_DIR)/make debstuff
+
+dist: clean
+	@$(MKIT_DIR)/make dist
+
+rpmstuff: dist
+	@$(MKIT_DIR)/make rpmstuff
+
+install: all
+	@$(MKIT_DIR)/make install
+
+release_x:
+	@$(MKIT_DIR)/make release_x
+
+release_y:
+	@$(MKIT_DIR)/make release_y
+
+release_z:
+	@$(MKIT_DIR)/make release_z
+
+uninstall:
+	@$(MKIT_DIR)/make uninstall
+
+vbump_x:
+	@$(MKIT_DIR)/make vbump_x
+
+vbump_y:
+	@$(MKIT_DIR)/make vbump_y
+
+vbump_z:
+	@$(MKIT_DIR)/make vbump_z
+
+.PHONY: all clean dist rpmstuff install uninstall release_x release_y release_z vbump_x vbump_y vbump_z