functions

#!/bin/sh

__sm.package.cli()
{
  trace_filter package || set -o xtrace

  typeset _token index
  typeset -a _ignored_args _package_args

  _package_args=( $@ )

  for (( index=1 ; index <= ${#_package_args} ; index++ ))
  do
    _token="${_package_args[$index]}"
    case "${_token}" in
      (src)
        src_path="${_package_args[$((++index))]}"
        [[ -n "${src_path}" ]] ||
          __sm.log.error "a path must follow keyword 'src'"
        ;;
      (data)
        data_path="${_package_args[$((++index))]}"
        [[ -n "${data_path}" ]] ||
          __sm.log.error "a path must follow keyword 'data'"
        ;;
      (user)
        package_user="${_package_args[$((++index))]}"
        [[ -n "${package_user}" ]] ||
          __sm.log.error "a user name must follow keyword 'user'"
        ;;
      (version)
        package_version="${_package_args[$((++index))]}"
        [[ -n "${package_version}" ]] ||
          __sm.log.error "a version number string must follow keyword 'version'"
        ;;
      (base_url)
        package_base_url="${_package_args[$((++index))]}"
        [[ -n "${package_base_url}" ]] ||
          __sm.log.error "a base path url must follow keyword 'base_url'"
        ;;
      (file)
        package_file="${_package_args[$((++index))]}"
        [[ -n "${package_file}" ]] ||
          __sm.log.error "a path must follow keyword 'file'"
        ;;
      (dir)
        package_directory="${_package_args[$((++index))]}"
        [[ -n "${package_directory}" ]] ||
          __sm.log.error "a single extracted directory name must follow keyword 'dir'"
        ;;
      (archive_format)
        archive_format="${_package_args[$((++index))]}"
        [[ -n "${archive_format}" ]] ||
          __sm.log.error "an archive format (tar.gz,tar.bz2,tar.xz,zip,...) must follow keyword 'archive_format'"
        ;;
      (checksum)
        package_checksum="${_package_args[$((++index))]}"
        [[ -n "${package_checksum}" ]] ||
          __sm.log.error "an checksum sum string must follow keyword 'checksum'. Format: '{type},{sum}'. eg. 'sha256,abcde...'"
        ;;
      (force)
        force_flag=1
        ;;
      (static)
        static_flag=1
        ;;
      (shared)
        shared_flag=1
        ;;
      (licence)
        extension_license
        succeed
        ;;
      (help)
        __sm.package.usage
        succeed
        ;;
      (--configure)
        _token="${_package_args[$((++index))]}"
        __sm.package.configure.flags "${_token}"
        ;;
      (--with*|--enable*|--disable*)
        __sm.package.configure.flags "${_token}"
        ;;
      (*)
        _ignored_args+=("${_token}")
        ;;
    esac

  done

  __sm.package.init "${_ignored_args[@]}"
}

__sm.package.init()
{
  trace_filter package || set -o xtrace

  typeset default_configure_flags _flag
  typeset -ga configure_flags >/dev/null

  true ${package_name:=${1:-${extension}}}

  [[ -n "${package_name}" ]] || __sm.log.fail "Package name must be given.\n"

  case "${package_name}" in
    (*\=*) # exact version specifier
      package_version="${package_name#*\=}"
      package_name="${package_name%%\=*}"
      ;;
    (*:*) # minimum version specifier
      # TODO: concept of 'minimum' ;)
      package_version="${package_name#*:}"
      package_name="${package_name%%:*}"
      ;;
    (*)
      true "${package_version:="${2:-}"}" "${archive_format:="${3:-}"}"
      ;;
  esac

  true \
    "${source_path:="${sm_path}/src"}" \
    "${archives_path:="${sm_path}/archives"}" \
    ${static_flag:=0}

  __sm.package.exports
  # Ensure that package_version is set at this point

  for variable in version base_url checksum_url user
  do
    if variable is empty "package_${variable}"
    then
      config read file defaults from ${package_name} key ${variable} into ${variable} prefix package
    fi
  done
  for variable in website_url archive_format
  do
    if variable is empty "${variable}"
    then
      config read file defaults from ${package_name} key ${variable} into ${variable}
    fi
  done
  for variable in package_dependencies configure_flags make_flags configure_flag_static configure_flag_shared
  do
    config read file defaults from ${package_name} key ${variable} into ${variable} prefix default
  done

  if command exists "${package_name}_initialize"
  then
    __sm.string.contains.word "${package_name}_initialize" "${FUNCNAME[*]}" ||
      "${package_name}_initialize"
  fi

  __sm.package.package_dependencies ${=default_package_dependencies[*]}
  __sm.package.configure.flags ${=default_configure_flags[*]}
  __sm.package.make.flags ${=default_make_flags[*]}
  [[ ${static_flag:-0} != 1 ]] || __sm.package.configure.flags ${default_configure_flag_static:---static}
  [[ ${shared_flag:-0} != 1 ]] || __sm.package.configure.flags ${default_configure_flag_shared:---enable-shared}

  true \
    "${package_version:="${package_default_version}"}" \
    "${package_dir:="${package_name}-${package_version}"}" \
    "${init_scripts_path:="$(init_scripts_path)"}" \
    "${archive_format:=tar.gz}" \
    "${package_file:="${package_name}-${package_version}.${archive_format}"}" \
    "${install_base_path:="${packages_path}/versions/${package_name}"}" \
    "${install_path:="${install_base_path}/${package_version}"}"

  __sm.package.configure.flag --prefix "${install_path}"

  # This check should only happen in places that require a version...
  #[[ -n "${package_version}" ]] ||
  #  __sm.log.fail "Package version must be specified.\n"\
  #  "(For example version=x.y.z set in extension's config/defaults file.)\n"

  fhs_dirs=( bin etc include lib libexec sbin share man )

  paths create "${active_path}"

  for dir in ${fhs_dirs}
  do
    paths create "${active_path}/${dir}"
  done

  if user is root
  then
    true \
      "${log_path:="/var/log/${package_name}"}" \
      "${package_user:="${package_name}"}"
  else
    true \
      "${log_path:="${active_path}/log"}" \
      "${package_user:="$USER"}"
  fi

  extension_patches_path="${extension_path}/patches"
}

__sm.package.error()
{
  trace_filter package || set -o xtrace
  typeset _message _log _lines
  _message="$1"
  _log="$2"
  _lines="${3:-50}"

  if [[ -n ${_log} && -s "${_log}" ]]
  then # Append tail of __sm.log.error log to the __sm.log.error message.
    _message="${_message}\n\nTail of ${_log}:\n$( tail -n ${_lines} ${_log} )"
  fi
  __sm.log.error "\n${_message}"
}

__sm.package.define()
{
  trace_filter package || set -o xtrace
  typeset key value
  while (( $# > 0 ))
  do
    key="$1" && shift
    value="$1"
    if ! shift
    then
      if echo "$key" | grep '='
      then
        __sm.log.fail "Invalid key '${key}'; Most likely the '=' is supposed to be a space?"
      else
        __sm.log.fail "Value not specified for key '${key}'; They should be specified in key/value pairs :)"
      fi
    fi

    case "$key" in
      (name)
        package_name="${value}"
        ;;
      (version)
        package_version="${value}"
        ;;
      (file)
        package_file="${value}"
        ;;
      (dir)
        package_dir="${value}"
        ;;
      (url)
        package_url="${value}"
        ;;
      (base_url)
        package_base_url="${value}"
        ;;
      (docs_url)
        package_docs_url="${value}"
        ;;
      (patches_url)
        package_patches_url="${value}"
        ;;
      (checksum_url)
        package_checksum_url="${value}"
        ;;
      (bin_path)
        bin_path="${value}"
        ;;
      (packages_path)
        packages_path="${value}"
        ;;
      (source_path)
        source_path="${value}"
        ;;
      (target_path)
        target_path="${value}"
        ;;
      (archive_format)
        archive_format="${value}"
        ;;
      # TODO: Simplify into
      #(+([[[:alnum:]]|])_path|name|version|url|checksum_url)
      #  eval "${key}=${value}"
      #  ;;
      (*)
        __sm.log.fail "Unknown key '${key}' (value: ${value})."
      ;;
    esac
  done
}

__sm.package.configure.flags()
{
  trace_filter package || set -o xtrace
  typeset _flag
  for _flag in "$@"
  do
    if ! __sm.string.contains.word "${_flag}" "${configure_flags[*]}"
    then
      configure_flags+=( "${_flag}" )
    fi
  done
}

__sm.package.configure.flag()
{
  trace_filter package || set -o xtrace
  typeset _key _value
  _key="$1"
  _value="$2"

  if ! __sm.string.contains.key "${_key}" "${configure_flags[*]}"
  then
    configure_flags+=( "${_key}=${_value}" )
  fi
}

__sm.package.make.flags()
{
  trace_filter package || set -o xtrace
  typeset _flag
  for _flag in "$@"
  do
    if ! __sm.string.contains.word "${_flag}" "${make_flags[*]}"
    then
      make_flags+=( "${_flag}" )
    fi
  done
}

__sm.package.package_dependencies()
{
  trace_filter package || set -o xtrace
  typeset _flag
  typeset -axg package_dependencies
  for _flag in "$@"
  do
    if ! __sm.string.contains.word "${_flag}" "${package_dependencies[*]}"
    then
      package_dependencies+=( "${_flag}" )
    fi
  done
}

__sm.package.set.cflags()
{
  trace_filter package || set -o xtrace
  export CFLAGS
  if
    ! __sm.string.contains.word "-I${active_path}/include" "${CFLAGS}"
  then
    CFLAGS="-I${active_path}/include${CFLAGS:+ }${CFLAGS:-}"
  fi
  if
    ! __sm.string.match " -m" " ${CFLAGS}" &&
    __sm.os.type.is darwin && __sm.os.arch.type.is x86_64
  then
    CFLAGS="-m64${CFLAGS:+ }${CFLAGS:-}"
  fi
}

__sm.package.set.cpath()
{
  trace_filter package || set -o xtrace
  export CPATH
  if ! __sm.string.contains.word "${active_path}/include" "${CPATH:-}"
  then
    CPATH="${CPATH:-}${CPATH:+ }${active_path}/include"
  fi
}

__sm.package.set.ldflags()
{
  trace_filter package || set -o xtrace
  export LDFLAGS

  if __sm.paths.exists "${active_path}/lib" &&
    ! __sm.string.contains.word "-L${active_path}/lib" "${LDFLAGS:-}"
  then
    LDFLAGS="-L${active_path}/lib${LDFLAGS:+ }${LDFLAGS:-}"
  fi

  if __sm.paths.exists "${active_path}/lib64" &&
    ! __sm.string.contains.word "-L${active_path}/lib64" "${LDFLAGS:-}"
  then
    LDFLAGS="-L${active_path}/lib64${LDFLAGS:+ }${LDFLAGS:-}"
  fi
}

__sm.package.set.cc()
{
  trace_filter package || set -o xtrace
  export CC

  if __sm.os.type.is darwin && [[ -x /usr/bin/gcc-4.2 ]]
  then CC=/usr/bin/gcc-4.2
  fi
}

__sm.package.common.methods()
{
  typeset method
  for method in activate deactivate install update uninstall
  do
    __sm.package.$method()
    {
      trace_filter package || set -o xtrace

      typeset method
      method=${0##*.}

      case "${package_strategy:=gnu}" in
        (gnu|binary|java)
          includes internal/package/strategies/${package_strategy}
          __sm.package.${package_strategy}.$method "$@"
          ;;
        *)
          __sm.log.fail "Unknown package strategy ${package_strategy} for $method"
          ;;
      esac
    }
  done
}
__sm.package.common.methods

__sm.package.is.active()
{
  trace_filter package || set -o xtrace

  typeset _name _version _path

  _name="${1:-}"
  _version="${2:-}"

  (( $# )) && shift || __sm.log.fail "No package name was given, or name is empty."

  _path="${packages_path}/versions/${_name}"

  if (( $# )) && shift
  then # version was passed
    [[ -d "${_path}/${_version}" ]]
  else # version was not passed
    [[ -L "${_path}/active" && -d $(readlink "${_path}/active") ]]
  fi
}

__sm.package.docs()
{
  trace_filter package || set -o xtrace
  __sm.os.open "${package_docs_url}"
}

__sm.package.website()
{
  trace_filter package || set -o xtrace
  __sm.os.open "${package_website_url}"
}

__sm.package.dependencies()
{
  trace_filter package || set -o xtrace
  typeset dependency _dependencies _missing_dependencies IFS
  _dependencies=(${package_dependencies[@]})
  _missing_dependencies=()

  unset package_dependencies

  # TODO: improve dependency management.
  for dependency in "${_dependencies[@]}"
  do
    if ! __sm.package.is.active ${dependency/-/ }
    then
      _missing_dependencies+=( ${dependency} )
    fi
  done

  if [[ -n "${_missing_dependencies}" ]]
  then
    IFS=','
    __sm.log.error "${extension} requires ${_missing_dependencies[*]}.\n
Please install via sm package module, and retry. Typically, this can be done as follows:\n
\tsm ${_missing_dependencies[*]} package install\n"
  fi
}

__sm.package.info()
{
  trace_filter package || set -o xtrace
  (( $# == 0 )) || __sm.package.cli $@

  typeset _installed _path package_checksum _installed
  _path="${packages_path}/versions/${package_name}"

  true "${package_dir:="${package_name}-${package_version}"}" \
    "${package_url:="${package_base_url}/${package_file}"}"

  [[ -n "${package_checksum}" ]] || __sm.config.read "${package_name}" checksum "${package_file}" package_checksum

  log "package_name: ${package_name}"
  if paths exist "${_path}"
  then
    _installed=($( __sm.package.versions.installed ${package_name} ${package_version} ))
    log "  versions_installed: ${_installed[*]}"
  else
    log "  versions_installed: none"
  fi
  log "  default_version: ${package_default_version}"

  if [[ -d "${_path}" ]] && [[ -L "${_path}/active" ]]
  then
    log "  version_active: $(readlink "${_path}/active")"
  else
    log "  version_active: none"
  fi
  log "  base_url: ${package_base_url}"
  log "  download_url: ${package_url}"
  log "  archive_format: ${package_file}"
  log "  stored archive_checksum: ${package_checksum:-}"
  log "  source_path: ${source_path}/${package_dir}"

  if [[ -n "${package_dependencies}" ]]
  then
    log "  dependencies: ${package_dependencies[*]}"
  fi
}

__sm.package.man()
{
  trace_filter package || set -o xtrace
  (( $# == 0 )) || __sm.package.cli $@

  true "${package_path:="${packages_path}/versions/${package_name}/${package_version}"}"

  MANPATH="${package_path}/man"

  paths exist $MANPATH ||
    __sm.log.error "No man page available for package ${package_name} ${package_version}"

  man ${extension_actions[@]:-${package_name}} || true
}

__sm.package.versions.installed()
{
  trace_filter package || set -o xtrace
  versionedfs versions path "${packages_path}" name "${package_name}"
}

__sm.packages.list.installed()
{
  trace_filter package || set -o xtrace
  versionedfs versions path "${packages_path}"
}

__sm.package.is.installed()
{
  trace_filter package || set -o xtrace
  versionedfs versions path "${packages_path}" name "${package_name}" | grep "${1:-}" >/dev/null
}

__sm.packages.list.active()
{
  trace_filter package || set -o xtrace
  if [[ -n "$1" ]]
  then
    versionedfs active path "${packages_path}" name "$1"
  else
    versionedfs active path "${packages_path}"
  fi
}

__sm.packages.available()
{
  trace_filter package || set -o xtrace
  __sm.extension.installed module "internal/package" "$@"
}

__sm.packages.list()
{
  trace_filter package || set -o xtrace
  typeset _args
  __sm.packages.list.${1:-installed} "$@"
}

__sm.packages.list.known()
{
  NIY "pkg list known"
}

__sm.package.usage()
{
  trace_filter package || set -o xtrace
  log "
  Usage:

  $0 [options]

  options:

  --prefix   - specify prefix path
  --src)     - specify source directory
  --data)    - specify data directory
  --user)    - specify user to install as
  --version) - specify version to install
  --licence) - view licence
  --help)    - view this usage information

  "
}

__sm.package.exports()
{
  typeset variable
  typeset -a variables

  variables=(
    archive_format
    bin_path
    configure_command
    data_path
    extension_patches_path
    force_flag
    package_base_url
    package_checksum
    package_checksum_url
    package_dir
    package_directory
    package_docs_url
    package_file
    package_name
    package_patches_url
    packages_path
    package_url
    package_user
    package_version
    shared_flag
    source_path
    src_path
    static_flag
    target_path
    CFLAGS
    CPATH
    LDFLAGS
  )

  for variable in ${variables[@]}
  do
    typeset -g ${variable}
  done

  typeset -ga configure_flags make_flags package_dependencies
}

__sm.package.reset()
{
  typeset variable
  typeset -a variables

  variables=(
    archive_format
    bin_path
    configure_command
    configure_flags
    data_path
    force_flag
    install_base_path
    install_path
    log_path
    make_flags
    package_base_url
    package_checksum
    package_checksum_url
    package_default_version
    package_dependencies
    package_dir
    package_directory
    package_docs_url
    package_file
    package_name
    package_patches_url
    package_url
    package_user
    package_version
    shared_flag
    source_path
    src_path
    static_flag
    target_path
    website_url
    CFLAGS
    CPATH
    LDFLAGS
  )

  for variable in ${variables[@]}
  do
    unset ${variable}
  done

  __sm.package.exports
}