275 lines
6.1 KiB
Bash
275 lines
6.1 KiB
Bash
#!/bin/bash
|
|
|
|
# export BASH_DEBUG=true
|
|
module_load debug
|
|
module_load iecho
|
|
|
|
isFile() {
|
|
if [[ -f $1 ]]
|
|
then
|
|
echo "true"
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
build_file () {
|
|
# local file
|
|
# echo build file $1 $2
|
|
# todo merge no cr
|
|
[[ $1 == "-f" ]] && file=true && shift 1
|
|
[[ -f "$2" ]] || { iecho "output file $2 does not exist"; return 1; }
|
|
if [[ -f "$1" ]]; then
|
|
# echo adding file $1 to $2
|
|
[[ $file ]] && echo -e "\n####### ADDED $1 ########" >> $2
|
|
# remove comment lines, remove blank last line
|
|
cat "$1" | sed '/^\s*#/d' | sed '/^$/{:a;N;s/\n$//;ta}' >> $2
|
|
[[ ! $file ]] && echo -e "\n" >> $2
|
|
else iecho "no such file $1 to append to $2"
|
|
fi
|
|
}
|
|
|
|
# TODO need to test
|
|
function lines_2_str () {
|
|
[[ ! -f "$1" ]] && return 1
|
|
local str=''
|
|
# echo the lines: $lines >&2
|
|
# lines="$(cat "$1")"
|
|
while read line; do
|
|
[[ "$line" =~ ^[[:space:]]*# ]] && continue
|
|
# echo line: "${line}" >&2
|
|
str="$str ${line}"
|
|
# echo str: $str >&2
|
|
done < $1
|
|
# for line in $lines ; do
|
|
# str+='"'$line'" '
|
|
# done
|
|
echo $str
|
|
}
|
|
|
|
|
|
|
|
# find, superceeds find use `command find` to get the super
|
|
function _find () {
|
|
|
|
# BASH_DEBUG=find
|
|
|
|
# USAGE
|
|
# all option arguments that contain globs/wildcards must be quoted to avoid expansion
|
|
# f sets path and file excludes from a supplied file path
|
|
# all lines ending in / will be treated as directory names to ignore, otherwise files
|
|
# p option explictly excludes paths(directories)
|
|
# d option sets the directory depth which is current directy by default, 0 is all
|
|
# n inclucdes only file globs otherwise it's all except .files
|
|
# if no directory is given it will attempt to source the present working directory
|
|
# example:
|
|
# source_dir -p "archive" -e '"*.off" "*.md"' -d 0 # $DIR/$SUBDIR
|
|
local EXCLUDE_FILE
|
|
local PATHS
|
|
local NAMES
|
|
local ENAMES
|
|
local DEPTH=1
|
|
local HIDDEN
|
|
local raw
|
|
local mounted
|
|
local usesudo
|
|
|
|
mounted="-mount"
|
|
|
|
declare OPTION
|
|
declare OPTARG
|
|
declare OPTIND
|
|
|
|
while getopts 'mrst:p:d:e:n:f:hl' OPTION; do
|
|
case "$OPTION" in
|
|
s)
|
|
usesudo=sudo
|
|
;;
|
|
r)
|
|
raw=true
|
|
;;
|
|
t)
|
|
TYPE=$OPTARG
|
|
# echo "TYPE $TYPE"
|
|
;;
|
|
f)
|
|
EXCLUDE_FILE=$OPTARG
|
|
# echo EXCLUDE FILE $EXCLUDE_FILE >&2
|
|
;;
|
|
p)
|
|
# PATHS=("$OPTARG")
|
|
IFS=',' read -r -a PATHS <<< "$OPTARG"
|
|
# echo EXCLUDING THESE PATHS ${PATHS[*]}
|
|
;;
|
|
e)
|
|
IFS=',' read -r -a ENAMES <<< "${OPTARG}"
|
|
# echo EXCLUDING THESE FILE NAMES ${ENAMES[*]}
|
|
;;
|
|
n)
|
|
# NAMES=("$OPTARG")
|
|
IFS=',' read -r -a NAMES <<< "${OPTARG}"
|
|
# NAMES=$OPTARG
|
|
;;
|
|
d)
|
|
DEPTH=$OPTARG
|
|
# echo "SOURCING TO DEPTH (0=any)" "$DEPTH"
|
|
;;
|
|
h)
|
|
HIDDEN=true
|
|
# echo "SOURCING TO DEPTH (0=any)" "$DEPTH"
|
|
;;
|
|
|
|
l)
|
|
LINKS=-L
|
|
;;
|
|
m)
|
|
# include mounted directories
|
|
mounted=""
|
|
;;
|
|
*)
|
|
echo unknown option $OPTION
|
|
;;
|
|
esac
|
|
done
|
|
|
|
shift $(( OPTIND - 1 ))
|
|
|
|
if [[ $raw ]]; then
|
|
echo executing raw find command
|
|
$usesudo $(which find) "$@"
|
|
fi
|
|
|
|
local DIR
|
|
DIR="$*"
|
|
if [ ! "$DIR" ]; then
|
|
if [ -v PS1 ]; then
|
|
echo no directory provided to search
|
|
echo searching present working directory $(pwd)
|
|
read -p "Do you want to continue? " -n 1 -r
|
|
[[ $REPLY =~ ^[Yy]$ ]] && DIR=$(pwd) || return 1
|
|
else
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
[ ! -d "$DIR" ] && echo " directory $DIR does not exist, aborting" && return 1
|
|
|
|
# echo dir $DIR
|
|
|
|
local FIND
|
|
FIND="$usesudo $(which find) $LINKS $DIR"
|
|
FIND+=$([ ! $DEPTH == 0 ] && echo " -maxdepth $DEPTH ")
|
|
# FIND+=" -type $([ $TYPE ] && echo "$TYPE" || echo "f")"
|
|
TYPE=${TYPE:-f}
|
|
debug exclude mounts: $mounted
|
|
FIND+=" $mounted -type $TYPE "
|
|
# include HIDDEN files and directories IS FALSE BY DEFULT
|
|
[[ ! $HIDDEN ]] && FIND+="! -path \"*/.*/*\" ! -name \".*\" "
|
|
|
|
local name
|
|
local path
|
|
|
|
if [[ -f $EXCLUDE_FILE ]]; then
|
|
local ignores=$(lines_2_str "$EXCLUDE_FILE")
|
|
# echo ignores: $ignores >&2
|
|
for exclude in $ignores ; do
|
|
# echo exclude: ${exclude} >&2
|
|
[[ "$exclude" == */ ]] && PATHS+=("${exclude::-1}") || ENAMES+=("$exclude")
|
|
done
|
|
fi
|
|
|
|
# echo paths ${PATHS[@]} >&2
|
|
# echo exclude names ${ENAMES[@]} >&2
|
|
|
|
set -o noglob
|
|
|
|
if [[ ${PATHS[0]} ]]; then
|
|
for path in ${PATHS[@]}; do
|
|
# echo excluding $path
|
|
FIND+=$(echo ' ! -path "*/'$path'/*"')
|
|
done
|
|
fi
|
|
|
|
if [[ ${ENAMES[0]} ]]; then
|
|
for name in ${ENAMES[@]}; do
|
|
debug excluding name "$name"
|
|
FIND+=$(echo ' ! -name '$name'')
|
|
done
|
|
fi
|
|
|
|
debug "INCLUDING ONLY THESE FILE NAMES ${NAMES[*]}"
|
|
if [[ ${NAMES[0]} ]]; then
|
|
for name in "${NAMES[@]}"; do
|
|
debug only finding $name
|
|
FIND+=$(echo " -name '${name}'")
|
|
done
|
|
fi
|
|
|
|
# if [[ $NAMES ]]; then
|
|
# debug names for find command $NAMES
|
|
# for name in $NAMES; do
|
|
# debug "xxonly finding '$name'"
|
|
# FIND+=$(set -o noglob;echo " -name '${name}'")
|
|
# done
|
|
# fi
|
|
|
|
# echo
|
|
# echo find dir: $DIR >&2
|
|
debug "find command: $FIND"
|
|
set +o noglob
|
|
local FILES
|
|
FILES=$(eval $FIND | sort)
|
|
[[ $FILES ]] && echo $FILES
|
|
return 0
|
|
}
|
|
|
|
source_dir () {
|
|
# BASH_DEBUG=source_dir
|
|
|
|
debug source_dir passed arguments: $*
|
|
debug function: source_dir
|
|
local FILES
|
|
FILES=$(_find -l "$@") # find function
|
|
# echo $FILES >&2
|
|
[[ $? -ne 0 ]] && return 1
|
|
for f in $FILES; do
|
|
debug sourcing: $f >&2
|
|
source "$f"
|
|
done
|
|
|
|
}
|
|
|
|
|
|
prepend_file () {
|
|
# ----------------------------------------------------------------------------------------------------------------------
|
|
# usage prepend_file <somefile> <anotherfile>
|
|
# ----------------------------------------------------------------------------------------------------------------------
|
|
# Prepend the contents of <somefile> [$1], to <anotherfile> [$2], leaving the result in <anotherfile> [$2].
|
|
# insert a newline at the end of <somefile> [$1] if necessary
|
|
# ----------------------------------------------------------------------------------------------------------------------
|
|
|
|
# check # echo $1 $2
|
|
[[ -f $1 ]] || return 1
|
|
[[ -f $2 ]] || return 2
|
|
# init
|
|
tmp_fn=$( mktemp -t TEMP_FILE_prepend.XXXXXXXX )
|
|
chmod 600 "$tmp_fn"
|
|
\cp $1 $tmp_fn
|
|
sed -i '$a\' $tmp_fn
|
|
cat $2 >> $tmp_fn
|
|
\mv "$tmp_fn" "$2"
|
|
# cleanup
|
|
rm -f "$tmp_fn"
|
|
return 0
|
|
|
|
# [End]
|
|
}
|
|
|
|
|
|
# alias to add for live user
|
|
if [ -v PS1 ]; then
|
|
alias dfind="_find -t d -d 0 -n "
|
|
alias sdfind="_find -s -t d -d 0 -n "
|
|
fi
|