args2array

#!/bin/bash

[[ ${__ARGS_LOADED__} -eq 1 ]] && return 0
export __ARGS_LOADED__=1

source /usr/local/lib/backUP/logging

validate_option() {
	# return 0 if option is valid and requires 1 or more arguments
	# return 1 if option is valid and requires exactly 1 argument
	# return 2 if option is valid and requires 0 arguments
	# return 3 if option is invalid

	local opt="$1"		# option to search for
	local lgth=${#opt}

	local goffset 
	if [[ $lgth -eq 1 ]]; then
		# opt is short
		local optstr=$SMOL_OPTS
		goffset=${optstr%%$opt*}
		goffset=${#goffset}
		if [[ $goffset -lt ${#optstr} ]]; then
			# a match was found
			if [[ "${optstr:$(( goffset + lgth )):1}" == ":" ]]; then
				# the option requires 1 or more arguments
				return 0
			elif [[ "${optstr:$(( goffset + lgth )):1}" == "!" ]]; then
				# the option requires exactly 1 argument
				return 1
			else
				return 2
			fi
		fi
	else # opt is long
		local optstr="$LONG_OPTS"
		local lastchar="${optstr: -1}"
		local firstchar="${optstr:0:1}"
	
		[[ "$firstchar" != "," ]] && optstr=",$optstr"
		[[ "$lastchar" != "," ]] && optstr="${optstr},"
	
		local -a fullstring_matches=(",${opt}," ",${opt}:," ",${opt}!,")
		
		local match
		for match in "${fullstring_matches[@]}"	; do
			goffset=${optstr%%$match*}
			goffset=${#goffset}
	
			if [[ $goffset -lt ${#optstr} ]]; then
				# a match was found
				if [[ "${match: -2:1}" == ":" ]]; then
					# the option requires one or more arguments
					return 0
				elif [[ "${match: -2:1}" == "!" ]]; then
					# the option requires exactly one argument
					return 1
				else
					# the option does not require any arguments
					return 2
				fi
			fi
		done
	fi
	return 3
}

expand_options() {
	declare -n _opts=$1
	
	local cmpd="$2"
	cmpd="${cmpd//-/}"
	_opts=()
	local i

	for (( i = 0; i < ${#cmpd}; i++ )); do
		validate_option "${cmpd:$i:1}"
		case "$?" in
			0 | 1 ) _opts+=("-${cmpd:i:1}" "${cmpd:i+1}")
					return 0
					;;
			2 ) _opts=("-${cmpd:i:1}" "${_opts[@]}")
				;;
			3 ) ecrit "option '-${cmpd:i:1}' is invalid."
				exit 3
				;;
		esac
	done
}

args2array() {
	declare -n __arr=$1 && shift
	
	local __exitcode __ctr=0 __i __exitcode __opt __temp

	while (( $# > 0 )); do	
		etrace "first positional is '$1'"
		if [[ ${1:0:1} == "-" ]]; then
			# we're working with an option
			if [[ ! "${1:1:1}" == "-" && ${#1} > 2 ]]; then
			# interpret parameter as concatenated
				expand_options __temp "${1//-/}"
				shift
				set -- "${__temp[@]}" "$@"
				continue
			elif [[ "${1:0:2}" == "--" && -n "${1//[^=]/}" ]]; then
				__temp="$1"
				shift
				set -- "${__temp%=*}" "${__temp#*=}" "$@"
			fi
			__opt=${1//-/}
			if [[ ${#__opt} -gt 1 ]]; then
				__opt=${1#'--'}
			else
				__opt=${1#'-'}
			fi
			etrace "searching optstrings for '$__opt'"
			validate_option "$__opt"
			__exitcode=$?
			if [[ $__exitcode -gt 2 ]]; then
				ecrit "option '$1' is not a valid option"
				exit $__exitcode
			else
				__ctr=0
				edumpvar __opt __arr[$__opt]
				if [[ $__exitcode -eq 0 ]]; then
					# option requires one or more arguments
					for __i in "${@:2}"; do
						if [[ ${__i:0:1} == "-" ]]; then
							break
						else
							if [[ ! ${__arr[$__opt]+isset} ]]; then
								__arr[$__opt]="${__i}"
							else
								__arr[$__opt]="${__arr[$__opt]};${__i}"
							fi
							etrace "appending: '$__i' ' to __arr[$__opt] which is now '${__arr[$__opt]}'"
							(( __ctr++ ))
						fi
					done
					if [[ $__ctr -eq 0 ]]; then
						ecrit "option '$1' requires an argument"
						exit 1
					fi
				elif [[ $__exitcode -eq 1 ]]; then
					# option requires exactly one argument
					if [[ ! ${__arr[$__opt]+isset} && -n "$2" && ${2:0:1} != "-" ]]; then
						# at least one parameter was passed
						if	[[ -z "$3" || "${3:0:1}" == "-" ]]; then
							# at most one parameter was passed
							 __arr[$__opt]="$2"
							__ctr=1
						else
							# too many arguments passed, no bueno
							ecrit "option '$1' takes exactly one argument"
							exit 5
						fi
					else
						# not enough arguments passed, no bueno
						ecrit "option '$1' takes exactly one argument"
						exit 5
					fi
				else
					# option does not accept any arguments
					if [[ -n "$2" && ${2:0:1} != "-" ]]; then
						# too many arguments passed to the option
						ecrit "option '$1' does not take any argument"
						exit 5
					else
						__arr[$__opt]=""
					fi
				fi
				edumpvar __opt __arr[$__opt]
				# all 3 blocks require a shift because each corresponds to a valid option which should be removed
				shift $(( __ctr + 1 ))
			fi
		else
			shift # ignore every option not starting with -
				  # can maybe (but not likely) be changed in the future for some sort of positional arguments...
		fi
	done
}

unpack_args() {
	declare -n _a=$1	# xD
	local _pld=$2
	local IFS=';'
	_a=($_pld)
}

# UNCOMMENT these lines and run the examples below for usage
# OUTPUT, RETURN CODES, CORE FUNCTIONS HAVE ALL CHANGED SINCE
# THESE EXAMPLES WERE COPIED, IT WILL PROBABLY CHANGE AGAIN...
# ---------------------------------------------------------------------

# SMOL_OPTS="a:b!c"    # NOT comma separated, : denotes mandatory argument
# LONG_OPTS="alpha!,beta:,gamma" # comma separated, : denotes mandatory argument

# declare -A associative_array # must be declared BEFORE function call

# args2array associative_array "$@"

# Print the key=value pairs
# for key in "${!associative_array[@]}"; do
#	printf "%s=%s\n" "$key" "'${associative_array[$key]% }'"
# done

# -----------------------------------------------------------------------
# EXAMPLE-1 USAGE 

# $ args2array -a arg-1 arg\ 2 "arg 3" --alpha --beta arg -a arg-4 -b
# beta=''arg''
# alpha=''
# b=''
# a=''arg-1' 'arg 2' 'arg 3' 'arg-4''

# $ echo $?
# 0

# -----------------------------------------------------------------------
# EXAMPLE-2 USAGE

# $ args2array -a arg-1 -f
# error: option '-f' is not a valid option

# $ echo $?
# 2

# -----------------------------------------------------------------------
# EXAMPLE-3 USAGE

# $ args2array -a
# error: option '-a' requires an argument

# $ echo $?
# 1

# ------------------------------------------------------------------------
# EXAMPLE-4 USAGE

# $ args2array --beta
# error: option '--beta' requires an argument

# echo $?
# 1

# ------------------------------------------------------------------------