mulle-sourcetree

#! /usr/bin/env mulle-bash
# shellcheck shell=bash
#
#   Copyright (c) 2015-2017 Nat! - Mulle kybernetiK
#   All rights reserved.
#
#   Redistribution and use in source and binary forms, with or without
#   modification, are permitted provided that the following conditions are met:
#
#   Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
#
#   Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
#   Neither the name of Mulle kybernetiK nor the names of its contributors
#   may be used to endorse or promote products derived from this software
#   without specific prior written permission.
#
#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
#   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
#   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
#   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
#   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
#   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
#   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
#   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
#   POSSIBILITY OF SUCH DAMAGE.
#
[ "${TRACE:-}" = 'YES' -o "${MULLE_SOURCETREE_TRACE:-}" = 'YES' ] && set -x && : "$0" "$@"


MULLE_EXECUTABLE_VERSION="1.3.4"

#
# Determine location of own libexec directory. Which is `src` in development
# and ../libexec when deployed. MULLE_EXECUTABLE needs to be defined for this.
#

if ! [ ${MULLE_SOURCETREE_LIBEXEC_DIR+x} ]
then
   r_get_libexec_dir "${MULLE_EXECUTABLE}" "mulle-sourcetree" "mulle-sourcetree-action.sh"
   MULLE_SOURCETREE_LIBEXEC_DIR="${RVAL}"
fi


# not -u clean yet
set +u

#
# This is the sourcetree::main user interface to mulle-sourcetree
# sorta like git
#

sourcetree::print_commands()
{
   local  show_all="${1:-NO}"

   SHOWN_COMMANDS="\
   add            : add a node to the sourcetree
   clean          : remove files added by a sync
   json           : show current sourcetree as JSON
   list           : list nodes in the current sourcetree
   mark           : add or remove a mark from a node in the sourcetree
   move           : move a node relative to other nodes in the sourcetree
   set            : set a node's properties in the sourcetree
   status         : query state of the tree
   sync           : synchronize the project tree with the sourcetree [default]"

   HIDDEN_COMMANDS="\
   config         : manipulate sourcetree config files
   craftorder     : emit nodes that are marked \"build\", in dependency order
   dbstatus       : query state of the database
   desecrate      : remove all graveyards
   dotdump        : create a picture of the sourcetree or the database
   duplicate      : duplicate a sourcetree node
   filter         : test a filter with user supplied marks
   fix            : support to track user modifications in the filesystem
   eval-add       : batch process mulle-sourcetree add commands
   get            : get a node's properties from the sourcetree
   info           : print current sourcetree information
   libexec-dir    : print path to ${MULLE_USAGE_NAME} libexec
   knownmarks     : list known marks
   plugin         : list available plugins
   rcopy          : copy a node from another sourcetree
   rename         : rename a node in the sourcetree
   rename-marks   : rename marks in the sourcetree
   remove         : remove a node from the sourcetree
   reset          : clear the database, to force a sync
   reuuid         : create new uuids for the sourcetree
   rewrite        : clean up marks of a sourcetree
   sourcetree-dir : print path to project (if a sourcetree exists)
   star-search    : search for duplicates by name listed as '*' in list
   supermark      : inspect supermarks
   wrap           : wrap nodetypes,branches,URLs in environment variables
   test           : test if a mark matches against a list of marks
   touch          : mark sourcetree as dirty
   uname          : ${MULLE_USAGE_NAME}'s simplified uname(1)
   unmark         : remove marks from a node in the sourcetree
   version        : print ${MULLE_USAGE_NAME} version
   walk           : visit all the sourcetree nodes with a callback"


   printf "%s\n" "${SHOWN_COMMANDS}"

   if [ "${MULLE_UNAME}" = 'darwin' ]
   then
      printf "%s\n" "${DARWIN_COMMANDS}"
   fi

   if [ "${show_all}" != 'NO' ]
   then
      printf "%s\n" "${HIDDEN_COMMANDS}"
   fi
}


sourcetree::usage()
{
   local verbose="${1:-NO}"

   cat <<EOF
Usage:
   ${MULLE_USAGE_NAME} [flags] [command] [options]

   Maintain a project sourcetree composed of multiple repositories
   and archives and other things. The sourcetree is backed by a database,
   which is created during \`sync\`.

   A sourcetree is created with the "add" of the first node. The actual
   contents will be fetched during "sync".

Flags:
EOF

   (
      cat <<EOF
   -N        : bypass search for enclosing source tree
   --flat    : flat operation
   --recurse : recursive operation
   --share   : share operation (default)
EOF

      options_technical_flags_usage "     : "
   ) | LC_ALL=C sort

   cat <<EOF

Commands:
EOF

   sourcetree::print_commands "${verbose}" | sort

   if [ "${verbose}" = 'NO' ]
   then
      cat <<EOF
      (use mulle-sourcetree -v help to show more commands)
EOF
   fi

   cat <<EOF
Options are command specific. Use mulle-sourcetree <command> -h for help.
EOF


   cat <<EOF

Environment:
   MULLE_SOURCETREE_CONFIG_NAME          : config name to search (config)
   MULLE_SOURCETREE_CONFIG_NAME_<name>   : config to use for dependency (config)
   MULLE_SOURCETREE_STASH_DIR            : place to store dependencies (stash)
   MULLE_SOURCETREE_SYMLINK              : allow symlinks to be used
   MULLE_SOURCETREE_FETCH_<name>         : if NO, inhibits dependency fetch
EOF
   exit 1
}


sourcetree::main()
{
   local MULLE_FLAG_DEFER=""  # test also uses this ?

   local FLAG_USE_FALLBACK='NO'     # should probably remove
   local FLAG_SOURCETREE_MODE=""
   local FLAG_CONFIG_DIR=""
   local FLAG_SHARE_DIR=""
   local FLAG_CONFIG_NAME=""

   #
   # simple option handling
   #
   while [ $# -ne 0 ]
   do
      case "$1" in
         -lxx|--trace-database)
            MULLE_FLAG_DB_LOG_EXEKUTOR='YES'
         ;;

         -lxw|--trace-walk)
            MULLE_FLAG_WALK_LOG_EXEKUTOR='YES'
         ;;
         # intentionaly fall through to options
      esac

      if options_technical_flags "$1"
      then
         shift
         continue
      fi

      case "$1" in
         -f|--force)
            MULLE_FLAG_MAGNUM_FORCE='YES'
         ;;

         -h*|--help|help)
            sourcetree::usage "${MULLE_TRACE}"
         ;;

         -lxx|--trace-database)
            MULLE_FLAG_DB_LOG_EXEKUTOR='YES'
         ;;

         -lxw|--trace-walk)
            MULLE_FLAG_WALK_LOG_EXEKUTOR='YES'
         ;;

         --echo-args)
            shift
            printf "%s\n" "$@"
            exit 0
         ;;

         --config-dir)
            [ $# -eq 1 ] && fail "Missing argument to \"$1\""
            shift

            FLAG_CONFIG_DIR="$1"
         ;;

         --config-name|--config-names)
            [ $# -eq 1 ] && fail "Missing argument to \"$1\""
            shift

            FLAG_CONFIG_NAME="$1"
         ;;

         -d|--directory)
            [ $# -eq 1 ] && fail "Missing argument to \"$1\""
            shift

            cd "$1" || exit
         ;;

         --git-terminal-prompt)
            [ $# -eq 1 ] && fail "Missing argument to \"$1\""
            shift

            GIT_TERMINAL_PROMPT="$1"
            export GIT_TERMINAL_PROMPT
         ;;

         #
         # DEFER MODES
         #
         -R|--defer-root)
            MULLE_FLAG_DEFER="ROOT"    # up to virtual root
         ;;

         -T|--defer-this)
            MULLE_FLAG_DEFER="NEAREST"    # this or next best
         ;;

         -P|--defer-parent)               # one above us
            MULLE_FLAG_DEFER="PARENT"
         ;;

         -N|--no-defer)                   # stay in PWD
            MULLE_FLAG_DEFER="NONE"
         ;;

         --virtual-root)                # stay in PWD
            MULLE_FLAG_DEFER="VIRTUAL"
         ;;

         --mode)
            [ $# -eq 1 ] && fail "Missing argument to \"$1\""
            shift

            FLAG_SOURCETREE_MODE="$1"
         ;;

         -r|--recurse|--recursive)
            FLAG_SOURCETREE_MODE="recurse"
         ;;

         --flat)
            FLAG_SOURCETREE_MODE="flat"
         ;;

         --share)
            FLAG_SOURCETREE_MODE="share"
         ;;

         --share-dir|--stash-dir)
            [ $# -eq 1 ] && fail "Missing argument to \"$1\""
            shift

            FLAG_SHARE_DIR="$1"
         ;;

         --use-fallback)
            FLAG_USE_FALLBACK='YES'
         ;;

         --version)
            printf "%s\n" "${MULLE_EXECUTABLE_VERSION}"
            exit 0
         ;;

         --zprof)
            RUN_ZPROF='YES'
            zmodload "zsh/zprof" || exit 1
         ;;

         -*)
            log_error "${MULLE_EXECUTABLE_FAIL_PREFIX}: Unknown flag \"$1\""
            sourcetree::usage "${MULLE_TRACE}"
         ;;

         *)
            break
         ;;
      esac

      shift
   done

   options_setup_trace "${MULLE_TRACE}" && set -x

   cmd="${1}"
   [ $# -eq 0 ] || shift

   case "${cmd}" in 
      libexec-dir|library-path)
         printf "%s\n" "${MULLE_SOURCETREE_LIBEXEC_DIR}"
         exit 0
      ;;
   esac

   # shellcheck source=mulle-sourcetree-environment.sh
   include "sourcetree::environment"

   local SOURCETREE_START
   local SOURCETREE_CONFIG_NAME

   FLAG_CONFIG_NAME="${FLAG_CONFIG_NAME:-${MULLE_SOURCETREE_CONFIG_NAME}}"

   sourcetree::environment::default "${FLAG_SHARE_DIR}" \
                                    "${FLAG_CONFIG_DIR}" \
                                    "${FLAG_CONFIG_NAME}" \
                                    "${FLAG_USE_FALLBACK}" \
                                    "${MULLE_FLAG_DEFER}"


   #
   # dbstatus should be fast and doesn't need share
   #
   if [ "${cmd}" = "dbstatus" ]
   then
      # shellcheck source=src/mulle-sourcetree-clean.sh
      include "sourcetree::dbstatus"

      sourcetree::dbstatus::main "$@"
      return $?
   fi

   #
   # dont' check if resetting
   #
   # for status it's debatable, but I don't like it
   # for craftorder, we want to be fast so we don't check and dont get
   # default mode
   #
   case "${cmd}" in
      reset|craftorder|dbstatus)
      ;;

      *)
         sourcetree::environment::check_sane_stash_dir
      ;;
   esac

   local SOURCETREE_MODE

   sourcetree::environment::set_default_db_mode "${SOURCETREE_START}" "${FLAG_SOURCETREE_MODE}" \
   || fail "Could not set database to \"${FLAG_SOURCETREE_MODE}\""

   log_setting "MULLE_SOURCETREE_PROJECT_DIR   : ${MULLE_SOURCETREE_PROJECT_DIR}"
   log_setting "MULLE_SOURCETREE_ETC_DIR       : ${MULLE_SOURCETREE_ETC_DIR}"
   log_setting "MULLE_SOURCETREE_STASH_DIRNAME : ${MULLE_SOURCETREE_STASH_DIRNAME}"
   log_setting "MULLE_SOURCETREE_STASH_DIR     : ${MULLE_SOURCETREE_STASH_DIR}"
   log_setting "MULLE_SOURCETREE_VAR_DIR       : ${MULLE_SOURCETREE_VAR_DIR}"
   log_setting "MULLE_VIRTUAL_ROOT             : ${MULLE_VIRTUAL_ROOT}"
   log_setting "PWD                            : ${PWD}"
   log_setting "SOURCETREE_CONFIG_NAME         : ${SOURCETREE_CONFIG_NAME}"
   log_setting "SOURCETREE_CONFIG_DIR          : ${SOURCETREE_CONFIG_DIR}"
   log_setting "SOURCETREE_DB_FILENAME         : ${SOURCETREE_DB_FILENAME}"
   log_setting "SOURCETREE_FIX_FILENAME        : ${SOURCETREE_FIX_FILENAME}"
   log_setting "SOURCETREE_MODE                : ${SOURCETREE_MODE}"
   log_setting "SOURCETREE_START               : ${SOURCETREE_START}"
   log_setting "MULLE_FLAG_DB_LOG_EXEKUTOR     : ${MULLE_FLAG_DB_LOG_EXEKUTOR}"
   log_setting "MULLE_FLAG_WALK_LOG_EXEKUTOR   : ${MULLE_FLAG_WALK_LOG_EXEKUTOR}"

   case "${cmd}" in
      add|copy|get|duplicate|info|knownmarks|mark|move|rcopy|rename|rename-marks|remove|set|unmark)
         # shellcheck source=src/mulle-sourcetree-commands.sh
         include "sourcetree::commands"

         sourcetree::commands::${cmd//-/_}_main "$@"
      ;;

      craftorder|clean|fix|json|list|reset|reuuid|rewrite|wrap|status|walk)
         include "sourcetree::${cmd}"

         sourcetree::${cmd}::main "$@"
      ;;

      supermark)
         include "sourcetree::${cmd}s"

         sourcetree::${cmd}s::main "$@"
      ;;

      commands)
         echo "\
add
clean
config
craftorder
dbstatus
desecrate
dotdump
duplicate
etc-dir
eval-add
filter
fix
get
info
json
knownmarks
libexec-dir
list
mark
move
plugin
project-dir
pwd
rcopy
remove
rename
rename-marks
reset
reuuid
rewrite
set
sourcetree-dir
star-search
status
supermark
sync
test
touch
uname
unmark
var-dir
version
wrap"
      ;;

      config)
         # shellcheck source=src/mulle-sourcetree-config.sh
         include "sourcetree::config"

         sourcetree::config::main "$@"
      ;;

      desecrate)
         # shellcheck source=src/mulle-sourcetree-clean.sh
         include "sourcetree::clean"

         sourcetree::clean::main --all-graveyards "$@"
      ;;

      dotdump)
         # shellcheck source=src/mulle-sourcetree-dotdump.sh
         include "sourcetree::dotdump"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         sourcetree::dotdump::main "$@"
      ;;

      eval-add)
         # shellcheck source=src/mulle-sourcetree-eval-add.sh
         include "sourcetree::eval-add"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         sourcetree::eval_add::main "$@"
      ;;

      filter)
         # shellcheck source=src/mulle-sourcetree-filter.sh
         include "sourcetree::filter"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         sourcetree::filter::main "$@"
      ;;

      mode)
         printf "%s\n" "${SOURCETREE_MODE}"
      ;;

      plugin|plugins)
         # shellcheck source=src/mulle-sourcetree-plugin.sh
         include "sourcetree::plugin"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         sourcetree::plugin::main "$@"
      ;;

      pwd|path)
         # shellcheck source=src/mulle-sourcetree-walk.sh
         pwd -P   # prefer physical path for our needs
      ;;

      etc-dir)
         printf "%s\n" "${MULLE_SOURCETREE_ETC_DIR}"
      ;;

      project-dir)
         printf "%s\n" "${MULLE_SOURCETREE_PROJECT_DIR}"
      ;;

      var-dir)
         printf "%s\n" "${MULLE_SOURCETREE_VAR_DIR}"
      ;;

      share-dir|stash-dir)
         printf "%s\n" "${MULLE_SOURCETREE_STASH_DIR}"
      ;;

      star-search)
         # shellcheck source=src/mulle-sourcetree-walk.sh
         include "sourcetree::walk"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         if [ -z "$1" -o "$#" -ne 1 -o "$1" = "-h" -o "$1" = "--help" -o "$1" = "help" ]
         then
            fail "star-search needs one node address to search for"
         fi

         sourcetree::walk::main \
            --dedupe-mode nodeline-no-uuid \
            --lenient \
            "[ \"\${NODE_ADDRESS}\" = \"$1\" ] && \
echo \"\${NODE_MARKS} \${NODE_TAG} \${NODE_BRANCH} \${NODE_URL} (\${WALK_DATASOURCE#\${PWD}/})\"" | sort -u
      ;;

      tool-env)
         printf "MULLE_SOURCETREE_PROJECT_DIR='%s'\n" "${MULLE_SOURCETREE_PROJECT_DIR}"
         printf "MULLE_SOURCETREE_STASH_DIR='%s'\n" "${MULLE_SOURCETREE_STASH_DIR}"
      ;;

      touch)
         if [ -f "${MULLE_SOURCETREE_ETC_DIR}/config}" ]
         then
            exekutor touch "${MULLE_SOURCETREE_ETC_DIR}/config"
         fi
         if [ -f "${MULLE_SOURCETREE_ETC_DIR}/config.${MULLE_UNAME}" ]
         then
            exekutor touch "${MULLE_SOURCETREE_ETC_DIR}/config.${MULLE_UNAME}"
         fi
      ;;

      uname)
         printf "%s\n" "${MULLE_UNAME}"
      ;;

      sync|update)
         # shellcheck source=src/mulle-sourcetree-sync.sh
         include "sourcetree::sync"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         sourcetree::sync::main "$@"
      ;;

      test)
         # shellcheck source=src/mulle-sourcetree-test.sh
         include "sourcetree::test"         # shellcheck source=src/mulle-sourcetree-dotdump.sh

         sourcetree::test::main "$@"
      ;;

      version)
         printf "%s\n" "${MULLE_EXECUTABLE_VERSION}"
         return 0
      ;;

      "")
         sourcetree::usage "${MULLE_TRACE}"
      ;;

      *)
         log_error "${MULLE_EXECUTABLE_FAIL_PREFIX}: Unknown command \"${cmd}\""
         sourcetree::usage "${MULLE_TRACE}"
      ;;
   esac
}


call_with_flags "sourcetree::main" "${MULLE_SOURCETREE_FLAGS:-}" "$@"
rval=$?

if [ "${RUN_ZPROF}" = 'YES' ]
then
   zprof
fi

exit $rval