diff --git a/home/scarab/gentoo/gentoo-x86/eclass/git.eclass b/eclass/git.eclass
index fb30350..4346622 100644
--- a/home/scarab/gentoo/gentoo-x86/eclass/git.eclass
+++ b/eclass/git.eclass
@@ -1,67 +1,64 @@
-# Copyright 1999-2006 Gentoo Foundation
+# 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.15 2009/02/19 17:07:28 scarabeus Exp $
-
-## --------------------------------------------------------------------------- #
-# subversion.eclass author: Akinori Hattori <hattya@gentoo.org>
-# modified for git by Donnie Berkholz <spyderous@gentoo.org>
-# improved by Fernando J. Pereda <ferdy@gentoo.org>
-# you should currently poke with updates Tomas Chvatal <scarabeus@gentoo.org>
-#
-# The git eclass is written to fetch the software sources from
-# git repositories like the subversion eclass.
-#
-#
-# Description:
-#   If you use this eclass, the ${S} is ${WORKDIR}/${P}.
-#   It is necessary to define the EGIT_REPO_URI variable at least.
-#
-## --------------------------------------------------------------------------- #
-
-inherit eutils
+# $Header: $
+
+# @ECLASS: git.eclass
+# @MAINTAINER:
+# Tomas Chvatal <scarabeus@gentoo.org>
+# Donnie Berkholz <dberkholz@gentoo.org>
+# @BLURB: This eclass provides functions for fetch and unpack git repozitories
+# @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 base eutils
 
 EGIT="git.eclass"
 
-EXPORT_FUNCTIONS src_unpack
+case "${EAPI:-0}" in
+	2) EXPORT_FUNCTIONS src_unpack src_prepare ;;
+	0|1) EXPORT_FUNCTIONS src_unpack ;;
+esac
 
 HOMEPAGE="http://git.or.cz/"
 DESCRIPTION="Based on the ${ECLASS} eclass"
 
+# We DEPEND on git
+DEPEND="dev-util/git"
 
-## -- add git in DEPEND
-#
-DEPEND=">=dev-util/git-1.5"
-
-
-## -- EGIT_STORE_DIR:  git sources store directory
-#
+# @ECLASS-VARIABLE: EGIT_STORE_DIR
+# @DESCRIPTION:
+# Storage directory for git sources.
 EGIT_STORE_DIR="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/git-src"
 
-
-## -- EGIT_FETCH_CMD:  git clone command
-#
+# @ECLASS-VARIABLE: EGIT_FETCH_CMD
+# @DESCRIPTION:
+# Command for cloning the repository.
 EGIT_FETCH_CMD="git clone --bare --depth 1"
 
-## -- EGIT_UPDATE_CMD:  git fetch command
-#
+# @ECLASS-VARIABLE: EGIT_UPDATE_CMD
+# @DESCRIPTION:
+# Git fetch command.
 EGIT_UPDATE_CMD="git fetch -f -u"
 
-## -- EGIT_DIFFSTAT_CMD: Command to get diffstat output
-#
+# @ECLASS-VARIABLE: EGIT_DIFFSTAT_CMD
+# @DESCRIPTION:
+# Git command for diffstat.
 EGIT_DIFFSTAT_CMD="git diff --stat"
 
-
-## -- EGIT_OPTIONS:
-#
-# the options passed to clone and fetch
-#
+# @ECLASS-VARIABLE: EGIT_OPTIONS
+# @DESCRIPTION:
+# This variable value is passed to clone and fetch.
 : ${EGIT_OPTIONS:=}
 
-
-## -- EGIT_REPO_URI:  repository uri
-#
+# @ECLASS-VARIABLE: EGIT_REPO_URI
+# @DESCRIPTION:
+# URI for the repository
 # e.g. http://foo, git://bar
-#
+# @NOTE:
 # supported protocols:
 #   http://
 #   https://
@@ -69,31 +66,24 @@ EGIT_DIFFSTAT_CMD="git diff --stat"
 #   git+ssh://
 #   rsync://
 #   ssh://
-#
 : ${EGIT_REPO_URI:=}
 
-
-## -- EGIT_PROJECT:  project name of your ebuild
-#
+# @ECLASS-VARIABLE: EGIT_PROJECT
+# @DESCRIPTION:
+# project name of your ebuild
+# @NOTE:
 # git eclass will check out the git repository like:
-#
-#   ${EGIT_STORE_DIR}/${EGIT_PROJECT}/${EGIT_REPO_URI##*/}
-#
+#	${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
-#
-# default: ${PN/-git}.
-#
+#	${EGIT_STORE_DIR}/subversion
+# @DEFAULT: ${PN/-git}.
 : ${EGIT_PROJECT:=${PN/-git}}
 
-
-## -- EGIT_BOOTSTRAP:
-#
-# bootstrap script or command like autogen.sh or etc..
-#
+# @ECLASS-VARIABLE: EGIT_BOOSTRAP
+# @DESCRIPTION:
+# bootstrap script or command like autogen.sh or etc...
 : ${EGIT_BOOTSTRAP:=}
 
 # @ECLASS-VARIABLE: EGIT_OFFLINE
@@ -103,58 +93,42 @@ EGIT_DIFFSTAT_CMD="git diff --stat"
 # tree by users.
 EGIT_OFFLINE="${EGIT_OFFLINE:-${ESCM_OFFLINE}}"
 
-## -- EGIT_PATCHES:
-#
-# git eclass can apply pathces in git_bootstrap().
-# you can use regexp in this valiable like *.diff or *.patch or etc.
-# NOTE: this patches will apply before eval EGIT_BOOTSTRAP.
-#
-# the process of applying the patch is:
-#   1. just epatch it, if the patch exists in the path.
-#   2. scan it under FILESDIR and epatch it, if the patch exists in FILESDIR.
-#   3. die.
-#
-: ${EGIT_PATCHES:=}
-
-
-## -- EGIT_BRANCH:
-#
+# @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().
-# If set, it must be before 'inherit git', otherwise both EGIT_BRANCH and
-# EGIT_TREE must be set after 'inherit git'.
-# Defaults to 'master'
-#
+# @DEFAULT: master
 : ${EGIT_BRANCH:=master}
 
-
-## -- EGIT_TREE:
-#
+# @ECLASS-VARIABLE: EGIT_TREE
+# @DESCRIPTION:
 # git eclass can checkout any tree.
-# Defaults to EGIT_BRANCH.
-#
+# @DEFAULT: EGIT_BRANCH
 : ${EGIT_TREE:=${EGIT_BRANCH}}
 
-
-## - EGIT_REPACK:
-#
+# @ECLASS-VARIABLE: EGIT_REPACK
 # git eclass will repack objects to save disk space. However this can take a
-# long time with VERY big repositories. If this is your case set:
-# EGIT_REPACK=false
-#
+# long time with VERY big repositories.
+# @DEFAULT: false
 : ${EGIT_REPACK:=false}
 
-## - EGIT_PRUNE:
-#
+# @ECLASS_VARIABLE: EGIT_PRUNE
+# @DESCRIPTION:
 # git eclass can prune the local clone. This is useful if upstream rewinds and
 # rebases branches too often. If you don't want this to happen, set:
-# EGIT_PRUNE=false
-#
+# @DEFAULT: false
 : ${EGIT_PRUNE:=false}
 
-
-## -- git_fetch() ------------------------------------------------- #
-
+# @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
 
@@ -164,14 +138,13 @@ git_fetch() {
 	# 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}: fetch from "${EGIT_REPO_URI%:*}" is not yet implemented."
-				;;
+			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 /
@@ -183,7 +156,7 @@ git_fetch() {
 	cd -P "${EGIT_STORE_DIR}" || die "${EGIT}: can't chdir to ${EGIT_STORE_DIR}"
 	EGIT_STORE_DIR=${PWD}
 
-	# every time
+	# allow writing into EGIT_STORE_DIR
 	addwrite "${EGIT_STORE_DIR}"
 
 	[[ -z ${EGIT_REPO_URI##*/} ]] && EGIT_REPO_URI="${EGIT_REPO_URI%/}"
@@ -240,59 +213,88 @@ git_fetch() {
 	git archive --format=tar ${EGIT_TREE} | ( cd "${S}" ; tar xf - )
 
 	echo ">>> Unpacked to ${S}"
-
 }
 
-
-## -- git_bootstrap() ------------------------------------------------ #
-
+# @FUNCTION: git_bootstrap
+# @DESCRIPTION:
+# Runs bootstrap command if EGIT_BOOTSTRAP variable contains some value
+# @NOTE:
+# Remember that what ever gets to the EGIT_BOOTSTRAP variable gets evaled by bash.
 git_bootstrap() {
+	debug-print-function ${FUNCNAME} "$@"
 
-	local patch lpatch
-
-	cd "${S}"
+	if [[ -n ${EGIT_BOOTSTRAP} ]] ; then
+		pushd "${S}" > /dev/null
+		einfo "Starting bootstrap"
 
-	if [[ -n ${EGIT_PATCHES} ]] ; then
-		einfo "apply patches -->"
+		if [[ -f ${EGIT_BOOTSTRAP} ]]; then
+			# we have file in the repo which we should execute
+			debug-print "$FUNCNAME: bootstraping with file \"${EGIT_BOOTSTRAP}\""
 
-		for patch in ${EGIT_PATCHES} ; do
-			if [[ -f ${patch} ]] ; then
-				epatch ${patch}
+			if [[ -x ${EGIT_BOOTSTRAP} ]]; then
+				eval "./${EGIT_BOOTSTRAP}" \
+					|| die "${EGIT}: bootstrap script failed"
 			else
-				for lpatch in "${FILESDIR}"/${patch} ; do
-					if [[ -f ${lpatch} ]] ; then
-						epatch ${lpatch}
-					else
-						die "${EGIT}: ${patch} is not found"
-					fi
-				done
+				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
-		done
-		echo
-	fi
-
-	if [[ -n ${EGIT_BOOTSTRAP} ]] ; then
-		einfo "begin bootstrap -->"
-
-		if [[ -f ${EGIT_BOOTSTRAP} ]] && [[ -x ${EGIT_BOOTSTRAP} ]] ; then
-			einfo "   bootstrap with a file: ${EGIT_BOOTSTRAP}"
-			eval "./${EGIT_BOOTSTRAP}" \
-				|| die "${EGIT}: can't execute EGIT_BOOTSTRAP."
 		else
-			einfo "   bootstrap with commands: ${EGIT_BOOTSTRAP}"
+			# we execute some system command
+			debug-print "$FUNCNAME: bootstraping with commands \"${EGIT_BOOTSTRAP}\""
+
 			eval "${EGIT_BOOTSTRAP}" \
-				|| die "${EGIT}: can't eval EGIT_BOOTSTRAP."
+				|| die "${EGIT}: bootstrap commands failed."
+
 		fi
-	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
+	else
+		for i in ${EGIT_PATCHES}; do
+			debug-print "$FUNCNAME: git_autopatch: patching from ${i}"
+			epatch "${x}"
+		done
+	fi
 
-## -- git_src_unpack() ------------------------------------------------ #
+	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()."
-	git_bootstrap || die "${EGIT}: unknown problem in git_bootstrap()."
+	git_fetch || die "${EGIT}: unknown problem in git_fetch()."
+}
+
+# @FUNCTION: git_src_prepare
+# @DESCRIPTION:
+# src_prepare function for git stuff. Patches, bootstrap...
+git_src_prepare() {
+	debug-print-function ${FUNCNAME} "$@"
 
+	git_apply_patches
+	base_src_prepare
+	git_bootstrap
 }