Tamarin/lib/build.sh

#!/usr/bin/env bash

#set -x

DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
source "${DIR}/util.sh"

DIST_DIR="${BASE_DIR}/dist"
SRC_DIR="${BASE_DIR}/src"

function get_project_opt {
  filter=${1}
  manifest_path=${SRC_DIR}/tamarin.json
  if [ -e "${manifest_path}" ]; then
    jq -r "${filter}" ${manifest_path} | sed 's/null//g'
  fi
}

function get_build_dir {
  project_name="${1}"
  temp_dir=$(mktemp -d)
  build_dir="${temp_dir}/${project_name}"
  mkdir -p "${build_dir}"
  echo ${build_dir}
}

function exec_hook {

  hook_name=${1}
  build_dir=${2}

  hook_script="$(get_project_opt .hooks.${hook_name} | sed 's/null//')"

  # Test hook script existence
  # if [ ! -f "${hook_script}" ]; then
  #   info "No ${hook_name} hook."
  #   return
  # fi

  if [ -z "${hook_script}" ]; then
    info "No ${hook_name} hook."
    return
  fi

  info "Executing ${hook_name} hook..."

  # Ensure the hook script is executable
  #chmod +x "${hook_script}"

  # Execute hook in a subshell
  ( cd ${SRC_DIR} && DESTDIR="${build_dir}" SRCDIR="${SRC_DIR}" ${hook_script} )

  # If the script did not execute properly, we stop here
  if [ $? != 0 ]; then
    fatal "The '${hook_name}' hook script did not finished properly !"
  fi

}

function create_debian_control_file {

  debian_dir="${1}"

  control_file="${debian_dir}/control"
  touch "${control_file}"

  package_name=$(get_project_opt .name)
  echo "Package: ${package_name}" > "${control_file}"

  package_version=$(get_project_opt .version)
  echo "Version: ${package_version:-0.0.0}" >> "${control_file}"

  package_section=$(get_project_opt .section)
  echo "Section: ${package_section:-unknown}" >> "${control_file}"

  package_priority=$(get_project_opt .priority)
  echo "Priority: ${package_priority:-optional}" >> "${control_file}"

  package_arch=$(get_project_opt .arch)
  echo "Architecture: ${package_arch:-all}" >> "${control_file}"

  dependencies=$(get_project_opt ".dependencies | .[\"${DISTRIB}\"]")

  if [ ! -z "${dependencies}" ]; then
    dependencies=""
    for depKey in $(get_project_opt ".dependencies | .[\"${DISTRIB}\"] | keys | @sh"); do
      depKey=$(echo ${depKey} | sed "s/^'\(.*\)'$/\1/");
      depValue=$(get_project_opt ".dependencies | .[\"${DISTRIB}\"] | .[\"${depKey}\"]" | sed "s/^'\(.*\)'$/\1/")
      dependencies="${depKey} ($depValue), ${dependencies}"
    done
  fi

  dependencies=$(echo ${dependencies} | sed 's/,$//')

  debug "Package dependencies: ${dependencies:-None}"

  echo "Depends: ${dependencies}" >> "${control_file}"

  package_maintainer=$(get_project_opt .maintainer)
  echo "Maintainer: ${package_maintainer:-Unknown}" >> "${control_file}"

  package_description=$(get_project_opt .description)
  echo "Description: ${package_description:-No description}" >> "${control_file}"

}

function create_debian_hooks {

  debian_dir="${1}"

  pre_install="$(get_project_opt .hooks.preInstall)"
  if [ ! -z "${pre_install}" ]; then
    cp "${SRC_DIR}/${pre_install}" "${debian_dir}/preinst"
    chmod +x "${debian_dir}/preinst"
  fi

  post_install="$(get_project_opt .hooks.postInstall)"
  if [ ! -z "${post_install}" ]; then
    cp "${SRC_DIR}/${post_install}" "${debian_dir}/postinst"
    chmod +x "${debian_dir}/postinst"
  fi

  pre_remove="$(get_project_opt .hooks.preRemove)"
  if [ ! -z "${pre_remove}" ]; then
    cp "${SRC_DIR}/${pre_remove}" "${debian_dir}/prerm"
    chmod +x "${debian_dir}/prerm"
  fi

  post_remove="$(get_project_opt .hooks.postRemove)"
  if [ ! -z "${post_remove}" ]; then
    cp "${SRC_DIR}/${post_remove}" "${debian_dir}/postrm"
    chmod +x "${debian_dir}/postrm"
  fi

}

function create_debian_changelog {

  debian_dir="${1}"
  changelog="${debian_dir}/changelog"

  logs="$(get_project_opt '.changelog' | sed 's/null//')"
  logs="$(echo ${logs:-[]} | jq 'map(.+"\n") | add' | sed 's/null/No information/g')"
  package_name=$(get_project_opt .name)
  package_version=$(get_project_opt .version)
  maintainer=$(get_project_opt .maintainer)

  echo "${package_name} (${package_version:-0.0.0}), ${DISTRIB}; urgency=low" > "${changelog}"
  echo >> "${changelog}"

  while read -r entry; do
    echo "  * ${entry}" >> "${changelog}"
  done <<< "$(echo -e "${logs}" | sed 's/^"//')"

  echo >> "${changelog}"

  echo "-- ${maintainer:-Unknown}  $(date -R)" >> "${changelog}"

}

function create_debian_metadata {

  build_dir="${1}"
  debian_dir="${build_dir}/DEBIAN"

  # Ensure debian dir exists
  mkdir -p "${debian_dir}"

  create_debian_control_file "${debian_dir}"
  create_debian_hooks "${debian_dir}"
  create_debian_changelog "${debian_dir}"

}

function build_project {

  info "Building project '${PROJECT_NAME}'..."

  build_dir="$(get_build_dir '${PROJECT_NAME}')"

  debug "Build dir: ${build_dir}"

  # We don't generate Debian metadata files if a debian directory is present
  if [  ! -d "${SRC_DIR}/debian" ]; then
    info "No Debian directory detected in sources."
    info "Generating Debian metadata files from Tamarin manifest..."
    create_debian_metadata "${build_dir}"
  else
    info "A Debian directory is already present in sources."
  fi

  exec_hook "prebuild" "${build_dir}"

  # Ensure $DIST_DIR exists
  mkdir -p "${DIST_DIR}"

  cd ${SRC_DIR}
  dpkg-buildpackage -us -uc

  if [ $? != 0 ]; then
    fatal "The build process has not completed successfuly !"
  fi

  # Create new directory
  mkdir -p "${DIST_DIR}/${PROJECT_NAME}/"

  # Move generated files
  mv ../*.deb "${DIST_DIR}/${PROJECT_NAME}/"
  mv ../*.changes "${DIST_DIR}/${PROJECT_NAME}/"
  mv ../*.dsc "${DIST_DIR}/${PROJECT_NAME}/"
  mv ../*.tar.xz "${DIST_DIR}/${PROJECT_NAME}/"

  exec_hook "postbuild" "${build_dir}"

}

function main {

  manifest_path=${SRC_DIR}/tamarin.json

  if [ ! -f "${manifest_path}" ] && [ ! -d "${SRC_DIR}/debian" ]; then
    fatal "There is no 'tamarin.json' nor debian packaging files in the project directory !"
  fi

  build_project

}

main