# 
# 
# patch "ChangeLog"
#  from [d4b922694eb36f78d3531d1c139fdb38ee65080c]
#    to [9570ccb82c172dd73101cd001480309f75006bf5]
# 
# patch "contrib/monotone.zsh_completion"
#  from [872e2d668a2b4c5775134fd1b2a7101d29c1cba5]
#    to [6dc48efeedf8d994fd1245ab55bc7c4a11916236]
# 
============================================================
--- ChangeLog	d4b922694eb36f78d3531d1c139fdb38ee65080c
+++ ChangeLog	9570ccb82c172dd73101cd001480309f75006bf5
@@ -1,3 +1,9 @@
+2006-06-24  Thomas Moschny <address@hidden>
+
+	* contrib/monotone.zsh_completion: Replace references to
+	'monotone' with 'mtn'. Allow more than one standard option on the
+	command line.
+
 2006-06-19  Nathaniel Smith  <address@hidden>
 
 	* cmd_automate.cc: #include <boost/function.hpp>, as requested in
============================================================
--- contrib/monotone.zsh_completion	872e2d668a2b4c5775134fd1b2a7101d29c1cba5
+++ contrib/monotone.zsh_completion	6dc48efeedf8d994fd1245ab55bc7c4a11916236
@@ -1,50 +1,54 @@
-#compdef monotone
-
+#compdef mtn # -*-sh-*-
+#
 # Installing into /etc/zsh/:
 #
 # 1) if not present, add the line "fpath=(/etc/zsh $fpath)" to either 
 #    your system wide zshrc, or user ~/.zshrc 
-# 2) cp $MONOTONE/contrib/monotone.zsh_completion /etc/zsh/_monotone
+# 2) cp $MONOTONE/contrib/monotone.zsh_completion /etc/zsh/_mtn
 #
 
-# redefine _monotone.
+# redefine _mtn.
 
-_monotone() {
+_mtn() {
   local extra
 
-  _arguments -s \
-    '(-)--debug[print debug log to stderr while running]' \
-    '(-)--dump=[file to dump debugging log to, on failure]:file:_files' \
-    '(-)--full-version[print full version]' \
-    '(-)--help[print help information]' \
-    '(-)--quiet[suppress log and progress messages]' \
- 	  '(-)--norc[do not load ~/.monotone/monotonerc or MT/monotonerc lua files]'\
-    '(-)--nostd[do not load standard lua hooks]' \
- 	  '(-)--rcfile=[load extra rc file]:file:_files'\
-  	'(-)--root=[limit search for working copy to specified root]:dir:_files -/'\
-  	'(-)--ticker=[set ticker style]'\
-    '(-)--version[print version and copyright information]' \
-  	'(-)'{-@,--xargs}'[insert command line arguments taken from the given]'\
-  	'(-)'{-d=,--db=}'[set name of database]:file:_files'\
-  	'(-)'{-k=,--key=}'[set key for signatures]:keys keys:_monotone_keys'\
-    '*::monotone command:_monotone_command'
+  _arguments -s : \
+    '--debug[print debug log to stderr while running]'\
+    '--dump=[file to dump debugging log to, on failure]:file:_files'\
+    '--log=[file to write the log to]:file:_files'\
+    '--quiet[suppress log and progress messages]'\
+    {'-h','--help'}'[display help message]'\
+    '(- *)--version[print version number, then exit]'\
+    '(- *)--full-version[print detailed version number, then exit]'\
+    {'address@hidden','--xargs='}'[insert command line arguments taken from the given file]:file:_files'\
+    '--ticker=[set ticker style]:style:(count dot none)'\
+    '--nostd[do not load standard lua hooks]'\
+    '--norc[do not load ~/.monotone/monotonerc or _MTN/monotonerc lua files]'\
+    '--rcfile=[load extra rc file]:file:_files'\
+    {'-k+','--key='}'[set key for signatures]:keys keys:_mtn_keys'\
+    {'-d+','--db='}'[set name of database]:file:_files'\
+    '--root=[limit search for working copy to specified root]:dir:_files -/'\
+    '--verbose[verbose completion output]'\
+    '--keydir=[set location of key store]'\
+    '--confdir=[set location of configuration directory]'\
+    '*::monotone command:_mtn_command'
 }
 
 # define monotone command dispatch function.
 
-(( $+functions[_monotone_command] )) ||
-_monotone_command() {
-  (( $+_monotone_cmds )) || _monotone_cmds=(add annotate approve attr automate cat checkout commit complete db diff disapprove drop explicit_merge heads merge log ls propagate pull push rename revert serve status sync update fload fmerge lca lcad rcs_import cdiff list cert chkeypass dropkey genkey trusted reindex certs fdata fdelta mdata mdelta privkey pubkey rdata read cvs_import comment tag fcommit refresh_inodeprints setup set unset drop identify testresult)
+(( $+functions[_mtn_command] )) ||
+_mtn_command() {
+  (( $+_mtn_cmds )) || _mtn_cmds=(add annotate approve attr automate cat cert checkout chkeypass ci co comment commit complete cvs_import db diff disapprove drop dropkey explicit_merge fload fmerge genkey get_roster heads help identify list log ls merge merge_into_dir mv pivot_root privkey propagate pubkey pull push rcs_import read refresh_inodeprints rename revert rm serve set setup show_conflicts status sync tag testresult trusted unset update)
 
   local cmd="$words[1]"
   if (( CURRENT == 1 )); then
-    _describe -t commands 'monotone command' _monotone_cmds
+    _describe -t commands 'monotone command' _mtn_cmds
   else
     local curcontext="$curcontext"
 
     if (( $#cmd )); then
       curcontext="${curcontext%:*:*}:monotone-${cmd}:"
-      _call_function ret _monotone_$cmd || _message 'no more arguments'
+      _call_function ret _mtn_$cmd || _message 'no more arguments'
     else
       _message "unknown monotone command: $cmd"
     fi
@@ -54,265 +58,283 @@
 
 # define completion functions for each monotone command
 
-(( $+functions[_monotone_add] )) ||
-_monotone_add() {
-  _arguments -s \
-	  '*:added file:_monotone_files_unmaintained'
+(( $+functions[_mtn_add] )) ||
+_mtn_add() {
+    _arguments -s \
+	'(-)--unknown[add unknown files from workspace]'\
+	'*:file to add:_mtn_files_unmaintained'
 }
 
-(( $+functions[_monotone_annotate] )) ||
-_monotone_annotate() {
-  _arguments -s \
-	  '*:added file:_monotone_existing_entries'
+(( $+functions[_mtn_annotate] )) ||
+_mtn_annotate() {
+    _arguments -s \
+	{'(-)-r+','(-)--revision='}'[select revision id for operation]:revision:_mtn_revisions'\
+	'--brief[print a brief version of the normal output]'\
+	'*:file to annotate:_mtn_existing_entries'
 }
 
-(( $+functions[_monotone_approve] )) ||
-_monotone_approve() {
-	_monotone_revisions
+(( $+functions[_mtn_approve] )) ||
+_mtn_approve() {
+    _arguments -s \
+	{'(-)-b+','(-)--branch='}'[select branch cert for operation]:branch:_mtn_branches'\
+	'(*)*:revision:_mtn_revisions'
 }
 
-(( $+functions[_monotone_attr] )) ||
-_monotone_attr() {
+(( $+functions[_mtn_attr] )) ||
+_mtn_attr() {
 	if (( CURRENT == 2 )); then	
 		compadd -- set get drop
 	elif (( CURRENT == 3 )); then	
-		compadd -- $(monotone automate attributes)
+		compadd -- $(mtn automate attributes)
 	else
 	  local fname="$words[3]";
-		compadd -- $(monotone automate attributes $fname)
+		compadd -- $(mtn automate attributes $fname)
 	fi
 }
 
-(( $+functions[_monotone_automate] )) ||
-_monotone_automate() {
-	compadd -- interface_version heads ancestors parents descendents children graph erase_ancestors toposort ancestry_difference leaves inventory
+(( $+functions[_mtn_automate] )) ||
+_mtn_automate() {
+	compadd -- \
+	    ancestors ancestry_difference attributes certs children \
+	    descendents erase_ancestors get_file get_manifest_of \
+	    get_revision graph heads interface_version inventory keys \
+	    leaves packet_for_certs packet_for_fdelta packet_for_rdata \
+	    parents select toposort 
 }
 
-(( $+functions[_monotone_cat] )) ||
-_monotone_cat() {
+(( $+functions[_mtn_cat] )) ||
+_mtn_cat() {
 	if (( CURRENT == 2 )); then	
 		compadd -- file manifest revision
 	else
 	  local mtype="$words[2]"
 		if [[ "$mtype" == "revision" ]]; then
-			_monotone_revisions
+			_mtn_revisions
 		else
 			local id="$words[3]"
 			if (( $#id )); then
-  			compadd -- $(monotone complete $mtype $id 2> /dev/null)
+  			compadd -- $(mtn complete $mtype $id 2> /dev/null)
 			fi
 	  fi
 	fi
 }
 
-(( $+functions[_monotone_cert] )) ||
-_monotone_cert() {
-	_monotone_revisions
+(( $+functions[_mtn_cert] )) ||
+_mtn_cert() {
+	_mtn_revisions
 }
 
-(( $+functions[_monotone_checkout] )) ||
-_monotone_checkout() {
+(( $+functions[_mtn_checkout] )) ||
+_mtn_checkout() {
   _arguments \
-    '--branch=-[branch name]:branch:_monotone_branches' \
-		':revision:_monotone_revisions'
+    '--branch=-[branch name]:branch:_mtn_branches' \
+		':revision:_mtn_revisions'
 }
 
-(( $+functions[_monotone_chkeypass] )) ||
-_monotone_chkeypass() {
-	_monotone_keys
+(( $+functions[_mtn_chkeypass] )) ||
+_mtn_chkeypass() {
+	_mtn_keys
 }
 
-(( $+functions[_monotone_comment] )) ||
-_monotone_comment() {
-	_monotone_revisions
+(( $+functions[_mtn_ci] )) ||
+_mtn_ci() {
+  _mtn_commit
 }
 
-(( $+functions[_monotone_commit] )) ||
-_monotone_commit() {
+(( $+functions[_mtn_co] )) ||
+_mtn_ci() {
+  _mtn_checkout
+}
+
+(( $+functions[_mtn_comment] )) ||
+_mtn_comment() {
+	_mtn_revisions
+}
+
+(( $+functions[_mtn_commit] )) ||
+_mtn_commit() {
   _arguments -s \
     '(-)--message=[logmsg]' \
-    '*:modified file:_monotone_existing_entries'
+    '*:modified file:_mtn_existing_entries'
 }
 
-(( $+functions[_monotone_complete] )) ||
-_monotone_complete() {
+(( $+functions[_mtn_complete] )) ||
+_mtn_complete() {
 	compadd -- file key manifest revision 
 }
 
-(( $+functions[_monotone_cvs_import] )) ||
-_monotone_cvs_import() {
+(( $+functions[_mtn_cvs_import] )) ||
+_mtn_cvs_import() {
   _arguments \
 	  '*:file:_files'
 }
 
-(( $+functions[_monotone_db] )) ||
-_monotone_db() {
+(( $+functions[_mtn_db] )) ||
+_mtn_db() {
 	compadd -- init info version dump load migrate check rebuild execute kill_rev_locally
 }
 
-(( $+functions[_monotone_diff] )) ||
-_monotone_diff() {
+(( $+functions[_mtn_diff] )) ||
+_mtn_diff() {
   _arguments -s \
-		'*--revision=:revision:_monotone_revisions' \
-	  '*:added file:_monotone_existing_entries'
+		'*--revision=:revision:_mtn_revisions' \
+	  '*:added file:_mtn_existing_entries'
 }
 
-(( $+functions[_monotone_disapprove] )) ||
-_monotone_disapprove() {
-	_monotone_revisions
+(( $+functions[_mtn_disapprove] )) ||
+_mtn_disapprove() {
+	_mtn_revisions
 }
 
-(( $+functions[_monotone_drop] )) ||
-_monotone_drop() {
-	_monotone_existing_entries
+(( $+functions[_mtn_drop] )) ||
+_mtn_drop() {
+	_mtn_existing_entries
 }
 
-(( $+functions[_monotone_explicit_merge] )) ||
-_monotone_explicit_merge() {
+(( $+functions[_mtn_dropkey] )) ||
+_mtn_dropkey() {
+	_mtn_keys
+}
+
+(( $+functions[_mtn_explicit_merge] )) ||
+_mtn_explicit_merge() {
   if (( CURRENT == 2 || CURRENT == 3)); then
-		_monotone_revisions
+		_mtn_revisions
 	else
-	  _monotone_branches
+	  _mtn_branches
 	fi
 }
 
-(( $+functions[_monotone_dropkey] )) ||
-_monotone_dropkey() {
-	_monotone_keys
-}
-
-(( $+functions[_monotone_heads] )) ||
-_monotone_heads() {
+(( $+functions[_mtn_heads] )) ||
+_mtn_heads() {
   _arguments -s \
-    '--branch=[branch name]:branch:_monotone_branches'
+    '--branch=[branch name]:branch:_mtn_branches'
 }
 
-(( $+functions[_monotone_log] )) ||
-_monotone_log() {
+(( $+functions[_mtn_log] )) ||
+_mtn_log() {
   _arguments -s \
     '--last=[n]' \
-		'--revision=:revision:_monotone_revisions' \
-	  '*:added file:_monotone_existing_entries'
+		'--revision=:revision:_mtn_revisions' \
+	  '*:added file:_mtn_existing_entries'
 }
 
-(( $+functions[_monotone_ls] )) ||
-_monotone_ls() {
+(( $+functions[_mtn_list] )) ||
+_mtn_list() {
   _arguments \
-		':op:_monotone_list_ops'
+		':op:_mtn_list_ops'
 }
 
-(( $+functions[_monotone_list] )) ||
-_monotone_list() {
-  _arguments \
-		':op:_monotone_list_ops'
+(( $+functions[_mtn_ls] )) ||
+_mtn_ls() {
+  _mtn_list
 }
 
-(( $+functions[_monotone_merge] )) ||
-_monotone_merge() {
+(( $+functions[_mtn_merge] )) ||
+_mtn_merge() {
   _arguments -s \
-    '--branch=[branch name]:branch:_monotone_branches'
+    '--branch=[branch name]:branch:_mtn_branches'
 }
 
-(( $+functions[_monotone_propagate] )) ||
-_monotone_propagate() {
-  _monotone_branches
+(( $+functions[_mtn_propagate] )) ||
+_mtn_propagate() {
+  _mtn_branches
 }
 
-(( $+functions[_monotone_pull] )) ||
-_monotone_pull() {
+(( $+functions[_mtn_pull] )) ||
+_mtn_pull() {
   _arguments -s \
-		'*:branch:_monotone_branches' 
+		'*:branch:_mtn_branches' 
 }
 
-(( $+functions[_monotone_push] )) ||
-_monotone_push() {
+(( $+functions[_mtn_push] )) ||
+_mtn_push() {
   _arguments -s \
-		'*:branch:_monotone_branches' 
+		'*:branch:_mtn_branches' 
 }
 
-(( $+functions[_monotone_rcs_import] )) ||
-_monotone_rcs_import() {
+(( $+functions[_mtn_rcs_import] )) ||
+_mtn_rcs_import() {
   _arguments \
 	  '*:file:_files'
 }
 
-(( $+functions[_monotone_rename] )) ||
-_monotone_rename() {
-	_monotone_existing_entries
+(( $+functions[_mtn_rename] )) ||
+_mtn_rename() {
+	_mtn_existing_entries
 }
 
-(( $+functions[_monotone_revert] )) ||
-_monotone_revert() {
-	_monotone_existing_entries
+(( $+functions[_mtn_revert] )) ||
+_mtn_revert() {
+	_mtn_existing_entries
 }
 
-(( $+functions[_monotone_serve] )) ||
-_monotone_serve() {
+(( $+functions[_mtn_serve] )) ||
+_mtn_serve() {
   _arguments -s \
-		'*:branch:_monotone_branches' 
+		'*:branch:_mtn_branches' 
 }
 
-(( $+functions[_monotone_status] )) ||
-_monotone_status() {
-	_monotone_existing_entries
+(( $+functions[_mtn_status] )) ||
+_mtn_status() {
+	_mtn_existing_entries
 }
 
-(( $+functions[_monotone_sync] )) ||
-_monotone_sync() {
+(( $+functions[_mtn_sync] )) ||
+_mtn_sync() {
   _arguments -s \
-		'*:branch:_monotone_branches' 
+		'*:branch:_mtn_branches' 
 }
 
-(( $+functions[_monotone_tag] )) ||
-_monotone_tag() {
-	_monotone_revisions
+(( $+functions[_mtn_tag] )) ||
+_mtn_tag() {
+	_mtn_revisions
 }
 
-(( $+functions[_monotone_result] )) ||
-_monotone_testresult() {
-	_monotone_revisions
+(( $+functions[_mtn_result] )) ||
+_mtn_testresult() {
+	_mtn_revisions
 }
 
-(( $+functions[_monotone_update] )) ||
-_monotone_update() {
-	_monotone_revisions
+(( $+functions[_mtn_update] )) ||
+_mtn_update() {
+	_mtn_revisions
 }
 
 # define completion functions for files maintained by monotone.
 
-(( $+functions[_monotone_files_unmaintained] )) ||
-_monotone_files_unmaintained() {
-	compadd -- $(monotone ls unknown)
+(( $+functions[_mtn_files_unmaintained] )) ||
+_mtn_files_unmaintained() {
+	compadd -- $(mtn ls unknown)
 }
 
-(( $+functions[_monotone_existing_entries] )) ||
-_monotone_existing_entries() {
-	for i in `monotone ls known --depth=0 .`; do compadd -- $i:t; done
+(( $+functions[_mtn_existing_entries] )) ||
+_mtn_existing_entries() {
+	for i in $(mtn ls known --depth=0 .); do compadd -- $i:t; done
 }
 
-(( $+functions[_monotone_branches] )) ||
-_monotone_branches() {
-	compadd -- $(monotone ls branches)
+(( $+functions[_mtn_branches] )) ||
+_mtn_branches() {
+	compadd -- $(mtn ls branches)
 }
 
-(( $+functions[_monotone_keys] )) ||
-_monotone_keys() {
+(( $+functions[_mtn_keys] )) ||
+_mtn_keys() {
 	local id="$words[CURRENT]:gs/-//"
 	if (( $#id )); then
-		compadd -X "$(monotone complete key --verbose $id 2>/dev/null)" -n -- $(monotone complete key $id 2>/dev/null)
+		compadd -X "$(mtn complete key --verbose $id 2>/dev/null)" -n -- $(mtn complete key $id 2>/dev/null)
 	fi
 }
 
-(( $+functions[_monotone_revisions] )) ||
-_monotone_revisions() {
-	if ! compset -P '*\='; then
-		compadd -X "$(monotone complete revision --verbose $PREFIX 2>/dev/null)" -n -- $(monotone complete revision $PREFIX 2>/dev/null)
-	fi
+(( $+functions[_mtn_revisions] )) ||
+_mtn_revisions() {
+    compadd -X "(prefix of a) revision" -n \
+	-- $(mtn complete revision $PREFIX 2>/dev/null)
 }
 
-(( $+functions[_monotone_list_ops] )) ||
-_monotone_list_ops() {
+(( $+functions[_mtn_list_ops] )) ||
+_mtn_list_ops() {
 	compadd -- certs keys branches epochs tags vars known unknown ignored missing
 }
 
+_mtn "$@"
-_monotone "$@"