1 # Copyright 1999-2015 Gentoo Foundation
2 # Distributed under the terms of the GNU General Public License v2
5 # @ECLASS: git-r3.eclass
7 # Michał Górny <mgorny@gentoo.org>
8 # @BLURB: Eclass for fetching and unpacking git repositories.
10 # Third generation eclass for easing maintenance of live ebuilds using
11 # git as remote repository.
17 die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}"
21 if [[ ! ${_GIT_R3} ]]; then
27 EXPORT_FUNCTIONS src_unpack
29 if [[ ! ${_GIT_R3} ]]; then
31 if [[ ! ${_INHERITED_BY_GIT_2} ]]; then
32 DEPEND=">=dev-vcs/git-1.8.2.1"
35 # @ECLASS-VARIABLE: EGIT_CLONE_TYPE
37 # Type of clone that should be used against the remote repository.
38 # This can be either of: 'mirror', 'single', 'shallow'.
40 # This is intended to be set by user in make.conf. Ebuilds are supposed
41 # to set EGIT_MIN_CLONE_TYPE if necessary instead.
43 # The 'mirror' type clones all remote branches and tags with complete
44 # history and all notes. EGIT_COMMIT can specify any commit hash.
45 # Upstream-removed branches and tags are purged from the local clone
46 # while fetching. This mode is suitable for cloning the local copy
47 # for development or hosting a local git mirror. However, clones
48 # of repositories with large diverged branches may quickly grow large.
50 # The 'single+tags' type clones the requested branch and all tags
51 # in the repository. All notes are fetched as well. EGIT_COMMIT
52 # can safely specify hashes throughout the current branch and all tags.
53 # No purging of old references is done (if you often switch branches,
54 # you may need to remove stale branches yourself). This mode is intended
55 # mostly for use with broken git servers such as Google Code that fail
56 # to fetch tags along with the branch in 'single' mode.
58 # The 'single' type clones only the requested branch or tag. Tags
59 # referencing commits throughout the branch history are fetched as well,
60 # and all notes. EGIT_COMMIT can safely specify only hashes
61 # in the current branch. No purging of old references is done (if you
62 # often switch branches, you may need to remove stale branches
63 # yourself). This mode is suitable for general use.
65 # The 'shallow' type clones only the newest commit on requested branch
66 # or tag. EGIT_COMMIT can only specify tags, and since the history is
67 # unavailable calls like 'git describe' will not reference prior tags.
68 # No purging of old references is done. This mode is intended mostly for
69 # embedded systems with limited disk space.
70 : ${EGIT_CLONE_TYPE:=single}
72 # @ECLASS-VARIABLE: EGIT_MIN_CLONE_TYPE
74 # 'Minimum' clone type supported by the ebuild. Takes same values
75 # as EGIT_CLONE_TYPE. When user sets a type that's 'lower' (that is,
76 # later on the list) than EGIT_MIN_CLONE_TYPE, the eclass uses
77 # EGIT_MIN_CLONE_TYPE instead.
79 # This variable is intended to be used by ebuilds only. Users are
80 # supposed to set EGIT_CLONE_TYPE instead.
82 # A common case is to use 'single' whenever the build system requires
83 # access to full branch history, or 'single+tags' when Google Code
84 # or a similar remote is used that does not support shallow clones
85 # and fetching tags along with commits. Please use sparingly, and to fix
86 # fatal errors rather than 'non-pretty versions'.
87 : ${EGIT_MIN_CLONE_TYPE:=shallow}
89 # @ECLASS-VARIABLE: EGIT3_STORE_DIR
91 # Storage directory for git sources.
93 # This is intended to be set by user in make.conf. Ebuilds must not set
96 # EGIT3_STORE_DIR=${DISTDIR}/git3-src
98 # @ECLASS-VARIABLE: EGIT_MIRROR_URI
101 # 'Top' URI to a local git mirror. If specified, the eclass will try
102 # to fetch from the local mirror instead of using the remote repository.
104 # The mirror needs to follow EGIT3_STORE_DIR structure. The directory
105 # created by eclass can be used for that purpose.
109 # EGIT_MIRROR_URI="git://mirror.lan/"
112 # @ECLASS-VARIABLE: EGIT_REPO_URI
115 # URIs to the repository, e.g. git://foo, https://foo. If multiple URIs
116 # are provided, the eclass will consider them as fallback URIs to try
117 # if the first URI does not work. For supported URI syntaxes, read up
118 # the manpage for git-clone(1).
120 # It can be overriden via env using ${PN}_LIVE_REPO variable.
122 # Can be a whitespace-separated list or an array.
126 # EGIT_REPO_URI="git://a/b.git https://c/d.git"
129 # @ECLASS-VARIABLE: EVCS_OFFLINE
132 # If non-empty, this variable prevents any online operations.
134 # @ECLASS-VARIABLE: EVCS_UMASK
137 # Set this variable to a custom umask. This is intended to be set by
138 # users. By setting this to something like 002, it can make life easier
139 # for people who do development as non-root (but are in the portage
140 # group), and then switch over to building with FEATURES=userpriv.
141 # Or vice-versa. Shouldn't be a security issue here as anyone who has
142 # portage group write access already can screw the system over in more
145 # @ECLASS-VARIABLE: EGIT_BRANCH
148 # The branch name to check out. If unset, the upstream default (HEAD)
151 # It can be overriden via env using ${PN}_LIVE_BRANCH variable.
153 # @ECLASS-VARIABLE: EGIT_COMMIT
156 # The tag name or commit identifier to check out. If unset, newest
157 # commit from the branch will be used. If set, EGIT_BRANCH will
160 # It can be overriden via env using ${PN}_LIVE_COMMIT variable.
162 # @ECLASS-VARIABLE: EGIT_CHECKOUT_DIR
164 # The directory to check the git sources out to.
166 # EGIT_CHECKOUT_DIR=${WORKDIR}/${P}
168 # @FUNCTION: _git-r3_env_setup
171 # Set the eclass variables as necessary for operation. This can involve
172 # setting EGIT_* to defaults or ${PN}_LIVE_* variables.
173 _git-r3_env_setup() {
174 debug-print-function ${FUNCNAME} "$@"
176 # check the clone type
177 case "${EGIT_CLONE_TYPE}" in
178 mirror|single+tags|single|shallow)
181 die "Invalid EGIT_CLONE_TYPE=${EGIT_CLONE_TYPE}"
183 case "${EGIT_MIN_CLONE_TYPE}" in
187 if [[ ${EGIT_CLONE_TYPE} == shallow ]]; then
188 einfo "git-r3: ebuild needs to be cloned in '\e[1msingle\e[22m' mode, adjusting"
189 EGIT_CLONE_TYPE=single
193 if [[ ${EGIT_CLONE_TYPE} == shallow || ${EGIT_CLONE_TYPE} == single ]]; then
194 einfo "git-r3: ebuild needs to be cloned in '\e[1msingle+tags\e[22m' mode, adjusting"
195 EGIT_CLONE_TYPE=single+tags
199 if [[ ${EGIT_CLONE_TYPE} != mirror ]]; then
200 einfo "git-r3: ebuild needs to be cloned in '\e[1mmirror\e[22m' mode, adjusting"
201 EGIT_CLONE_TYPE=mirror
205 die "Invalid EGIT_MIN_CLONE_TYPE=${EGIT_MIN_CLONE_TYPE}"
211 livevar=${esc_pn}_LIVE_REPO
212 EGIT_REPO_URI=${!livevar:-${EGIT_REPO_URI}}
214 && ewarn "Using ${livevar}, no support will be provided"
216 livevar=${esc_pn}_LIVE_BRANCH
217 EGIT_BRANCH=${!livevar:-${EGIT_BRANCH}}
219 && ewarn "Using ${livevar}, no support will be provided"
221 livevar=${esc_pn}_LIVE_COMMIT
222 EGIT_COMMIT=${!livevar:-${EGIT_COMMIT}}
224 && ewarn "Using ${livevar}, no support will be provided"
226 # Migration helpers. Remove them when git-2 is removed.
228 if [[ ${EGIT_SOURCEDIR} ]]; then
229 eerror "EGIT_SOURCEDIR has been replaced by EGIT_CHECKOUT_DIR. While updating"
230 eerror "your ebuild, please check whether the variable is necessary at all"
231 eerror "since the default has been changed from \${S} to \${WORKDIR}/\${P}."
232 eerror "Therefore, proper setting of S may be sufficient."
233 die "EGIT_SOURCEDIR has been replaced by EGIT_CHECKOUT_DIR."
236 if [[ ${EGIT_MASTER} ]]; then
237 eerror "EGIT_MASTER has been removed. Instead, the upstream default (HEAD)"
238 eerror "is used by the eclass. Please remove the assignment or use EGIT_BRANCH"
239 eerror "as necessary."
240 die "EGIT_MASTER has been removed."
243 if [[ ${EGIT_HAS_SUBMODULES} ]]; then
244 eerror "EGIT_HAS_SUBMODULES has been removed. The eclass no longer needs"
245 eerror "to switch the clone type in order to support submodules and therefore"
246 eerror "submodules are detected and fetched automatically."
247 die "EGIT_HAS_SUBMODULES is no longer necessary."
250 if [[ ${EGIT_PROJECT} ]]; then
251 eerror "EGIT_PROJECT has been removed. Instead, the eclass determines"
252 eerror "the local clone path using path in canonical EGIT_REPO_URI."
253 eerror "If the current algorithm causes issues for you, please report a bug."
254 die "EGIT_PROJECT is no longer necessary."
257 if [[ ${EGIT_BOOTSTRAP} ]]; then
258 eerror "EGIT_BOOTSTRAP has been removed. Please create proper src_prepare()"
260 die "EGIT_BOOTSTRAP has been removed."
263 if [[ ${EGIT_NOUNPACK} ]]; then
264 eerror "EGIT_NOUNPACK has been removed. The eclass no longer calls default"
265 eerror "unpack function. If necessary, please declare proper src_unpack()."
266 die "EGIT_NOUNPACK has been removed."
270 # @FUNCTION: _git-r3_set_gitdir
274 # Obtain the local repository path and set it as GIT_DIR. Creates
275 # a new repository if necessary.
277 # <repo-uri> may be used to compose the path. It should therefore be
278 # a canonical URI to the repository.
279 _git-r3_set_gitdir() {
280 debug-print-function ${FUNCNAME} "$@"
282 local repo_name=${1#*://*/}
284 # strip the trailing slash
285 repo_name=${repo_name%/}
287 # strip common prefixes to make paths more likely to match
288 # e.g. git://X/Y.git vs https://X/git/Y.git
289 # (but just one of the prefixes)
290 case "${repo_name}" in
291 # gnome.org... who else?
292 browse/*) repo_name=${repo_name#browse/};;
293 # cgit can proxy requests to git
294 cgit/*) repo_name=${repo_name#cgit/};;
296 git/*) repo_name=${repo_name#git/};;
298 gitroot/*) repo_name=${repo_name#gitroot/};;
299 # google code, sourceforge
300 p/*) repo_name=${repo_name#p/};;
302 pub/scm/*) repo_name=${repo_name#pub/scm/};;
304 # ensure a .git suffix, same reason
305 repo_name=${repo_name%.git}.git
306 # now replace all the slashes
307 repo_name=${repo_name//\//_}
309 local distdir=${PORTAGE_ACTUAL_DISTDIR:-${DISTDIR}}
310 : ${EGIT3_STORE_DIR:=${distdir}/git3-src}
312 GIT_DIR=${EGIT3_STORE_DIR}/${repo_name}
314 if [[ ! -d ${EGIT3_STORE_DIR} ]]; then
317 mkdir -p "${EGIT3_STORE_DIR}" || die
318 ) || die "Unable to create ${EGIT3_STORE_DIR}"
321 addwrite "${EGIT3_STORE_DIR}"
322 if [[ ! -d ${GIT_DIR} ]]; then
324 if [[ ${EVCS_UMASK} ]]; then
326 umask "${EVCS_UMASK}" || die "Bad options to umask: ${EVCS_UMASK}"
328 mkdir "${GIT_DIR}" || die
329 git init --bare || die
330 if [[ ${saved_umask} ]]; then
331 umask "${saved_umask}" || die
336 # @FUNCTION: _git-r3_set_submodules
337 # @USAGE: <file-contents>
340 # Parse .gitmodules contents passed as <file-contents>
341 # as in "$(cat .gitmodules)"). Composes a 'submodules' array that
342 # contains in order (name, URL, path) for each submodule.
343 _git-r3_set_submodules() {
344 debug-print-function ${FUNCNAME} "$@"
348 # ( name url path ... )
353 # submodule.<path>.path=<path>
354 # submodule.<path>.url=<url>
355 [[ ${l} == submodule.*.url=* ]] || continue
358 local subname=${l%%.url=*}
360 # skip modules that have 'update = none', bug #487262.
361 local upd=$(echo "${data}" | git config -f /dev/fd/0 \
362 submodule."${subname}".update)
363 [[ ${upd} == none ]] && continue
367 "$(echo "${data}" | git config -f /dev/fd/0 \
368 submodule."${subname}".url || die)"
369 "$(echo "${data}" | git config -f /dev/fd/0 \
370 submodule."${subname}".path || die)"
372 done < <(echo "${data}" | git config -f /dev/fd/0 -l || die)
375 # @FUNCTION: _git-r3_set_subrepos
376 # @USAGE: <submodule-uri> <parent-repo-uri>...
379 # Create 'subrepos' array containing absolute (canonical) submodule URIs
380 # for the given <submodule-uri>. If the URI is relative, URIs will be
381 # constructed using all <parent-repo-uri>s. Otherwise, this single URI
382 # will be placed in the array.
383 _git-r3_set_subrepos() {
384 debug-print-function ${FUNCNAME} "$@"
387 subrepos=( "${@:2}" )
389 if [[ ${suburl} == ./* || ${suburl} == ../* ]]; then
390 # drop all possible trailing slashes for consistency
391 subrepos=( "${subrepos[@]%%/}" )
394 if [[ ${suburl} == ./* ]]; then
396 elif [[ ${suburl} == ../* ]]; then
399 # XXX: correctness checking
401 # drop the last path component
402 subrepos=( "${subrepos[@]%/*}" )
403 # and then the trailing slashes, again
404 subrepos=( "${subrepos[@]%%/}" )
410 # append the preprocessed path to the preprocessed URIs
411 subrepos=( "${subrepos[@]/%//${suburl}}")
413 subrepos=( "${suburl}" )
418 # @FUNCTION: _git-r3_is_local_repo
422 # Determine whether the given URI specifies a local (on-disk)
424 _git-r3_is_local_repo() {
425 debug-print-function ${FUNCNAME} "$@"
429 [[ ${uri} == file://* || ${uri} == /* ]]
432 # @FUNCTION: _git-r3_find_head
436 # Given a ref to which remote HEAD was fetched, try to find
437 # a branch matching the commit. Expects 'git show-ref'
438 # or 'git ls-remote' output on stdin.
439 _git-r3_find_head() {
440 debug-print-function ${FUNCNAME} "$@"
443 local head_hash=$(git rev-parse --verify "${1}" || die)
446 # TODO: some transports support peeking at symbolic remote refs
447 # find a way to use that rather than guessing
449 # (based on guess_remote_head() in git-1.9.0/remote.c)
452 # look for matching head
453 if [[ ${h} == ${head_hash} ]]; then
454 # either take the first matching ref, or master if it is there
455 if [[ ! ${matching_ref} || ${ref} == refs/heads/master ]]; then
461 if [[ ! ${matching_ref} ]]; then
462 die "Unable to find a matching branch for remote HEAD (${head_hash})"
465 echo "${matching_ref}"
468 # @FUNCTION: git-r3_fetch
469 # @USAGE: [<repo-uri> [<remote-ref> [<local-id>]]]
471 # Fetch new commits to the local clone of repository.
473 # <repo-uri> specifies the repository URIs to fetch from, as a space-
474 # -separated list. The first URI will be used as repository group
475 # identifier and therefore must be used consistently. When not
476 # specified, defaults to ${EGIT_REPO_URI}.
478 # <remote-ref> specifies the remote ref or commit id to fetch.
479 # It is preferred to use 'refs/heads/<branch-name>' for branches
480 # and 'refs/tags/<tag-name>' for tags. Other options are 'HEAD'
481 # for upstream default branch and hexadecimal commit SHA1. Defaults
482 # to the first of EGIT_COMMIT, EGIT_BRANCH or literal 'HEAD' that
483 # is set to a non-null value.
485 # <local-id> specifies the local branch identifier that will be used to
486 # locally store the fetch result. It should be unique to multiple
487 # fetches within the repository that can be performed at the same time
488 # (including parallel merges). It defaults to ${CATEGORY}/${PN}/${SLOT%/*}.
489 # This default should be fine unless you are fetching multiple trees
490 # from the same repository in the same ebuild.
492 # The fetch operation will affect the EGIT_STORE only. It will not touch
493 # the working copy, nor export any environment variables.
494 # If the repository contains submodules, they will be fetched
497 debug-print-function ${FUNCNAME} "$@"
499 [[ ${EVCS_OFFLINE} ]] && return
504 elif [[ $(declare -p EGIT_REPO_URI) == "declare -a"* ]]; then
505 repos=( "${EGIT_REPO_URI[@]}" )
507 repos=( ${EGIT_REPO_URI} )
510 local branch=${EGIT_BRANCH:+refs/heads/${EGIT_BRANCH}}
511 local remote_ref=${2:-${EGIT_COMMIT:-${branch:-HEAD}}}
512 local local_id=${3:-${CATEGORY}/${PN}/${SLOT%/*}}
513 local local_ref=refs/git-r3/${local_id}/__main__
515 [[ ${repos[@]} ]] || die "No URI provided and EGIT_REPO_URI unset"
518 _git-r3_set_gitdir "${repos[0]}"
520 # prepend the local mirror if applicable
521 if [[ ${EGIT_MIRROR_URI} ]]; then
523 "${EGIT_MIRROR_URI%/}/${GIT_DIR##*/}"
528 # try to fetch from the remote
529 local r success saved_umask
530 if [[ ${EVCS_UMASK} ]]; then
532 umask "${EVCS_UMASK}" || die "Bad options to umask: ${EVCS_UMASK}"
534 for r in "${repos[@]}"; do
535 einfo "Fetching \e[1m${r}\e[22m ..."
537 local fetch_command=( git fetch "${r}" )
538 local clone_type=${EGIT_CLONE_TYPE}
540 if [[ ${r} == https://* ]] && ! ROOT=/ has_version 'dev-vcs/git[curl]'; then
541 eerror "git-r3: fetching from https:// requested. In order to support https,"
542 eerror "dev-vcs/git needs to be built with USE=curl. Example solution:"
544 eerror " echo dev-vcs/git curl >> /etc/portage/package.use"
545 eerror " emerge -1v dev-vcs/git"
546 die "dev-vcs/git built with USE=curl required."
549 if [[ ${r} == https://code.google.com/* ]]; then
550 # Google Code has special magic on top of git that:
551 # 1) can't handle shallow clones at all,
552 # 2) fetches duplicately when tags are pulled in with branch
553 # so automatically switch to single+tags mode.
554 if [[ ${clone_type} == shallow ]]; then
555 einfo " Google Code does not support shallow clones"
556 einfo " using \e[1mEGIT_CLONE_TYPE=single+tags\e[22m"
557 clone_type=single+tags
558 elif [[ ${clone_type} == single ]]; then
559 einfo " git-r3: Google Code does not send tags properly in 'single' mode"
560 einfo " using \e[1mEGIT_CLONE_TYPE=single+tags\e[22m"
561 clone_type=single+tags
565 if [[ ${clone_type} == mirror ]]; then
568 # mirror the remote branches as local branches
569 "+refs/heads/*:refs/heads/*"
570 # pull tags explicitly in order to prune them properly
571 "+refs/tags/*:refs/tags/*"
572 # notes in case something needs them
573 "+refs/notes/*:refs/notes/*"
574 # and HEAD in case we need the default branch
575 # (we keep it in refs/git-r3 since otherwise --prune interferes)
576 "+HEAD:refs/git-r3/HEAD"
578 else # single or shallow
579 local fetch_l fetch_r
581 if [[ ${remote_ref} == HEAD ]]; then
584 elif [[ ${remote_ref} == refs/heads/* ]]; then
586 fetch_l=${remote_ref}
589 # let ls-remote figure it out
590 local tagref=$(git ls-remote "${r}" "refs/tags/${remote_ref}")
592 # if it was a tag, ls-remote obtained a hash
593 if [[ ${tagref} ]]; then
595 fetch_l=refs/tags/${remote_ref}
598 # so we need to fetch the branch
599 if [[ ${branch} ]]; then
605 # fetching by commit in shallow mode? can't do.
606 if [[ ${clone_type} == shallow ]]; then
612 if [[ ${fetch_l} == HEAD ]]; then
613 fetch_r=refs/git-r3/HEAD
619 "+${fetch_l}:${fetch_r}"
622 if [[ ${clone_type} == single+tags ]]; then
624 # pull tags explicitly as requested
625 "+refs/tags/*:refs/tags/*"
630 if [[ ${clone_type} == shallow ]]; then
631 if _git-r3_is_local_repo; then
632 # '--depth 1' causes sandbox violations with local repos
635 elif [[ ! $(git rev-parse --quiet --verify "${fetch_r}") ]]
637 # use '--depth 1' when fetching a new branch
638 fetch_command+=( --depth 1 )
640 else # non-shallow mode
641 if [[ -f ${GIT_DIR}/shallow ]]; then
642 fetch_command+=( --unshallow )
646 set -- "${fetch_command[@]}"
649 if [[ ${clone_type} == mirror ]]; then
650 # find remote HEAD and update our HEAD properly
651 git symbolic-ref HEAD \
652 "$(_git-r3_find_head refs/git-r3/HEAD \
653 < <(git show-ref --heads || die))" \
654 || die "Unable to update HEAD"
655 else # single or shallow
656 if [[ ${fetch_l} == HEAD ]]; then
657 # find out what branch we fetched as HEAD
658 local head_branch=$(_git-r3_find_head \
660 < <(git ls-remote --heads "${r}" || die))
662 # and move it to its regular place
663 git update-ref --no-deref "${head_branch}" \
665 || die "Unable to sync HEAD branch ${head_branch}"
666 git symbolic-ref HEAD "${head_branch}" \
667 || die "Unable to update HEAD"
671 # now let's see what the user wants from us
672 local full_remote_ref=$(
673 git rev-parse --verify --symbolic-full-name "${remote_ref}"
676 if [[ ${full_remote_ref} ]]; then
677 # when we are given a ref, create a symbolic ref
678 # so that we preserve the actual argument
679 set -- git symbolic-ref "${local_ref}" "${full_remote_ref}"
681 # otherwise, we were likely given a commit id
682 set -- git update-ref --no-deref "${local_ref}" "${remote_ref}"
687 die "Referencing ${remote_ref} failed (wrong ref?)."
694 if [[ ${saved_umask} ]]; then
695 umask "${saved_umask}" || die
697 [[ ${success} ]] || die "Unable to fetch from any of EGIT_REPO_URI"
699 # submodules can reference commits in any branch
700 # always use the 'clone' mode to accomodate that, bug #503332
701 local EGIT_CLONE_TYPE=mirror
703 # recursively fetch submodules
704 if git cat-file -e "${local_ref}":.gitmodules &>/dev/null; then
706 _git-r3_set_submodules \
707 "$(git cat-file -p "${local_ref}":.gitmodules || die)"
709 while [[ ${submodules[@]} ]]; do
710 local subname=${submodules[0]}
711 local url=${submodules[1]}
712 local path=${submodules[2]}
714 # use only submodules for which path does exist
715 # (this is in par with 'git submodule'), bug #551100
716 # note: git cat-file does not work for submodules
717 if [[ $(git ls-tree -d "${local_ref}" "${path}") ]]
719 local commit=$(git rev-parse "${local_ref}:${path}" || die)
721 if [[ ! ${commit} ]]; then
722 die "Unable to get commit id for submodule ${subname}"
726 _git-r3_set_subrepos "${url}" "${repos[@]}"
728 git-r3_fetch "${subrepos[*]}" "${commit}" "${local_id}/${subname}"
731 submodules=( "${submodules[@]:3}" ) # shift
736 # @FUNCTION: git-r3_checkout
737 # @USAGE: [<repo-uri> [<checkout-path> [<local-id>]]]
739 # Check the previously fetched tree to the working copy.
741 # <repo-uri> specifies the repository URIs, as a space-separated list.
742 # The first URI will be used as repository group identifier
743 # and therefore must be used consistently with git-r3_fetch.
744 # The remaining URIs are not used and therefore may be omitted.
745 # When not specified, defaults to ${EGIT_REPO_URI}.
747 # <checkout-path> specifies the path to place the checkout. It defaults
748 # to ${EGIT_CHECKOUT_DIR} if set, otherwise to ${WORKDIR}/${P}.
750 # <local-id> needs to specify the local identifier that was used
751 # for respective git-r3_fetch.
753 # The checkout operation will write to the working copy, and export
754 # the repository state into the environment. If the repository contains
755 # submodules, they will be checked out recursively.
757 debug-print-function ${FUNCNAME} "$@"
762 elif [[ $(declare -p EGIT_REPO_URI) == "declare -a"* ]]; then
763 repos=( "${EGIT_REPO_URI[@]}" )
765 repos=( ${EGIT_REPO_URI} )
768 local out_dir=${2:-${EGIT_CHECKOUT_DIR:-${WORKDIR}/${P}}}
769 local local_id=${3:-${CATEGORY}/${PN}/${SLOT%/*}}
772 _git-r3_set_gitdir "${repos[0]}"
774 einfo "Checking out \e[1m${repos[0]}\e[22m to \e[1m${out_dir}\e[22m ..."
776 if ! git cat-file -e refs/git-r3/"${local_id}"/__main__; then
777 if [[ ${EVCS_OFFLINE} ]]; then
778 die "No local clone of ${repos[0]}. Unable to work with EVCS_OFFLINE."
780 die "Logic error: no local clone of ${repos[0]}. git-r3_fetch not used?"
784 git symbolic-ref --quiet refs/git-r3/"${local_id}"/__main__
786 local new_commit_id=$(
787 git rev-parse --verify refs/git-r3/"${local_id}"/__main__
790 git-r3_sub_checkout() {
791 local orig_repo=${GIT_DIR}
792 local -x GIT_DIR=${out_dir}/.git
793 local -x GIT_WORK_TREE=${out_dir}
795 mkdir -p "${out_dir}" || die
797 # use git init+fetch instead of clone since the latter doesn't like
798 # non-empty directories.
800 git init --quiet || die
801 # setup 'alternates' to avoid copying objects
802 echo "${orig_repo}/objects" > "${GIT_DIR}"/objects/info/alternates || die
804 # [htn]* safely catches heads, tags, notes without complaining
805 # on non-existing ones, and omits internal 'git-r3' ref
806 cp -R "${orig_repo}"/refs/[htn]* "${GIT_DIR}"/refs/ || die
808 # (no need to copy HEAD, we will set it via checkout)
810 if [[ -f ${orig_repo}/shallow ]]; then
811 cp "${orig_repo}"/shallow "${GIT_DIR}"/ || die
814 set -- git checkout --quiet
815 if [[ ${remote_ref} ]]; then
816 set -- "${@}" "${remote_ref#refs/heads/}"
818 set -- "${@}" "${new_commit_id}"
821 "${@}" || die "git checkout ${remote_ref:-${new_commit_id}} failed"
825 local old_commit_id=$(
826 git rev-parse --quiet --verify refs/git-r3/"${local_id}"/__old__
828 if [[ ! ${old_commit_id} ]]; then
829 echo "GIT NEW branch -->"
830 echo " repository: ${repos[0]}"
831 echo " at the commit: ${new_commit_id}"
833 # diff against previous revision
834 echo "GIT update -->"
835 echo " repository: ${repos[0]}"
836 # write out message based on the revisions
837 if [[ "${old_commit_id}" != "${new_commit_id}" ]]; then
838 echo " updating from commit: ${old_commit_id}"
839 echo " to commit: ${new_commit_id}"
841 git --no-pager diff --stat \
842 ${old_commit_id}..${new_commit_id}
844 echo " at the commit: ${new_commit_id}"
847 git update-ref --no-deref refs/git-r3/"${local_id}"/{__old__,__main__} || die
849 # recursively checkout submodules
850 if [[ -f ${out_dir}/.gitmodules ]]; then
852 _git-r3_set_submodules \
853 "$(<"${out_dir}"/.gitmodules)"
855 while [[ ${submodules[@]} ]]; do
856 local subname=${submodules[0]}
857 local url=${submodules[1]}
858 local path=${submodules[2]}
860 # use only submodules for which path does exist
861 # (this is in par with 'git submodule'), bug #551100
862 if [[ -d ${out_dir}/${path} ]]; then
864 _git-r3_set_subrepos "${url}" "${repos[@]}"
866 git-r3_checkout "${subrepos[*]}" "${out_dir}/${path}" \
867 "${local_id}/${subname}"
870 submodules=( "${submodules[@]:3}" ) # shift
874 # keep this *after* submodules
875 export EGIT_DIR=${GIT_DIR}
876 export EGIT_VERSION=${new_commit_id}
879 # @FUNCTION: git-r3_peek_remote_ref
880 # @USAGE: [<repo-uri> [<remote-ref>]]
882 # Peek the reference in the remote repository and print the matching
883 # (newest) commit SHA1.
885 # <repo-uri> specifies the repository URIs to fetch from, as a space-
886 # -separated list. When not specified, defaults to ${EGIT_REPO_URI}.
888 # <remote-ref> specifies the remote ref to peek. It is preferred to use
889 # 'refs/heads/<branch-name>' for branches and 'refs/tags/<tag-name>'
890 # for tags. Alternatively, 'HEAD' may be used for upstream default
891 # branch. Defaults to the first of EGIT_COMMIT, EGIT_BRANCH or literal
892 # 'HEAD' that is set to a non-null value.
894 # The operation will be done purely on the remote, without using local
895 # storage. If commit SHA1 is provided as <remote-ref>, the function will
896 # fail due to limitations of git protocol.
898 # On success, the function returns 0 and writes hexadecimal commit SHA1
899 # to stdout. On failure, the function returns 1.
900 git-r3_peek_remote_ref() {
901 debug-print-function ${FUNCNAME} "$@"
906 elif [[ $(declare -p EGIT_REPO_URI) == "declare -a"* ]]; then
907 repos=( "${EGIT_REPO_URI[@]}" )
909 repos=( ${EGIT_REPO_URI} )
912 local branch=${EGIT_BRANCH:+refs/heads/${EGIT_BRANCH}}
913 local remote_ref=${2:-${EGIT_COMMIT:-${branch:-HEAD}}}
915 [[ ${repos[@]} ]] || die "No URI provided and EGIT_REPO_URI unset"
918 for r in "${repos[@]}"; do
919 einfo "Peeking \e[1m${remote_ref}\e[22m on \e[1m${r}\e[22m ..." >&2
921 local is_branch lookup_ref
922 if [[ ${remote_ref} == refs/heads/* || ${remote_ref} == HEAD ]]
925 lookup_ref=${remote_ref}
927 # ls-remote by commit is going to fail anyway,
928 # so we may as well pass refs/tags/ABCDEF...
929 lookup_ref=refs/tags/${remote_ref}
932 # split on whitespace
934 $(git ls-remote "${r}" "${lookup_ref}")
937 if [[ ${ref[0]} ]]; then
947 debug-print-function ${FUNCNAME} "$@"
949 if [[ ! ${EGIT3_STORE_DIR} && ${EGIT_STORE_DIR} ]]; then
950 ewarn "You have set EGIT_STORE_DIR but not EGIT3_STORE_DIR. Please consider"
951 ewarn "setting EGIT3_STORE_DIR for git-r3.eclass. It is recommended to use"
952 ewarn "a different directory than EGIT_STORE_DIR to ease removing old clones"
953 ewarn "when git-2 eclass becomes deprecated."
960 git-r3_src_unpack() {
961 debug-print-function ${FUNCNAME} "$@"
968 # https://bugs.gentoo.org/show_bug.cgi?id=482666
969 git-r3_pkg_needrebuild() {
970 debug-print-function ${FUNCNAME} "$@"
972 local new_commit_id=$(git-r3_peek_remote_ref)
973 [[ ${new_commit_id} && ${EGIT_VERSION} ]] || die "Lookup failed"
975 if [[ ${EGIT_VERSION} != ${new_commit_id} ]]; then
976 einfo "Update from \e[1m${EGIT_VERSION}\e[22m to \e[1m${new_commit_id}\e[22m"
978 einfo "Local and remote at \e[1m${EGIT_VERSION}\e[22m"
981 [[ ${EGIT_VERSION} != ${new_commit_id} ]]
984 # 'export' locally until this gets into EAPI
985 pkg_needrebuild() { git-r3_pkg_needrebuild; }