yash 2.35-2 / usr / share / yash / completion / svn

# (C) 2011-2012 magicant

# Completion script for the "svn" command.
# Supports Subversion 1.7.

function completion/svn {

	typeset OPTIONS COMMONOPTIONS ADDOPTIONS ARGOPT PREFIX
	COMMONOPTIONS=( #>#
	"--config-dir:; specify a directory containing configuration files"
	"--config-option:; specify a configuration option"
	"h ? --help; print help"
	"--no-auth-cache; don't cache user name and password"
	"--non-interactive; disable interactive prompt"
	"--password:; specify a password for authentication"
	"--trust-server-cert; accept suspicious SSL server certificate"
	"--username:; specify a user name for authentication"
	) #<#
	ADDOPTIONS=( #>#
	"--accept:; specify an action for conflict resolution"
	"--allow-mixed-revisions" # not documented as not recommended
	"--auto-props; enable automatic property setting"
	"c: --change:; specify a change (revision)"
	"--changelist: --cl:; specify a changelist to operate on"
	"--depth:; specify directory depth to operate on"
	"--diff; show diff"
	"--diff-cmd:; specify an external program to be used as \"diff\""
	"--diff3-cmd:; specify an external program to be used as \"diff3\""
	"--dry-run; don't make any actual changes"
	"--editor-cmd:; specify an external program to be used as an editor"
	"--encoding:; specify the encoding of the log message"
	"x: --extensions:; specify arguments that is passed to the external diff command"
	"F: --file:; use the specified file's contents instead of invoking an editor"
	"--force; force operation to run"
	"--force-log; accept a suspicious parameter value for log messages"
	"--git; print in Git-like format"
	"--ignore-ancestry; ignore ancestry when calculating differences"
	"--ignore-externals; ignore externals and its working copies"
	"--ignore-whitespace; tolerate whitespace mismatches"
	"--incremental; print output in a format suitable for concatenation"
	"--keep-changelists; don't delete changelists after committing"
	"--keep-local; keep the local working copy"
	"l: --limit:; specify the number of log messages to be shown"
	"m: --message:; specify a log message"
	"--native-eol:; specify an end-of-line marker for native EOL settings"
	"--new:; specify the newer one of the compared files"
	"--no-auto-props; disable automatic property setting"
	"--no-diff-deleted; don't print diff for deleted files"
	"--no-ignore; don't ignore files"
	"--no-unlock; don't unlock files after committing"
	#deprecated "N --non-recursive"
	"--notice-ancestry; take ancestry into account when making a diff"
	"--old:; specify the older one of the compared files"
	"--parents; create nonexistent parent directories"
	"q --quiet; print essential information only"
	"--record-only; update mergeinfo without actually merging files"
	"R --recursive; operate on subdirectories recursively"
	"--reintegrate; merge a branch into the trunk"
	"--relocate; change the location of the repository"
	"--remove; remove files from a changelist"
	"--reverse-diff; patch in reverse"
	"r: --revision:; specify a revision or a revision range"
	"--revprop; operate on a revision property rather than a file property"
	"--set-depth:; specify a new sticky depth of working directories"
	"--show-copies-as-adds; treat copied files as newly added"
	"--show-revs:; specify the type of mergeinfo to print"
	"--show-updates; show which files will be updated by \"svn update\""
	"--stop-on-copy; operate on revisions after the file was copied last"
	"--strict; output the raw value without pretty-formatting"
	"--strip:; specify the number of pathname components to strip from file names"
	"--summarize; print a summary of changes only"
	"--targets:; specify a file containing target paths"
	"g --use-merge-history; use mergeinfo to show history before merges"
	"v --verbose; print additional info"
	"--version"
	"--with-all-revprops; include all revision properties"
	"--with-no-revprops; include no revision properties"
	"--with-revprop:; specify a revision property to set or print"
	"--xml; print in the XML format"
	) #<#
	OPTIONS=("$COMMONOPTIONS" "$ADDOPTIONS")

	command -f completion//parseoptions -es

	# find subcommand name
	typeset SUBCMD= separatorindex=2
	while [ $separatorindex -lt ${WORDS[#]} ]; do
		case ${WORDS[separatorindex]} in (--)
			SUBCMD=${WORDS[separatorindex+1]}
			break
		esac
		separatorindex=$((separatorindex+1))
	done

	# normalize subcommand name
	case $SUBCMD in
		(praise|annotate|ann)
			SUBCMD=blame;;
		(cl)
			SUBCMD=changelist;;
		(co)
			SUBCMD=checkout;;
		(ci)
			SUBCMD=commit;;
		(cp)
			SUBCMD=copy;;
		(del|remove|rm)
			SUBCMD=delete;;
		(di)
			SUBCMD=diff;;
		(h|\?)
			SUBCMD=help;;
		(ls)
			SUBCMD=list;;
		(mv|rename|ren)
			SUBCMD=move;;
		(pdel|pd)
			SUBCMD=propdel;;
		(pedit|pe)
			SUBCMD=propedit;;
		(pget|pg)
			SUBCMD=propget;;
		(plist|pl)
			SUBCMD=proplist;;
		(pset|ps)
			SUBCMD=propset;;
		(stat|st)
			SUBCMD=status;;
		(sw)
			SUBCMD=switch;;
		(up)
			SUBCMD=update;;
	esac

	case $ARGOPT in
	(-)
		OPTIONS=("$COMMONOPTIONS")
		if command -vf "completion/svn::$SUBCMD:opt" >/dev/null 2>&1; then
			command -f "completion/svn::$SUBCMD:opt"
		fi
		command -f completion//completeoptions
		;;
	(--accept) #>>#
		complete -P "$PREFIX" -D "discard all local and remote changes" base
		complete -P "$PREFIX" -D "discard all remote changes" mine-full
		complete -P "$PREFIX" -D "resolve conflicts by discarding remote changes" mine-conflict
		complete -P "$PREFIX" -D "discard all local changes" theirs-full
		complete -P "$PREFIX" -D "resolve conflicts by discarding local changes" theirs-conflict
		complete -P "$PREFIX" -D "mark the current working copy as resolved" working
		case $SUBCMD in
			(resolve)
				;;
			(*)
				complete -P "$PREFIX" -D "launch an editor to merge by hand" edit
				complete -P "$PREFIX" -D "launch a predefined external program" launch
				complete -P "$PREFIX" -D "leave the conflict unresolved" postpone
				;;
		esac
		;; #<<#
#	(c|--change)
#		;;
	(--changelist|--cl)
		command -f completion/svn::completechangelist
		;;
	(--config-dir)
		complete -P "$PREFIX" -S / -T -d
		;;
	(--config-option)
		#TODO
		;;
	(--depth|--set-depth) #>>#
		complete -P "$PREFIX" -D "only the target itself" empty
		complete -P "$PREFIX" -D "the target and non-directory immediate children" files
		complete -P "$PREFIX" -D "the target and immediate children" immediates
		complete -P "$PREFIX" -D "the target and all of its descendants" infinity
		#<<#
		case $ARGOPT in (--set-depth) #>>#
			complete -P "$PREFIX" -D "exclude the target from the parent" exclude
		esac #<<#
		;;
	(--encoding)
		#TODO
		;;
	(x|--extensions)
		WORDS=(diff)
		command -f completion//reexecute
		;;
	(F|--file)
		complete -P "$PREFIX" -f
		;;
#	(l|--limit)
#		;;
#	(m|--message)
#		;;
#	(--password)
#		;;
	(--native-eol) #>>#
		complete -P "$PREFIX" LF CR CRLF
		;; #<<#
	(--new|--old)
		command -f completion/svn::completelocal -cm
		command -f completion/svn::completeurl
		;;
	(r|--revision)
		typeset word="${TARGETWORD#"$PREFIX"}"
		PREFIX="${TARGETWORD%"${word#*:}"}"
		#>>#
		complete -P "$PREFIX" -D "the latest revision in the repository" HEAD
		complete -P "$PREFIX" -D "the revision you checked out" BASE
		complete -P "$PREFIX" -D "the latest revision in which a change was made" COMMITTED
		complete -P "$PREFIX" -D "the revision immediately before COMMITTED" PREV
		;; #<<#
	(--show-revs) #>>#
		complete -P "$PREFIX" -D "info about merges already performed" merged
		complete -P "$PREFIX" -D "info about possible merges that can be performed" eligible
		;; #<<#
	(--target)
		complete -P "$PREFIX" -f
		;;
	(--username)
		complete -P "$PREFIX" -u
		;;
	(--with-revprop)
		#TODO
		;;
	(--*-cmd)
		WORDS=()
		command -f completion//reexecute -e
		;;
	('')
		if [ $separatorindex -eq ${WORDS[#]} ] ||
				command -f completion/svn::containshelp; then
			command -f completion/svn::completesubcmd
		else
			if command -vf "completion/svn::$SUBCMD:arg" >/dev/null 2>&1; then
				command -f "completion/svn::$SUBCMD:arg"
			fi
		fi
		;;
	esac

}

function completion/svn::containshelp {
	typeset opt
	for opt in "${WORDS[2,separatorindex-1]}"; do
		case $opt in (--help|-[h\?])
			return 0
		esac
	done
	return 1
}

function completion/svn::setoptions {
	typeset opt i=1
	for opt in "$ADDOPTIONS"; do
		if [ $# -le 0 ]; then
			break
		fi
		case " ${{opt%%;*}//:} " in (*" --$1 "*)
			OPTIONS=("$OPTIONS" "$opt")
			shift
		esac
	done
}

function completion/svn::completesubcmd {
	complete -P "$PREFIX" -D "add files for versioning" add
	complete -P "$PREFIX" -D "show files with author and revision info" blame praise annotate
	complete -P "$PREFIX" -D "print the contents of files" cat
	complete -P "$PREFIX" -D "put files into a changelist" changelist cl
	complete -P "$PREFIX" -D "check out a working copy from a repository" checkout co
	complete -P "$PREFIX" -D "resolve file locks and unfinished operations" cleanup
	complete -P "$PREFIX" -D "make a new revision in the repository" commit ci
	complete -P "$PREFIX" -D "copy a file" copy cp
	complete -P "$PREFIX" -D "delete files" delete remove rm
	complete -P "$PREFIX" -D "print differences between two files or revisions" diff
	complete -P "$PREFIX" -D "make a copy of the versioned directory tree" export
	complete -P "$PREFIX" -D "print usage of subcommands" help
	complete -P "$PREFIX" -D "commit new files into the repository" import
	complete -P "$PREFIX" -D "print info about versioned files" info
	complete -P "$PREFIX" -D "print a list of versioned files" list ls
	complete -P "$PREFIX" -D "lock files in the repository" lock
	complete -P "$PREFIX" -D "print commit log messages" log
	complete -P "$PREFIX" -D "apply changes between two files or revisions" merge
	complete -P "$PREFIX" -D "print info about merge" mergeinfo
	complete -P "$PREFIX" -D "make directories" mkdir
	complete -P "$PREFIX" -D "move files" move mv
	complete -P "$PREFIX" -D "apply a patch" patch
	complete -P "$PREFIX" -D "delete a property of files" propdel pdel
	complete -P "$PREFIX" -D "edit a property of files" propedit pedit
	complete -P "$PREFIX" -D "print a property of files" propget pget
	complete -P "$PREFIX" -D "print properties of files" proplist plist
	complete -P "$PREFIX" -D "set a property of files" propset pset
	complete -P "$PREFIX" -D "change the repository root URL" relocate
	complete -P "$PREFIX" -D "resolve conflicts" resolve
	# deprecated: complete -P "$PREFIX" -D "" resolved
	complete -P "$PREFIX" -D "undo local edits" revert
	complete -P "$PREFIX" -D "print the status of working copy" status
	complete -P "$PREFIX" -D "update working copy to a different URL" switch
	complete -P "$PREFIX" -D "unlock files in the repository" unlock
	complete -P "$PREFIX" -D "update the working copy" update
	complete -P "$PREFIX" -D "upgrade the working copy format" upgrade
}

function completion/svn::completeurl {
	typeset OPTIND=1 opt dironly=false
	while getopts d opt; do
		case $opt in
			(d) dironly=true;;
		esac
	done

	typeset target="${TARGETWORD#"$PREFIX"}"
	case $target in
		(?*://* | ^/*) ;;
		(*)            return ;;
	esac
	typeset targetdir="$(dirname -- "$target"X)"

	typeset file prefix="${TARGETWORD%"${TARGETWORD##*/}"}"
	while read -r file; do
		case $file in
			(*/)
				complete -P "$prefix" -T -- "$file"
				;;
			(*) 
				if ! $dironly; then
					complete -P "$prefix" -- "$file"
				fi
				;;
		esac
	done <(svn --non-interactive ls -- "${targetdir}/" 2>/dev/null)
}

function completion/svn::completelocal {
	typeset OPTIND=1 opt clean= modified= unversioned=
	while getopts cmu opt; do
		case $opt in
			(c) clean=true;;
			(m) modified=true;;
			(u) unversioned=true;;
		esac
	done

	complete -P "$PREFIX" -S / -T -d

	case "$clean-$modified-$unversioned" in
		(true-true-true)
			complete -P "$PREFIX" -f
			return
			;;
		(--)
			return
			;;
	esac

	typeset target="${TARGETWORD#"$PREFIX"}"
	typeset targetdir="$(dirname -- "$target"X)"

	if ! command -f completion/svn::isworkingdir "$targetdir"; then
		if [ "$unversioned" ]; then
			complete -P "$PREFIX" -f
		fi
		return
	fi

	typeset path prefix opt
	while read -r path; do
		if [ "$path" -ef "$targetdir" ]; then
			continue
		fi
		case $target in
			(*/*) prefix="$PREFIX${target%/*}/" ;;
			(*)   prefix="$PREFIX" ;;
		esac
		complete -P "$prefix" -- "${path##*/}"
	done 2>/dev/null <(
		if [ "$unversioned" ]; then
			svn st --depth=files --no-ignore -- "$targetdir" |
			grep '^[?I]' |
			cut -c 9-
		fi
		if [ "$clean$modified" ]; then
			case $clean-$modified in
				(true-true) regex='^[^?I]';;
				(true-    ) regex='^  ';;
				(    -true) regex='^[^ ?I]|^.[^ ]';;
			esac
			svn st -v --depth=files -- "$targetdir" |
			grep -E "$regex" |
			cut -c 10- |
			while read -r _ _ _ file; do
				printf '%s\n' "$file"
			done
		fi
	)
	# XXX should honor the dotglob option
}

function completion/svn::completepropname { #>>#
	complete -P "$PREFIX" -D "make the file executable" svn:executable
	complete -P "$PREFIX" -D "specify the file's MIME type" svn:mime-type
	complete -P "$PREFIX" -D "specify unversioned filenames not listed in status" svn:ignore
	complete -P "$PREFIX" -D "specify keywords substituted in file" svn:keywords
	complete -P "$PREFIX" -D "specify how end-of-line markers are manipulated" svn:eol-style
	complete -P "$PREFIX" -D "specify external paths and repositories" svn:externals
	complete -P "$PREFIX" -D "indicate that the file is not a regular file" svn:special
	complete -P "$PREFIX" -D "disable editing without lock" svn:needs-lock
	complete -P "$PREFIX" -D "info about merge" svn:mergeinfo
} #<<#

function completion/svn::completechangelist {
	typeset changelist
	while read -r changelist; do
		changelist=${changelist%\':}
		changelist=${changelist##*\'}
		complete -P "$PREFIX" "$changelist"
	done 2>/dev/null <(svn status | grep "^--- .*'.*':\$")
}

function completion/svn::isworkingdir (
	cd -P -- "$1" 2>/dev/null &&
	until [ -d .svn ]; do
		if [ . -ef .. ] || [ . -ef / ]; then
			return 1
		fi
		cd -P ..
	done
)

function completion/svn:::opt {
	command -f completion/svn::setoptions version
}

function completion/svn::add:opt {
	command -f completion/svn::setoptions \
		auto-props depth force no-auto-props no-ignore parents quiet \
		targets
}

function completion/svn::add:arg {
	command -f completion/svn::completelocal -u
}

function completion/svn::blame:opt {
	command -f completion/svn::setoptions \
		extensions force incremental revision use-merge-history \
		verbose xml
}

function completion/svn::blame:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::cat:opt {
	command -f completion/svn::setoptions revision
}

function completion/svn::cat:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::changelist:opt {
	command -f completion/svn::setoptions \
		changelist depth quiet recursive remove targets
}

function completion/svn::changelist:arg {
	typeset i=2 remove=false
	while [ $i -lt $separatorindex ]; do
		case ${WORDS[i]} in
			(--remove) remove=true;;
		esac
		i=$((i+1))
	done
	if ! $remove && [ $(($separatorindex+1)) -eq ${WORDS[#]} ]; then
		command -f completion/svn::completechangelist
	else
		command -f completion/svn::completelocal -cm
	fi
}

function completion/svn::checkout:opt {
	command -f completion/svn::setoptions \
		depth force ignore-externals quiet revision
}

function completion/svn::checkout:arg {
	command -f completion/svn::completeurl
	if [ $(($separatorindex+1)) -lt ${WORDS[#]} ]; then
		complete -P "$PREFIX" -f
	fi
}

function completion/svn::cleanup:opt {
	command -f completion/svn::setoptions diff3-cmd
}

function completion/svn::cleanup:arg {
	complete -P "$PREFIX" -S / -T -d
}

function completion/svn::commit:opt {
	command -f completion/svn::setoptions \
		changelist depth editor-cmd encoding file force-log \
		kee-changelists message no-unlock quiet targets with-revprop
}

function completion/svn::commit:arg {
	command -f completion/svn::completelocal -m
}

function completion/svn::copy:opt {
	command -f completion/svn::setoptions \
		editor-cmd encoding file force-log ignore-externals message \
		parents quiet revision with-revprop
}

function completion/svn::copy:arg {
	command -f completion/svn::completelocal -cmu
	command -f completion/svn::completeurl
}

function completion/svn::delete:opt {
	command -f completion/svn::setoptions \
		editor-cmd encoding file force force-log keep-local \
		message quiet targets with-revprop
}

function completion/svn::delete:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::diff:opt {
	command -f completion/svn::setoptions \
		change changelist depth diff-cmd extensions force git new \
		no-diff-deleted notice-ancestry old revision \
		show-copies-as-adds summarize xml
}

function completion/svn::diff:arg {
	# XXX should be relative to the argument of --old=...
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::export:opt {
	command -f completion/svn::setoptions \
		depth force ignore-externals native-eol quiet revision
}

function completion/svn::export:arg {
	case $((${WORDS[#]} - $separatorindex)) in
		(1)
			command -f completion/svn::completelocal -cm
			command -f completion/svn::completeurl
			;;
		(2)
			complete -P "$PREFIX" -f
			;;
	esac
}

function completion/svn::help:opt {
}

function completion/svn::help:arg {
	command -f completion/svn::completesubcmd
}

function completion/svn::import:opt {
	command -f completion/svn::setoptions \
		auto-props depth editor-cmd encoding file force force-log \
		message no-auto-props no-ignore quiet with-revprop
}

function completion/svn::import:arg {
	case $((${WORDS[#]} - $separatorindex)) in
		(1)
			command -f completion/svn::completelocal -u
			;;
		(2)
			command -f completion/svn::completeurl
			;;
	esac
}

function completion/svn::info:opt {
	command -f completion/svn::setoptions \
		changelist depth incremental recursive revision targets xml
}

function completion/svn::info:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::list:opt {
	command -f completion/svn::setoptions \
		depth incremental recursive revision verbose xml
}

function completion/svn::list:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::lock:opt {
	command -f completion/svn::setoptions \
		encoding file force force-log message targets
}

function completion/svn::lock:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::log:opt {
	command -f completion/svn::setoptions \
		change incremental limit quiet revision stop-on-copy targets \
		use-merge-history verbose with-all-revprops with-no-revprops \
		with-revprop xml
}

function completion/svn::log:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::merge:opt {
	command -f completion/svn::setoptions \
		accept allow-mixed-revisions change depth diff3-cmd dry-run \
		extensions force ignore-ancestry quiet record-only reintegrate \
		revision
}

function completion/svn::merge:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::mergeinfo:opt {
	command -f completion/svn::setoptions revision show-revs
}

function completion/svn::mergeinfo:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::mkdir:opt {
	command -f completion/svn::setoptions editor-cmd encoding file \
		force-log message parents quiet with-revprop
}

function completion/svn::mkdir:arg {
	complete -P "$PREFIX" -S / -T -d
	command -f completion/svn::completeurl -d
}

function completion/svn::move:opt {
	command -f completion/svn::setoptions editor-cmd encoding file force \
		force-log message parents quiet revision with-revprop
}

function completion/svn::move:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::patch:opt {
	command -f completion/svn::setoptions \
		dry-run ignore-whitespace quiet reverse-diff strip
}

function completion/svn::patch:arg {
	if [ $(($separatorindex+1)) -eq ${WORDS[#]} ]; then
		complete -P "$PREFIX" -f
	else
		complete -P "$PREFIX" -S / -T -d
	fi
}

function completion/svn::propdel:opt {
	command -f completion/svn::setoptions \
		changelist depth quiet recursive revision revprop
}

function completion/svn::propdel:arg {
	if [ $(($separatorindex+1)) -eq ${WORDS[#]} ]; then
		command -f completion/svn::completepropname
	else
		command -f completion/svn::completelocal -cm
		command -f completion/svn::completeurl
	fi
}

function completion/svn::propedit:opt {
	command -f completion/svn::setoptions editor-cmd encoding file force \
		force-log message revision revprop with-revprop
}

function completion/svn::propedit:arg {
	if [ $(($separatorindex+1)) -eq ${WORDS[#]} ]; then
		command -f completion/svn::completepropname
	else
		command -f completion/svn::completelocal -cm
		command -f completion/svn::completeurl
	fi
}

function completion/svn::propget:opt {
	command -f completion/svn::setoptions \
		changelist depth recursive revision revprop strict verbose xml
}

function completion/svn::propget:arg {
	if [ $(($separatorindex+1)) -eq ${WORDS[#]} ]; then
		command -f completion/svn::completepropname
	else
		command -f completion/svn::completelocal -cm
		command -f completion/svn::completeurl
	fi
}

function completion/svn::proplist:opt {
	command -f completion/svn::setoptions \
		changelist depth quiet recursive revision revprop verbose xml
}

function completion/svn::proplist:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::propset:opt {
	command -f completion/svn::setoptions changelist depth encoding file \
		force quiet recursive revision revprop targets
}

function completion/svn::propset:arg {
	typeset i=2 hasfile=false
	while [ $i -lt $separatorindex ]; do
		case ${WORDS[i]} in
			(--file=*|-F*) hasfile=true;;
		esac
		i=$((i+1))
	done
	if [ $(($separatorindex+1)) -eq ${WORDS[#]} ]; then
		command -f completion/svn::completepropname
	elif ! $hasfile && [ $(($separatorindex+2)) -eq ${WORDS[#]} ]; then 
		# there is no completion for a property value
	else
		command -f completion/svn::completelocal -cm
		command -f completion/svn::completeurl
	fi
}

function completion/svn::relocate:opt {
	command -f completion/svn::setoptions ignore-externals
}

function completion/svn::relocate:arg {
	command -f completion/svn::switch:arg "$@"
}

function completion/svn::resolve:opt {
	command -f completion/svn::setoptions \
		accept depth quiet recursive targets
}

function completion/svn::resolve:arg {
	command -f completion/svn::completelocal -cm
}

function completion/svn::resolved:opt {
	command -f completion/svn::setoptions \
		depth quiet recursive targets
}

function completion/svn::resolved:arg {
	command -f completion/svn::completelocal -cm
}

function completion/svn::revert:opt {
	command -f completion/svn::setoptions \
		changelist depth quiet recursive targets
}

function completion/svn::revert:arg {
	command -f completion/svn::completelocal -m
}

function completion/svn::status:opt {
	command -f completion/svn::setoptions \
		changelist depth ignore-externals incremental no-ignore quiet \
		show-updates verbose xml
}

function completion/svn::status:arg {
	command -f completion/svn::completelocal -cm
}

function completion/svn::switch:opt {
	command -f completion/svn::setoptions \
		accept depth diff3-cmd force ignore-externals ignore-ancestry \
		quiet relocate revision set-depth
}

function completion/svn::switch:arg {
	if [ $(($separatorindex+1)) -lt ${WORDS[#]} ]; then
		complete -P "$PREFIX" -S / -T -d
	fi
	command -f completion/svn::completeurl
}

function completion/svn::unlock:opt {
	command -f completion/svn::setoptions force targets
}

function completion/svn::unlock:arg {
	command -f completion/svn::completelocal -cm
	command -f completion/svn::completeurl
}

function completion/svn::update:opt {
	command -f completion/svn::setoptions \
		accept changelist depth diff3-cmd editor-cmd force \
		ignore-externals parents quiet revision set-depth
}

function completion/svn::update:arg {
	command -f completion/svn::completelocal -cm
}

function completion/svn::upgrade:opt {
	command -f completion/svn::setoptions quiet
}

function completion/svn::upgrade:arg {
	complete -P "$PREFIX" -S / -T -d
}


# vim: set ft=sh ts=8 sts=8 sw=8 noet: