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.27 2009/05/14 13:52:08 scarabeus Exp $

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

inherit eutils

EGIT="git.eclass"

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

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

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

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

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

# @ECLASS-VARIABLE: EGIT_FETCH_CMD
# @DESCRIPTION:
# Command for cloning the repository.
: ${EGIT_FETCH_CMD:="git clone --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 --no-pager diff --stat"

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

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

# @ECLASS-VARIABLE: EGIT_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().
eval X="\$${PN//-/_}_LIVE_BRANCH"
if [[ ${X} = "" ]]; then
        EGIT_BRANCH=${EGIT_BRANCH:=master}
else
        EGIT_BRANCH="${X}"
fi

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

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

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

# @FUNCTION: git_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 a 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}"

        # we also have to remove all shallow copied repositories
        # and fetch them again
        if [[ -e "${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}/shallow" ]]; then
                rm -rf "${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}"
                einfo "The ${EGIT_CLONE_DIR} was shallow copy. Refetching."
        fi

        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}."

                cursha1=$(git rev-parse ${EGIT_BRANCH})
                ${elogcmd} "   at the commit:           ${cursha1}"
                # 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
                cursha1=$(git rev-parse ${EGIT_BRANCH})
                ${elogcmd} "GIT offline update -->"
                ${elogcmd} "   repository:              ${EGIT_REPO_URI}"
                ${elogcmd} "   at the commit:           ${cursha1}"
        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})

                ${elogcmd} ${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}."

                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}"
                        # @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}..${EGIT_BRANCH}
        fi

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

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

        # unpack to the ${S}
        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}"
        
        # set correct branch and the tree ebuild specified
        pushd "${S}" > /dev/null
        local branchname=branch-${EGIT_BRANCH} src=origin/${EGIT_BRANCH}
        if [[ ${EGIT_TREE} != ${EGIT_BRANCH} ]]; then
                branchname=tree-${EGIT_TREE}
                src=${EGIT_TREE}
        fi
        debug-print "git checkout -b ${branchname} ${src}"
        git checkout -b ${branchname} ${src} 2>&1 > /dev/null
        debug-print "git submodule init"
        git submodule init 2>&1 > /dev/null
        debug-print "git submodule update"
        git submodule update 2>&1 > /dev/null
        popd > /dev/null

        unset branchname src

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

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

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

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

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

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

                fi

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

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

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

        popd > /dev/null
}

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

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

        has src_prepare ${EXPORTED_FUNCTIONS} || git_src_prepare
}

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