gentoo-x86/eclass/git.eclass

# Copyright 1999-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/git.eclass,v 1.31 2009/10/20 10:05:47 scarabeus Exp $

# @ECLASS: git.eclass
# @MAINTAINER:
# Tomas Chvatal <scarabeus@gentoo.org>
# Donnie Berkholz <dberkholz@gentoo.org>
# @BLURB: This eclass provides functions for fetch and unpack git repositories
# @DESCRIPTION:
# The eclass is based on subversion eclass.
# If you use this eclass, the ${S} is ${WORKDIR}/${P}.
# It is necessary to define the EGIT_REPO_URI variable at least.
# @THANKS TO:
# Fernando J. Pereda <ferdy@gentoo.org>

inherit eutils

EGIT="git.eclass"

EXPORTED_FUNCTIONS="src_unpack"
case "${EAPI:-0}" in
        2) EXPORTED_FUNCTIONS="${EXPORTED_FUNCTIONS} src_prepare" ;;
        0|1) ;;
        *) die "Unknown EAPI, Bug eclass maintainers." ;;
esac
EXPORT_FUNCTIONS ${EXPORTED_FUNCTIONS}

# define some nice defaults but only if nothing is set already
: ${HOMEPAGE:=http://git-scm.com/}

# We DEPEND on at least a bit recent git version
DEPEND=">=dev-util/git-1.6"

# @ECLASS-VARIABLE: EGIT_QUIET
# @DESCRIPTION:
# Enables user specified verbosity for the eclass elog informations.
# The user just needs to add EGIT_QUIET="ON" to the /etc/make.conf.
: ${EGIT_QUIET:="OFF"}

# @ECLASS-VARIABLE: EGIT_STORE_DIR
# @DESCRIPTION:
# Storage directory for git sources.
# Can be redefined.
[[ -z ${EGIT_STORE_DIR} ]] && EGIT_STORE_DIR="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/git-src"

# @ECLASS-VARIABLE: EGIT_FETCH_CMD
# @DESCRIPTION:
# Command for cloning the repository.
: ${EGIT_FETCH_CMD:="git clone"}

# @ECLASS-VARIABLE: EGIT_UPDATE_CMD
# @DESCRIPTION:
# Git fetch command.
EGIT_UPDATE_CMD="git pull -f -u"

# @ECLASS-VARIABLE: EGIT_DIFFSTAT_CMD
# @DESCRIPTION:
# Git command for diffstat.
EGIT_DIFFSTAT_CMD="git --no-pager diff --stat"

# @ECLASS-VARIABLE: EGIT_OPTIONS
# @DESCRIPTION:
# This variable value is passed to clone and fetch.
: ${EGIT_OPTIONS:=}

# @ECLASS-VARIABLE: EGIT_REPO_URI
# @DESCRIPTION:
# URI for the repository
# e.g. http://foo, git://bar
# Supported protocols:
#   http://
#   https://
#   git://
#   git+ssh://
#   rsync://
#   ssh://
eval X="\$${PN//[-+]/_}_LIVE_REPO"
if [[ ${X} = "" ]]; then
        EGIT_REPO_URI=${EGIT_REPO_URI:=}
else
        EGIT_REPO_URI="${X}"
fi
# @ECLASS-VARIABLE: EGIT_PROJECT
# @DESCRIPTION:
# Project name of your ebuild.
# Git eclass will check out the git repository like:
#       ${EGIT_STORE_DIR}/${EGIT_PROJECT}/${EGIT_REPO_URI##*/}
# so if you define EGIT_REPO_URI as http://git.collab.net/repo/git or
# http://git.collab.net/repo/git. and PN is subversion-git.
# it will check out like:
#       ${EGIT_STORE_DIR}/subversion
: ${EGIT_PROJECT:=${PN/-git}}

# @ECLASS-VARIABLE: EGIT_BOOTSTRAP
# @DESCRIPTION:
# bootstrap script or command like autogen.sh or etc...
: ${EGIT_BOOTSTRAP:=}

# @ECLASS-VARIABLE: EGIT_OFFLINE
# @DESCRIPTION:
# Set this variable to a non-empty value to disable the automatic updating of
# an GIT source tree. This is intended to be set outside the git source
# tree by users.
EGIT_OFFLINE="${EGIT_OFFLINE:-${ESCM_OFFLINE}}"

# @ECLASS-VARIABLE: EGIT_PATCHES
# @DESCRIPTION:
# Similar to PATCHES array from base.eclass
# Only difference is that this patches are applied before bootstrap.
# Please take note that this variable should be bash array.

# @ECLASS-VARIABLE: EGIT_BRANCH
# @DESCRIPTION:
# git eclass can fetch any branch in git_fetch().
eval X="\$${PN//[-+]/_}_LIVE_BRANCH"
if [[ ${X} = "" ]]; then
        EGIT_BRANCH=${EGIT_BRANCH:=master}
else
        EGIT_BRANCH="${X}"
fi

# @ECLASS-VARIABLE: EGIT_COMMIT
# @DESCRIPTION:
# git eclass can checkout any commit.
eval X="\$${PN//[-+]/_}_LIVE_COMMIT"
if [[ ${X} = "" ]]; then
        : ${EGIT_COMMIT:=${EGIT_BRANCH}}
else
        EGIT_COMMIT="${X}"
fi

# @ECLASS-VARIABLE: EGIT_REPACK
# @DESCRIPTION:
# git eclass will repack objects to save disk space. However this can take a
# long time with VERY big repositories.
: ${EGIT_REPACK:=false}

# @ECLASS-VARIABLE: EGIT_PRUNE
# @DESCRIPTION:
# git eclass can prune the local clone. This is useful if upstream rewinds and
# rebases branches too often.
: ${EGIT_PRUNE:=false}

# @FUNCTION: git_submodules
# @DESCRIPTION:
# Internal function wrapping the submodule initialisation and update
git_sumbodules() {
        debug-print "git submodule init"
        git submodule init
        debug-print "git submodule update"
        git submodule update
}

# @FUNCTION: git_fetch
# @DESCRIPTION:
# Gets repository from EGIT_REPO_URI and store it in specified EGIT_STORE_DIR
git_fetch() {
        debug-print-function ${FUNCNAME} "$@"

        local GIT_DIR EGIT_CLONE_DIR oldsha1 cursha1

        # choose if user wants elog or just einfo.
        if [[ ${EGIT_QUIET} != OFF ]]; then
                elogcmd="einfo"
        else
                elogcmd="elog"
        fi

        # If we have same branch and the tree we can do --depth 1 clone
        # which outputs into really smaller data transfers.
        # Sadly we can do shallow copy for now because quite a few packages need .git
        # folder.
        #[[ ${EGIT_COMMIT} = ${EGIT_BRANCH} ]] && \
        #       EGIT_FETCH_CMD="${EGIT_FETCH_CMD} --depth 1"
        if [[ ! -z ${EGIT_TREE} ]] ; then
                EGIT_COMMIT=${EGIT_TREE}
                eqawarn "Usage of deprecated EGIT_TREE variable detected."
                eqawarn "Use EGIT_COMMIT variable instead."
        fi

        # EGIT_REPO_URI is empty.
        [[ -z ${EGIT_REPO_URI} ]] && die "${EGIT}: EGIT_REPO_URI is empty."

        # check for the protocol or pull from a local repo.
        if [[ -z ${EGIT_REPO_URI%%:*} ]] ; then
                case ${EGIT_REPO_URI%%:*} in
                        git*|http|https|rsync|ssh) ;;
                        *) die "${EGIT}: protocol for fetch from "${EGIT_REPO_URI%:*}" is not yet implemented in eclass." ;;
                esac
        fi

        # initial clone, we have to create master git storage directory and play
        # nicely with sandbox
        if [[ ! -d ${EGIT_STORE_DIR} ]] ; then
                debug-print "${FUNCNAME}: initial clone. creating git directory"
                addwrite /
                mkdir -p "${EGIT_STORE_DIR}" \
                        || die "${EGIT}: can't mkdir ${EGIT_STORE_DIR}."
                export SANDBOX_WRITE="${SANDBOX_WRITE%%:/}"
        fi

        cd -P "${EGIT_STORE_DIR}" || die "${EGIT}: can't chdir to ${EGIT_STORE_DIR}"
        EGIT_STORE_DIR=${PWD}

        # allow writing into EGIT_STORE_DIR
        addwrite "${EGIT_STORE_DIR}"

        [[ -z ${EGIT_REPO_URI##*/} ]] && EGIT_REPO_URI="${EGIT_REPO_URI%/}"
        EGIT_CLONE_DIR="${EGIT_PROJECT}"

        debug-print "${FUNCNAME}: EGIT_OPTIONS = \"${EGIT_OPTIONS}\""

        GIT_DIR="${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}"
        pushd ${EGIT_STORE_DIR} &> /dev/null
        # we also have to remove all shallow copied repositories
        # and fetch them again
        if [[ -e "${GIT_DIR}/shallow" ]]; then
                rm -rf "${GIT_DIR}"
                einfo "The ${EGIT_CLONE_DIR} was shallow copy. Refetching."
        fi
        # repack from bare copy to normal one
        if [[ -d ${GIT_DIR} && ! -d "${GIT_DIR}/.git/" ]]; then
                rm -rf "${GIT_DIR}"
                einfo "The ${EGIT_CLONE_DIR} was bare copy. Refetching."
        fi

        if [[ ! -d ${GIT_DIR} ]] ; then
                # first clone
                ${elogcmd} "GIT NEW clone -->"
                ${elogcmd} "   repository:              ${EGIT_REPO_URI}"

                debug-print "${EGIT_FETCH_CMD} ${EGIT_OPTIONS} \"${EGIT_REPO_URI}\" ${GIT_DIR}"
                ${EGIT_FETCH_CMD} ${EGIT_OPTIONS} "${EGIT_REPO_URI}" ${GIT_DIR} \
                        || die "${EGIT}: can't fetch from ${EGIT_REPO_URI}."
                
                pushd "${GIT_DIR}" &> /dev/null
                cursha1=$(git rev-parse origin/${EGIT_BRANCH})
                ${elogcmd} "   at the commit:           ${cursha1}"

                git_sumbodules
                popd &> /dev/null
        elif [[ -n ${EGIT_OFFLINE} ]] ; then
                pushd "${GIT_DIR}" &> /dev/null
                cursha1=$(git rev-parse origin/${EGIT_BRANCH})
                ${elogcmd} "GIT offline update -->"
                ${elogcmd} "   repository:              ${EGIT_REPO_URI}"
                ${elogcmd} "   at the commit:           ${cursha1}"
                popd &> /dev/null
        else
                pushd "${GIT_DIR}" &> /dev/null
                # Git urls might change, so unconditionally set it here
                git config remote.origin.url "${EGIT_REPO_URI}"

                # fetch updates
                ${elogcmd} "GIT update -->"
                ${elogcmd} "   repository:              ${EGIT_REPO_URI}"
                
                oldsha1=$(git rev-parse origin/${EGIT_BRANCH})

                debug-print "${EGIT_UPDATE_CMD} ${EGIT_OPTIONS}"
                ${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} \
                        || die "${EGIT}: can't update from ${EGIT_REPO_URI}."

                git_sumbodules
                cursha1=$(git rev-parse origin/${EGIT_BRANCH})

                # write out message based on the revisions
                if [[ ${oldsha1} != ${cursha1} ]]; then
                        ${elogcmd} "   updating from commit:    ${oldsha1}"
                        ${elogcmd} "   to commit:               ${cursha1}"
                else
                        ${elogcmd} "   at the commit:           ${cursha1}"
                        # @ECLASS_VARIABLE: LIVE_FAIL_FETCH_IF_REPO_NOT_UPDATED
                        # @DESCRIPTION:
                        # If this variable is set to TRUE in make.conf or somewhere in
                        # enviroment the package will fail if there is no update, thus in
                        # combination with --keep-going it would lead in not-updating
                        # pakcages that are up-to-date.
                        # TODO: this can lead to issues if more projects/packages use same repo
                        [[ ${LIVE_FAIL_FETCH_IF_REPO_NOT_UPDATED} = true ]] && \
                                debug-print "${FUNCNAME}: Repository \"${EGIT_REPO_URI}\" is up-to-date. Skipping." && \
                                die "${EGIT}: Repository \"${EGIT_REPO_URI}\" is up-to-date. Skipping."
                fi
                ${EGIT_DIFFSTAT_CMD} ${oldsha1}..origin/${EGIT_BRANCH}
                popd &> /dev/null
        fi
        
        pushd "${GIT_DIR}" &> /dev/null
        if ${EGIT_REPACK} || ${EGIT_PRUNE} ; then
                ebegin "Garbage collecting the repository"
                git gc $(${EGIT_PRUNE} && echo '--prune')
                eend $?
        fi
        popd &> /dev/null

        # export the git version
        export EGIT_VERSION="${cursha1}"

        [[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]] && elog "   commit:                      ${EGIT_COMMIT}"
        ${elogcmd} "   branch:                  ${EGIT_BRANCH}"
        ${elogcmd} "   storage directory:       \"${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}\""

        # unpack to the ${S}
        popd &> /dev/null
        debug-print "cp -aR \"${GIT_DIR}\" \"${S}\""
        cp -aR "${GIT_DIR}" "${S}"

        # set correct branch and the tree ebuild specified
        pushd "${S}" > /dev/null
        local branchname=branch-${EGIT_BRANCH} src=origin/${EGIT_BRANCH}
        if [[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]]; then
                branchname=tree-${EGIT_COMMIT}
                src=${EGIT_COMMIT}
        fi
        debug-print "git checkout -b ${branchname} ${src}"
        git checkout -b ${branchname} ${src} 2>&1 > /dev/null
        git_sumbodules
        popd > /dev/null

        unset branchname src

        echo ">>> Unpacked to ${S}"
}

# @FUNCTION: git_bootstrap
# @DESCRIPTION:
# Runs bootstrap command if EGIT_BOOTSTRAP variable contains some value
# Remember that what ever gets to the EGIT_BOOTSTRAP variable gets evaled by bash.
git_bootstrap() {
        debug-print-function ${FUNCNAME} "$@"

        if [[ -n ${EGIT_BOOTSTRAP} ]] ; then
                pushd "${S}" > /dev/null
                einfo "Starting bootstrap"

                if [[ -f ${EGIT_BOOTSTRAP} ]]; then
                        # we have file in the repo which we should execute
                        debug-print "$FUNCNAME: bootstraping with file \"${EGIT_BOOTSTRAP}\""

                        if [[ -x ${EGIT_BOOTSTRAP} ]]; then
                                eval "./${EGIT_BOOTSTRAP}" \
                                        || die "${EGIT}: bootstrap script failed"
                        else
                                eerror "\"${EGIT_BOOTSTRAP}\" is not executable."
                                eerror "Report upstream, or bug ebuild maintainer to remove bootstrap command."
                                die "${EGIT}: \"${EGIT_BOOTSTRAP}\" is not executable."
                        fi
                else
                        # we execute some system command
                        debug-print "$FUNCNAME: bootstraping with commands \"${EGIT_BOOTSTRAP}\""

                        eval "${EGIT_BOOTSTRAP}" \
                                || die "${EGIT}: bootstrap commands failed."

                fi

                einfo "Bootstrap finished"
                popd > /dev/null
        fi
}

# @FUNCTION: git_apply_patches
# @DESCRIPTION:
# Apply patches from EGIT_PATCHES bash array.
# Preffered is using the variable as bash array but for now it allows to write
# it also as normal space separated string list. (This part of code should be
# removed when all ebuilds get converted on bash array).
git_apply_patches() {
        debug-print-function ${FUNCNAME} "$@"

        pushd "${S}" > /dev/null
        if [[ ${#EGIT_PATCHES[@]} -gt 1 ]] ; then
                for i in "${EGIT_PATCHES[@]}"; do
                        debug-print "$FUNCNAME: git_autopatch: patching from ${i}"
                        epatch "${i}"
                done
        elif [[ ${EGIT_PATCHES} != "" ]]; then
                # no need for loop if space separated string is passed.
                debug-print "$FUNCNAME: git_autopatch: patching from ${EGIT_PATCHES}"
                epatch "${EGIT_PATCHES}"
        fi

        popd > /dev/null
}

# @FUNCTION: git_src_unpack
# @DESCRIPTION:
# src_upack function, calls src_prepare one if EAPI!=2.
git_src_unpack() {
        debug-print-function ${FUNCNAME} "$@"

        git_fetch || die "${EGIT}: unknown problem in git_fetch()."

        has src_prepare ${EXPORTED_FUNCTIONS} || git_src_prepare
}

# @FUNCTION: git_src_prepare
# @DESCRIPTION:
# src_prepare function for git stuff. Patches, bootstrap...
git_src_prepare() {
        debug-print-function ${FUNCNAME} "$@"

        git_apply_patches
        git_bootstrap
}
1	# Copyright 1999-2009 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/git.eclass,v 1.31 2009/10/20 10:05:47 scarabeus Exp $
4
5	# @ECLASS: git.eclass
6	# @MAINTAINER:
7	# Tomas Chvatal <scarabeus@gentoo.org>
8	# Donnie Berkholz <dberkholz@gentoo.org>
9	# @BLURB: This eclass provides functions for fetch and unpack git repositories
10	# @DESCRIPTION:
11	# The eclass is based on subversion eclass.
12	# If you use this eclass, the ${S} is ${WORKDIR}/${P}.
13	# It is necessary to define the EGIT_REPO_URI variable at least.
14	# @THANKS TO:
15	# Fernando J. Pereda <ferdy@gentoo.org>
16
17	inherit eutils
18
19	EGIT="git.eclass"
20
21	EXPORTED_FUNCTIONS="src_unpack"
22	case "${EAPI:-0}" in
23	2) EXPORTED_FUNCTIONS="${EXPORTED_FUNCTIONS} src_prepare" ;;
24	0\|1) ;;
25	*) die "Unknown EAPI, Bug eclass maintainers." ;;
26	esac
27	EXPORT_FUNCTIONS ${EXPORTED_FUNCTIONS}
28
29	# define some nice defaults but only if nothing is set already
30	: ${HOMEPAGE:=http://git-scm.com/}
31
32	# We DEPEND on at least a bit recent git version
33	DEPEND=">=dev-util/git-1.6"
34
35	# @ECLASS-VARIABLE: EGIT_QUIET
36	# @DESCRIPTION:
37	# Enables user specified verbosity for the eclass elog informations.
38	# The user just needs to add EGIT_QUIET="ON" to the /etc/make.conf.
39	: ${EGIT_QUIET:="OFF"}
40
41	# @ECLASS-VARIABLE: EGIT_STORE_DIR
42	# @DESCRIPTION:
43	# Storage directory for git sources.
44	# Can be redefined.
45	[[ -z ${EGIT_STORE_DIR} ]] && EGIT_STORE_DIR="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/git-src"
46
47	# @ECLASS-VARIABLE: EGIT_FETCH_CMD
48	# @DESCRIPTION:
49	# Command for cloning the repository.
50	: ${EGIT_FETCH_CMD:="git clone"}
51
52	# @ECLASS-VARIABLE: EGIT_UPDATE_CMD
53	# @DESCRIPTION:
54	# Git fetch command.
55	EGIT_UPDATE_CMD="git pull -f -u"
56
57	# @ECLASS-VARIABLE: EGIT_DIFFSTAT_CMD
58	# @DESCRIPTION:
59	# Git command for diffstat.
60	EGIT_DIFFSTAT_CMD="git --no-pager diff --stat"
61
62	# @ECLASS-VARIABLE: EGIT_OPTIONS
63	# @DESCRIPTION:
64	# This variable value is passed to clone and fetch.
65	: ${EGIT_OPTIONS:=}
66
67	# @ECLASS-VARIABLE: EGIT_REPO_URI
68	# @DESCRIPTION:
69	# URI for the repository
70	# e.g. http://foo, git://bar
71	# Supported protocols:
72	# http://
73	# https://
74	# git://
75	# git+ssh://
76	# rsync://
77	# ssh://
78	eval X="\$${PN//[-+]/_}_LIVE_REPO"
79	if [[ ${X} = "" ]]; then
80	EGIT_REPO_URI=${EGIT_REPO_URI:=}
81	else
82	EGIT_REPO_URI="${X}"
83	fi
84	# @ECLASS-VARIABLE: EGIT_PROJECT
85	# @DESCRIPTION:
86	# Project name of your ebuild.
87	# Git eclass will check out the git repository like:
88	# ${EGIT_STORE_DIR}/${EGIT_PROJECT}/${EGIT_REPO_URI##*/}
89	# so if you define EGIT_REPO_URI as http://git.collab.net/repo/git or
90	# http://git.collab.net/repo/git. and PN is subversion-git.
91	# it will check out like:
92	# ${EGIT_STORE_DIR}/subversion
93	: ${EGIT_PROJECT:=${PN/-git}}
94
95	# @ECLASS-VARIABLE: EGIT_BOOTSTRAP
96	# @DESCRIPTION:
97	# bootstrap script or command like autogen.sh or etc...
98	: ${EGIT_BOOTSTRAP:=}
99
100	# @ECLASS-VARIABLE: EGIT_OFFLINE
101	# @DESCRIPTION:
102	# Set this variable to a non-empty value to disable the automatic updating of
103	# an GIT source tree. This is intended to be set outside the git source
104	# tree by users.
105	EGIT_OFFLINE="${EGIT_OFFLINE:-${ESCM_OFFLINE}}"
106
107	# @ECLASS-VARIABLE: EGIT_PATCHES
108	# @DESCRIPTION:
109	# Similar to PATCHES array from base.eclass
110	# Only difference is that this patches are applied before bootstrap.
111	# Please take note that this variable should be bash array.
112
113	# @ECLASS-VARIABLE: EGIT_BRANCH
114	# @DESCRIPTION:
115	# git eclass can fetch any branch in git_fetch().
116	eval X="\$${PN//[-+]/_}_LIVE_BRANCH"
117	if [[ ${X} = "" ]]; then
118	EGIT_BRANCH=${EGIT_BRANCH:=master}
119	else
120	EGIT_BRANCH="${X}"
121	fi
122
123	# @ECLASS-VARIABLE: EGIT_COMMIT
124	# @DESCRIPTION:
125	# git eclass can checkout any commit.
126	eval X="\$${PN//[-+]/_}_LIVE_COMMIT"
127	if [[ ${X} = "" ]]; then
128	: ${EGIT_COMMIT:=${EGIT_BRANCH}}
129	else
130	EGIT_COMMIT="${X}"
131	fi
132
133	# @ECLASS-VARIABLE: EGIT_REPACK
134	# @DESCRIPTION:
135	# git eclass will repack objects to save disk space. However this can take a
136	# long time with VERY big repositories.
137	: ${EGIT_REPACK:=false}
138
139	# @ECLASS-VARIABLE: EGIT_PRUNE
140	# @DESCRIPTION:
141	# git eclass can prune the local clone. This is useful if upstream rewinds and
142	# rebases branches too often.
143	: ${EGIT_PRUNE:=false}
144
145	# @FUNCTION: git_submodules
146	# @DESCRIPTION:
147	# Internal function wrapping the submodule initialisation and update
148	git_sumbodules() {
149	debug-print "git submodule init"
150	git submodule init
151	debug-print "git submodule update"
152	git submodule update
153	}
154
155	# @FUNCTION: git_fetch
156	# @DESCRIPTION:
157	# Gets repository from EGIT_REPO_URI and store it in specified EGIT_STORE_DIR
158	git_fetch() {
159	debug-print-function ${FUNCNAME} "$@"
160
161	local GIT_DIR EGIT_CLONE_DIR oldsha1 cursha1
162
163	# choose if user wants elog or just einfo.
164	if [[ ${EGIT_QUIET} != OFF ]]; then
165	elogcmd="einfo"
166	else
167	elogcmd="elog"
168	fi
169
170	# If we have same branch and the tree we can do --depth 1 clone
171	# which outputs into really smaller data transfers.
172	# Sadly we can do shallow copy for now because quite a few packages need .git
173	# folder.
174	#[[ ${EGIT_COMMIT} = ${EGIT_BRANCH} ]] && \
175	# EGIT_FETCH_CMD="${EGIT_FETCH_CMD} --depth 1"
176	if [[ ! -z ${EGIT_TREE} ]] ; then
177	EGIT_COMMIT=${EGIT_TREE}
178	eqawarn "Usage of deprecated EGIT_TREE variable detected."
179	eqawarn "Use EGIT_COMMIT variable instead."
180	fi
181
182	# EGIT_REPO_URI is empty.
183	[[ -z ${EGIT_REPO_URI} ]] && die "${EGIT}: EGIT_REPO_URI is empty."
184
185	# check for the protocol or pull from a local repo.
186	if [[ -z ${EGIT_REPO_URI%%:*} ]] ; then
187	case ${EGIT_REPO_URI%%:*} in
188	git*\|http\|https\|rsync\|ssh) ;;
189	) die "${EGIT}: protocol for fetch from "${EGIT_REPO_URI%:}" is not yet implemented in eclass." ;;
190	esac
191	fi
192
193	# initial clone, we have to create master git storage directory and play
194	# nicely with sandbox
195	if [[ ! -d ${EGIT_STORE_DIR} ]] ; then
196	debug-print "${FUNCNAME}: initial clone. creating git directory"
197	addwrite /
198	mkdir -p "${EGIT_STORE_DIR}" \
199	\|\| die "${EGIT}: can't mkdir ${EGIT_STORE_DIR}."
200	export SANDBOX_WRITE="${SANDBOX_WRITE%%:/}"
201	fi
202
203	cd -P "${EGIT_STORE_DIR}" \|\| die "${EGIT}: can't chdir to ${EGIT_STORE_DIR}"
204	EGIT_STORE_DIR=${PWD}
205
206	# allow writing into EGIT_STORE_DIR
207	addwrite "${EGIT_STORE_DIR}"
208
209	[[ -z ${EGIT_REPO_URI##*/} ]] && EGIT_REPO_URI="${EGIT_REPO_URI%/}"
210	EGIT_CLONE_DIR="${EGIT_PROJECT}"
211
212	debug-print "${FUNCNAME}: EGIT_OPTIONS = \"${EGIT_OPTIONS}\""
213
214	GIT_DIR="${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}"
215	pushd ${EGIT_STORE_DIR} &> /dev/null
216	# we also have to remove all shallow copied repositories
217	# and fetch them again
218	if [[ -e "${GIT_DIR}/shallow" ]]; then
219	rm -rf "${GIT_DIR}"
220	einfo "The ${EGIT_CLONE_DIR} was shallow copy. Refetching."
221	fi
222	# repack from bare copy to normal one
223	if [[ -d ${GIT_DIR} && ! -d "${GIT_DIR}/.git/" ]]; then
224	rm -rf "${GIT_DIR}"
225	einfo "The ${EGIT_CLONE_DIR} was bare copy. Refetching."
226	fi
227
228	if [[ ! -d ${GIT_DIR} ]] ; then
229	# first clone
230	${elogcmd} "GIT NEW clone -->"
231	${elogcmd} " repository: ${EGIT_REPO_URI}"
232
233	debug-print "${EGIT_FETCH_CMD} ${EGIT_OPTIONS} \"${EGIT_REPO_URI}\" ${GIT_DIR}"
234	${EGIT_FETCH_CMD} ${EGIT_OPTIONS} "${EGIT_REPO_URI}" ${GIT_DIR} \
235	\|\| die "${EGIT}: can't fetch from ${EGIT_REPO_URI}."
236
237	pushd "${GIT_DIR}" &> /dev/null
238	cursha1=$(git rev-parse origin/${EGIT_BRANCH})
239	${elogcmd} " at the commit: ${cursha1}"
240
241	git_sumbodules
242	popd &> /dev/null
243	elif [[ -n ${EGIT_OFFLINE} ]] ; then
244	pushd "${GIT_DIR}" &> /dev/null
245	cursha1=$(git rev-parse origin/${EGIT_BRANCH})
246	${elogcmd} "GIT offline update -->"
247	${elogcmd} " repository: ${EGIT_REPO_URI}"
248	${elogcmd} " at the commit: ${cursha1}"
249	popd &> /dev/null
250	else
251	pushd "${GIT_DIR}" &> /dev/null
252	# Git urls might change, so unconditionally set it here
253	git config remote.origin.url "${EGIT_REPO_URI}"
254
255	# fetch updates
256	${elogcmd} "GIT update -->"
257	${elogcmd} " repository: ${EGIT_REPO_URI}"
258
259	oldsha1=$(git rev-parse origin/${EGIT_BRANCH})
260
261	debug-print "${EGIT_UPDATE_CMD} ${EGIT_OPTIONS}"
262	${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} \
263	\|\| die "${EGIT}: can't update from ${EGIT_REPO_URI}."
264
265	git_sumbodules
266	cursha1=$(git rev-parse origin/${EGIT_BRANCH})
267
268	# write out message based on the revisions
269	if [[ ${oldsha1} != ${cursha1} ]]; then
270	${elogcmd} " updating from commit: ${oldsha1}"
271	${elogcmd} " to commit: ${cursha1}"
272	else
273	${elogcmd} " at the commit: ${cursha1}"
274	# @ECLASS_VARIABLE: LIVE_FAIL_FETCH_IF_REPO_NOT_UPDATED
275	# @DESCRIPTION:
276	# If this variable is set to TRUE in make.conf or somewhere in
277	# enviroment the package will fail if there is no update, thus in
278	# combination with --keep-going it would lead in not-updating
279	# pakcages that are up-to-date.
280	# TODO: this can lead to issues if more projects/packages use same repo
281	[[ ${LIVE_FAIL_FETCH_IF_REPO_NOT_UPDATED} = true ]] && \
282	debug-print "${FUNCNAME}: Repository \"${EGIT_REPO_URI}\" is up-to-date. Skipping." && \
283	die "${EGIT}: Repository \"${EGIT_REPO_URI}\" is up-to-date. Skipping."
284	fi
285	${EGIT_DIFFSTAT_CMD} ${oldsha1}..origin/${EGIT_BRANCH}
286	popd &> /dev/null
287	fi
288
289	pushd "${GIT_DIR}" &> /dev/null
290	if ${EGIT_REPACK} \|\| ${EGIT_PRUNE} ; then
291	ebegin "Garbage collecting the repository"
292	git gc $(${EGIT_PRUNE} && echo '--prune')
293	eend $?
294	fi
295	popd &> /dev/null
296
297	# export the git version
298	export EGIT_VERSION="${cursha1}"
299
300	[[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]] && elog " commit: ${EGIT_COMMIT}"
301	${elogcmd} " branch: ${EGIT_BRANCH}"
302	${elogcmd} " storage directory: \"${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}\""
303
304	# unpack to the ${S}
305	popd &> /dev/null
306	debug-print "cp -aR \"${GIT_DIR}\" \"${S}\""
307	cp -aR "${GIT_DIR}" "${S}"
308
309	# set correct branch and the tree ebuild specified
310	pushd "${S}" > /dev/null
311	local branchname=branch-${EGIT_BRANCH} src=origin/${EGIT_BRANCH}
312	if [[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]]; then
313	branchname=tree-${EGIT_COMMIT}
314	src=${EGIT_COMMIT}
315	fi
316	debug-print "git checkout -b ${branchname} ${src}"
317	git checkout -b ${branchname} ${src} 2>&1 > /dev/null
318	git_sumbodules
319	popd > /dev/null
320
321	unset branchname src
322
323	echo ">>> Unpacked to ${S}"
324	}
325
326	# @FUNCTION: git_bootstrap
327	# @DESCRIPTION:
328	# Runs bootstrap command if EGIT_BOOTSTRAP variable contains some value
329	# Remember that what ever gets to the EGIT_BOOTSTRAP variable gets evaled by bash.
330	git_bootstrap() {
331	debug-print-function ${FUNCNAME} "$@"
332
333	if [[ -n ${EGIT_BOOTSTRAP} ]] ; then
334	pushd "${S}" > /dev/null
335	einfo "Starting bootstrap"
336
337	if [[ -f ${EGIT_BOOTSTRAP} ]]; then
338	# we have file in the repo which we should execute
339	debug-print "$FUNCNAME: bootstraping with file \"${EGIT_BOOTSTRAP}\""
340
341	if [[ -x ${EGIT_BOOTSTRAP} ]]; then
342	eval "./${EGIT_BOOTSTRAP}" \
343	\|\| die "${EGIT}: bootstrap script failed"
344	else
345	eerror "\"${EGIT_BOOTSTRAP}\" is not executable."
346	eerror "Report upstream, or bug ebuild maintainer to remove bootstrap command."
347	die "${EGIT}: \"${EGIT_BOOTSTRAP}\" is not executable."
348	fi
349	else
350	# we execute some system command
351	debug-print "$FUNCNAME: bootstraping with commands \"${EGIT_BOOTSTRAP}\""
352
353	eval "${EGIT_BOOTSTRAP}" \
354	\|\| die "${EGIT}: bootstrap commands failed."
355
356	fi
357
358	einfo "Bootstrap finished"
359	popd > /dev/null
360	fi
361	}
362
363	# @FUNCTION: git_apply_patches
364	# @DESCRIPTION:
365	# Apply patches from EGIT_PATCHES bash array.
366	# Preffered is using the variable as bash array but for now it allows to write
367	# it also as normal space separated string list. (This part of code should be
368	# removed when all ebuilds get converted on bash array).
369	git_apply_patches() {
370	debug-print-function ${FUNCNAME} "$@"
371
372	pushd "${S}" > /dev/null
373	if [[ ${#EGIT_PATCHES[@]} -gt 1 ]] ; then
374	for i in "${EGIT_PATCHES[@]}"; do
375	debug-print "$FUNCNAME: git_autopatch: patching from ${i}"
376	epatch "${i}"
377	done
378	elif [[ ${EGIT_PATCHES} != "" ]]; then
379	# no need for loop if space separated string is passed.
380	debug-print "$FUNCNAME: git_autopatch: patching from ${EGIT_PATCHES}"
381	epatch "${EGIT_PATCHES}"
382	fi
383
384	popd > /dev/null
385	}
386
387	# @FUNCTION: git_src_unpack
388	# @DESCRIPTION:
389	# src_upack function, calls src_prepare one if EAPI!=2.
390	git_src_unpack() {
391	debug-print-function ${FUNCNAME} "$@"
392
393	git_fetch \|\| die "${EGIT}: unknown problem in git_fetch()."
394
395	has src_prepare ${EXPORTED_FUNCTIONS} \|\| git_src_prepare
396	}
397
398	# @FUNCTION: git_src_prepare
399	# @DESCRIPTION:
400	# src_prepare function for git stuff. Patches, bootstrap...
401	git_src_prepare() {
402	debug-print-function ${FUNCNAME} "$@"
403
404	git_apply_patches
405	git_bootstrap
406	}