gentoo-x86/eclass/git.eclass

# Copyright 1999-2013 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/git.eclass,v 1.59 2012/09/27 16:35:41 axs Exp $

# @DEPRECATED
# This eclass has been superseded by git-2 eclass.
# Please modify your ebuilds to use that one instead.

# @ECLASS: git.eclass
# @MAINTAINER:
# Donnie Berkholz <dberkholz@gentoo.org>
# @BLURB: Fetching and unpacking of git repositories
# @DESCRIPTION:
# The git eclass provides functions to fetch, patch and bootstrap
# software sources from git repositories and is based on the subversion eclass.
# It is necessary to define at least the EGIT_REPO_URI variable.
#
# THANKS TO:
# Fernando J. Pereda <ferdy@gentoo.org>

inherit eutils

EGIT="git.eclass"

# We DEPEND on a not too ancient git version
DEPEND=">=dev-vcs/git-1.6"

EXPORTED_FUNCTIONS="src_unpack"
case "${EAPI:-0}" in
        2|3|4|5) EXPORTED_FUNCTIONS="${EXPORTED_FUNCTIONS} src_prepare" ;;
        1|0) ;;
        *) die "EAPI=${EAPI} is not supported" ;;
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 non-empty value to supress some eclass messages.
: ${EGIT_QUIET:=${ESCM_QUIET}}

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

# @ECLASS-VARIABLE: EGIT_UNPACK_DIR
# @DESCRIPTION:
# Directory to unpack git sources in.

# @ECLASS-VARIABLE: EGIT_HAS_SUBMODULES
# @DESCRIPTION:
# Set this to non-empty 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:=}
else
        EGIT_REPO_URI="${X}"
fi
# @ECLASS-VARIABLE: EGIT_PROJECT
# @DESCRIPTION:
# Project name, it must be unique across EGIT_STORE_DIR.
# Git eclass will check out the git repository into ${EGIT_STORE_DIR}/${EGIT_PROJECT}/${EGIT_REPO_URI##*/}
# Default is ${PN}.
: ${EGIT_PROJECT:=${PN}}

# @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:=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:
# Set to non-empty value to repack objects to save disk space. However this can
# take a long time with VERY big repositories.
: ${EGIT_REPACK:=}

# @ECLASS-VARIABLE: EGIT_PRUNE
# @DESCRIPTION:
# Set to non-empty value to prune loose objects on each fetch. This is useful
# if upstream rewinds and rebases branches 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 sync"
                git submodule sync
                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} "$@"

        eqawarn "git.eclass is deprecated."
        eqawarn "Please update your ebuilds to use git-2 instead. For details, see"
        eqawarn "http://archives.gentoo.org/gentoo-dev/msg_b7ba363cae580845819ae3501fb157e9.xml"

        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 [[ -n ${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 -m 775 -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"
                local args
                [[ -n ${EGIT_PRUNE} ]] && args='--prune'
                git gc ${args}
                eend $?
        fi
        popd &> /dev/null

        # export the git version
        export EGIT_VERSION="${cursha1}"

        # log the repo state
        [[ "${EGIT_COMMIT}" != "${EGIT_BRANCH}" ]] && ${elogcmd} "   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 . \"${EGIT_UNPACK_DIR:-${S}}\""
                time rsync -rlpgo . "${EGIT_UNPACK_DIR:-${S}}"
                popd &> /dev/null
        else
                unset GIT_DIR
                debug-print "git clone -l -s -n \"${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}\" \"${EGIT_UNPACK_DIR:-${S}}\""
                git clone -l -s -n "${EGIT_STORE_DIR}/${EGIT_CLONE_DIR}" "${EGIT_UNPACK_DIR:-${S}}"
        fi

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

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