zshlibs/global.funcs.zsh

typeset -g globaldots_path="${HOME}/.global"
if [[ -a $(realpath -m $(dirname $0)/../../.globaldir ) ]]
then
    typeset -g globaldots_path=$(realpath -m $(dirname $0)/../../)
fi

if [[ -n ${GLOBALDOTS_PATH} ]]
then
    typeset -g globaldots_path=${GLOBALDOTS_PATH}
fi

if [[ -z $globaldots_path ]]; then
    echo 'functions require $globaldots_path to be set!'
fi

#### BASIC ZSHLIBS TOOLS

function zshlibs_update()
{
  zshlibs_log zlibs_update "preparing self update …"
  if [[ -n "$zshlibs_install" ]] 
  then
    zshlibs_log zlibs_update "cd into '$zshlibs_install' …"
    pushd $zshlibs_install 2>&1 > /dev/null
    zshlibs_log zlibs_update "git pull …"
    (
    git pull 2>&1 |zshlibs_log zlibs_update & # > "${HOME}/.log/z_zshlibs_update" &
    )
    zshlibs_log zlibs_update "update done"
    popd 2>&1 > /dev/null
  else
    echo "\$zshlibs_install not set!"
    return 1
    zlibs_install
  fi
}

function zshlibs_ensure()
{
  target=${2}
  typ=${1}
  if ! test -e ${target}
  then
    zshlibs_log zshlibs_ensure "creating '${target}' ($typ) …"
    case $typ in
      -d)
        mkdir -p ${target} \
          || zshlibs_log $0 "unable to create directory '${target}'"  \
          && return 2
        ;;
      -f)
        touch ${target} \
          || zshlibs_log $0 "unable to create file '${target}'" \
          && return 2
    esac
    zshlibs_log zshlibs_ensure "target '${target}' created"
  elif test ${typ} ${target}
  then 
    zshlibs_log zshlibs_ensure "target '${target}' ($typ) present"
    return 0
  else
    zshlibs_log zshlibs_ensure "target '${target}' already exists and it is not a directory"
    return 1
  fi
}

function zshlibs_log()
{
  local facility=$1
  shift
  if [[ -n "${@}" ]]
  then
    echo "$(date -Ins) ${@}" >> "${HOME}/.log/z_$facility.log"
  else
    echo "$(date -Ins) $(cat)" >> "${HOME}/.log/z_$facility.log"
  fi
}

function zshlibs_path_add()
{
  local pathtoadd="${1}"
  zshlibs_log $0 "adding path '$pathtoadd' to \$PATH"
  if [[ ! ${path[(r)${pathtoadd}]} ]]
  then
    path+=(${pathtoadd})
  fi
}

function zshlibs_fpath_add()
{
  local fpathtoadd="${1}"
  zshlibs_log $0 "adding fpath '$fpathtoadd' to \$fpath"
  if [[ ! ${fpath[(r)${fpathtoadd}]} ]]
  then
    path+=(${fpathtoadd})
  fi
}

##### GLOBAL BUCKET STUFF


function global_path_expand()
{
	local bin_base=${globaldots_path}/bin
	for pathnew in ${*}; do
    zshlibs_path_add "${bin_base}/${pathnew}"
	done;
}

function global_fpath_expand()
{
	local bin_base=${globaldots_path}/bin
	for pathnew in ${*}; do
    zshlibs_fpath_add "${bin_base}/${pathnew}"
	done;
}

##### CONFIGURATION 


function zconfig_checkload()
{
  typeset -a -g zconfig_loaded
  if [[ ! ${zconfig_loaded[(r)${1}]} ]] 
  then
    zshlibs_log zbootstrap "sourcing config '$1'"
    . -- $1 2>&1 >(zshlibs_log zbootstrap) # >> "${HOME}/.log/z_zbootstrap.log"
    zconfig_loaded+=("$1")
    zshlibs_log zbootstrap "end sourcing config '$1'"
  else
    zshlibs_log zbootstrap "config '$1' already loaded"
  fi
}

function zconfigs_load()
{
  for configfile in ${*}; do
    zconfig_checkload $configfile
  done
}



function zconfigs_local_load()
{
  if [[ ! -a ${zconfig_local_path} ]]; then
    zshlibs_log $0 "local config missing, recreating from '${zconfig_shared_path}/zshconfig.example'"
    mkdir -p -m 700 ${zconfig_local_path}
    cp ${zconfig_shared_path}/zshconfig.example ${zconfig_local_path}/local.config.zsh
  fi
  if [[ ! -d ${zconfig_local_path} ]]; then
    zshlibs_log zconfigs ""
    zconfig_checkload ${zconfig_local_path}
  else
    zconfigs_load ${zconfig_local_path}/*.config.zsh;
  fi
}


function zshlibs_boot()
{
  # ensure log directory
  zshlibs_log zbootstrap "ensure directory '${HOME}/.log/'"
  zshlibs_ensure -d "${HOME}/.log/"
  # loading configs
  typeset -a -g zconfig_loaded
  typeset -a -g path_extra
  typeset -a -g config_extra
  typeset -g zconfig_shared_path="${zshlibs_install}/config"
  typeset -g zconfig_local_path="${HOME}/.config/zsh"
}

function zbootstrap_noninteractive()
{
  zshlibs_log zbootstrap 'load global config'
  zconfig_checkload ${zconfig_shared_path}/global.config.zsh
  zshlibs_log zbootstrap 'load local configs'
  zconfigs_local_load
  for zconfig in $config_extra; do
    zshlibs_log zbootstrap 'load config extra $zconfig'
    zconfig_checkload ${zconfig_shared_path}/${zconfig}.config.zsh
  done
  # expanding settings
  zshlibs_log zbootstrap "expanding path with '$path_extra'"
  global_path_expand $path_extra
  zshlibs_log zbootstrap "expanding fpath with '$fpath_extra'"
  global_fpath_expand vanilla
  zshlibs_log zbootstrap "done loading noninteractive config"
}

function zbootstrap ()
{
  zshlibs_boot
  zbootstrap_noninteractive
  zconfig_checkload ${zconfig_shared_path}/global.style.zsh
  zshlibs_update
  zshlibs_log zbootstrap "done loading interactive config"
}