1 files changed, 155 insertions, 498 deletions

diff --git a/bin/dv b/bin/dv
index 0737295..39164db 100755
--- a/bin/dv
+++ b/bin/dv
@@ -1,556 +1,213 @@
 #!/bin/sh
 
-# Local dv (aka sim)
+# - Usage: dv command [options] [args]
+# -   dv is a dumb version management tool.
+# - Options:
+# -   -a num  set ancestor level (default 1)
+# -   -n      dry-run mode, no changes are made
+# -   -v      verbose mode
+# - Commands:
 
-dv_version='dv-0.23 Copyright 2013-2014 Marc Vertes, Philippe Bergheaud'
 unset CDPATH
 export LC_ALL=C IFS=' 	
 '
-
-anc() {
-	usage 'anc [Version]' 'print ancestor' && return
-	getdv .dv || die no item
-	case $1 in
-	(""|.|$PWD)
-		[ "$Opt_N" ] && Opt_N=$(($Opt_N - 1))
-		[ "$Opt_N" ] && info anc $R2 $Opt_N || echo $R2
+version=dv-0.2
+dvlib=${DVLIB:-$HOME/dvlib}
+script="$(cd "$(dirname "$0")" && pwd)/${0##*/}"
+aopt=1
+
+case $(uname -o) in
+	(Android|Linux)
+		diffopt='--color=always'
+		lsopt='-v --color'
 		;;
-	(*) info anc $1 ${Opt_N:-1};;
-	esac
-}
+	(Darwin)
+		diffopt='--color=always'
+		lsopt='-G'
+		;;
+	(*BSD)
+		;;
+esac
 
-cache() {
-	isremote "$1" || return
-	o=$1 _d=$cacheprefix/$1; pd=${_d%/*}; ppd=${pd%/*} t=$pd/.${_d##*/}
-	[ -d "$ppd" ] || mkdir -p "$ppd"
-	[ -L "$ppd/.dv." ] || ln -s . "$ppd/.dv."
-	[ -f "$_d/.dv" ] && return
-	[ -d "$pd" ] || mkdir -p "$pd"
-	set -- $pd/*; shift $(($# - 1))
-	[ -d "$1" ] && ropt="--link-dest=../${1##*/}" || ropt=
-	rsync -aDS $ropt "$o/" "$t" && mv "$t" "$_d"
+# anc [-a num] [dir] - prints the current ancestor of dir or current.
+anc() {
+	set -- "$(dvdir "$1")"
+	for _ in $(seq "$aopt"); do
+		set -- "$1/.dv/anc"
+	done
+	[ -L "$1" ] && readlink -f "$1"
 }
 
-client() {
-	usage 'client [Version]' 'print clients' && return
-	getdv .dv || die no item
+# clone [-nv] v1 [dir] - clones an iterm version into dir (default: item).
+clone() {
 	case $1 in
-	(""|.|$PWD)
-		while getpdir .dv ..
-		do
-			cd "$R1"
-			getdv ".dv"
-			[ "$OptM" ] && echo "$R2 -> $PWD" || echo "$R2"
-			((Opt_N = Opt_N-1)) || break
-		done ;;
-	(*) info cli $1 ${Opt_N:-9999} | sort -u ;;
+		('')      die 'missing argument' ;;
+		(*[/.-]*) set -- "$(path "$1")" "$2" ;;
+		(*)       set -- "$(head "$1")" "$2" ;;
 	esac
+	[ "$2" ] || { set -- "$1" "${1##*/}"; set -- "$1" "${2%%-*}"; } 
+	[ -d "$1" ] || die "not found: $1"
+	rsync ${vopt:+"$vopt"} ${nopt:+"$nopt"} -a "$1/" "$2/"
+	rm -f "$2/.dv/anc" && ln -s "$1" "$2/.dv/anc"
 }
 
-clone() {
-	usage 'clone [-A Author] [-m Msg] Version [Dir]' \
-		'Copy version to dir' && return
-	[ "$1" ] || die missing argument
-	[ "$3" ] && die too many arguments
-	getpdir .dv . && root=$R1 && getdv $root/.dv && lib=$R1 item=${R2%/*}
-	new_version=${1##*/}
-	if [ "$new_version" = "$1" ]
-	then
-		getdv .dv && lib=$R1 new_item=${R2%/*} || die no item
-	else
-		v=${1%/$new_version}
-		new_item=${v##*/}
-		[ "$new_item" = "$v" ] || new_lib=${v%/$new_item}
-	fi
-	[ "$PWD" = "$root" ] && [ "$item" != "$new_item" ] &&
-	die "already a clone of $item"
-	lib=${lib:-$new_lib}
-	[ "$lib" ] || die no lib
-	[ "$new_lib" -a "$new_lib" != "$lib" ] && die "already in lib: $lib"
-	if [ "$new_version" = 0 ]	# Init item in lib
-	then
-		initlib "$lib"
-		getdvinfo "$lib" || die "could not lock $lib"
-		mkdir -p /tmp/dv.$$/$new_item/0
-		dv_write $new_item/0 $new_item/0 >/tmp/dv.$$/$new_item/0/.dv
-		{ cat /tmp/dv.$$/$new_item/0/.dv; echo; } >>/tmp/dv.$$/.dvinfo.0
-		ln -f /tmp/dv.$$/.dvinfo.0 /tmp/dv.$$/.dvinfo.1
-		rsync -a /tmp/dv.$$/ "$lib"
-	fi
-	if [ ! "$2" ]	# Use the item name as default directory (a la git)
-	then
-		set -- "$1" "${1%/*}"
-		set -- "$1" "${2##*/}"
-		echo cloning into "$2"
-	fi
-	[ ! -d "$2" ] && mkdir "$2"
-	cd "$2" || die cannot chdir to "$2"
-	# Rename existing supplier directories to allow supplier symlinks
-	find . -name .dv | while read l
-	do
-		l=${l%/.dv} && [ "$l" = "." ] && continue
-		mv "$l" "$l.dvold"
-	done
-	# Sync from lib, starting from most client item, up to last supplier
-	d=. s=$new_item/$new_version
-	while [ "$d" ]
-	do
-		[ -L "$d" ] && {
-			rm -f "$d"
-			[ -d "$d.dvold" ] && mv "$d.dvold" "$d"
-		}
-		cache "$lib/$s" && pref=$cacheprefix/ || pref=
-		rsync -aDS "$pref$lib/$s/" "$d"
-		dv_header "$d" Anc "$s"
-		dv_header "$d" Lib "$lib"
-		# Find next symlink pointing to a supplier
-		d= l=
-		eval "$(find . -type l | while read -r l
-			do
-				f=$(readlink "$l")
-				case $f in
-				(*/.dv./*) echo "d=\"$l\" s=\"${f#*/.dv./}\""
-					   break;;
-				esac
-			done)"
+# desc - prints the descendants of a version
+desc() {
+	set -- "$(path "$1")"
+	set -- "$1" "${1%/*}"
+	set -- "$1" "${2##*/}"
+	for a in "$dvlib/$2"/*/.dv/anc*; do
+		[ "$a" -ef "$1" ] && echo "${a%/*/*}"
 	done
 }
 
-desc() {
-	usage 'desc [Version]' 'print descendants' && return
-	getdv .dv || die no item
-	case $1 in
-	(""|.|$PWD) ;;
-	(*) info desc $1 ;;
-	esac
+die() {
+	echo "$@" >&2
+	exit 1
 }
 
-die() { echo "$0: fatal: $@" >&2; exit 1; }
-
+# diff [-a num] [[v1] v2] - prints differences (default: current and ancestor).
 diff() {
-	usage 'diff [-x pat] [-F File] [V1 [V2]]' 'Print differences' && return
-	getpdir .dv && getdv "$R1/.dv" || die not in a clone
-	lib=$R1 item=${R2%/*} old=${R2#*/}
-	[ "$lib" = "" ] && [ -L "../../.dv." ] && lib=${PWD%/*/*}
-	if [ "$2" ]
-	then
-		case $2 in
-		(.)	new=. new_is_clone=1 ;;
-		(*)	new=$lib/$item/$2 ;;
-		esac
-		cache "$new" && np=$cacheprefix/ || np=
-		old=$lib/$item/$1
-	elif [ "$1" ]
-	then
-		case $1 in
-		(.)	new=. new_is_clone=1 ;;
-		(*)	new=$lib/$item/$1 ;;
-		esac
-		cache "$new" && np=$cacheprefix/ || np=
-		getdv "$np$new/.dv" && old=${R1:-$lib}/$R2
+	if [ "$2" ]; then
+		set -- "$(path "$2")" "$(path "$1")"
+	elif [ "$1" ]; then
+		set -- "$(path "$1")" "$(anc "$(path "$1")")"
 	else
-		new=$PWD new_is_clone=1
-		cache "$new" && np=$cacheprefix/ || np=
-		getdv "$np$new/.dv" && old=${R1:-$lib}/$R2
+		set -- "$(dvdir)" "$(anc)"
 	fi
-	cache "$old" && op=$cacheprefix/ || op=
-	[ "$Opts" ] || printf "old %s\nnew %s\n" "$old" "$new"
-	# Itemized diff for all suppliers, deepest first
-	cd "$np$new" && for f in $(find . -type f -name .dv | sort -r)
-	do
-		d=${f%/.dv}
-		[ "$d" = . ] && prefix= || prefix=${d#./}/
-		getdv "$f" && cache "$lib/$R2"
-		[ "$new_is_clone" ] && dest=$np$d || dest=$prefix$d
-		diffdir "$op$lib/$R2" "$dest"
-		Optx="$Optx --exclude=${d##*/}"
-	done
-}
-
-# Usage: diffdir oldpath newpath
-# Print differences between 2 directories
-diffdir() {
-	[ -f "$2/.dvignore" ] && xf=--exclude-from=$2/.dvignore || xf=
-	rsync -aDSniv $xf --delete --exclude=".dv.*/" $Optx "$2/" "$1" |
-	awk -v OptF="${OptF#./}" -v prefix=$prefix '
-	NF == 0 {exit}
-	NR < 2 || /\/*\.dv$/ || /\/$/ {next}
-	# Match an itemized status for all versions of rsync -i
-	$1 !~ /^[<>ch.*][fdLDS+][.+?cstpoguaxz]+$/ {next}
-	{key = $1; file = substr($0, length(key) + 2)}
-	OptF && OptF != file {next}
-	key == "*deleting" {print "deleted " prefix file; next}
-	substr(key, 3, 7) == "+++++++" {print "created " prefix file; next}
-	{	# Avoid false positive if only mtime is changed.
-		of = "'$1'/" file; gsub("'\''", "'\'\\\\\'\''", of)
-		nf = "'$2'/" file; gsub("'\''", "'\'\\\\\'\''", nf)
-		if (substr(key, 2, 1) == "L") {	# Symlink
-			src = target = file
-			sub(/.* -> /, "", target);
-			sub(/ -> .*/, "", src);
-			"readlink '$2'/" src | getline otarget
-			if (target != otarget)
-				print "changed " src
-		} else if (system("cmp -s '\''" of "'\'\ \''" nf "'\''"))
-			print "changed " file
-	}'
-	# Or: scan key for file/link size, checksum or permission change
-	#     rsync -c is required
-	#key ~ /[cps]/ { print "changed " prefix file }'
+	[ "$2" ] && command diff $diffopt -U 3 -x .dv "$2" "$1" | less -F
 }
 
-dv_write() {
-	cat <<- EOT
-	From $(username)
-	Date: $(date +"%F %T %z")
-	Version: $1
-	Anc: $2
-	EOT
-
-	[ "$OptA" ] && echo "Author: $OptA"
-	printf "\n%s\n" "$Optm"
+# dvdir prints the dir containing .dv.
+dvdir() {
+	set -- "$(realpath "${1:-.}")"
+	while [ "$1" ]; do
+		[ -d "$1/.dv" ] && echo "$1" && return
+		set -- "${1%/*}"
+	done
 }
 
-dv_header() {
-	awk -v val="$3" '/^'$2':/ {print "'$2': " val; done = 1; next}
-	NF == 0 && done == 0 {print "'$2': " val; done = 1}
-	{print}' $1/.dv >$1/.dv.$$ && mv $1/.dv.$$ $1/.dv
+# head - prints the branch head versions.
+head() {
+	for v in "$dvlib/${1:-$(name)}/"*; do
+		[ "$(desc "$v")" ] || echo "$v"
+	done
 }
 
-# Usage: getdv path
-# Return lib in R1, anc in R2, version in R3
-getdv() {
-	R1= R2=
-	while read -r line
-	do
+# help - prints this help text.
+help() {
+	while read -r line; do
 		case $line in
-		("Lib: "*)	R1=${line#Lib: };;
-		("Anc: "*)	R2=${line#Anc: };;
-		("Version: "*)	R3=${line#Version: };;
+			(\#*\ -\ *) ;;
+			(*) continue ;;
 		esac
-	done <$1
-	[ "$R1" -o "$R2" ]
+		set -- "${line% - *}" "${line#* - }" 
+		[ "$1" = '#' ] || printf "  %-26s" "${1#\# }"
+		echo "$2"
+	done < "$script"
 }
 
-# Usage: getdvinfo lib
-# Get exclusive write access to a dvlib, for new version commit
-getdvinfo() {
-	[ -d /tmp/dv.$$ ] || mkdir /tmp/dv.$$
-	[ "$Optn" ] && { rsync "$1/.dvinfo.1" /tmp/dv.$$/.dvinfo.0; return; }
-	t=0
-	for i in 1 2 3 4 5
-	do
-		rsync --remove-source-files "$1/.dvinfo.0" /tmp/dv.$$/ && break
-		t=$(($t + $i)) && sleep $t
-	done
-	test -f /tmp/dv.$$/.dvinfo.0
+# incv increments version.
+incv() {
+	set -- "$1" "${1##*[-.a-z_A-Z]}"
+	set -- "${1%"$2"}" "$2"
+	echo "$1$(($2 + 1))"
 }
 
-putdvinfo() {
-	[ "$Optn" ] && return
-	ln -f /tmp/dv.$$/.dvinfo.0 /tmp/dv.$$/.dvinfo.1
-	rsync -a /tmp/dv.$$/.dvinfo.[01] "$1/"
-	isremote "$1" && cp /tmp/dv.$$/.dvinfo.0 "$cacheprefix/$1/"
+# init - creates an initial clone in the current directory.
+init() {
+	[ "$(dvdir)" ] && die "already initialized: $(dvdir)"
+	mkdir .dv
 }
 
-# Usage: getpdir file [path]
-# Return absolute parent dir of path or PWD containing file
-getpdir() {
-	R1="$([ -d "${2:-.}" ] && cd "${2:-.}" && pwd)"
-	while [ "$R1" ]
-	do
-		[ -f "$R1/$1" ] && return || R1=${R1%/*}
-	done
-	return 1
-}
+# ls [item] - lists dvlib.
+ls() (
+	cd "$dvlib" && command ls $lsopt "$@"
+)
 
-# Usage: getprd file [path]
-# Return relative path to parent directory containing file
-getprd() {
-	R2="$(cd "${2:-.}" && pwd)"; R2=${R2%/*} R1=..
-	while [ "$R2" ]
-	do
-		[ -f "$R2/$1" ] && return || R2=${R2%/*} R1=$R1/..
-	done
-	return 1
+# name prints the item name.
+name() {
+	set -- "$(dvdir)"
+	[ "$1" ] && echo "${1##*/}" || die "not a dv item, no .dv found"
 }
 
-info() {
-	usage info && return
-	case $2 in
-	(*:*) lib=${2%/*/*} ;;
-	(*) getpdir .dv && getdv $R1/.dv && lib=$R1 || die no dvlib found
-	esac
-	case $2 in				# $2 specifies:
-	(*/*/*) v=${2%/*/*}; v=${2#$v/} ;;	# lib/item/version
-	(*/*) v=$2 ;;				# item/version
-	(*) v=${R2%/*}/$2 ;;			# version
+# path prints the version path, if exist.
+path() {
+	case $1 in
+		(*/*|.) dvdir "$1"; return ;;
+		([0-9]*) set -- "$(name)-$1" ;;
 	esac
-	isremote "$lib" && {
-		p=$cacheprefix
-		[ -d "$p/$lib" ] || mkdir -p "$p/$lib"
-		[ "$Optl" ] || rsync -a "$lib/.dvinfo.1" "$p/$lib/"
-	} || p=
-	info_query $1 $v $3 <$p/$lib/.dvinfo.1
-}
-
-info_query()
-{
-	awk -v arg0=$1 -v arg1=$2 -v arg2=$3 '
-	/^From / {
-		if (v) msg[v] = var["Body"]
-		delete var
-		var["From"] = substr($0, 6)
-		header = 1
-		next
-	}
-	header == 1 && NF == 0 {
-		v = var["Version"]; a = var["Anc"]; s = var["Sup"]
-		if (a != v) {
-			anc[v] = a; desc[a] = desc[a] ? desc[a] " " v : v
-		}
-		n = split(s, as)
-		for (i = 1; i <= n; i++) {
-			cli[as[i]] = cli[as[i]] ? cli[as[i]] " " v : v
-		}
-		sup[v] = s; msg[v] = var["Msg"]; date[v] = var["Date"]
-		if (var["Root"]) root[v] = var["Root"]
-		header = 0
-		next
-	}
-	header == 1 {
-		i = index($0, ":")
-		var[substr($0, 1, i-1)] = substr($0, i+2)
-		next
-	}
-	header == 0 {
-		if ($0 ~ />+From /) sub(/>/, "")
-		var["Body"] = var["Body"] ? var["Body"] "\n" $0 : $0
-	}
-	END {
-		if (v) msg[v] = var["Body"]
-		if (arg0 == "graph") anc_graph()
-		else if (arg0 == "anc") query_anc(arg1, arg2)
-		else if (arg0 == "sup") query_sup(arg1, arg2)
-		else if (arg0 == "cli") query_cli(arg1, arg2)
-		else if (arg0 == "log") print msg[arg1]
-		else if (arg0 == "from") print from[arg1]
-		else if (arg0 == "date") print date[arg1]
-		else if (arg0 == "desc") printl(desc[arg1])
-	}
-	function anc_graph() {
-		print "digraph G {"
-		for (v in anc) print "\"" anc[v] "\" -> \"" v "\""
-		print "}"
-	}
-	function query_anc(v, n) { while (n-- > 0) v = anc[v]; print v }
-	function query_cli(v, n) {
-		while (n-- > 0 && v != "") {
-			num = split(v, av); v = ""
-			for (i = 1; i <= num; i++) {
-				printl(cli[av[i]])
-				v = v ? v " " cli[av[i]] : cli[av[i]]
-			}
-		}
-	}
-	function query_sup(v, n) {
-		while (n-- > 0 && v != "") {
-			num = split(v, av); v = ""
-			for (i = 1; i <= num; i++) {
-				printl(sup[av[i]])
-				v = v ? v " " sup[av[i]] : sup[av[i]]
-			}
-		}
-	}
-	function printl(l, i, n) {
-		n = split(l, al)
-		for (i = 1; i <= n; i++)
-			if (root[al[i]])
-				print al[i] " -> '"$PWD/"'" root[al[i]]
-			else
-				print al[i]
-	}'
+	set -- "${1%%-*}" "${1#*-}"
+	[ -d "$dvlib/$1/$1-$2" ] && echo "$dvlib/$1/$1-$2"
 }
 
-initlib() {
-	rsync --list-only "$1/.dv." >/dev/null 2>&1 && return
-	mkdir -p /tmp/dv.$$
-	ln -s . /tmp/dv.$$/.dv.
-	>/tmp/dv.$$/.dvinfo.0
-	>/tmp/dv.$$/.dvinfo.1
-	chmod g+w /tmp/dv.$$/.dvinfo.[01]
-	rsync -a /tmp/dv.$$/ "$1"
-}
+# save [-nv] [v1] - creates a new version from clone.
+save() {
+	[ "$1" ] && case $1 in (*[0-9]) ;; (*) die "invalid version: $1" ;; esac
+	set -- "$(dvdir)" "$(aopt=1 anc)" "$(name)" "${1#[a-zA-Z_]*-}"
+	set -- "$1" "$2" "$3" "${4:-$(incv "${2##*/[a-zA-Z_]*-}")}"
+	echo "$dvlib/$3/$3-$4"
+	command diff -q -x .dv "$2" "$1" >/dev/null 2>&1 && die 'no changes, abort'
+	[ "$nopt" ] && return
 
-isremote() { case $1 in (*:*) return;; esac; return 1; }
+	# Update ancestor in clone then copy in dvlib.
+	rm -f "$1/.dv/anc" && [ "$2" ] && ln -s "../../${2##*/}" "$1/.dv/anc"
+	rsync ${vopt:+"$vopt"} -a ${2:+--link-dest="$2"} --mkpath "$1/" "$dvlib/$3/$3-$4/"
 
-help_all() {
-	printf "$dv_version\nUsage: dv command [options] [args]\n"
-	Opth=1; for c in $Cmdlist; do $c; done
+	# After save, clone ancestor points to new saved version.
+	rm -f "$1/.dv/anc" && ln -s "$dvlib/$3/$3-$4" "$1/.dv/anc"
 }
 
-newversion() {
-	[ "$OptV" ] && R1=$OptV && return
-	case $OptB in
-	('') R1=$1 ;;
-	(*[-/]*) die 'illegal character [-/] in branch name' ;;
-	(*[0-9.]) die  'illegal end character [0-9.] in branch name' ;;
-	(*) case $1 in (*-${OptB}[1-9]*) R1=$1;; (*) R1=$1-${OptB}0;; esac ;;
-	esac
-	R2=${R1##*[!0-9]}
-	optb=$Optb
-	[ "$optb" ] && R3=.1 optb=${optb%b} || R3= R1=${R1%$R2}$(($R2 + 1))
-	while [ "${optb}" ]; do optb=${optb%b} R3=.0$R3; done
-	R1=$R1$R3
-	while grep -q "^Version: $item/$R1\$" /tmp/dv.$$/.dvinfo.0
-	do
-		R2=${R1##*[!0-9]}
-		[ "$R2" ] && R1=${R1%$R2}$(($R2 - 1)).1 || R1=${R1}1
-	done
+# status - prints dv informations.
+status() {
+	echo "lib:  $dvlib"
+	set -- "$(dvdir)" "$(anc)"
+	[ "$1" ] || die "not a dv item, no .dv found"
+	echo "root: $1"
+	[ "$2" ] || die "no ancestor found, please save it first"
+	echo "anc:  $2"
+	command diff -q -x .dv "$2" "$1"
 }
 
-patch() {
-	usage 'patch [-x pat] [-F File] [Dir|Version]' \
-		'Print patch diff from ancestor' && return
-	diff "$@" | awk -v wdflag="-v${OptD:+3}${OptN:+1}${OptO:+2}" '
-	{ key = $1; file = substr($0, length(key) + 2) }
-	key == "old" { old = (file ~ /:/ ? "'$cacheprefix'/" : "") file; next }
-	key == "new" { new = (file ~ /:/ ? "'$cacheprefix'/" : "") file; next }
-	{
-		of = old "/" file; gsub("'\''", "'\'\\\\\'\''", of)
-		nf = new "/" file; gsub("'\''", "'\'\\\\\'\''", nf)
-		system("diff -Naup '\''" of "'\'\ \''" nf "'\''; echo")
-	}'
+# sync [url] - synchronize a remote dvlib.
+sync() {
+	set -- "${1:-$(cat "$dvlib/.url" 2>/dev/null)}"
+	[ "$1" ] || die "missing url"
+	[ "$(cat "$dvlib/.url" 2>/dev/null)" = "$1" ] || echo "$1" > "$dvlib/.url"
+	rsync ${vopt:+"$vopt"} ${nopt:+"$nopt"} -aH --mkpath "$1/" "$dvlib/"
+	rsync ${vopt:+"$vopt"} ${nopt:+"$nopt"} -aH --mkpath "$dvlib/" "$1/"
 }
 
-save() {
-	usage 'save [-bln] [-A Author] [-m msg] [-x pat] [-B Branch|-V Version] [Dir]'\
-		'Save dir into a new version' && return
-	[ "$2" ] && die 'too many arguments'
-	getpdir .dv "$1" || die "not in a clone: ${1:-$PWD}" && root=$R1
-	cd "$root"
-	getdv .dv && lib=$R1 && getdvinfo "$lib"
-	# Process supplier subdirs from the deepest up to "." (most client)
-	for d in $(find . -type f -name .dv | sort -r)
-	do
-		d=${d%/.dv}
-		cd "$root/$d"
-		OptF= save1 "$d" && nanc=$R1 && echo $nanc
-		[ "$d" = . ] && continue	# not a supplier, done
-
-		# Replace supplier subdir by symlink in lib
-		getprd .dv && s=$R1/../.dv./$nanc
-		t=${d##*/}; t=.dv.$t
-		mv "$root/$d" "$root/${d%/*}/$t"
-		ln -s "$s" "$root/$d"
-	done
-	putdvinfo "$lib"
-	# Restore supplier subdirs and remove links to lib, deepest first
-	find . -type d -name ".dv.*" | sort -r | while read d
-	do
-		t=${d##*/.dv.}; t=${d%/*}/$t
-		rm -f "$t" && mv "$d" "$t"
-	done
+# version - prints the current version of dv.
+version() {
+	echo "$version"
 }
 
-save1() {
-	getdv .dv && lib=$R1 anc=$R2 && item=${anc%/*} old=${anc#*/}
-	[ "$(diffdir "$lib/$anc" .)" ] || { R1=$anc; return; }
-	newversion $old && new=$item/$R1
-	[ "$Optn" ] || dv_write "$new" "$anc" >.dv
-	# Compute list of direct suppliers, for caching in .dvinfo.0
-	lsup=$(find . -type l | while read -r l
-	do
-		case $l in (*/.dv.*) continue ;; esac
-		f=$(readlink "$l")
-		case $f in (*/.dv./*) printf "%s " ${f#*/.dv./} ;; esac
-	done)
-	[ ! "$Optn" ] && [ "$lsup" ] && dv_header . Sup "$lsup"
-	{ cat .dv; echo; } >>/tmp/dv.$$/.dvinfo.0
-	[ -f ".dvignore" ] && xf=--exclude-from=.dvignore || xf=
-	rsync -aDS$Optn$Optv --link-dest=../$old $xf --exclude=".dv.*/" \
-	      ./ "$lib/$new"
-	R1=$new
-	[ "$Optn" ] && return
-	isremote "$lib" && rsync -aDS --link-dest=../$old --exclude=".dv.*/" \
-				 ./ "$cacheprefix/$lib/$new"
-	dv_header . Anc "$new"
-	dv_header . Lib "$lib"
-}
-
-supplier() {
-	usage 'supplier [Version]' 'print suppliers' && return
-	getdv .dv || die no item
+# Main program starts here.
+[ "$DVDEBUG" ] && set -x ||
 	case $1 in
-	(""|.|$PWD)	# create a temporary dvinfo file, query it
-		V=$R2; find . -name .dv |
-		while read dv
-		do
-			[ "$dv" = "./.dv" ] && continue
-			# get the supplier
-			getdv "$dv"; v=$R2; dv=${dv%/.dv}
-			# get the client
-			getpdir .dv "${dv%/*}"; getdv "$R1/.dv"
-			# declare the client as supplier
-			printf "From \nVersion: %s\nSup: %s\n" "$v" "$R2"
-			[ "$OptM" ] && echo "Root: ${dv#./}"; echo
-		done | info_query cli $V ${Opt_N:-9999} ;;
-	(*) info sup $1 ${Opt_N:-9999} ;;
-	esac | sort -u
-}
-
-usage() { [ "$Opth" ] && printf " %-34s %s\n" "$1" "$2"; }
-
-username() {
-	case $(uname -s) in
-	(Darwin) id -P | awk -v FS=: '{print $8}' ;;
-	(*)	 awk -v FS=[:,] '/^'$USER':/ {print $5; exit}' /etc/passwd ;;
+		(anc|clone|desc|diff|head|help|init|ls|path|save|status|sync|version) ;;
+		(*) help; exit 1;;
 	esac
-}
-
-wdiff() {
-	usage 'wdiff [-DNO] [-x pat] [-F File] [Dir|Version]' \
-		'Print word diffs from ancestor' && return
-	diff "$@" |
-	awk -v wdflag="-v${OptD:+3}${OptN:+1}${OptO:+2}" '
-	{ key = $1; file = substr($0, length(key) + 2) }
-	key == "old" { old = (file ~ /:/ ? "'$cacheprefix'/" : "") file; next }
-	key == "new" { new = (file ~ /:/ ? "'$cacheprefix'/" : "") file; next }
-	{
-		of = old "/" file; gsub("'\''", "'\'\\\\\'\''", of)
-		nf = new "/" file; gsub("'\''", "'\'\\\\\'\''", nf)
-		system("wd " wdflag " '\''" of "'\'\ \''" nf "'\''; echo")
-	}' | less -FCimnqGrX -j5 -h0 +/'\[0'
-}
-
-cacheprefix=$HOME/.cache/dv
-Cmdlist='anc client clone desc diff info patch save supplier wdiff'
-while getopts :nvV opt	# Parse global options
-do
+cmd="$1"
+shift
+while getopts :a:nv opt; do
 	case $opt in
-	(V)	echo "$dv_version"; exit ;;
-	(*)	help_all; exit ;;
+	(a) aopt="$OPTARG" ;;
+	(n) nopt=-n ;;
+	(v) vopt=-v ;;
+	(*) help; exit ;;
 	esac
 done
 shift $((OPTIND - 1))
-[ $1 ] && C=$1 && shift 1 || { help_all; exit 1; }
-for c in $Cmdlist
-do
-	case $c in
-	($C|_$C) cmd=$c; break;;
-	($C*)    [ $cmd ] && die ambiguous command $C || cmd=$c;;
-	esac
-done
-while getopts :0123456789A:bB:F:hl:m:MnNOsvV:x: opt	# Parse command options
-do
-	case $opt in
-	([0-9])		Opt_N=$Opt_N$opt;;
-	([bhlnMNOsv])	eval Opt$opt=\${Opt$opt}$opt ;;
-	([ABFmV])	eval Opt$opt=\$OPTARG ;;
-	(x)		Optx="$Optx --exclude=$OPTARG" ;;
-	(*)		Opth=1; $cmd; exit 1;;
-	esac
-done
-shift $(($OPTIND - 1))
-trap "rm -rf /tmp/dv.$$" EXIT
-[ "$cmd" ] || die "no command \"$C\"" && $cmd "$@"
+$cmd "$@"
+
+# Todo:
+# * a function to squash a branch in the trunk
+# * merge another ancestor (use anc0, anc1, ...)
+# * vendor management
+# * show graphs (dot)
+# * sync: dvlib sync / mirror: resolve conflict by branching
+# * rename version.
+# * .dvignore
+# * make dvlib versions immutable.