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.44 2010/03/17 15:17:10 sping 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"

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

EXPORTED_FUNCTIONS="src_unpack"
case "${EAPI:-0}" in
        3|2) EXPORTED_FUNCTIONS="${EXPORTED_FUNCTIONS} src_prepare" ;;
        1|0) ;;
        :) DEPEND="EAPI-UNSUPPORTED" ;;
esac
EXPORT_FUNCTIONS ${EXPORTED_FUNCTIONS}

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

# @ECLASS-VARIABLE: EGIT_QUIET
# @DESCRIPTION:
# Set to nonempty value to supress some eclass messages.
: ${EGIT_QUIET:=${ESCM_QUIET}}

# @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_HAS_SUBMODULES
# @DESCRIPTION:
# Set this to nonzero value to enable submodule support (slower).
: ${EGIT_HAS_SUBMODULES:=}

# @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.
if [[ -n ${EGIT_HAS_SUBMODULES} ]]; then
        EGIT_UPDATE_CMD="git pull -f -u"
else
        EGIT_UPDATE_CMD="git fetch -f -u"
fi

# @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_MASTER
# @DESCRIPTION:
# Variable for specifying master branch.
# Usefull when upstream don't have master branch.
: ${EGIT_MASTER:=master}

# @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:=${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:=}

# @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:=}

# @FUNCTION: git_submodules
# @DESCRIPTION:
# Internal function wrapping the submodule initialisation and update
git_submodules() {
        if [[ -n ${EGIT_HAS_SUBMODULES} ]]; then
                debug-print "git submodule init"
                git submodule init
                debug-print "git submodule update"
                git submodule update
        fi
}

# @FUNCTION: git_branch
# @DESCRIPTION:
# Internal function that changes branch for the repo based on EGIT_TREE and
# EGIT_BRANCH variables.
git_branch() {
        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} &> /dev/null

        unset branchname src
}

# @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 extra_clone_opts upstream_branch
        [[ -z ${EGIT_HAS_SUBMODULES} ]] && export GIT_DIR

        # choose if user wants elog or just einfo.
        if [[ -n ${EGIT_QUIET} ]]; 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}
                ewarn "QA: Usage of deprecated EGIT_TREE variable detected."
                ewarn "QA: 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}"
        # 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 [[ -n ${EGIT_HAS_SUBMODULES} ]] && [[ -d ${GIT_DIR} && ! -d "${GIT_DIR}/.git/" ]]; then
                rm -rf "${GIT_DIR}"
                einfo "The ${EGIT_CLONE_DIR} was bare copy. Refetching."
        fi
        if [[ -z ${EGIT_HAS_SUBMODULES} ]] && [[ -d ${GIT_DIR} && -d ${GIT_DIR}/.git ]]; then
                rm -rf "${GIT_DIR}"
                einfo "The ${EGIT_CLONE_DIR} was not a bare copy. Refetching."
        fi

        if [[ -n ${EGIT_HAS_SUBMODULES} ]]; then
                upstream_branch=origin/${EGIT_BRANCH}
        else
                upstream_branch=${EGIT_BRANCH}
                extra_clone_opts=--bare
        fi

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

                debug-print "${EGIT_FETCH_CMD} ${extra_clone_opts} ${EGIT_OPTIONS} \"${EGIT_REPO_URI}\" ${GIT_DIR}"
                ${EGIT_FETCH_CMD} ${extra_clone_opts} ${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 ${upstream_branch})
                ${elogcmd} "   at the commit:           ${cursha1}"

                git_submodules
                popd &> /dev/null
        elif [[ -n ${EGIT_OFFLINE} ]] ; then
                pushd "${GIT_DIR}" &> /dev/null
                cursha1=$(git rev-parse ${upstream_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 ${upstream_branch})

                if [[ -n ${EGIT_HAS_SUBMODULES} ]]; then
                        debug-print "${EGIT_UPDATE_CMD} ${EGIT_OPTIONS}"
                        # fix branching
                        git checkout ${EGIT_MASTER}
                        for x in $(git branch |grep -v "* ${EGIT_MASTER}" |tr '\n' ' '); do
                                git branch -D ${x}
                        done
                        ${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} \
                                || die "${EGIT}: can't update from ${EGIT_REPO_URI}."
                else
                        debug-print "${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} origin ${EGIT_BRANCH}:${EGIT_BRANCH}"
                        ${EGIT_UPDATE_CMD} ${EGIT_OPTIONS} origin ${EGIT_BRANCH}:${EGIT_BRANCH} \
                                || die "${EGIT}: can't update from ${EGIT_REPO_URI}."
                fi

                git_submodules
                cursha1=$(git rev-parse ${upstream_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}..${upstream_branch}
                popd &> /dev/null
        fi

        pushd "${GIT_DIR}" &> /dev/null
        if [[ -n ${EGIT_REPACK} ]] || [[ -n ${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}"

        # log the repo state
        [[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]] && elog "   commit:                      ${EGIT_COMMIT}"
        ${elogcmd} "   branch:                  ${EGIT_BRANCH}"
        ${elogcmd} "   storage directory:       \"${GIT_DIR}\""

        if [[ -n ${EGIT_HAS_SUBMODULES} ]]; then
                pushd "${GIT_DIR}" &> /dev/null
                debug-print "rsync -rlpgo . \"${S}\""
                time rsync -rlpgo . "${S}"
                popd &> /dev/null
        else
                unset GIT_DIR
                debug-print "git clone -l -s -n \"${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}\" \"${S}\""
                git clone -l -s -n "${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}" "${S}"
        fi

        pushd "${S}" &> /dev/null
        git_branch
        # submodules always reqire net (thanks to branches changing)
        [[ -n ${EGIT_OFFLINE} ]] || git_submodules
        popd &> /dev/null

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