# mercurial: Fetch sources from mercurial repositories, similar to cvs.eclass.

# @ECLASS: mercurial.eclass

# To use this from an ebuild, set EHG_REPO_URI in your ebuild.  Then either

# @MAINTAINER:

# leave the default src_unpack or call mercurial_src_unpack.

# nelchael@gentoo.org

# @BLURB: This eclass provides generic mercurial fetching functions

# @DESCRIPTION:

# This eclass provides generic mercurial fetching functions. To fetch sources

# from mercurial repository just set EHG_REPO_URI to correct repository URI. If

# you need to share single repository between several ebuilds set EHG_PROJECT to

# project name in all of them.

DEPEND="dev-util/mercurial net-misc/rsync"

DEPEND="dev-util/mercurial"

EHG_STORE_DIR="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/hg-src"

# This must be set by the ebuild

# @ECLASS-VARIABLE: EHG_REPO_URI

: ${EHG_REPO_URI:=}                 # repository uri

# @DESCRIPTION:

# Mercurial repository URI.

# @ECLASS-VARIABLE: EHG_REVISION

# @DESCRIPTION:

# Create working directory for specified revision, defaults to tip.

[[ -z "${EHG_REVISION}" ]] && EHG_REVISION="tip"

# @ECLASS-VARIABLE: EHG_PROJECT

# @DESCRIPTION:

# Project name.

#

# This variable default to $PN, but can be changed to allow repository sharing

# between several ebuilds.

[[ -z "${EHG_PROJECT}" ]] && EHG_PROJECT="${PN}"

# @ECLASS-VARIABLE: EHG_CLONE_CMD

# @DESCRIPTION:

# Command used to perform initial repository clone.

[[ -z "${EHG_CLONE_CMD}" ]] && EHG_CLONE_CMD="hg clone --quiet --pull --noupdate"

# @ECLASS-VARIABLE: EHG_PULL_CMD

# @DESCRIPTION:

# Command used to update repository.

[[ -z "${EHG_PULL_CMD}" ]] && EHG_PULL_CMD="hg pull --quiet"

# @FUNCTION: mercurial_fetch

# @USAGE: [repository_uri] [module]

# @DESCRIPTION:

# Clone or update repository.

#

# If not repository URI is passed it defaults to EHG_REPO_URI, if module is

# empty it defaults to basename of EHG_REPO_URI.

function mercurial_fetch {

	debug-print-function ${FUNCNAME} ${*}

# These can be set by the ebuild but are usually fine as-is

	EHG_REPO_URI=${1-${EHG_REPO_URI}}

: ${EHG_PROJECT:=$PN}               # dir under EHG_STORE_DIR

	[[ -z "${EHG_REPO_URI}" ]] && die "EHG_REPO_URI is empty"

: ${EHG_CLONE_CMD:=hg clone --pull} # clone cmd

: ${EHG_PULL_CMD:=hg pull -u}       # pull cmd

# should be set but blank to prevent using $HOME/.hgrc

	local hg_src_dir="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/hg-src"

export HGRCPATH=

	local module="${2-$(basename "${EHG_REPO_URI}")}"

function mercurial_fetch {

	# Should be set but blank to prevent using $HOME/.hgrc

	declare repo=${1:-$EHG_REPO_URI}

	export HGRCPATH=

	repo=${repo%/}  # remove trailing slash

	[[ -n $repo ]] || die "EHG_REPO_URI is empty"

	# Check ${hg_src_dir} directory:

	declare module=${2:-${repo##*/}}

	addwrite "$(dirname "${hg_src_dir}")" || die "addwrite failed"

	if [[ ! -d "${hg_src_dir}" ]]; then

	if [[ ! -d ${EHG_STORE_DIR} ]]; then

		mkdir -p "${hg_src_dir}" || die "failed to create ${hg_src_dir}"

		ebegin "create ${EHG_STORE_DIR}"

		chmod -f g+rw "${hg_src_dir}" || \

		addwrite / &&

			die "failed to chown ${hg_src_dir}"

			mkdir -p "${EHG_STORE_DIR}" &&

			chmod -f g+rw "${EHG_STORE_DIR}" &&

			export SANDBOX_WRITE="${SANDBOX_WRITE%:/}"

		eend $? || die

	pushd "${EHG_STORE_DIR}" >/dev/null \

	# Create project directory:

		|| die "can't chdir to ${EHG_STORE_DIR}"

	mkdir -p "${hg_src_dir}/${EHG_PROJECT}" || \

	addwrite "$(pwd -P)"

		die "failed to create ${hg_src_dir}/${EHG_PROJECT}"

	chmod -f g+rw "${hg_src_dir}/${EHG_PROJECT}" || \

	if [[ ! -d ${EHG_PROJECT}/${module} ]]; then

		die "failed to chwon ${EHG_PROJECT}"

		# first check out

	cd "${hg_src_dir}/${EHG_PROJECT}" || \

		ebegin "${EHG_CLONE_CMD} ${repo}"

		die "failed to cd to ${hg_src_dir}/${EHG_PROJECT}"

		mkdir -p "${EHG_PROJECT}" &&

			chmod -f g+rw "${EHG_PROJECT}" &&

	# Clone/update repository:

			cd "${EHG_PROJECT}" &&

	if [[ ! -d "${module}" ]]; then

			${EHG_CLONE_CMD} "${repo}" "${module}" &&

		einfo "Cloning ${EHG_REPO_URI} to ${hg_src_dir}/${EHG_PROJECT}/${module}"

			cd "${module}"

		${EHG_CLONE_CMD} "${EHG_REPO_URI}" "${module}" || {

		eend $? || die

			rm -rf "${module}"

			die "failed to clone ${EHG_REPO_URI}"

		}

		cd "${module}"

		# update working copy

		einfo "Updating ${hg_src_dir}/${EHG_PROJECT}/${module} from ${EHG_REPO_URI}"

		ebegin "${EHG_PULL_CMD} ${repo}"

		cd "${module}" || die "failed to cd to ${module}"

		cd "${EHG_PROJECT}/${module}" &&

		${EHG_PULL_CMD} || die "update failed"

			${EHG_PULL_CMD}

		case $? in

			# hg pull returns status 1 when there were no changes to pull

			1) eend 0 ;;

			*) eend $? || die ;;

		esac

	# use rsync instead of cp for --exclude

	# Checkout working copy:

	ebegin "rsync to ${WORKDIR}/${module}"

	einfo "Creating working directory export in ${WORKDIR}/${module} (revision: ${EHG_REVISION})"

	mkdir -p "${WORKDIR}/${module}" &&

	hg archive \

		rsync -a --delete --exclude=.hg/ . "${WORKDIR}/${module}"

		--quiet \

	eend $? || die

		--rev="${EHG_REVISION}" \

		--type=files \

	popd >/dev/null

		"${WORKDIR}/${module}" || die "hg archive failed"