/[gentoo-x86]/eclass/git.eclass
Gentoo

Diff of /eclass/git.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.12  
changed lines
  Added in v.1.54

  ViewVC Help
Powered by ViewVC 1.1.20