makedeb

#!/bin/bash

# makedeb - build Debain packages from PKGBUILD files
# Copyright (C) 2018 Michael R. Shannon <mrshannon.aerospace@gmail.com>
#
# 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.



# used for passing function outputs around
declare retval
declare missing_depends=()
declare installed_depends=()
declare source_files=()


declare pkgname=""
declare pkgver=""
declare pkgrel=""
declare depends=()
declare makedepends=()
declare checkdepends=()
declare source=()
declare sources=()
declare noextract=()
declare section=""
declare priority="optional"
declare essential="no"
declare maintainer=""
declare pkgdesc=""
declare pkglong=""
declare url=""
declare predepends=()
declare suggests=()
declare enhances=()
declare replaces=()
declare conflicts=()
declare provides=()
declare arch=""
declare copyright=""
declare changelog=""
declare backup=()
declare conffiles=()
declare install=""




# GLOBALS

# ansi codes
declare -r ANSI_RESET='\033[0m'
declare -r ANSI_BOLD='\033[1m'
declare -r ANSI_RED='\033[0;31m'
declare -r ANSI_GREEN='\033[0;32m'
declare -r ANSI_YELLOW='\033[0;33m'
declare -r ANSI_BLUE='\033[0;34m'

declare -r EXIT_ON_FAIL=1



# OPTIONS
INSTALL_DEPENDS=
REMOVE_DEPENDS=0



# FUNCTIONS

msg1() {
    echo -e "${ANSI_GREEN}${ANSI_BOLD}==>${ANSI_RESET}${ANSI_BOLD} ${1}${ANSI_RESET}"
}


msg2() {
    echo -e "  ${ANSI_BLUE}${ANSI_BOLD}->${ANSI_RESET}${ANSI_BOLD} ${1}${ANSI_RESET}"
}


msg3() {
    echo "      $1"
}


warning() {
    echo -e "${ANSI_YELLOW}${ANSI_BOLD}==> WARNING:${ANSI_RESET}${ANSI_BOLD} ${1}${ANSI_RESET}"
}


error() {
    echo -e "${ANSI_RED}${ANSI_BOLD}==> ERROR:${ANSI_RESET}${ANSI_BOLD} ${1}${ANSI_RESET}"
    if [[ "$EXIT_ON_FAIL" -ne 0 ]]; then
        exit 1
    fi
}


# https://stackoverflow.com/a/17841619
join() {
    local d=$1
    shift
    echo -n "$1"
    shift
    printf "%s" "${@/#/$d}"
}


stripstr() {
    sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'
}


date_string() {
    date -u '+%a %d %b %Y %r UTC'
    # date -u '+%F %T UTC'
}


ctrl_c() {
    echo -e "\nExiting..."
    exit 1
}


# https://stackoverflow.com/a/24067243
version_gt() {
    test "$(printf '%s\n' "$@" | sort -V | head -n 1)" != "$1"
}


version_compare() {
    local first=$1
    local op=$2
    local second=$3
    
    case "$op" in
        "<")
            version_gt "$second" "$first"
            ;;
        "<=")
            test "$first" == "$second" || version_gt "$second" "$first"
            ;;
        "==")
            test "$first" == "$second"
            ;;
        ">=")
            test "$first" == "$second" || version_gt "$first" "$second"
            ;;
        ">")
            version_gt "$first" "$second"
            ;;
        *)
            error "Invalid operator $op"
            exit 1
            ;;
    esac
    return $?
}


# reads the maintainer from the comment at the top of the PKGBUILD file, this
# is here for compatibility with Arch Linux makepkg, you should explicitly set
# the maintainer field in PKGBUILD for makedeb
read_maintainer() {
    maintainer=$(grep -Po -m 1 '(?<=Maintainer:).*$' "${startdir}/PKGBUILD")
    maintainer=$(echo "$maintainer" | stripstr)
}


print_start_message() {
    msg1 "Making package: ${pkgname} ${pkgver}-${pkgrel} ($(date_string))"
}


# validates entries in the sourced PKGBUILD file, which must be sourced before
# calling this function.
validate_pkgbuild() {
    local tmp=()
    # combine source and sources and save them back
    tmp=("${source[@]}" "${sources[@]}")
    source=("${tmp[@]}")
    sources=("${tmp[@]}")
    # combine optdepends and recommends and save them back
    tmp=("${optdepends[@]}" "${recommends[@]}")
    optdepends=("${tmp[@]}")
    recommends=("${tmp[@]}")
    # combine backup and conffiles and save them back
    tmp=("${backup[@]}" "${conffiles[@]}")
    backup=("${tmp[@]}")
    conffiles=("${tmp[@]}")
}


check_depends() {
    local package
    local packages
    local name
    local op
    local required_version
    local installed_version
    local found
    retval=()
    for package_string in "$@"; do
        # convert an alternative list with | into an array
        IFS='|' read -r -a packages <<< "${package_string}"
        found=""
        for package in "${packages[@]}"; do
            name=$(echo "$package" | stripstr | grep -o '^[^<=>]*')
            op=$(echo "$package" | stripstr | grep -Po "(?<=^$name)"'[<=>]*')
            required_version=$(echo "$package" | stripstr | \
                grep -Po "(?<=^$name$op)"'[0-9\.]*')
            installed_version=$(dpkg -s "${name}" 2>/dev/null | \
                grep -Po '(?<=Version: )[0-9\.]*')
            if [[ -n "$installed_version" ]]; then
                if [[ -n "$required_version" ]]; then
                    if ! version_compare "$installed_version" "$op" \
                            "$required_version"; then
                        local msg
                        msg="${name}'s installed version "
                        msg="${msg}(${installed_version}) is not ${op} "
                        msg="${msg}${required_version}"
                        error "$msg"
                    fi
                fi
                msg2 "Found ${name}"
                found=1
            fi
        done
        if [[ -z "$found" ]]; then
            retval+=("${package_string}")
        fi
    done
}


check_runtime_depends() {
    if [[ ${#depends[@]} -gt 0 ]]; then
        msg1 "Checking runtime dependencies..."
        check_depends "${depends[@]}"
        missing_depends+=("${retval[@]}")
    fi
}


check_buildtime_depends() {
    if [[ ${#makedepends[@]} -gt 0 ]]; then
        msg1 "Checking buildtime dependencies..."
        check_depends "${makedepends[@]}"
        missing_depends+=("${retval[@]}")
    fi
}


check_checktime_depends() {
    if [[ ${#checkdepends[@]} -gt 0 ]]; then
        msg1 "Checking checktime dependencies..."
        check_depends "${checkdepends[@]}"
        missing_depends+=("${retval[@]}")
    fi
}


install_missing_depends() {
    local packages
    local name
    if [[ $(( ${#missing_depends[@]})) -gt 0 ]]; then
        msg1 "Missing dependencies:"
        for package in "${missing_depends[@]}"; do
            msg2 "$package"
        done
        if [[ -z "$INSTALL_DEPENDS" ]]; then
            local msg
            msg="Would you like to install the required dependencies? (y/N): "
            read -p "$msg" -n 1 -r
            echo ""
            if [[ "$REPLY" == "y" || "$REPLY" == "Y" ]]; then
                INSTALL_DEPENDS=1
            fi
        fi
        if [[ "$INSTALL_DEPENDS" -ne 0 ]]; then
            msg1 "Installing dependencies..."
            sudo -k
            for package in "${missing_depends[@]}"; do
                packages=(${package//|/})
                name=$(echo "${packages[0]}" | grep -o '^[^<=>]*')
                msg2 "${name}"
                if sudo apt-get install --yes "${name}"; then
                    sudo apt-mark auto "${name}"
                    installed_depends+=("${name}")
                else
                    error "Failed to install ${name}."
                fi
            done
        else
            error "Could not resolve all dependencies."
        fi
    fi
}


retrieve_sources() {
    msg1 "Retrieving sources..."
    local source_file
    local name
    local url
    # loop through each source file
    for source_file in "${sources[@]}"; do
        url=$(echo "$source_file" | awk -F'::' '{print $2}')
        name=$(echo "$source_file" | awk -F'::' '{print $1}')
        if [[ "$(basename "$name")" != "$name" ]]; then
            url=$name
            name=$(basename "$name")
        fi
        # check if file is already downloaded
        if [[ -f "${startdir}/${name}" ]]; then
            msg2 "Found ${name}"
        elif [[ -n "${name}" && -n "${url}" ]]; then
            msg2 "Downloading ${name}"
            if ! curl --location --output "${startdir}/${name}" "$url"; then
                error "Failed to download '${name}' from ${url}"
            fi
        else
            error "File ${name} does not exist."
        fi
        source_files+=("$name")
    done
}


validate_sources() {
    local failed=0
    if ! _validate_sources md5sum; then
        failed=1
    fi
    if ! _validate_sources sha1sum; then
        failed=1
    fi
    if ! _validate_sources sha256sum; then
        failed=1
    fi
    if ! _validate_sources sha384sum; then
        failed=1
    fi
    if ! _validate_sources sha512sum; then
        failed=1
    fi
    if [[ $failed -gt 0 ]]; then
        error "One or more files did not pass the validity check!"
    fi
}


_validate_sources() {
    local -n sums="${1}s"
    if [[ ${#sums[@]} -gt 0 ]]; then
        msg1 "Validating source files with ${1}s..."
        if [[ ${#sums[@]} -ne ${#source_files[@]} ]]; then
            error "'${1}s' array not the same length as the 'source' array."
        fi
        local sum
        local failed=0
        for ((i=0;i<${#source_files[@]};++i)); do
            if [[ ${sums[i]^^} != "SKIP" ]]; then
                echo -en "  ${ANSI_BLUE}${ANSI_BOLD}->${ANSI_RESET} "
                echo -en "${ANSI_BOLD}${source_files[i]} ... ${ANSI_RESET}"
                sum=$(${1} "${startdir}/${source_files[i]}" | cut -d' ' -f1)
                if [[ "$sum" == "${sums[i]}" ]]; then
                    echo -e "${ANSI_BOLD}Passed${ANSI_RESET}"
                else
                    echo -e "${ANSI_RED}${ANSI_BOLD}FAILED${ANSI_RESET}"
                    failed=1
                fi
            fi
        done
        return $failed
    fi
}


extract_sources() {
    mkdir -p "${srcdir}"
    msg1 "Extracting sources..."
    for file in "${source_files[@]}"; do
        local extract=1
        for exception in "${noextract[@]}"; do
            if [[ $(basename "$exception") == "$(basename "$file")" ]]; then
                extract=0
            fi
        done
        if [[ $extract -gt 0 ]]; then
            case ${file,,} in
                *.tar|*.zip|*.tar.bz2|*.tar.gz|*.tar.xz|*.tbz2|*.tgz|*.txz|*.7z|*.iso|*.tpz)
                    msg2 "Extracting ${file} with bsdtar"
                    if ! bsdtar -C "${srcdir}" -xf "${startdir}/${file}"; then
                        error "Failed to extract $file"
                    fi
                    ;;
                *)
                    extract=0
                    ;;
            esac
        fi
        if [[ $extract -eq 0 ]]; then
            cp "${startdir}/${file}" "${srcdir}/${file}"
        fi
    done
}


run_prepare() {
    cd "${startdir}"
    if [[ "$(type -t prepare)" == "function" ]]; then
        msg1 "Starting prepare()"
        prepare
    fi
}


run_build() {
    cd "${startdir}"
    if [[ "$(type -t build)" == "function" ]]; then
        msg1 "Starting build()"
        build
    fi
}


run_check() {
    cd "${startdir}"
    if [[ "$(type -t check)" == "function" ]]; then
        msg1 "Starting check()"
        check
    fi
}


run_package() {
    cd "${startdir}"
    if [[ "$(type -t package)" != "function" ]]; then
        error "No package() function in PKGBUILD."
    fi
    mkdir -p "${pkgdir}"
    msg1 "Starting package()"
    package
}


install_docs() {
    msg1 "Installing docs..."
    install_copyright
    install_changelog
}


install_copyright() {
    if [[ -n "${copyright}" ]]; then
        if [[ -f "${startdir}/${changelog}" ]]; then
            msg2 "copyright"
            mkdir -p "${pkgdir}/usr/share/doc/${pkgname}"
            cat "${startdir}/${copyright}" >\
                "${pkgdir}/usr/share/doc/${pkgname}/copyright"
        else
            error "Cannot find copyright file: ${copyright}"
        fi
    fi
}


install_changelog() {
    if [[ -n "${changelog}" ]]; then
        if [[ -f "${startdir}/${changelog}" ]]; then
            msg1 "changelog.Debian.gz"
            mkdir -p "${pkgdir}/usr/share/doc/${pkgname}"
            gzip -9 < "${startdir}/${changelog}" >\
                "${pkgdir}/usr/share/doc/${pkgname}/changelog.gz"
        else
            error "Cannot find changelog file: ${changelog}"
        fi
    fi
}


make_debian() {
    msg1 "Creating DEBIAN directory..."
    mkdir -p "${pkgdir}/DEBIAN"
    make_debian_control
    make_debian_conffiles
    make_debian_preinst
    make_debian_postinst
    make_debian_prerm
    make_debian_postrm
}


make_debian_control() {
    msg2 "DEBIAN/control"
    local control="${pkgdir}/DEBIAN/control"
    true >"${control}"

    # Package
    echo "Package: ${pkgname}" >>"${control}"

    # Version
    if [[ -n "$pkgrel" ]]; then
        echo "Version: ${pkgver}-${pkgrel}" >>"${control}"
    else
        echo "Version: ${pkgver}" >>"${control}"
    fi

    # Section
    if [[ -n "${section}" ]]; then
        echo "Section: ${section}" >>"${control}"
    fi

    # Priority
    if [[ -n "${priority}" ]]; then
        echo "Priority: ${priority}" >>"${control}"
    fi

    # Architecture
    local debarch=""
    case "${arch}" in
        any)
            debarch=all
            ;;
        i686)
            debarch=i386
            ;;
        x86_64)
            debarch=amd64
            ;;
        *)
            debarch=$arch
    esac
    echo "Architecture: ${debarch}" >>"${control}"

    # Essential
    if [[ -n "$essential" && "$essential" != "no" ]]; then
        echo "Essential: ${essential}" >>"${control}"
    fi

    # Depends
    if [[ ${#depends[@]} -gt 0 ]]; then
        echo "Depends: $(dependency_string "${depends[@]}")" >>"${control}"
    else
        echo "Depends: " >>"${control}"
    fi

    # Pre-Depends
    if [[ ${#predepends[@]} -gt 0 ]]; then
        echo "Pre-Depends: $(dependency_string "${predepends[@]}")" >>"${control}"
    fi

    # Recommends
    if [[ ${#recommends[@]} -gt 0 ]]; then
        echo "Recommends: $(dependency_string "${recommends[@]}")" >>"${control}"
    fi

    # Suggests
    if [[ ${#suggests[@]} -gt 0 ]]; then
        echo "Suggests: $(dependency_string "${suggests[@]}")" >>"${control}"
    fi

    # Enhances
    if [[ ${#enhances[@]} -gt 0 ]]; then
        echo "Enhances: $(dependency_string "${enhances[@]}")" >>"${control}"
    fi

    # Breaks and Replaces
    if [[ ${#replaces[@]} -gt 0 ]]; then
        echo "Breaks: $(dependency_string "${replaces[@]}")" >>"${control}"
        echo "Replaces: $(dependency_string "${replaces[@]}")" >>"${control}"
    fi

    # Conflicts
    if [[ ${#conflicts[@]} -gt 0 ]]; then
        echo "Conflicts: $(dependency_string "${conflicts[@]}")" >>"${control}"
    fi

    # Provides
    if [[ ${#provides[@]} -gt 0 ]]; then
        echo "Provides: $(dependency_string "${provides[@]}")" >>"${control}"
    fi

    # Installed-Size
    # local size
    # size=$(du -ks --apparent-size "${pkgdir}" | cut -f1)
    # echo "Installed-Size: ${size}" >>"${control}"
    echo "Installed-Size: __INSTALLED_SIZE__" >>"${control}"

    # Maintainer
    echo "Maintainer: ${maintainer}" >>"${control}"

    # Homepage
    if [[ -n "${url}" ]]; then
        echo "Homepage: ${url}" >>"${control}"
    fi

    # Description
    echo "Description: ${pkgdesc}" >>"${control}"
    if [[ -n "$pkglong" ]]; then
        echo "${pkglong}" | sed -e 's/^/ /g' >>"${control}"
    fi
}


dependency_string() {
    local name
    local op
    local version
    local packages
    local tmp
    local dependencies=()
    for package_string in "$@"; do
        # convert an alternative list with | into an array
        IFS='|' read -r -a packages <<< "${package_string}"
        tmp=()
        for package in "${packages[@]}"; do
            name=$(echo "$package" | stripstr | grep -o '^[^<=>]*')
            op=$(echo "$package" | stripstr | grep -Po "(?<=^${name//+/\\+})"'[<=>]*')
            version=$(echo "$package" | stripstr | \
                grep -Po "(?<=^${name//+/\\+}${op})"'[0-9\.]*')
            if [[ -n ${version} ]]; then
                tmp+=("${name} (${op} ${version})")
            else
                tmp+=("$name")
            fi
        done
        dependencies+=("$(join ' | ' "${tmp[@]}")")
    done
    join ', ' "${dependencies[@]}"
}


make_debian_conffiles() {
    if [[ ${#conffiles[@]} -gt 0 ]]; then
        msg2 "DEBIAN/conffiles"
        local outfile="${pkgdir}/DEBIAN/conffiles"
        true >"${outfile}"
        for file in "${conffiles[@]}"; do
            echo "/${file}" >>"${outfile}"
        done
    fi
}


# returns true (0) if the file ($1) contains the function $($2)
has_function() {
    grep -q 'function\s*'"$1" "$2" || grep -q "$1"'\s*(\s*)' "$2"
}


make_debian_preinst() {
    if [[ -n "$install" && -f "${startdir}/${install}" ]] && \
        (has_function pre_install "${startdir}/${install}" || \
         has_function pre_upgrade "${startdir}/${install}")
    then
        msg2 "DEBIAN/preinst"
        local file="${pkgdir}/DEBIAN/preinst"
cat >"$file" <<EOF
#!/bin/bash -e

pkgname=${pkgname}
pkgver=${pkgver}
pkgrel=${pkgrel}
EOF
        cat "${startdir}/${install}" >>"$file"
        cat >>"$file" <<'EOF'

case "$1" in
    install)
        if [[ $# -ge 2 ]]; then
            if [[ $(type -t pre_upgrade) == "function" ]]; then
                pre_upgrade "$2" "${pkgver}-${pkgrel}"
            fi
        else
            if [[ $(type -t pre_install) == "function" ]]; then
                pre_install "${pkgver}-${pkgrel}"
            fi
        fi
        ;;
    upgrade)
        if [[ $(type -t pre_install) == "function" ]]; then
            pre_upgrade "$2" "${pkgver}-${pkgrel}"
        fi
        ;;
esac
EOF
        chmod 755 "$file"
    fi
}


make_debian_postinst() {
    if [[ -n "$install" && -f "${startdir}/${install}" ]] && \
        (has_function post_install "${startdir}/${install}" || \
         has_function post_upgrade "${startdir}/${install}")
    then
        msg2 "DEBIAN/postinst"
        local file="${pkgdir}/DEBIAN/postinst"
cat >"$file" <<EOF
#!/bin/bash -e

pkgname=${pkgname}
pkgver=${pkgver}
pkgrel=${pkgrel}
EOF
        cat "${startdir}/${install}" >>"$file"
        cat >>"$file" <<'EOF'

case "$1" in
    configure)
        if [[ $# -ge 2 ]]; then
            if [[ $(type -t post_upgrade) == "function" ]]; then
                post_upgrade "$2" "${pkgver}-${pkgrel}"
            fi
        else
            if [[ $(type -t post_install) == "function" ]]; then
                post_install "${pkgver}-${pkgrel}"
            fi
        fi
        ;;
    abort-remove)
        if [[ $(type -t post_install) == "function" ]]; then
            post_install "${pkgver}-${pkgrel}"
        fi
        ;;
    abort-upgrade)
        if [[ $# -ge 2 ]]; then
            if [[ $(type -t post_install) == "function" ]]; then
                post_install "${pkgver}-${pkgrel}"
            fi
        fi
        ;;
esac
EOF
        chmod 755 "$file"
    fi
}


make_debian_prerm() {
    if [[ -n "$install" && -f "${startdir}/${install}" ]] && \
        has_function pre_remove "${startdir}/${install}"
    then
        msg2 "DEBIAN/prerm"
        local file="${pkgdir}/DEBIAN/prerm"
cat >"$file" <<EOF
#!/bin/bash -e

pkgname=${pkgname}
pkgver=${pkgver}
pkgrel=${pkgrel}
EOF
        cat "${startdir}/${install}" >>"$file"
        cat >>"$file" <<'EOF'

case "$1" in
    remove)
        if [[ $(type -t pre_remove) == "function" ]]; then
            pre_remove "${pkgver}-${pkgrel}"
        fi
        ;;
esac
EOF
        chmod 755 "$file"
    fi
}


make_debian_postrm() {
    if [[ -n "$install" && -f "${startdir}/${install}" ]] && \
        (has_function post_remove "${startdir}/${install}" || \
         has_function post_purge "${startdir}/${install}")
    then
        msg2 "DEBIAN/postrm"
        local file="${pkgdir}/DEBIAN/postrm"
cat >"$file" <<EOF
#!/bin/bash -e

pkgname=${pkgname}
pkgver=${pkgver}
pkgrel=${pkgrel}
EOF
        cat "${startdir}/${install}" >>"$file"
        cat >>"$file" <<'EOF'

case "$1" in
    remove)
        if [[ $(type -t post_remove) == "function" ]]; then
            post_remove "${pkgver}-${pkgrel}"
        fi
        ;;
    purge)
        if [[ $(type -t purge) == "function" ]]; then
            purge "${pkgver}-${pkgrel}"
        fi
        ;;
    abort_install)
        if [[ $# -ge 2 ]]; then
            if [[ $(type -t post_remove) == "function" ]]; then
                post_remove "${pkgver}-${pkgrel}"
                # force Half-Installed state since we can't restore the old
                # configuration files
                return 1
            fi
        else
            if [[ $(type -t post_remove) == "function" ]]; then
                post_remove "${pkgver}-${pkgrel}"
            fi
        fi
        ;;
    abort-upgrade)
        if [[ $# -ge 2 ]]; then
            if [[ $(type -t post_remove) == "function" ]]; then
                post_remove "${pkgver}-${pkgrel}"
            fi
        fi
        ;;
esac
EOF
        chmod 755 "$file"
    fi
}


update_size() {
    msg1 "Updating Installed-Size..."
    local size
    size=$(du -ks --apparent-size "${pkgdir}" | cut -f1)
    sed -i "s/__INSTALLED_SIZE__/${size}/g" "${pkgdir}/DEBIAN/control"
}


gen_sums() {
    cd "${pkgdir}" || exit 1
    find  -type f \
        ! -regex '.*?debian-binary.*' \
        ! -regex '.*?DEBIAN.*' -printf '%P\n' | \
        xargs -d '\n' md5sum > "${pkgdir}/DEBIAN/md5sums"
    cd "${startdir}"
}


build_deb() {
    msg1 "Creating package '${pkgname}'..."
    dpkg-deb --build "${startdir}/${pkgname}-${pkgver}-${pkgrel}"
}


check_deb() {
    if [[ "$nolint" -gt 0 ]]; then
        msg1 "Skipping linting '${pkgname}-${pkgver}-${pkgrel}.deb'..."
    else
        msg1 "Linting '${pkgname}-${pkgver}-${pkgrel}.deb'..."
        lintian "${startdir}/${pkgname}-${pkgver}-${pkgrel}.deb"
    fi
}


print_completion_message() {
    msg1 "Finished making: ${pkgname} ${pkgver}-${pkgrel} ($(date_string))"
}


cleanup() {
    if [[ ${#installed_depends[@]} -gt 0 ]]; then
        if [[ -z "$REMOVE_DEPENDS" ]]; then
            local msg
            msg="Would you like to remove the build dependencies installed "
            msg="${msg} earlier? (y/N): "
            read -p "$msg" -n 1 -r
            echo ""
            if [[ "$REPLY" == "y" || "$REPLY" == "Y" ]]; then
                REMOVE_DEPENDS=1
            fi
        fi
        if [[ "$REMOVE_DEPENDS" -ne 0 ]]; then
            msg1 "Removing dependencies installed earlier..."
            for package in "${installed_depends[@]}"; do
                msg2 "${package}"
                if ! sudo apt-get purge --yes "${package}"; then
                    warning "Failed to remove ${package}."
                fi
            done
        fi
        installed_depends=()
    fi
}




# BEGIN SCRIPT

trap ctrl_c INT
trap cleanup EXIT

declare startdir="$PWD"


if [[ ! -f "${startdir}/PKGBUILD" ]]; then
    error "No PKGBUILD file found."
fi


# source the build script
read_maintainer
. "${startdir}/PKGBUILD"
validate_pkgbuild

declare srcdir="${startdir}/src"
declare pkgdir="${startdir}/${pkgname}-${pkgver}-${pkgrel}"
declare docdir="${pkgdir}/usr/share/doc/${pkgname}"

# clean
if [[ "$1" == "clean" ]]; then
    rm -R "$srcdir"
    rm -R "$pkgdir"
    rm -R "${pkgdir}.deb"
    exit 0
fi

# pre fakeroot
print_start_message
# check_runtime_depends
check_buildtime_depends
check_checktime_depends
install_missing_depends
retrieve_sources
validate_sources
extract_sources
run_prepare
run_build
run_check

# fakeroot
msg1 "Entering fakeroot environment..."
    fakeroot bash <<EOF

declare pkgname=""
declare pkgver=""
declare pkgrel=""
declare depends=()
declare makedepends=()
declare checkdepends=()
declare source=()
declare sources=()
declare noextract=()
declare section=""
declare priority="optional"
declare essential="no"
declare maintainer=""
declare pkgdesc=""
declare pkglong=""
declare url=""
declare predepends=()
declare suggests=()
declare enhances=()
declare replaces=()
declare conflicts=()
declare provides=()
declare arch=""
declare copyright=""
declare changelog=""
declare backup=()
declare conffiles=()
declare install=""

declare -r ANSI_RESET='\033[0m'
declare -r ANSI_BOLD='\033[1m'
declare -r ANSI_RED='\033[0;31m'
declare -r ANSI_GREEN='\033[0;32m'
declare -r ANSI_YELLOW='\033[0;33m'
declare -r ANSI_BLUE='\033[0;34m'

$(declare -f msg1)
$(declare -f msg2)
$(declare -f msg3)
$(declare -f warning)
$(declare -f error)
$(declare -f join)
$(declare -f stripstr)

$(declare -f read_maintainer)
$(declare -f validate_pkgbuild)
$(declare -f install_docs)
$(declare -f install_copyright)
$(declare -f install_changelog)
$(declare -f make_debian)
$(declare -f make_debian_control)
$(declare -f dependency_string)
$(declare -f make_debian_conffiles)
$(declare -f has_function)
$(declare -f make_debian_preinst)
$(declare -f make_debian_postinst)
$(declare -f make_debian_prerm)
$(declare -f make_debian_postrm)
$(declare -f run_package)
$(declare -f update_size)
$(declare -f gen_sums)
$(declare -f build_deb)

declare startdir="$startdir"

read_maintainer
. "${startdir}/PKGBUILD"
validate_pkgbuild
declare srcdir="${srcdir}"
declare pkgdir="${pkgdir}"
declare docdir="${docdir}"

install_docs
make_debian
run_package
update_size
gen_sums
build_deb

EOF

msg1 "Leaving fakeroot environment..."


# post fakeroot
check_deb
cleanup
print_completion_message