Initial commit

.gitignore

@@ -0,0 +1,3 @@
+.mkit/autoclean
+saturnin-demo-*.tar.gz
+artifacts

LICENSE

@@ -0,0 +1,344 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software
+    interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the 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 Program
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Program does not specify a
+version number of this License, you may choose any version ever
+published by the Free Software Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
+

Makefile

@@ -0,0 +1,5 @@
+# saturnin - Spirit of your toolbox
+# See LICENSE file for copyright and license details.
+
+MKIT_DIR=utils/mkit
+include $(MKIT_DIR)/mkit.mk

README.md

@@ -0,0 +1,4 @@
+SATURNIN
+========
+
+Spirit of your toolbox

mkit.ini

@@ -0,0 +1,50 @@
+#mkit version=0.0.14
+
+[project]
+    version     = 0.0.1
+    name        = SATURNIN-DEMO
+    tagline     = saturnin example toolkit
+    pkgname     = saturnin-demo
+    relsrc      = devel
+
+[dist]
+    tarball = LICENSE
+    tarball = Makefile
+    tarball = README.md
+    tarball = mkit.ini
+    tarball = packaging
+    tarball = src
+    tarball = utils
+    rpmstuff = packaging/template.spec
+    debstuff = packaging/debian
+
+[ENV]
+    PREFIX = /usr/local
+
+[roots]
+    bin     = [ENV:PREFIX]/bin
+    libexec = [ENV:PREFIX]/libexec/saturnin-demo
+    share   = [ENV:PREFIX]/share/saturnin-demo
+    doc     = [ENV:PREFIX]/share/doc/saturnin-demo
+    etc     = /etc/saturnin-demo
+    etc_bc  = /etc/bash_completion.d
+
+[tokens]
+    __SATURNIN_DEMO_CACHE_HOME__     = $HOME/.cache/saturnin-demo
+    __SATURNIN_DEMO_CONFIG_USER__    = $HOME/.saturnin-demo
+    __SATURNIN_DEMO_CONFIG_LOCAL__   = [roots:etc]
+    __SATURNIN_DEMO_LIBEXEC__        = [roots:libexec]
+    __SATURNIN_DEMO_SHARE__          = [roots:share]
+
+[modes]
+    bin     = 755
+    libexec = 755
+    share   = 644
+
+[files]
+    bin = src/bin/app saturnin-demo
+    doc = README.md
+    etc_bc = src/complete.bash          saturnin-demo.bash
+    libexec = src/libexec/saturnin-demo-dump
+    libexec = src/libexec/saturnin-demo-echo
+    share = src/ini.d/main/echo.ini     ini.d/main/echo.ini

packaging/debian/changelog

@@ -0,0 +1,5 @@
+saturnin-demo (__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,22 @@
+Source: saturnin-demo
+Maintainer: Alois Mahdal <netvor@vornet.cz>
+Vcs-Browser: http://git.vornet.cz/cgit/saturnin.git/
+Section: misc
+Priority: extra
+Standards-Version: 3.9.2
+Build-Depends: debhelper (>= 9)
+
+Package: saturnin-demo
+Architecture: all
+Depends: bash, shellfu-bash, shellfu-bash-core, shellfu-bash-saturnin
+Description: __MKIT_PROJ_TAGLINE__
+ saturnin is Shellfu library that helps you easily build toolkit from
+ various scripts that you may have lying around.  Instead of having a
+ herd of untamed undocumented and hard-to-share scripts, with help of
+ saturnin you can easily create and package a meta-command with a set
+ of discoverable and maintainable sub-commands.
+ .
+ This package contains a demo meta-command built with saturnin; you can
+ also re-use the source as template for your new toolkit.
+
+# control file built with MKit __MKIT_SELF_VERSION__

packaging/debian/copyright

@@ -0,0 +1 @@
+

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/saturnin-demo.install

@@ -0,0 +1,6 @@
+/etc/bash_completion.d/saturnin-demo.bash
+/usr/local/bin/saturnin-demo
+/usr/local/libexec/saturnin-demo/saturnin-demo-dump
+/usr/local/libexec/saturnin-demo/saturnin-demo-echo
+/usr/local/share/doc/saturnin-demo/README.md
+/usr/local/share/saturnin-demo/ini.d/main/echo.ini

packaging/debian/source/format

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

packaging/template.spec

@@ -0,0 +1,51 @@
+Name:		__MKIT_PROJ_PKGNAME__
+Version:	__MKIT_PROJ_VERSION__
+Release:	1%{?dist}
+Summary:	__MKIT_PROJ_NAME__ - __MKIT_PROJ_TAGLINE__
+
+License:	LGPLv2
+Source0:	%{name}-%{version}.tar.gz
+
+BuildArch:	noarch
+BuildRequires:	coreutils git
+Requires:	shellfu-bash
+Requires:	shellfu-bash-core
+Requires:	shellfu-bash-saturnin
+
+%description
+saturnin is Shellfu library that helps you easily build toolkit from
+various scripts that you may have lying around.  Instead of having a
+herd of untamed undocumented and hard-to-share scripts, with help of
+saturnin you can easily create and package a meta-command with a set
+of discoverable and maintainable sub-commands.
+
+This package contains a demo meta-command built with saturnin; you can
+also re-use the source as template for your new toolkit.
+
+%prep
+%setup -q
+
+
+%build
+# %%configure
+make %{?_smp_mflags}
+
+%install
+%make_install
+
+%files
+%config %{_sysconfdir}/bash_completion.d/saturnin-demo.bash
+%dir /usr/local/libexec/saturnin-demo
+%dir /usr/local/share/saturnin-demo
+%dir /usr/local/share/saturnin-demo/ini.d
+%dir /usr/local/share/saturnin-demo/ini.d/main
+%doc /usr/local/share/doc/saturnin-demo/README.md
+/usr/local/bin/saturnin-demo
+/usr/local/libexec/saturnin-demo/saturnin-demo-dump
+/usr/local/libexec/saturnin-demo/saturnin-demo-echo
+/usr/local/share/saturnin-demo/ini.d/main/echo.ini
+
+
+%changelog
+
+# specfile built with MKit __MKIT_SELF_VERSION__

src/bin/app.skel

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+. "$(shellfu-get path)" || exit 3
+
+#
+# =====BEGIN BUILT PART=====
+#
+
+#shellcheck disable=SC2034
+{
+    SATURNIN_APP_CODENAME="__MKIT_PROJ_CODENAME__"
+    SATURNIN_APP_TAGLINE="__MKIT_PROJ_TAGLINE__"
+    SATURNIN_APP_VERSION="__MKIT_PROJ_VERSION__"
+    SATURNIN_APP_GIT_HASH="__MKIT_PROJ_GIT_LASTHASH__"
+    SATURNIN_CACHE_HOME="__SATURNIN_DEMO_CACHE_HOME__"
+    SATURNIN_LIBEXEC="__SATURNIN_DEMO_LIBEXEC__"
+    SATURNIN_LIBEXEC_PREFIX="__MKIT_PROJ_PKGNAME__-"
+    PRETTY_USAGE="subcommand"
+}
+
+shellfu import saturnin
+
+SATURNIN_CONF_PATH="$(
+    saturnin__conf_mkpath \
+        __SATURNIN_DEMO_CONFIG_USER__/ini.d \
+        __SATURNIN_DEMO_CONFIG_USER__ \
+        __SATURNIN_DEMO_CONFIG_LOCAL__ \
+        __SATURNIN_DEMO_SHARE__/ini.d
+)"
+
+#
+# =====END BUILT PART=====
+#
+
+export SATURNIN_CONF_PATH SHELLFU_PATH PRETTY_USAGE \
+       SATURNIN_CACHE_HOME
+
+saturnin__main "$@"

src/complete.bash

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+__SATURNIN_COMPLETE_CMDNAME=saturnin-demo
+
+#shellcheck disable=SC2016
+__SATURNIN_COMPLETE_CODETMPL='
+__%s() {
+    local cur opts sopts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    sopts="-d -h -v"
+    opts="--help --verbose --debug --version --version-semver"
+    case "$cur" in
+        -*)
+            COMPREPLY=(
+                $(compgen -W "$sopts $opts" -- "${cur}")
+            )
+            ;;
+        --*)
+            COMPREPLY=(
+                $(compgen -W "$opts" -- "${cur}")
+            )
+            ;;
+        *)
+            COMPREPLY=(
+                $(compgen -W "$(%s _ls_sc)" "${cur}")
+            )
+    esac
+}'
+
+eval "$(
+    #shellcheck disable=SC2059
+    printf "$__SATURNIN_COMPLETE_CODETMPL" \
+        $__SATURNIN_COMPLETE_CMDNAME \
+        $__SATURNIN_COMPLETE_CMDNAME
+)"
+
+complete -F "__$__SATURNIN_COMPLETE_CMDNAME" "$__SATURNIN_COMPLETE_CMDNAME"

src/ini.d/main/echo.ini

@@ -0,0 +1,7 @@
+
+[echo]
+
+    #
+    # default prefix
+    #
+    prefix = so:

src/libexec/saturnin-demo-dump

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+. "$(shellfu-get path)" || exit 3
+
+env | sort | xargs -L 1 saturnin-demo echo

src/libexec/saturnin-demo-echo

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+. "$(shellfu-get path)" || exit 3
+
+shellfu import saturnin
+
+SATCMD_ECHO__PREFIX="${SATCMD_ECHO__PREFIX:-$(saturnin__conf "echo.prefix")}"
+
+echo -n "$SATCMD_ECHO__PREFIX"
+echo "$@"

src/shellfu/saturnin.sh

@@ -0,0 +1,410 @@
+#!/bin/bash
+
+shellfu import exit
+shellfu import inigrep
+shellfu import pretty
+
+#
+# Path where saturnin__conf should look for files
+#
+# If filename does not contain slash, it is looked up in each
+# (or all, based on strategy--see saturnin__conf() doc) path in this
+# list.  The list is colon-separated and non-dirs as well as
+# empty strings are silently ignored.
+#
+SATURNIN_CONF_PATH="${SATURNIN_CONF_PATH:-}"
+
+#
+# Expected config filename extension (for guessing from path head)
+#
+# If no filename to read is given, saturnin__conf() will guess
+# filename as the path head plus this suffix (e.g. `foo.ini` for
+# `saturnin__conf foo.bar.baz`)
+#
+SATURNIN_CONF_SUFFIX="${SATURNIN_CONF_SUFFIX:-.ini}"
+
+saturnin__conf() {
+    #
+    # inigrep smart loader
+    #
+    # Usage:
+    #   saturnin__conf [-j] [inigrep-query] [-- [file]..]
+    #
+    #
+    # File arguments
+    # ==============
+    #
+    # If omitted, *file* argument is inferred by taking part of
+    # kpath name before first dot and appending value of
+    # `$SATURNIN_CONF_SUFFIX`, (".ini" by default).
+    #
+    # Each *file* argument is then processed as follows:
+    #
+    #  *  `-` (single dash) is interpreted as reading from
+    #     STDIN.
+    #
+    #  *  If argument contains slash, it is expanded as a regular
+    #     path (relative or absolute).
+    #
+    #  *  Otherwise, it is taken as filename and searched for
+    #     in directories given in `$SATURNIN_CONF_PATH`.  (This can
+    #     yield more than one path, which is equivalent as if
+    #     all paths were provided.)
+    #
+    #     Not all files expanded based on `$SATURNIN_CONF_PATH`
+    #     are read by default; reading is governed by "merge
+    #     strategy": the default strategy "first" reads only
+    #     the first existing file.
+    #
+    #     "join" strategy on the other hand, means that any
+    #     files are simply concatenated and prefixed with
+    #     comment (visible only in raw mode) containing path
+    #     to the file.
+    #
+    #     This means that if a section is queried that is
+    #     present in both files, it is effectively concatenated
+    #     as well.
+    #
+    # Following calls are equivalent
+    #
+    #     saturnin__conf foo.bar.baz
+    #     saturnin__conf foo.bar.baz foo.ini
+    #
+    # and both result in reading of key *baz* from section *foo.bar*
+    # in file *foo.ini*, which is selected from *SATURNIN_CONF_PATH*.
+    # Should there be more foo.ini's, the first is selected.
+    # Using `-j` switch
+    #
+    #     saturnin__conf -j foo.bar.baz
+    #
+    # would cause all foo.ini's on *SATURNIN_CONF_PATH* be
+    # concatenated instead.
+    #
+    local ig_mode               # retrieval mode
+    local ig_query              # keypath or section name (when listing keys)
+    local ig_limit              # line limit
+    local files=()              # file specification
+    local Strategy=first        # merge strategy
+    while true; do case $1:$2 in
+        "":*)   break ;;
+        -j:*)   Strategy=join;           shift 1        ;;
+        -1:*)   ig_limit=$1;             shift 1        ;;
+        -e:*.*) ig_mode=$1; ig_query=$2; shift 2; break ;;
+        -r:*.*) ig_mode=$1; ig_query=$2; shift 2; break ;;
+        -K:*)   ig_mode=$1; ig_query=$2; shift 2; break ;;
+        -S:*)   ig_mode=$1; ig_query=""; shift 1; break ;;
+        -P:*)   ig_mode=$1; ig_query=""; shift 1; break ;;
+        .*:*)   warn "bad syntax: $*"; _saturnin__conf_usage ;;
+        *.*:*)  ig_mode=-e; ig_query=$1; shift 1; break ;;
+        --help:*) _saturnin__conf_usage -e 0                 ;;
+        *)      warn "bad syntax: $*"; _saturnin__conf_usage ;;
+    esac done
+    test -n "$ig_mode" || { warn "could not determine inigrep mode"; _saturnin__conf_usage; }
+    debug -v ig_limit ig_query ig_mode Strategy
+    if test -n "$*";
+    then
+        files=("$@")
+    elif test -n "$ig_query";
+    then
+        files=("${ig_query%%.*}$SATURNIN_CONF_SUFFIX")
+    else
+        warn "dunno what to load"
+        _saturnin__conf_usage
+    fi
+    debug -v files
+    #shellcheck disable=SC2086
+    _saturnin__conf__load "${files[@]}" | inigrep $ig_limit $ig_mode "$ig_query"
+    return "${PIPESTATUS[0]}"
+}
+
+saturnin__get() {
+    #
+    # Show Saturnin Internal info by key $1 and exit
+    #
+    # Key $1 can be whole `--saturnin-get-stuff` argument or just
+    # the part after `--saturnin-get-`.
+    #
+    # This is aimed to help debugging and testing the app (or
+    # Saturnin itself) by showing packaging and deployment related
+    # info.
+    #
+    local key=${1#--saturnin-get-}
+    case "$key" in
+        shellfu-path)   echo "$SHELLFU_PATH"                ;;
+        saturnin-conf-path) echo "$SATURNIN_CONF_PATH"      ;;
+        app-git-hash)   echo "$SATURNIN_APP_GIT_HASH"       ;;
+        app-version)    echo "$SATURNIN_APP_VERSION"        ;;
+        cache-home)     echo "$SATURNIN_CACHE_HOME"         ;;
+        libexec)        echo "$SATURNIN_LIBEXEC"            ;;
+        libexec-prefix) echo "$SATURNIN_LIBEXEC_PREFIX"     ;;
+        *)              warn "unknown devel key: $key"
+                        exit "$EXIT_USAGE" ;;
+    esac
+    exit "$EXIT_OK"
+}
+
+saturnin__lssc() {
+    #
+    # List subcommands
+    #
+    echo conf
+    find "$SATURNIN_LIBEXEC" \
+        -mindepth 1 \
+        -maxdepth 1 \
+        -executable \
+      | sed -e "s|^.*/||; s|^$SATURNIN_LIBEXEC_PREFIX||" \
+      | sort
+}
+
+saturnin__main() {
+    local subcommand
+    while true; do case $1 in
+        -d|--debug)     export PRETTY_DEBUG=true;   shift ;;
+        -v|--verbose)   export PRETTY_VERBOSE=true; shift ;;
+        -h|--help)      saturnin__usage -e 0;       exit  ;;
+        --version)      saturnin__version;          exit  ;;
+        --version-semver) saturnin__get app-version ;;
+        --saturnin-get-*) saturnin__get "$1"        ;;
+        -*)             saturnin__usage;            ;;
+        --*)            saturnin__usage;            ;;
+        --)             shift; break                ;;
+        "")             saturnin__usage;            ;;
+        *)              break;                      ;;
+    esac done
+    subcommand="$1"; shift
+    debug -v SHELLFU_PATH SATURNIN_LIBEXEC SATURNIN_CONF_PATH
+    case "$subcommand" in
+        conf)    saturnin__conf "$@"                ;;
+        _ls_sc)  saturnin__lssc                     ;;
+        _lsfun)  shellfu-get lsfun                  ;;
+        _lsmod)  shellfu-get lsmod                  ;;
+        *)       saturnin__runsc "$subcommand" "$@" ;;
+    esac
+}
+
+saturnin__conf_mkpath() {
+    #
+    # Assemble SATURNIN_CONF_PATH from locations $@
+    #
+    # For each location, print colon-delimited list of
+    # directories.  If location ends with "/ini.d", list of
+    # subfolders, sorted by C locale is printed--this allows
+    # for modular configuration.  Otherwise the location
+    # is printed.  Non-existent or non-directory locations
+    # are silently ignored.
+    #
+    local location      # one location argument
+    local path          # one path listed
+    for location in "$@";
+    do
+        test -d "$location" || continue
+        case "$location" in
+            */ini.d)    # modular location--sort subfolders
+                find -L "$location" -mindepth 1 -maxdepth 1 -type d \
+                  | LC_ALL=C sort
+                ;;
+            *)
+                echo "$location"
+                ;;
+        esac
+    done \
+      | _saturnin__nl2colon
+}
+
+saturnin__runhook() {
+    #
+    # Run custom hook
+    #
+    local hname="$1"
+    local hook_code
+    test -n "$SATURNIN_SUBCOMMAND" || {
+        warn "unknown subcommand, ignoring hook: $hname"
+        return 0
+    }
+    hook_code="$(saturnin__conf -j "hook.$SATURNIN_SUBCOMMAND.$hname")"
+    debug -v SATURNIN_SUBCOMMAND hook_code hname
+    bash -n <<<"$hook_code" || {
+        warn "syntax errors, ignoring hook: $hname"
+        return 0
+    }
+    eval "$hook_code"
+}
+
+saturnin__runsc() {
+    #
+    # Run subcommand $SATURNIN_SUBCOMMAND
+    #
+    local subcommand="$1"; shift
+    local binpath   # path to subcommand's binary
+    binpath+="$SATURNIN_LIBEXEC/"
+    binpath+="$SATURNIN_LIBEXEC_PREFIX$subcommand"
+    debug -v binpath
+    debug "\$*='$*'"
+    test -x "$binpath" || {
+        warn "invalid sub-command: $subcommand"
+        saturnin__usage
+    }
+    SATURNIN_SUBCOMMAND="$subcommand" "$binpath" "$@"
+}
+
+saturnin__usage() {
+    #
+    # Show usage message and exit
+    #
+    #shellcheck disable=SC2046
+    mkusage "$@"                                            \
+            "[options] COMMAND [ARG...]"                    \
+        -o                                                  \
+            "-d, --debug    turn on debugging"              \
+            "-h, --help     show this help message and exit"\
+            "-v, --verbose  turn on verbosity"              \
+            "--version      show version and exit"          \
+        -c                                                  \
+            $(saturnin__lssc)
+}
+
+saturnin__version() {
+    #
+    # Print version info
+    #
+    local tagline=${SATURNIN_APP_TAGLINE:-Some app with default tagline}
+    local maybe_codename=""
+    test -n "$SATURNIN_APP_CODENAME" && maybe_codename=" - $SATURNIN_APP_CODENAME"
+    echo "$(basename "$0") ($tagline) $SATURNIN_APP_VERSION$maybe_codename"
+    return "$EXIT_OK"
+}
+
+saturnin__wraphook() {
+    #
+    # Wrap command "$@" in hooks
+    #
+    # Run pre hook, then "$@", then post hook.  Always exit
+    # with status of "$@", even if hooks fail.  Ignore
+    # post-hook if "$@" failed.
+    #
+    local es=0
+    saturnin__runhook pre
+    "$@" || return $?
+    es=$?
+    saturnin__runhook post
+    return $es
+}
+
+
+#          #                           that what you see below this line #
+# INTERNAL # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#          #                        use in your code to anger the divine #
+
+_saturnin__conf__merge() {
+    #
+    # Take paths and applying merge strategy, load file(s)
+    #
+    local path
+    local found=false
+    while read -r path;
+    do
+        test -f "$path" || continue
+        found=true
+        case $Strategy in
+            first)
+                debug "winner: $path"
+                cat "$path"
+                cat >/dev/null  # throw away rest of paths
+                ;;
+            join)
+                echo "# file: ${path/$HOME/~}"
+                cat "$path" 2>/dev/null
+                ;;
+        esac
+    done
+    $found
+}
+
+_saturnin__conf__load() {
+    #
+    # Print contents of files specified in $@
+    #
+    # Each argument means possible file candidate.  If candidate
+    # contains slash, it's treated as file path and is printed
+    # directly.  If it's single dash, standard input is copied.
+    #
+    # In all other cases, filename is searched in all elements
+    # of SATURNIN_CONF_PATH; output then depends on chosen $Strategy:
+    # with 'first' strategy, first existing file is printed, with
+    # 'join' strategy. all existing files are printed.
+    #
+    local arg trydir trypath es
+    es=0
+    for arg in "$@";
+    do
+        case $arg in
+            -|*/*)      # stdin, or path (with slash)
+                cat "$arg" || es=3
+            ;;
+        *)              # name given, find all its incarnations
+            debug -v SATURNIN_CONF_PATH
+            echos "$SATURNIN_CONF_PATH" \
+              | tr ':' '\n' \
+              | while read -r trydir;
+                do
+                    test -n "$trydir" || continue
+                    trypath="$trydir/$arg"
+                    echos "$trypath"
+                done \
+              |  _saturnin__conf__merge; es=$?
+            ;;
+        esac
+    done
+    return $es
+}
+
+_saturnin__conf_usage() {
+    #
+    # Show usage message and exit
+    #
+    PRETTY_USAGE="self=${0##*/} conf" \
+    mkusage "$@"                                                               \
+            "[options] [-e] SECTION.KEY [FNAME]"                               \
+            "[options] -r SECTION.KEY [FNAME]"                                 \
+            "[options] -K SECTION [FNAME]"                                     \
+            "[options] -P FNAME"                                               \
+            "[options] -S FNAME"                                               \
+        --                                                                     \
+            "Use inigrep to query config files."                               \
+        -o                                                                     \
+            "-j     join all files before applying query"                      \
+            "-1     ensure single line is returned"                            \
+        -c                                                                     \
+            "-e     use normal mode (default)"                                 \
+            "-r     use raw mode (preserves RHS whitespace and some comments)" \
+            "-K     list available keys in SECTION"                            \
+            "-S     list available sections in FNAME"                          \
+            "-P     list available keypaths (SECTION.KEY) in FNAME"            \
+        --                                                                     \
+            "FNAME is filename, which is then searched on all paths specified" \
+            "in SATURNIN_CONF_PATH and depending on -j parameter, first one"   \
+            "wins or all are joined.  If FNAME contains slash, this search is" \
+            "not done and FNAME is taken as path to file that is then queried."\
+            ""                                                                 \
+            "If FNAME is omitted, it is inferred from SECTION (e.g. .'foo.ini'"\
+            "if 'foo.bar' was section name; note that section name may contain"\
+            "dot)."
+}
+
+_saturnin__nl2colon() {
+    #
+    # Convert newline-based list of paths to colon:based:list
+    #
+    # Empty paths must not be included in the resulting list,
+    # so we need to drop them and also get the colons right.
+    #
+    local idx=0     # current item index (zero-based)
+    local path
+    while read -r path;
+    do
+        test -z "$path" && continue
+        test $idx -gt 0 && echo -n ':'
+        echo -n "$path"
+        ((idx++))
+    done
+}

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,180 @@
+#!/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 "$(_release_msg)" "$newtag"
+
+    reldst=$(ini 1value project:reldst)
+    debug_var reldst
+    if test -n "$reldst";
+    then
+        git branch -f "$reldst" "$newtag"
+    fi
+}
+
+_release_msg() {
+    #
+    # Generate message for annotated tag
+    #
+    # The last commit before issuing a release must be "Bump version" commit
+    # suggested by _vbump_gitmsg() and  manually edited by user.  Since the
+    # commit contains changelog, this function just uses the message body.
+    #
+    # The sort message (first line) is replaced with a nicer one (with project
+    # name, codename and version).
+    #
+    echo "$(ini 1value project:name) $newtag - $(ini 1value project:codename)"
+    echo
+    git show -s --format=%B \
+      | tail -n +3
+}
+
+_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.18
+
+
+. "$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