gentoo-x86/eclass/git.eclass

# Copyright 1999-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: $

# @ECLASS: git.eclass
# @MAINTAINER:
# Tomas Chvatal <scarabeus@gentoo.org>
# Donnie Berkholz <dberkholz@gentoo.org>
# @BLURB: This eclass provides functions for fetch and unpack git repozitories
# @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) EXPORT_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.
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 --bare"

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

# @ECLASS-VARIABLE: EGIT_DIFFSTAT_CMD
# @DESCRIPTION:
# Git command for diffstat.
EGIT_DIFFSTAT_CMD="git 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://
: ${EGIT_REPO_URI:=}

# @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_BOOSTRAP
# @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().
: ${EGIT_BRANCH:=master}

# @ECLASS-VARIABLE: EGIT_TREE
# @DESCRIPTION:
# git eclass can checkout any tree.
: ${EGIT_TREE:=${EGIT_BRANCH}}

# @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_fetch
# @DESCRIPTION:
# Gets repository from EGIT_REPO_URI and store it in specified EGIT_STORE_DIR
git_fetch() {
        debug-print-function ${FUNCNAME} "$@"

        local 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 few packages need .git
        # folder.
        #[[ ${EGIT_TREE} = ${EGIT_BRANCH} ]] && \
        #       EGIT_FETCH_CMD="${EGIT_FETCH_CMD} --depth 1"

        # 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}\""

        export GIT_DIR="${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}"

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

                ${EGIT_FETCH_CMD} ${EGIT_OPTIONS} "${EGIT_REPO_URI}" ${EGIT_PROJECT} \
                        || die "${EGIT}: can't fetch from ${EGIT_REPO_URI}."

                oldsha1=$(git rev-parse ${EGIT_BRANCH})
                ${elogcmd} "   at the commit:           ${oldsha1}"

                # We use --bare cloning, so git doesn't do this for us.
                git config remote.origin.url "${EGIT_REPO_URI}"
        elif [[ -n ${EGIT_OFFLINE} ]] ; then
                oldsha1=$(git rev-parse ${EGIT_BRANCH})
                ${elogcmd} "GIT offline update -->"
                ${elogcmd} "   repository:              ${EGIT_REPO_URI}"
                ${elogcmd} "   at the commit:           ${oldsha1}"
        else
                # 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 ${EGIT_BRANCH})

                ${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} origin ${EGIT_BRANCH}:${EGIT_BRANCH} \
                        || die "${EGIT}: can't update from ${EGIT_REPO_URI}."

                cursha1=$(git rev-parse ${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}"
                fi
                # piping through cat is needed to avoid a stupid Git feature
                ${EGIT_DIFFSTAT_CMD} ${oldsha1}..${EGIT_BRANCH} | cat
        fi

        if ${EGIT_REPACK} || ${EGIT_PRUNE} ; then
                ebegin "Garbage collecting the repository"
                git gc $(${EGIT_PRUNE} && echo '--prune')
                eend $?
        fi

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

        # export to the ${WORKDIR}
        mkdir -p "${S}"

        # git data are used in some packages for various variables definition. So we
        # copy also .git folder.
        pushd "${S}" > /dev/null
        git clone --bare ${EGIT_STORE_DIR}/${EGIT_CLONE_DIR} .git
        popd > /dev/null

        git archive --format=tar ${EGIT_TREE} | ( cd "${S}" ; tar xf - )

        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	scarabeus	1.17	# Copyright 1999-2009 Gentoo Foundation
2	ferdy	1.1	# Distributed under the terms of the GNU General Public License v2
3	scarabeus	1.17	# $Header: $
4	ferdy	1.1
5	scarabeus	1.17	# @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 repozitories
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	ferdy	1.1
17			inherit eutils
18
19			EGIT="git.eclass"
20
21	scarabeus	1.17	EXPORTED_FUNCTIONS="src_unpack"
22			case "${EAPI:-0}" in
23			2) EXPORT_FUNCTIONS="${EXPORTED_FUNCTIONS} src_prepare" ;;
24			0\|1) ;;
25			*) die "Unknown EAPI, Bug eclass maintainers." ;;
26			esac
27			EXPORT_FUNCTIONS ${EXPORTED_FUNCTIONS}
28	ferdy	1.1
29	scarabeus	1.17	# define some nice defaults but only if nothing is set already
30			: ${HOMEPAGE:=http://git-scm.com/}
31	ferdy	1.1
32	scarabeus	1.17	# We DEPEND on at least a bit recent git version
33			DEPEND=">=dev-util/git-1.6"
34	ferdy	1.1
35	scarabeus	1.17	# @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	ferdy	1.1
41	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_STORE_DIR
42			# @DESCRIPTION:
43			# Storage directory for git sources.
44	ferdy	1.1	EGIT_STORE_DIR="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/git-src"
45
46	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_FETCH_CMD
47			# @DESCRIPTION:
48			# Command for cloning the repository.
49	scarabeus	1.16	EGIT_FETCH_CMD="git clone --bare"
50	ferdy	1.1
51	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_UPDATE_CMD
52			# @DESCRIPTION:
53			# Git fetch command.
54	ferdy	1.1	EGIT_UPDATE_CMD="git fetch -f -u"
55
56	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_DIFFSTAT_CMD
57			# @DESCRIPTION:
58			# Git command for diffstat.
59	ferdy	1.3	EGIT_DIFFSTAT_CMD="git diff --stat"
60	ferdy	1.1
61	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_OPTIONS
62			# @DESCRIPTION:
63			# This variable value is passed to clone and fetch.
64	ferdy	1.1	: ${EGIT_OPTIONS:=}
65
66	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_REPO_URI
67			# @DESCRIPTION:
68			# URI for the repository
69	ferdy	1.1	# e.g. http://foo, git://bar
70	scarabeus	1.17	# Supported protocols:
71	ferdy	1.1	# http://
72			# https://
73			# git://
74			# git+ssh://
75			# rsync://
76			# ssh://
77			: ${EGIT_REPO_URI:=}
78
79	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_PROJECT
80			# @DESCRIPTION:
81			# Project name of your ebuild.
82			# Git eclass will check out the git repository like:
83			# ${EGIT_STORE_DIR}/${EGIT_PROJECT}/${EGIT_REPO_URI##*/}
84	ferdy	1.1	# so if you define EGIT_REPO_URI as http://git.collab.net/repo/git or
85			# http://git.collab.net/repo/git. and PN is subversion-git.
86			# it will check out like:
87	scarabeus	1.17	# ${EGIT_STORE_DIR}/subversion
88	ferdy	1.1	: ${EGIT_PROJECT:=${PN/-git}}
89
90	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_BOOSTRAP
91			# @DESCRIPTION:
92			# bootstrap script or command like autogen.sh or etc...
93	ferdy	1.1	: ${EGIT_BOOTSTRAP:=}
94
95	robbat2	1.9	# @ECLASS-VARIABLE: EGIT_OFFLINE
96			# @DESCRIPTION:
97			# Set this variable to a non-empty value to disable the automatic updating of
98	robbat2	1.10	# an GIT source tree. This is intended to be set outside the git source
99	robbat2	1.9	# tree by users.
100			EGIT_OFFLINE="${EGIT_OFFLINE:-${ESCM_OFFLINE}}"
101	ferdy	1.1
102	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_PATCHES
103			# @DESCRIPTION:
104			# Similar to PATCHES array from base.eclass
105			# Only difference is that this patches are applied before bootstrap.
106			# Please take note that this variable should be bash array.
107	ferdy	1.1
108	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_BRANCH
109			# @DESCRIPTION:
110	ferdy	1.1	# git eclass can fetch any branch in git_fetch().
111			: ${EGIT_BRANCH:=master}
112
113	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_TREE
114			# @DESCRIPTION:
115	ferdy	1.1	# git eclass can checkout any tree.
116			: ${EGIT_TREE:=${EGIT_BRANCH}}
117
118	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_REPACK
119			# @DESCRIPTION:
120	ferdy	1.1	# git eclass will repack objects to save disk space. However this can take a
121	scarabeus	1.17	# long time with VERY big repositories.
122	ferdy	1.1	: ${EGIT_REPACK:=false}
123
124	scarabeus	1.17	# @ECLASS-VARIABLE: EGIT_PRUNE
125			# @DESCRIPTION:
126			# git.eclass can prune the local clone. This is useful if upstream rewinds and
127			# rebases branches too often.
128	ferdy	1.1	: ${EGIT_PRUNE:=false}
129
130	scarabeus	1.17	# @FUNCTION: git_fetch
131			# @DESCRIPTION:
132			# Gets repository from EGIT_REPO_URI and store it in specified EGIT_STORE_DIR
133			git_fetch() {
134			debug-print-function ${FUNCNAME} "$@"
135	ferdy	1.1
136	scarabeus	1.17	local EGIT_CLONE_DIR oldsha1 cursha1
137	ferdy	1.1
138	scarabeus	1.17	# choose if user wants elog or just einfo.
139			if [[ ${EGIT_QUIET} != OFF ]]; then
140			elogcmd="einfo"
141			else
142			elogcmd="elog"
143			fi
144	ferdy	1.1
145	scarabeus	1.17	# If we have same branch and the tree we can do --depth 1 clone
146			# which outputs into really smaller data transfers.
147			# Sadly we can do shallow copy for now because quite few packages need .git
148			# folder.
149			#[[ ${EGIT_TREE} = ${EGIT_BRANCH} ]] && \
150			# EGIT_FETCH_CMD="${EGIT_FETCH_CMD} --depth 1"
151	ferdy	1.1
152			# EGIT_REPO_URI is empty.
153			[[ -z ${EGIT_REPO_URI} ]] && die "${EGIT}: EGIT_REPO_URI is empty."
154
155	ferdy	1.4	# check for the protocol or pull from a local repo.
156			if [[ -z ${EGIT_REPO_URI%%:*} ]] ; then
157			case ${EGIT_REPO_URI%%:*} in
158	scarabeus	1.17	git*\|http\|https\|rsync\|ssh) ;;
159			) die "${EGIT}: protocol for fetch from "${EGIT_REPO_URI%:}" is not yet implemented in eclass." ;;
160	ferdy	1.4	esac
161			fi
162	ferdy	1.1
163	scarabeus	1.17	# initial clone, we have to create master git storage directory and play
164			# nicely with sandbox
165	ferdy	1.1	if [[ ! -d ${EGIT_STORE_DIR} ]] ; then
166			debug-print "${FUNCNAME}: initial clone. creating git directory"
167			addwrite /
168			mkdir -p "${EGIT_STORE_DIR}" \
169			\|\| die "${EGIT}: can't mkdir ${EGIT_STORE_DIR}."
170			export SANDBOX_WRITE="${SANDBOX_WRITE%%:/}"
171			fi
172
173			cd -P "${EGIT_STORE_DIR}" \|\| die "${EGIT}: can't chdir to ${EGIT_STORE_DIR}"
174			EGIT_STORE_DIR=${PWD}
175
176	scarabeus	1.17	# allow writing into EGIT_STORE_DIR
177	ferdy	1.1	addwrite "${EGIT_STORE_DIR}"
178
179			[[ -z ${EGIT_REPO_URI##*/} ]] && EGIT_REPO_URI="${EGIT_REPO_URI%/}"
180			EGIT_CLONE_DIR="${EGIT_PROJECT}"
181
182			debug-print "${FUNCNAME}: EGIT_OPTIONS = \"${EGIT_OPTIONS}\""
183
184	zlin	1.12	export GIT_DIR="${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}"
185	ferdy	1.1
186			if [[ ! -d ${EGIT_CLONE_DIR} ]] ; then
187			# first clone
188	scarabeus	1.17	${elogcmd} "GIT NEW clone -->"
189			${elogcmd} " repository: ${EGIT_REPO_URI}"
190	ferdy	1.1
191	scarabeus	1.17	${EGIT_FETCH_CMD} ${EGIT_OPTIONS} "${EGIT_REPO_URI}" ${EGIT_PROJECT} \
192	ferdy	1.1	\|\| die "${EGIT}: can't fetch from ${EGIT_REPO_URI}."
193
194	scarabeus	1.17	oldsha1=$(git rev-parse ${EGIT_BRANCH})
195			${elogcmd} " at the commit: ${oldsha1}"
196
197	ferdy	1.1	# We use --bare cloning, so git doesn't do this for us.
198	ferdy	1.7	git config remote.origin.url "${EGIT_REPO_URI}"
199	robbat2	1.9	elif [[ -n ${EGIT_OFFLINE} ]] ; then
200	scarabeus	1.17	oldsha1=$(git rev-parse ${EGIT_BRANCH})
201			${elogcmd} "GIT offline update -->"
202			${elogcmd} " repository: ${EGIT_REPO_URI}"
203			${elogcmd} " at the commit: ${oldsha1}"
204	ferdy	1.1	else
205	ferdy	1.7	# Git urls might change, so unconditionally set it here
206			git config remote.origin.url "${EGIT_REPO_URI}"
207
208	ferdy	1.1	# fetch updates
209	scarabeus	1.17	${elogcmd} "GIT update -->"
210			${elogcmd} " repository: ${EGIT_REPO_URI}"
211	ferdy	1.1
212	scarabeus	1.17	oldsha1=$(git rev-parse ${EGIT_BRANCH})
213	ferdy	1.1
214			${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} origin ${EGIT_BRANCH}:${EGIT_BRANCH} \
215			\|\| die "${EGIT}: can't update from ${EGIT_REPO_URI}."
216
217	scarabeus	1.17	cursha1=$(git rev-parse ${EGIT_BRANCH})
218
219			# write out message based on the revisions
220			if [[ ${oldsha1} != ${cursha1} ]]; then
221			${elogcmd} " updating from commit: ${oldsha1}"
222			${elogcmd} " to commit: ${cursha1}"
223			else
224			${elogcmd} " at the commit: ${cursha1}"
225			fi
226	ferdy	1.3	# piping through cat is needed to avoid a stupid Git feature
227			${EGIT_DIFFSTAT_CMD} ${oldsha1}..${EGIT_BRANCH} \| cat
228	ferdy	1.1	fi
229
230	ferdy	1.6	if ${EGIT_REPACK} \|\| ${EGIT_PRUNE} ; then
231			ebegin "Garbage collecting the repository"
232			git gc $(${EGIT_PRUNE} && echo '--prune')
233	ferdy	1.1	eend $?
234			fi
235
236	scarabeus	1.17	[[ ${EGIT_TREE} != ${EGIT_BRANCH} ]] && elog " tree: ${EGIT_TREE}"
237			${elogcmd} " branch: ${EGIT_BRANCH}"
238			${elogcmd} " storage directory: \"${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}\""
239	ferdy	1.1
240			# export to the ${WORKDIR}
241	zlin	1.14	mkdir -p "${S}"
242	scarabeus	1.17
243			# git data are used in some packages for various variables definition. So we
244			# copy also .git folder.
245			pushd "${S}" > /dev/null
246			git clone --bare ${EGIT_STORE_DIR}/${EGIT_CLONE_DIR} .git
247			popd > /dev/null
248
249	zlin	1.14	git archive --format=tar ${EGIT_TREE} \| ( cd "${S}" ; tar xf - )
250	vapier	1.5
251			echo ">>> Unpacked to ${S}"
252	ferdy	1.1	}
253
254	scarabeus	1.17	# @FUNCTION: git_bootstrap
255			# @DESCRIPTION:
256			# Runs bootstrap command if EGIT_BOOTSTRAP variable contains some value
257			# Remember that what ever gets to the EGIT_BOOTSTRAP variable gets evaled by bash.
258	ferdy	1.1	git_bootstrap() {
259	scarabeus	1.17	debug-print-function ${FUNCNAME} "$@"
260	ferdy	1.1
261	scarabeus	1.17	if [[ -n ${EGIT_BOOTSTRAP} ]] ; then
262			pushd "${S}" > /dev/null
263			einfo "Starting bootstrap"
264	ferdy	1.1
265	scarabeus	1.17	if [[ -f ${EGIT_BOOTSTRAP} ]]; then
266			# we have file in the repo which we should execute
267			debug-print "$FUNCNAME: bootstraping with file \"${EGIT_BOOTSTRAP}\""
268
269			if [[ -x ${EGIT_BOOTSTRAP} ]]; then
270			eval "./${EGIT_BOOTSTRAP}" \
271			\|\| die "${EGIT}: bootstrap script failed"
272	ferdy	1.1	else
273	scarabeus	1.17	eerror "\"${EGIT_BOOTSTRAP}\" is not executable."
274			eerror "Report upstream, or bug ebuild maintainer to remove bootstrap command."
275			die "${EGIT}: \"${EGIT_BOOTSTRAP}\" is not executable."
276	ferdy	1.1	fi
277	scarabeus	1.17	else
278			# we execute some system command
279			debug-print "$FUNCNAME: bootstraping with commands \"${EGIT_BOOTSTRAP}\""
280	ferdy	1.1
281	scarabeus	1.17	eval "${EGIT_BOOTSTRAP}" \
282			\|\| die "${EGIT}: bootstrap commands failed."
283	ferdy	1.1
284			fi
285	scarabeus	1.17
286			einfo "Bootstrap finished"
287			popd > /dev/null
288	ferdy	1.1	fi
289	scarabeus	1.17	}
290	ferdy	1.1
291	scarabeus	1.17	# @FUNCTION: git_apply_patches
292			# @DESCRIPTION:
293			# Apply patches from EGIT_PATCHES bash array.
294			# Preffered is using the variable as bash array but for now it allows to write
295			# it also as normal space separated string list. (This part of code should be
296			# removed when all ebuilds get converted on bash array).
297			git_apply_patches() {
298			debug-print-function ${FUNCNAME} "$@"
299
300			pushd "${S}" > /dev/null
301			if [[ ${#EGIT_PATCHES[@]} -gt 1 ]] ; then
302			for i in "${EGIT_PATCHES[@]}"; do
303			debug-print "$FUNCNAME: git_autopatch: patching from ${i}"
304			epatch "${i}"
305			done
306			elif [[ ${EGIT_PATCHES} != "" ]]; then
307			# no need for loop if space separated string is passed.
308			debug-print "$FUNCNAME: git_autopatch: patching from ${EGIT_PATCHES}"
309			epatch "${EGIT_PATCHES}"
310			fi
311
312			popd > /dev/null
313	ferdy	1.1	}
314
315	scarabeus	1.17	# @FUNCTION: git_src_unpack
316			# @DESCRIPTION:
317			# src_upack function, calls src_prepare one if EAPI!=2.
318			git_src_unpack() {
319			debug-print-function ${FUNCNAME} "$@"
320	ferdy	1.1
321	scarabeus	1.17	git_fetch \|\| die "${EGIT}: unknown problem in git_fetch()."
322	ferdy	1.1
323	scarabeus	1.17	has src_prepare ${EXPORTED_FUNCTIONS} \|\| git_src_prepare
324			}
325	ferdy	1.1
326	scarabeus	1.17	# @FUNCTION: git_src_prepare
327			# @DESCRIPTION:
328			# src_prepare function for git stuff. Patches, bootstrap...
329			git_src_prepare() {
330			debug-print-function ${FUNCNAME} "$@"
331	ferdy	1.1
332	scarabeus	1.17	git_apply_patches
333			git_bootstrap
334	ferdy	1.1	}