# Copyright (C) 2008 The Android Open Source Project

# Copyright (C) 2017 Wave Computing, Inc. John McGehee

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

from __future__ import print_function

import errno

import filecmp

import glob

import os

import random

import re

import shutil

import stat

import subprocess

import sys

import tarfile

import tempfile

import time

import traceback

from color import Coloring

from git_command import GitCommand, git_require

from git_config import GitConfig, IsId, GetSchemeFromUrl, GetUrlCookieFile, \

ID_RE

from error import GitError, HookError, UploadError, DownloadError

from error import ManifestInvalidRevisionError

from error import NoManifestException

import platform_utils

from trace import IsTrace, Trace

from git_refs import GitRefs, HEAD, R_HEADS, R_TAGS, R_PUB, R_M

from pyversion import is_python3

if is_python3():

import urllib.parse

else:

import imp

import urlparse

urllib = imp.new_module('urllib')

urllib.parse = urlparse

# pylint:disable=W0622

input = raw_input

# pylint:enable=W0622

def _lwrite(path, content):

lock = '%s.lock' % path

fd = open(lock, 'w')

try:

fd.write(content)

finally:

fd.close()

try:

platform_utils.rename(lock, path)

except OSError:

platform_utils.remove(lock)

raise

def _error(fmt, *args):

msg = fmt % args

print('error: %s' % msg, file=sys.stderr)

def _warn(fmt, *args):

msg = fmt % args

print('warn: %s' % msg, file=sys.stderr)

def not_rev(r):

return '^' + r

def sq(r):

return "'" + r.replace("'", "'\''") + "'"

_project_hook_list = None

def _ProjectHooks():

"""List the hooks present in the 'hooks' directory.

These hooks are project hooks and are copied to the '.git/hooks' directory

of all subprojects.

This function caches the list of hooks (based on the contents of the

'repo/hooks' directory) on the first call.

Returns:

A list of absolute paths to all of the files in the hooks directory.

"""

global _project_hook_list

if _project_hook_list is None:

d = platform_utils.realpath(os.path.abspath(os.path.dirname(__file__)))

d = os.path.join(d, 'hooks')

_project_hook_list = [os.path.join(d, x) for x in os.listdir(d)]

return _project_hook_list

class DownloadedChange(object):

_commit_cache = None

def __init__(self, project, base, change_id, ps_id, commit):

self.project = project

self.base = base

self.change_id = change_id

self.ps_id = ps_id

self.commit = commit

@property

def commits(self):

if self._commit_cache is None:

self._commit_cache = self.project.bare_git.rev_list('--abbrev=8',

'--abbrev-commit',

'--pretty=oneline',

'--reverse',

'--date-order',

not_rev(self.base),

self.commit,

'--')

return self._commit_cache

class ReviewableBranch(object):

_commit_cache = None

def __init__(self, project, branch, base):

self.project = project

self.branch = branch

self.base = base

@property

def name(self):

return self.branch.name

@property

def commits(self):

if self._commit_cache is None:

self._commit_cache = self.project.bare_git.rev_list('--abbrev=8',

'--abbrev-commit',

'--pretty=oneline',

'--reverse',

'--date-order',

not_rev(self.base),

R_HEADS + self.name,

'--')

return self._commit_cache

@property

def unabbrev_commits(self):

r = dict()

for commit in self.project.bare_git.rev_list(not_rev(self.base),

R_HEADS + self.name,

'--'):

r[commit[0:8]] = commit

return r

@property

def date(self):

return self.project.bare_git.log('--pretty=format:%cd',

'-n', '1',

R_HEADS + self.name,

'--')

def UploadForReview(self, people,

auto_topic=False,

draft=False,

private=False,

wip=False,

dest_branch=None,

validate_certs=True):

self.project.UploadForReview(self.name,

people,

auto_topic=auto_topic,

draft=draft,

private=private,

wip=wip,

dest_branch=dest_branch,

validate_certs=validate_certs)

def Push(self, dest_branch=None,

validate_certs=True):

self.project.Push(self.name,

dest_branch=dest_branch,

validate_certs=validate_certs)

def GetPublishedRefs(self):

refs = {}

output = self.project.bare_git.ls_remote(

self.branch.remote.SshReviewUrl(self.project.UserEmail),

'refs/changes/*')

for line in output.split('\n'):

try:

(sha, ref) = line.split()

refs[sha] = ref

except ValueError:

pass

return refs

class StatusColoring(Coloring):

def __init__(self, config):

Coloring.__init__(self, config, 'status')

self.project = self.printer('header', attr='bold')

self.branch = self.printer('header', attr='bold')

self.nobranch = self.printer('nobranch', fg='red')

self.important = self.printer('important', fg='red')

self.added = self.printer('added', fg='green')

self.changed = self.printer('changed', fg='red')

self.untracked = self.printer('untracked', fg='red')

class DiffColoring(Coloring):

def __init__(self, config):

Coloring.__init__(self, config, 'diff')

self.project = self.printer('header', attr='bold')

class _Annotation(object):

def __init__(self, name, value, keep):

self.name = name

self.value = value

self.keep = keep

class _CopyFile(object):

def __init__(self, src, dest, abssrc, absdest):

self.src = src

self.dest = dest

self.abs_src = abssrc

self.abs_dest = absdest

def _Copy(self):

src = self.abs_src

dest = self.abs_dest

# copy file if it does not exist or is out of date

if not os.path.exists(dest) or not filecmp.cmp(src, dest):

try:

# remove existing file first, since it might be read-only

if os.path.exists(dest):

platform_utils.remove(dest)

else:

dest_dir = os.path.dirname(dest)

if not os.path.isdir(dest_dir):

os.makedirs(dest_dir)

shutil.copy(src, dest)

# make the file read-only

mode = os.stat(dest)[stat.ST_MODE]

mode = mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)

os.chmod(dest, mode)

except IOError:

_error('Cannot copy file %s to %s', src, dest)

class _LinkFile(object):

def __init__(self, git_worktree, src, dest, relsrc, absdest):

self.git_worktree = git_worktree

self.src = src

self.dest = dest

self.src_rel_to_dest = relsrc

self.abs_dest = absdest

def __linkIt(self, relSrc, absDest):

# link file if it does not exist or is out of date

if not platform_utils.islink(absDest) or (platform_utils.readlink(absDest) != relSrc):

try:

# remove existing file first, since it might be read-only

if os.path.lexists(absDest):

platform_utils.remove(absDest)

else:

dest_dir = os.path.dirname(absDest)

if not os.path.isdir(dest_dir):

os.makedirs(dest_dir)

platform_utils.symlink(relSrc, absDest)

except IOError:

_error('Cannot link file %s to %s', relSrc, absDest)

def _Link(self):

"""Link the self.rel_src_to_dest and self.abs_dest. Handles wild cards

on the src linking all of the files in the source in to the destination

directory.

"""

# We use the absSrc to handle the situation where the current directory

# is not the root of the repo

absSrc = os.path.join(self.git_worktree, self.src)

if os.path.exists(absSrc):

# Entity exists so just a simple one to one link operation

self.__linkIt(self.src_rel_to_dest, self.abs_dest)

else:

# Entity doesn't exist assume there is a wild card

absDestDir = self.abs_dest

if os.path.exists(absDestDir) and not os.path.isdir(absDestDir):

_error('Link error: src with wildcard, %s must be a directory',

absDestDir)

else:

absSrcFiles = glob.glob(absSrc)

for absSrcFile in absSrcFiles:

# Create a releative path from source dir to destination dir

absSrcDir = os.path.dirname(absSrcFile)

relSrcDir = os.path.relpath(absSrcDir, absDestDir)

# Get the source file name

srcFile = os.path.basename(absSrcFile)

# Now form the final full paths to srcFile. They will be

# absolute for the desintaiton and relative for the srouce.

absDest = os.path.join(absDestDir, srcFile)

relSrc = os.path.join(relSrcDir, srcFile)

self.__linkIt(relSrc, absDest)

class RemoteSpec(object):

def __init__(self,

name,

url=None,

pushUrl=None,

review=None,

revision=None,

orig_name=None,

fetchUrl=None):

self.name = name

self.url = url

self.pushUrl = pushUrl

self.review = review

self.revision = revision

self.orig_name = orig_name

self.fetchUrl = fetchUrl

class RepoHook(object):

"""A RepoHook contains information about a script to run as a hook.

Hooks are used to run a python script before running an upload (for instance,

to run presubmit checks). Eventually, we may have hooks for other actions.

This shouldn't be confused with files in the 'repo/hooks' directory. Those

files are copied into each '.git/hooks' folder for each project. Repo-level

hooks are associated instead with repo actions.

Hooks are always python. When a hook is run, we will load the hook into the

interpreter and execute its main() function.

"""

def __init__(self,

hook_type,

hooks_project,

topdir,

manifest_url,

abort_if_user_denies=False):

"""RepoHook constructor.

Params:

hook_type: A string representing the type of hook. This is also used

to figure out the name of the file containing the hook. For

example: 'pre-upload'.

hooks_project: The project containing the repo hooks. If you have a

manifest, this is manifest.repo_hooks_project. OK if this is None,

which will make the hook a no-op.

topdir: Repo's top directory (the one containing the .repo directory).

Scripts will run with CWD as this directory. If you have a manifest,

this is manifest.topdir

manifest_url: The URL to the manifest git repo.

abort_if_user_denies: If True, we'll throw a HookError() if the user

doesn't allow us to run the hook.

"""

self._hook_type = hook_type

self._hooks_project = hooks_project

self._manifest_url = manifest_url

self._topdir = topdir

self._abort_if_user_denies = abort_if_user_denies

# Store the full path to the script for convenience.

if self._hooks_project:

self._script_fullpath = os.path.join(self._hooks_project.worktree,

self._hook_type + '.py')

else:

self._script_fullpath = None

def _GetHash(self):

"""Return a hash of the contents of the hooks directory.

We'll just use git to do this. This hash has the property that if anything

changes in the directory we will return a different has.

SECURITY CONSIDERATION:

This hash only represents the contents of files in the hook directory, not

any other files imported or called by hooks. Changes to imported files

can change the script behavior without affecting the hash.

Returns:

A string representing the hash. This will always be ASCII so that it can

be printed to the user easily.

"""

assert self._hooks_project, "Must have hooks to calculate their hash."

# We will use the work_git object rather than just calling GetRevisionId().

# That gives us a hash of the latest checked in version of the files that

# the user will actually be executing. Specifically, GetRevisionId()

# doesn't appear to change even if a user checks out a different version

# of the hooks repo (via git checkout) nor if a user commits their own revs.

#

# NOTE: Local (non-committed) changes will not be factored into this hash.

# I think this is OK, since we're really only worried about warning the user

# about upstream changes.

return self._hooks_project.work_git.rev_parse('HEAD')

def _GetMustVerb(self):

"""Return 'must' if the hook is required; 'should' if not."""

if self._abort_if_user_denies:

return 'must'

else:

return 'should'

def _CheckForHookApproval(self):

"""Check to see whether this hook has been approved.

We'll accept approval of manifest URLs if they're using secure transports.

This way the user can say they trust the manifest hoster. For insecure

hosts, we fall back to checking the hash of the hooks repo.

Note that we ask permission for each individual hook even though we use

the hash of all hooks when detecting changes. We'd like the user to be

able to approve / deny each hook individually. We only use the hash of all

hooks because there is no other easy way to detect changes to local imports.

Returns:

True if this hook is approved to run; False otherwise.

Raises:

HookError: Raised if the user doesn't approve and abort_if_user_denies

was passed to the consturctor.

"""

if self._ManifestUrlHasSecureScheme():

return self._CheckForHookApprovalManifest()

else:

return self._CheckForHookApprovalHash()

def _CheckForHookApprovalHelper(self, subkey, new_val, main_prompt,

changed_prompt):

"""Check for approval for a particular attribute and hook.

Args:

subkey: The git config key under [repo.hooks.<hook_type>] to store the

last approved string.

new_val: The new value to compare against the last approved one.

main_prompt: Message to display to the user to ask for approval.

changed_prompt: Message explaining why we're re-asking for approval.

Returns:

True if this hook is approved to run; False otherwise.

Raises:

HookError: Raised if the user doesn't approve and abort_if_user_denies

was passed to the consturctor.

"""

hooks_config = self._hooks_project.config

git_approval_key = 'repo.hooks.%s.%s' % (self._hook_type, subkey)

# Get the last value that the user approved for this hook; may be None.

old_val = hooks_config.GetString(git_approval_key)

if old_val is not None:

# User previously approved hook and asked not to be prompted again.

if new_val == old_val:

# Approval matched. We're done.

return True

else:

# Give the user a reason why we're prompting, since they last told

# us to "never ask again".

prompt = 'WARNING: %s\n\n' % (changed_prompt,)

else:

prompt = ''

# Prompt the user if we're not on a tty; on a tty we'll assume "no".

if sys.stdout.isatty():

prompt += main_prompt + ' (yes/always/NO)? '

response = input(prompt).lower()

print()

# User is doing a one-time approval.

if response in ('y', 'yes'):

return True

elif response == 'always':

hooks_config.SetString(git_approval_key, new_val)

return True

# For anything else, we'll assume no approval.

if self._abort_if_user_denies:

raise HookError('You must allow the %s hook or use --no-verify.' %

self._hook_type)

return False

def _ManifestUrlHasSecureScheme(self):

"""Check if the URI for the manifest is a secure transport."""

secure_schemes = ('file', 'https', 'ssh', 'persistent-https', 'sso', 'rpc')

parse_results = urllib.parse.urlparse(self._manifest_url)

return parse_results.scheme in secure_schemes

def _CheckForHookApprovalManifest(self):

"""Check whether the user has approved this manifest host.

Returns:

True if this hook is approved to run; False otherwise.

"""

return self._CheckForHookApprovalHelper(

'approvedmanifest',

self._manifest_url,

'Run hook scripts from %s' % (self._manifest_url,),

'Manifest URL has changed since %s was allowed.' % (self._hook_type,))

def _CheckForHookApprovalHash(self):

"""Check whether the user has approved the hooks repo.

Returns:

True if this hook is approved to run; False otherwise.

"""

prompt = ('Repo %s run the script:\n'

' %s\n'

'\n'

'Do you want to allow this script to run')

return self._CheckForHookApprovalHelper(

'approvedhash',

self._GetHash(),

prompt % (self._GetMustVerb(), self._script_fullpath),

'Scripts have changed since %s was allowed.' % (self._hook_type,))

def _ExecuteHook(self, **kwargs):

"""Actually execute the given hook.

This will run the hook's 'main' function in our python interpreter.

Args:

kwargs: Keyword arguments to pass to the hook. These are often specific

to the hook type. For instance, pre-upload hooks will contain

a project_list.

"""

# Keep sys.path and CWD stashed away so that we can always restore them

# upon function exit.

orig_path = os.getcwd()

orig_syspath = sys.path

try:

# Always run hooks with CWD as topdir.

os.chdir(self._topdir)

# Put the hook dir as the first item of sys.path so hooks can do

# relative imports. We want to replace the repo dir as [0] so

# hooks can't import repo files.

sys.path = [os.path.dirname(self._script_fullpath)] + sys.path[1:]

# Exec, storing global context in the context dict. We catch exceptions

# and convert to a HookError w/ just the failing traceback.

context = {'__file__': self._script_fullpath}

try:

exec(compile(open(self._script_fullpath).read(),

self._script_fullpath, 'exec'), context)

except Exception:

raise HookError('%s\nFailed to import %s hook; see traceback above.' %

(traceback.format_exc(), self._hook_type))

# Running the script should have defined a main() function.

if 'main' not in context:

raise HookError('Missing main() in: "%s"' % self._script_fullpath)

# Add 'hook_should_take_kwargs' to the arguments to be passed to main.

# We don't actually want hooks to define their main with this argument--

# it's there to remind them that their hook should always take **kwargs.

# For instance, a pre-upload hook should be defined like:

# def main(project_list, **kwargs):

#

# This allows us to later expand the API without breaking old hooks.

kwargs = kwargs.copy()

kwargs['hook_should_take_kwargs'] = True

# Call the main function in the hook. If the hook should cause the

# build to fail, it will raise an Exception. We'll catch that convert

# to a HookError w/ just the failing traceback.

try:

context['main'](**kwargs)

except Exception:

raise HookError('%s\nFailed to run main() for %s hook; see traceback '

'above.' % (traceback.format_exc(),

self._hook_type))

finally:

# Restore sys.path and CWD.

sys.path = orig_syspath

os.chdir(orig_path)

def Run(self, user_allows_all_hooks, **kwargs):

"""Run the hook.

If the hook doesn't exist (because there is no hooks project or because

this particular hook is not enabled), this is a no-op.

Args:

user_allows_all_hooks: If True, we will never prompt about running the

hook--we'll just assume it's OK to run it.

kwargs: Keyword arguments to pass to the hook. These are often specific

to the hook type. For instance, pre-upload hooks will contain

a project_list.

Raises:

HookError: If there was a problem finding the hook or the user declined

to run a required hook (from _CheckForHookApproval).

"""

# No-op if there is no hooks project or if hook is disabled.

if ((not self._hooks_project) or (self._hook_type not in

self._hooks_project.enabled_repo_hooks)):

return

# Bail with a nice error if we can't find the hook.

if not os.path.isfile(self._script_fullpath):

raise HookError('Couldn\'t find repo hook: "%s"' % self._script_fullpath)

# Make sure the user is OK with running the hook.

if (not user_allows_all_hooks) and (not self._CheckForHookApproval()):

return

# Run the hook with the same version of python we're using.

self._ExecuteHook(**kwargs)

class Project(object):

# These objects can be shared between several working trees.

shareable_files = ['description', 'info']

shareable_dirs = ['hooks', 'objects', 'rr-cache', 'svn']

# These objects can only be used by a single working tree.

working_tree_files = ['config', 'packed-refs', 'shallow']

working_tree_dirs = ['logs', 'refs']

def __init__(self,

manifest,

name,

remote,

gitdir,

objdir,

worktree,

relpath,

revisionExpr,

revisionId,

rebase=True,

groups=None,

sync_c=False,

sync_s=False,

clone_depth=None,

upstream=None,

parent=None,

is_derived=False,

dest_branch=None,

optimized_fetch=False,

old_revision=None):

"""Init a Project object.

Args:

manifest: The XmlManifest object.

name: The `name` attribute of manifest.xml's project element.

remote: RemoteSpec object specifying its remote's properties.

gitdir: Absolute path of git directory.

objdir: Absolute path of directory to store git objects.

worktree: Absolute path of git working tree.

relpath: Relative path of git working tree to repo's top directory.

revisionExpr: The `revision` attribute of manifest.xml's project element.

revisionId: git commit id for checking out.

rebase: The `rebase` attribute of manifest.xml's project element.

groups: The `groups` attribute of manifest.xml's project element.

sync_c: The `sync-c` attribute of manifest.xml's project element.

sync_s: The `sync-s` attribute of manifest.xml's project element.

upstream: The `upstream` attribute of manifest.xml's project element.

parent: The parent Project object.

is_derived: False if the project was explicitly defined in the manifest;

True if the project is a discovered submodule.

dest_branch: The branch to which to push changes for review by default.

optimized_fetch: If True, when a project is set to a sha1 revision, only

fetch from the remote if the sha1 is not present locally.

old_revision: saved git commit id for open GITC projects.

"""

self.manifest = manifest

self.name = name

self.remote = remote

self.gitdir = gitdir.replace('\\', '/')

self.objdir = objdir.replace('\\', '/')

if worktree:

self.worktree = os.path.normpath(worktree).replace('\\', '/')

else:

self.worktree = None

self.relpath = relpath

self.revisionExpr = revisionExpr

if revisionId is None \

and revisionExpr \

and IsId(revisionExpr):

self.revisionId = revisionExpr

else:

self.revisionId = revisionId

self.rebase = rebase

self.groups = groups

self.sync_c = sync_c

self.sync_s = sync_s

self.clone_depth = clone_depth

self.upstream = upstream

self.parent = parent

self.is_derived = is_derived

self.optimized_fetch = optimized_fetch

self.subprojects = []

self.snapshots = {}

self.copyfiles = []

self.linkfiles = []

self.annotations = []

self.config = GitConfig.ForRepository(gitdir=self.gitdir,

defaults=self.manifest.globalConfig)

if self.worktree:

self.work_git = self._GitGetByExec(self, bare=False, gitdir=gitdir)

else:

self.work_git = None

self.bare_git = self._GitGetByExec(self, bare=True, gitdir=gitdir)

self.bare_ref = GitRefs(gitdir)

self.bare_objdir = self._GitGetByExec(self, bare=True, gitdir=objdir)

self.dest_branch = dest_branch

self.old_revision = old_revision

# This will be filled in if a project is later identified to be the

# project containing repo hooks.

self.enabled_repo_hooks = []

@property

def Derived(self):

return self.is_derived

@property

def Exists(self):

return os.path.isdir(self.gitdir) and os.path.isdir(self.objdir)

@property

def CurrentBranch(self):

"""Obtain the name of the currently checked out branch.

The branch name omits the 'refs/heads/' prefix.

None is returned if the project is on a detached HEAD.

"""

b = self.work_git.GetHead()

if b.startswith(R_HEADS):

return b[len(R_HEADS):]

return None

def IsRebaseInProgress(self):

w = self.worktree

g = os.path.join(w, '.git')

return os.path.exists(os.path.join(g, 'rebase-apply')) \

or os.path.exists(os.path.join(g, 'rebase-merge')) \

or os.path.exists(os.path.join(w, '.dotest'))

def IsDirty(self, consider_untracked=True):

"""Is the working directory modified in some way?

"""

self.work_git.update_index('-q',

'--unmerged',

'--ignore-missing',

'--refresh')

if self.work_git.DiffZ('diff-index', '-M', '--cached', HEAD):

return True

if self.work_git.DiffZ('diff-files'):

return True

if consider_untracked and self.work_git.LsOthers():

return True

return False

_userident_name = None

_userident_email = None

@property

def UserName(self):

"""Obtain the user's personal name.

"""

if self._userident_name is None:

self._LoadUserIdentity()

return self._userident_name

@property

def UserEmail(self):

"""Obtain the user's email address. This is very likely

to be their Gerrit login.

"""

if self._userident_email is None:

self._LoadUserIdentity()

return self._userident_email

def _LoadUserIdentity(self):

u = self.bare_git.var('GIT_COMMITTER_IDENT')

m = re.compile("^(.*) <([^>]*)> ").match(u)

if m:

self._userident_name = m.group(1)

self._userident_email = m.group(2)

else:

self._userident_name = ''

self._userident_email = ''

def GetRemote(self, name):

"""Get the configuration for a single remote.

"""

return self.config.GetRemote(name)

def GetBranch(self, name):

"""Get the configuration for a single branch.

"""

return self.config.GetBranch(name)

def GetBranches(self):

"""Get all existing local branches.

"""

current = self.CurrentBranch

all_refs = self._allrefs

heads = {}

for name, ref_id in all_refs.items():

if name.startswith(R_HEADS):

name = name[len(R_HEADS):]

b = self.GetBranch(name)

b.current = name == current

b.published = None

b.revision = ref_id

heads[name] = b

for name, ref_id in all_refs.items():

if name.startswith(R_PUB):

name = name[len(R_PUB):]

b = heads.get(name)

if b:

b.published = ref_id

return heads

def MatchesGroups(self, manifest_groups):

"""Returns true if the manifest groups specified at init should cause

this project to be synced.

Prefixing a manifest group with "-" inverts the meaning of a group.

All projects are implicitly labelled with "all".

labels are resolved in order. In the example case of

project_groups: "all,group1,group2"

manifest_groups: "-group1,group2"

the project will be matched.

The special manifest group "default" will match any project that

does not have the special project group "notdefault"

"""

expanded_manifest_groups = manifest_groups or ['default']

expanded_project_groups = ['all'] + (self.groups or [])

if 'notdefault' not in expanded_project_groups:

expanded_project_groups += ['default']

matched = False

for group in expanded_manifest_groups:

if group.startswith('-') and group[1:] in expanded_project_groups:

matched = False

elif group in expanded_project_groups:

matched = True

return matched

# Status Display ##

def UncommitedFiles(self, get_all=True):

"""Returns a list of strings, uncommitted files in the git tree.

Args:

get_all: a boolean, if True - get information about all different

uncommitted files. If False - return as soon as any kind of

uncommitted files is detected.

"""

details = []

self.work_git.update_index('-q',

'--unmerged',

'--ignore-missing',

'--refresh')

if self.IsRebaseInProgress():

details.append("rebase in progress")

if not get_all:

return details

changes = self.work_git.DiffZ('diff-index', '--cached', HEAD).keys()

if changes:

details.extend(changes)

if not get_all:

return details

changes = self.work_git.DiffZ('diff-files').keys()

if changes:

details.extend(changes)

if not get_all:

return details

changes = self.work_git.LsOthers()

if changes:

details.extend(changes)

return details

def HasChanges(self):

"""Returns true if there are uncommitted changes.

"""

if self.UncommitedFiles(get_all=False):

return True

else:

return False

def PrintWorkTreeStatus(self, output_redir=None, quiet=False):

"""Prints the status of the repository to stdout.

Args:

output: If specified, redirect the output to this object.

quiet: If True then only print the project name. Do not print

the modified files, branch name, etc.

"""

if not os.path.isdir(self.worktree):

if output_redir is None:

output_redir = sys.stdout

print(file=output_redir)

print('project %s/' % self.relpath, file=output_redir)

print(' missing (run "repo sync")', file=output_redir)

return

self.work_git.update_index('-q',

'--unmerged',

'--ignore-missing',

'--refresh')

rb = self.IsRebaseInProgress()

di = self.work_git.DiffZ('diff-index', '-M', '--cached', HEAD)

df = self.work_git.DiffZ('diff-files')

do = self.work_git.LsOthers()

if not rb and not di and not df and not do and not self.CurrentBranch:

return 'CLEAN'

out = StatusColoring(self.config)

if output_redir is not None:

out.redirect(output_redir)

out.project('project %-40s', self.relpath + '/ ')

if quiet:

out.nl()

return 'DIRTY'

branch = self.CurrentBranch

if branch is None:

out.nobranch('(*** NO BRANCH ***)')

else:

out.branch('branch %s', branch)

out.nl()

if rb:

out.important('prior sync failed; rebase still in progress')

out.nl()

paths = list()

paths.extend(di.keys())

paths.extend(df.keys())

paths.extend(do)

for p in sorted(set(paths)):

try:

i = di[p]

except KeyError:

i = None

try:

f = df[p]

except KeyError:

f = None

if i:

i_status = i.status.upper()

else:

i_status = '-'

if f:

f_status = f.status.lower()

else: