saturnin-demo/utils/mkit/include/build.sh

#!/bin/bash
# MKit - simple install helper
# See LICENSE file for copyright and license details.

mkit_import ini
mkit_import facts


_build1() {
    #
    # Process one skeleton $1 of type $3 (or guessed) to path $2
    #
    local srcpath=$1    # skeleton path
    local dstpath=$2    # destination meaty animal path
    local ftype=$3      # file/builder type
    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; fom stdin to stdout
    #
    local ftype=$1      # file/builder type
    case $ftype in
        MKIT_COMMON)    _expand_tokens "tokens" ;;
        markdown)       _expand_includes | _expand_tokens "tokens" ;;
        rpmstuff)       _expand_tokens "tokens" "rpmstuff:tokens" ;;
        debstuff)       _expand_tokens "tokens" "debstuff: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() {
    #
    # Read stdin, expanding tokens from sections $@
    #
    local script        # sed script cache
    local section       # each section to expand tokens from
    local varname       # each token name
    local varvalue      # each token value
    script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
    {
        for section in "$@"; do
            debug_var section
            ini lskeys "$section" \
              | while read -r varname; do
                    varvalue="$(ini 1value "$section:$varname" | _qfs )"
                    echo "s|$varname|$varvalue|g;"
                    debug_var varname varvalue
                done
        done
        echo "s|__MKIT_PROJ_NAME__|$(ini 1value project:name | _qfs)|g;"
        echo "s|__MKIT_PROJ_CODENAME__|$(ini 1value project:codename | _qfs)|g;"
        echo "s|__MKIT_PROJ_LICENSE__|$(ini 1value project:license | _qfs)|g;"
        echo "s|__MKIT_PROJ_PKGNAME__|$(ini 1value project:pkgname | _qfs)|g;"
        echo "s|__MKIT_PROJ_TAGLINE__|$(ini 1value project:tagline | _qfs)|g;"
        echo "s|__MKIT_PROJ_MAINTAINER__|$(ini 1value project:maintainer | _qfs)|g;"
        echo "s|__MKIT_PROJ_VCS_BROWSER__|$(ini 1value project:vcs_browser | _qfs)|g;"
        echo "s|__MKIT_PROJ_GIT_LASTHASH__|$(git_lasthash | _qfs)|g;"
        echo "s|__MKIT_PROJ_VERSION__|$(semver | _qfs)|g;"
        echo "s|__MKIT_SELF_VERSION__|$MKIT_VERSION|g;"
    } >> "$script"
    sed -f "$script" || die "_expand_tokens failed"
    rm "$script"
}

_guess_ftype() {
    #
    # Guess file type from destination path $1
    #
    local dstpath=$1    # destination path
    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   # each source path
    find -type f -name '*.skel' \
     | while read -r srcpath; do
           _build1 "$srcpath"
       done
}

build_manpages() {
    #
    # Build manpages using ronn
    #
    local manfile   # each manual file listed in '[files:man]'
    local mdfile    # each source markdown file
    if command -v ronn >/dev/null; then
        ini lskeys "files:man" \
          | while read -r 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       # package version
    local debian_skel   # 'debian' folder skeleton
    local dfsrc         # each source file from ^^
    local dftgt         # each built packaging file
    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
    #
    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
    find "$debian_skel" -type f \
      | while read -r dfsrc; do
            dftgt="debian/${dfsrc#$debian_skel}"
            mkdir -p "$(dirname "$dftgt")"
            _build1 "$dfsrc" "$dftgt" debstuff
        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           # tarball version
    local git_lasthash      # last git commit hash
    local dirname           # directory and tarball name
    version=$(semver)
    dirname=$MKIT_PROJ_PKGNAME-$version
    git_lasthash=$(git_lasthash)
    mkdir -p "$dirname"
    ini values "dist:tarball" | xargs -I DIST_ITEM cp -R DIST_ITEM "$dirname"
    update_version "$version" "$dirname/mkit.ini"
    mkdir -p "$dirname/.mkit"
    echo -n "$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      # .spec filename
    local specsrc                               # source of specfile
    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" rpmstuff
}