new rewritten cvs.eclass and kde-source.eclass changed to match. see gnetoo-dev,core posts for details abt the changes.

1 files changed, 163 insertions, 259 deletions

diff --git a/eclass/cvs.eclass b/eclass/cvs.eclass
index 0ea43b35344d..27e816a120da 100644
--- a/eclass/cvs.eclass
+++ b/eclass/cvs.eclass
@@ -1,10 +1,13 @@
 # Copyright 1999-2003 Gentoo Technologies, Inc.
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.35 2003/04/17 09:05:03 cretin Exp $
+# $Header: /var/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.36 2003/04/19 11:52:50 danarmak Exp $
 #
 # Author Dan Armak <danarmak@gentoo.org>
 #
 # This eclass provides the generic cvs fetching functions.
+# to use from an ebuild, set the 'ebuild-configurable settings' below in your ebuild before inheriting.
+# then either leave the default src_unpack or extend over cvs_src_unpack.
+# if you find that you need to call the cvs_* functions directly, i'd be interested to hear about it.
 
 ECLASS=cvs
 INHERITED="$INHERITED $ECLASS"
@@ -20,12 +23,12 @@ INHERITED="$INHERITED $ECLASS"
 # the ~/.cvsrc config file and to use maximum compression.
 [ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4"
 
-# cvs options given after the command (i.e. cvs update foo)
-# don't remove -dP or things won't work
-[ -z "$ECVS_CVS_OPTIONS" ] && ECVS_CVS_OPTIONS="-dP"
+# cvs options given after the cvs command (update or checkout)
+# don't remove -dP from update or things won't work
+[ -z "$ECVS_UP_OPTS" ] && ECVS_UP_OPTS="-dP"
+[ -z "$ECVS_CO_OPTS" ] && ECVS_CO_OPTS=""
 
-# set this for the module/subdir to be fetched non-recursively
-#[ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l"
+# set this to some value for the module/subdir to be fetched non-recursively: ECVS_LOCAL
 
 # Where the cvs modules are stored/accessed
 [ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src"
@@ -36,85 +39,81 @@ INHERITED="$INHERITED $ECLASS"
 # parts of the full CVSROOT (which looks like
 # ":pserver:anonymous@anoncvs.kde.org:/home/kde"); these are added from
 # other settings
+# the special value 'offline' disables fetching, assumes sources are alread in ECVS_TOP_DIR
 [ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline"
 
-# Anonymous cvs login?
-# if 'yes' uses :pserver: with empty password, if 'no' uses :ext: with $ECVS_PASS, other values not allowed
-[ -z "$ECVS_ANON" ] && ECVS_ANON="yes"
-
-# Authentication method to use on ECVS_ANON="no" - possible values are "pserver" and "ext"
-[ -z "$ECVS_AUTH" ] && ECVS_AUTH="ext"
+# Authentication method to use - possible values are "pserver" and "ext"
+# WARNING ext is NOT supported! (never was, despite what earlier version of this file said)
+[ -z "$ECVS_AUTH" ] && ECVS_AUTH="pserver"
+[ "$ECVS_AUTH" == ext ] && die "ERROR: ext auth not supported. If you want it, please contact danarmak@gentoo.org."
 
 # Use su to run cvs as user
-[ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`"
+# Currently b0rked and wouldn't work with portage userpriv anyway without special magic
+# [ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`"
 
-# Username to use
+# Username to give to the server
 [ -z "$ECVS_USER" ] && ECVS_USER="anonymous"
 
-# Password to use if anonymous login is off, or if 'anonymous' pserver access
-# uses a password and ECVS_ANON = yes
+# Password to use
 [ -z "$ECVS_PASS" ] && ECVS_PASS=""
 
-# Module to be fetched, must be set explicitly -
-# I don't like the former ="$PN" default setting
-[ -z "$ECVS_MODULE" ] && debug-print "$ECLASS: error: ECVS_MODULE not set, cannot continue"
+# Module to be fetched, must be set when kde_src_unpack is called
+# can include several directory levels, ie foo/bar/baz
+#[ -z "$ECVS_MODULE" ] && die "$ECLASS: error: ECVS_MODULE not set, cannot continue"
 
 # Branch/tag to use, default is HEAD
-# uncomment the following line to enable the reset-branch-to-HEAD behaviour
-# [ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD"
+# the following default _will_ reset your branch checkout to head if used
+#[ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD"
 
-# Subdirectory in module to be fetched, default is not defined = whole module
-# DO NOT set default to "", if it's defined at all code will break!
-# don't uncomment following line!
-#[ -z "$ECVS_SUBDIR" ] && ECVS_SUBDIR=""
+# deprecated - do not use
+[ -n "$ECVS_SUBDIR" ] && die "ERROR: deprecated ECVS_SUBDIR defined. Please fix this ebuild."
 
 # --- end ebuild-configurable settings ---
 
 # add cvs to deps
-DEPEND="$DEPEND dev-util/cvs dev-python/pexpect"
+# ssh is used for ext auth
+# sudo is used to run as a specified user
+DEPEND="$DEPEND dev-util/cvs app-admin/sudo"
+#[ "$ECVS_AUTH" == "ext" ] && DEPEND="$DEPEND net-misc/openssh"
 
-# since we no longer have src_fetch as a redefinable ebuild function,
-# we are forced to call this function from cvs_src_unpack
+# calls cvs_contorl, is called from cvs_src_unpack
 cvs_fetch() {
 
 	debug-print-function $FUNCNAME $*
 
-	debug-print "$FUNCNAME: init:
-9ECVS_CVS_COMMAND=$ECVS_CVS_COMMAND
-ECVS_CVS_OPTIONS=$ECVS_CVS_OPTIONS
-ECVS_TOP_DIR=$ECVS_TOP_DIR
-ECVS_SERVER=$ECVS_SERVER
-ECVS_ANON=$ECVS_ANON
-ECVS_USER=$ECVS_USER
-ECVS_PASS=$ECVS_PASS
-ECS_MODULE=$ECVS_MODULE
-ECVS_SUBDIR=$ECVS_SUBDIR
-ECVS_LOCAL=$ECVS_LOCAL
-DIR=$DIR"
-
-	# a shorthand
-	DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}"
-	debug-print "$FUNCNAME: now DIR=$DIR"
+	# parameters modifying other parameters that should be effective every time cvs_prep is called, and not
+	# just every time cvs.eclas is inherited
+	# 1. parameter for local (non-recursive) fetching
+	if [ -n "$ECVS_LOCAL" ]; then
+		ECVS_UP_OPTS="$ECVS_UP_OPTS -l"
+		ECVS_CO_OPTS="$ECVS_CO_OPTS -l"
+	fi
+	# 2. cvs auto-switches branches, we just have to pass the correct -rBRANCH option to it when updating.
+	# doing it this way we get multiple -rX options - harmless afaik
+	if [ -n "$ECVS_BRANCH" ]; then
+		ECVS_UP_OPTS="$ECVS_UP_OPTS -r$ECVS_BRANCH"
+		ECVS_CO_OPTS="$ECVS_CO_OPTS -r$ECVS_BRANCH"
+	fi
 
-	if [ "$ECVS_SERVER" == "offline" ]; then
-		# we're not required to fetch anything, the module already exists and shouldn't be updated
-		if [ -d "$DIR" ]; then
-			debug-print "$FUNCNAME: offline mode, exiting"
-			return 0
-		else
-			einfo "ERROR: Offline mode specified, but module/subdir not found. Aborting."
-			debug-print "$FUNCNAME: offline mode specified but module/subdir not found, exiting with error"
-			return 1
-		fi
+	# it's easiest to always be in "run-as mode", logic-wise
+	# or would be if sudo didn't ask for a password even when sudo'ing to `whoami`
+	if [ -z "$ECVS_RUNAS" ]; then
+		run=""
+	else
+		run="sudo -u $ECVS_RUNAS"
 	fi
 
-	# create target directory as needed
-	if [ ! -d "$DIR" ]; then
-		debug-print "$FUNCNAME: creating cvs directory $DIR"
-		#export SANDBOX_WRITE="$SANDBOX_WRITE:/foobar:/"
+	# create the top dir if needed
+	if [ ! -d "$ECVS_TOP_DIR" ]; then
+		# note that the addwrite statements in this block are only there to allow creating ECVS_TOP_DIR;
+		# we've already allowed writing inside it
+		# this is because it's simpler than trying to find out the parent path of the directory, which
+		# would need to be the real path and not a symlink for things to work (so we can't just remove
+		# the last path element in the string)
+		debug-print "$FUNCNAME: checkout mode. creating cvs directory"
 		addwrite /foobar
 		addwrite /
-		mkdir -p "/$DIR"
+		$run mkdir -p "/$ECVS_TOP_DIR"
 		export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}"
 	fi
 
@@ -122,244 +121,149 @@ DIR=$DIR"
 	# otherwise addwrite() doesn't work.
 	cd -P "$ECVS_TOP_DIR" > /dev/null
 	ECVS_TOP_DIR="`/bin/pwd`"
-	DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}"
-	cd "$OLDPWD"
-	
-	debug-print "$FUNCNAME: now DIR=$DIR"
-	
-	# disable the sandbox for this dir
-	# not just $DIR because we want to create moduletopdir/CVS too
-	addwrite "$ECVS_TOP_DIR/$ECVS_MODULE"
 
-	# add option for local (non-recursive) fetching
-	[ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l"
-	
-	# prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass
-	touch "${T}/cvspass"
-	export CVS_PASSFILE="${T}/cvspass"
-	chown $ECVS_RUNAS "${T}/cvspass"
-
-	# Note: cvs update and checkout commands are unified.
-	# we make sure a CVS/ dir exists in our module subdir with the right
-	# Root and Repository entries in it and cvs update.
-	
-	[ "${ECVS_ANON}" == "yes" ] && \
-		newserver=":pserver:${ECVS_USER}@${ECVS_SERVER}" || \
-		newserver=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" 
-		
-	
-	# CVS/Repository files can't (I think) contain two concatenated slashes
-	if [ -n "$ECVS_SUBDIR" ]; then
-		repository="${ECVS_MODULE}/${ECVS_SUBDIR}"
+	# determine checkout or update mode
+	if [ ! -d "$ECVS_TOP_DIR/$ECVS_MODULE/CVS" ]; then
+		mode=checkout
 	else
-		repository="${ECVS_MODULE}"
+		mode=update
 	fi
-	
-	debug-print "$FUNCNAME: Root<-$newserver, Repository<-$repository"
-	debug-print "$FUNCNAME: entering directory $DIR"
-	cd "/$DIR"
-	
-	if [ ! -d "CVS" ]; then
-		# create a new CVS/ directory (checkout)
-		debug-print "$FUNCNAME: creating new cvs directory"
-		
-		mkdir CVS
-		echo $newserver > CVS/Root
-		echo $repository > CVS/Repository
-		touch CVS/Entries
-		
-		# if we're checking out a subdirectory only, create a CVS/ dir
-		# in the module's top dir so that the user (and we) can cvs update
-		# from there to get the full module.
-		if [ ! -d "$ECVS_TOP_DIR/$ECVS_MODULE/CVS" ]; then
-			debug-print "$FUNCNAME: Copying CVS/ directory to module top-level dir"
-			cp -r CVS "$ECVS_TOP_DIR/$ECVS_MODULE/"
-			echo $ECVS_MODULE > "$ECVS_TOP_DIR/$ECVS_MODULE/CVS/Repository"
-		fi
-		
-	else
-		#update existing module
-		debug-print "$FUNCNAME: updating existing module/subdir"
-		
-		# Switch servers if needed
-		# cvs keeps the server info in the CVS/Root file in every checked-out dir;
-		# we can fix those files to point to the new server
-		oldserver="`cat CVS/Root`"
-		if [ "$newserver" != "$oldserver" ]; then
-
-			einfo "Changing CVS server from $oldserver to $newserver:"
-			debug-print "$FUNCNAME: Changing CVS server from $oldserver to $newserver:"
+
+	# disable the sandbox for this dir
+	addwrite "$ECVS_TOP_DIR"
+
+	# chowning the directory and all contents
+	if [ -n "$ECVS_RUNAS" ]; then
+		$run chown -R "$ECVS_RUNAS" "/$ECVS_TOP_DIR"
+	fi
+
+	# our server string (aka CVSHOST), without the password so it can be put in Root
+	server=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}"
+
+	# switch servers automagically if needed
+	if [ "$mode" == "update" ]; then
+		cd /$ECVS_TOP_DIR/$ECVS_MODULE
+		oldserver="`$run cat CVS/Root`"
+		if [ "$server" != "$oldserver" ]; then
+
+			einfo "Changing CVS server from $oldserver to $server:"
+			debug-print "$FUNCNAME: Changing CVS server from $oldserver to $server:"
 
 			einfo "Searching for CVS dirs..."
-			cvsdirs="`find . -iname CVS -print`"
+			cvsdirs="`$run find . -iname CVS -print`"
 			debug-print "$FUNCNAME: CVS dirs found:"
 			debug-print "$cvsdirs"
 
 			einfo "Modifying CVS dirs..."
 			for x in $cvsdirs; do
 				debug-print "In $x"
-				echo $newserver > "$x/Root"
+				$run echo "$server" > "$x/Root"
 			done
 
 		fi
-
 	fi
 
-	# cvs auto-switches branches, how nice
-	# warning: if we do it this way we get multiple -rX options - harmless i think
-	[ -n "$ECVS_BRANCH" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -r$ECVS_BRANCH"
+	# the server string with the password in it
+	# needed for mode=update too as we may not be inside ECVS_MODULE but only inside ECVS_TOP_DIR
+	# however putting the password in in update mode can break (?)
+	if [ "$mode" == "checkout" ]; then
+		export CVSROOT=":${ECVS_AUTH}:${ECVS_USER}:${ECVS_PASS}@${ECVS_SERVER}"
+	else
+		export CVSROOT=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}"
+	fi
 
-	# Chowning the directory
-	if [ "${ECVS_RUNAS}" != "`whoami`" ]; then
-		chown -R "$ECVS_RUNAS" "/$DIR"
+	# prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass
+	touch "${T}/cvspass"
+	export CVS_PASSFILE="${T}/cvspass"
+	if [ -n "$ECVS_RUNAS" ]; then
+		chown "$ECVS_RUNAS" "${T}/cvspass"
 	fi
 
-	# finally run the cvs update command
-	debug-print "$FUNCNAME: is in dir `/bin/pwd`"
-	debug-print "$FUNCNAME: running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS with $ECVS_SERVER for module $ECVS_MODULE subdir $ECVS_SUBDIR"
-	einfo "Running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS with $ECVS_SERVER for $ECVS_MODULE/$ECVS_SUBDIR..."
-
-	if [ "${ECVS_ANON}" == "no" ]; then
-	
-		debug-print "$FUNCNAME: starting non-anonymous cvs login..."
-		# CVS Login - written in python :: the right way ;)
-		# Tilman Klar, <phoenix@gentoo.org>
-
-		export CVS_RSH="/usr/bin/ssh"
-
-############################## inline-python #####################################
-/usr/bin/env python << EndOfFile
-
-import pexpect,os
-
-mypasswd  = "${ECVS_PASS}"
-myauth    = "${ECVS_AUTH}"
-mytimeout = 10
-
-if "${ECVS_RUNAS}" == "`whoami`":
-    mycommand = "${ECVS_CVS_COMMAND} update ${ECVS_CVS_OPTIONS}"
-else:
-    mycommand = "su ${ECVS_RUNAS} -c \"${ECVS_CVS_COMMAND} update ${ECVS_CVS_OPTIONS}\""
-
-if myauth == "ext":
-	child = pexpect.spawn(mycommand)
-
-	index = child.expect(['continue connecting','word:'], mytimeout)
-	if index == 0:
-		child.sendline('yes')
-		## Added server to ~/.ssh/known_hosts
-		child.expect('word:', mytimeout)
-	else:
-		## Server already is in ~/.ssh/known_hosts
-		pass
-
-	child.sendline(mypasswd)
-	child.expect(pexpect.EOF)	
-
-elif myauth == "pserver":
-	if "${ECVS_RUNAS}" == "`whoami`":
-		mycommand2 = "cvs login"
-	else:
-		mycommand2 = "su ${ECVS_RUNAS} -c \"cvs login\""
-	child = pexpect.spawn(mycommand2)
-	child.expect("CVS password:",mytimeout)
-	child.sendline(mypasswd)
-	child.expect(pexpect.EOF)
-
-	# Logged in - checking out
-	os.system(mycommand)
-	
-EndOfFile
-########################### End of inline-python ##################################
-	else
-		# is anonymous cvs.
-		# is there a password to use for login with this "anonymous" login
-		if [ -n "$ECVS_PASS" ]; then
-			debug-print "$FUNCNAME: using anonymous cvs login with password"
+	# commands to run
+	cmdupdate="${run} ${ECVS_CVS_COMMAND} update ${ECVS_UP_OPTS} ${ECVS_MODULE}"
+	cmdcheckout="${run} ${ECVS_CVS_COMMAND} checkout ${ECVS_CO_OPTS} ${ECVS_MODULE}"
 
-# inline-python #
-/usr/bin/env python << EndOfFile
+	cd "${ECVS_TOP_DIR}"
+	if [ "${ECVS_AUTH}" == "pserver" ]; then
+		if [ "${mode}" == "update" ]; then
+			$cmdupdate
+		elif [ "${mode}" == "checkout" ]; then
+			$cmdcheckout
+		fi
+#	elif [ "${ECVS_AUTH}" == "ext" ]; then
+#		# for ext there's also a possible ssh prompt, code not yet written
+#		echo "${ECVS_DELAY} continue connecting&yes" >> "$instruct"
+#		echo "${ECVS_DELAY} CVS password:&${ECVS_PASS}" >> "$instruct"
+#		if [ "$mode" == "update" ]; then
+#			expect "$cvsout" "$instruct" | $cmdupdate > "$cvsout"
+#		elif [ "$mode" == "checkout" ]; then
+#			expect "$cvsout" "$instruct" | $cmdcheckout > "$cvsout"
+#		fi
+	fi
 
-import pexpect,os
+	# restore ownership. not sure why this is needed, but someone added it in the orig ECVS_RUNAS stuff.
+	if [ -n "$ECVS_RUNAS" ]; then
+		chown `whoami` "${T}/cvspass"
+	fi
 
-myuser	  = "${ECVS_USER}"
-mypasswd  = "${ECVS_PASS}"
+}
 
-mytimeout = 10
 
-# implicitly myauth == "pserver" here.
-mycommand = "cvs login"
-child = pexpect.spawn(mycommand)
-child.expect("CVS password:",mytimeout)
-child.sendline(mypasswd)
-child.expect(pexpect.EOF)
-EndOfFile
-# End of inline-python #
+cvs_src_unpack() {
 
-		else
-		    debug-print "$FUNCNAME: using anonymous cvs login (without password)"
-		    # passwordless, truly anonymous login; or login with empty (but existing)
-		    # password.
-		    # make cvs think we're logged in at the cvs server,
-		    # because i don't trust myself to write the right code for the case
-		    # where the password is empty but still required (what's the bash test
-		    # to see if a variable is defined? -n returns false if it is defined
-		    # but empty...)
-		    echo ":pserver:${ECVS_SERVER} A" > "${T}/cvspass"
-		    # remember we did this so we don't try to run cvs logout later
-		    DONT_LOGOUT=yes
-		fi
+	debug-print-function $FUNCNAME $*
 
-		debug-print "$FUNCNAME: running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS"
-		$ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS || die "died running cvs update"
+	debug-print "$FUNCNAME: init:
+ECVS_CVS_COMMAND=$ECVS_CVS_COMMAND
+ECVS_UP_OPTS=$ECVS_UP_OPTS
+ECVS_CO_OPTS=$ECVS_CO_OPTS
+ECVS_TOP_DIR=$ECVS_TOP_DIR
+ECVS_SERVER=$ECVS_SERVER
+ECVS_USER=$ECVS_USER
+ECVS_PASS=$ECVS_PASS
+ECS_MODULE=$ECVS_MODULE
+ECVS_LOCAL=$ECVS_LOCAL
+ECVS_RUNAS=$ECVS_RUNAS"
 
-	fi
+	[ -z "$ECVS_MODULE" ] && die "ERROR: CVS module not set, cannot continue."
 
-	# log out and restore ownership as needed
-	if [ -z "$DONT_LOGOUT" ]; then
-	    debug-print "$FUNCNAME: cvs logout stuff"
-	    if [ "$ECVS_RUNAS" == "`whoami`" ]; then
-		cvs logout &> /dev/null
-	    else
-		su $ECVS_RUNAS -c "cvs logout" &> /dev/null
-	    fi
+	if [ "$ECVS_SERVER" == "offline" ]; then
+		# we're not required to fetch anything, the module already exists and shouldn't be updated
+	 		if [ -d "${ECVS_TOP_DIR}/${ECVS_MODULE}" ]; then
+			debug-print "$FUNCNAME: offline mode, exiting"
+			return 0
+		else
+			debug-print "$FUNCNAME: offline mode specified but module/subdir not found, exiting with error"
+			die "ERROR: Offline mode specified, but module/subdir checkout not found. Aborting."
+		fi
+	elif [ -n "$ECVS_SERVER" ]; then # ECVS_SERVER!=offline --> real fetching mode
+		einfo "Fetching cvs module $ECVS_MODULE into $ECVS_TOP_DIR..."
+		cvs_fetch
+	else	# ECVS_SERVER not set
+		die "ERROR: CVS server not set, cannot continue."
 	fi
-	chown `whoami` "${T}/cvspass"
-}
 
-cvs_src_unpack() {
-
-	debug-print-function $FUNCNAME $*
-	cvs_fetch || die "died running cvs_fetch"
+	einfo "Copying $ECVS_MODULE from $ECVS_TOP_DIR..."
+	debug-print "Copying module $ECVS_MODULElocal_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..."
 
-	einfo "Copying $ECVS_MODULE/$ECVS_SUBDIR from $ECVS_TOP_DIR..."
-	debug-print "Copying module $ECVS_MODULE subdir $ECVS_SUBDIR local_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..."
-	
 	# probably redundant, but best to make sure
-	mkdir -p "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR"
-	
-	if [ -n "$ECVS_SUBDIR" ]; then
-		if [ -n "$ECVS_LOCAL" ]; then
-			cp -f "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR"/* "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR"
-		else
-			cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR" "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR/.."
-		fi    
+	mkdir -p "$WORKDIR/$ECVS_MODULE"
+
+	if [ -n "$ECVS_LOCAL" ]; then
+		mkdir -p "$WORKDIR/$ECVS_MODULE"
+		cp -f "$ECVS_TOP_DIR/$ECVS_MODULE"/* "$WORKDIR/$ECVS_MODULE"
 	else
-		if [ -n "$ECVS_LOCAL" ]; then
-			cp -f "$ECVS_TOP_DIR/$ECVS_MODULE"/* $WORKDIR/$ECVS_MODULE
-		else
-			cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE" "$WORKDIR"
-		fi
+		cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE" "$WORKDIR/$ECVS_MODULE/.."
 	fi
-	
+
 	# if the directory is empty, remove it; empty directories cannot exist in cvs.
 	# this happens when fex. kde-source requests module/doc/subdir which doesn't exist.
 	# still create the empty directory in workdir though.
-	if [ "`ls -A \"$DIR\"`" == "CVS" ]; then
-		debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_MODULE/$ECVS_SUBDIR"
-		rm -rf "$DIR"
+	if [ "`ls -A \"${ECVS_TOP_DIR}/${ECVS_MODULE}\"`" == "CVS" ]; then
+		debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_MODULE"
+		rm -rf "${ECVS_TOP_DIR}/${ECVS_MODULE}"
 	fi
-	    
+
 	# implement some of base_src_unpack's functionality;
 	# note however that base.eclass may not have been inherited!
 	if [ -n "$PATCHES" ]; then