Revert "Repo: fall back to http, if ssh connection fails for http repos"

This reverts commit 488bf092d5. Issue 230 Change-Id: I3a5725301f576e1a2ac499cb6daa631895115640
Merge "On project cleanup, don't remove nested projects"
2025-06-28 20:17:26 +00:00 · 2016-09-22 16:40:27 +00:00 · 2016-09-21 22:23:44 +00:00 · 2016-09-20 17:16:12 -07:00 · 2016-09-20 15:31:20 +00:00 · 2016-09-20 08:06:12 +00:00
31 changed files with 1703 additions and 806 deletions
--- a/.flake8
+++ b/.flake8
@ -0,0 +1,3 @@
 [flake8]
 max-line-length=80
 ignore=E111,E114,E402
--- a/.gitattributes
+++ b/.gitattributes
@ -1,4 +1,4 @@
 # Prevent /bin/sh scripts from being clobbered by autocrlf=true
 git_ssh text eol=lf
 main.py text eol=lf
 repo text eol=lf
 hooks/* text eol=lf
--- a/.mailmap
+++ b/.mailmap
@ -0,0 +1,11 @@
 Anthony Newnam <anthony.newnam@garmin.com>    Anthony <anthony@bnovc.com>
 Hu Xiuyun <xiuyun.hu@hisilicon.com>           Hu xiuyun <xiuyun.hu@hisilicon.com>
 Hu Xiuyun <xiuyun.hu@hisilicon.com>           Hu Xiuyun <clouds08@qq.com>
 Jelly Chen <chenguodong@huawei.com>           chenguodong <chenguodong@huawei.com>
 Jia Bi <bijia@xiaomi.com>                     bijia <bijia@xiaomi.com>
 JoonCheol Park <jooncheol@gmail.com>          Jooncheol Park <jooncheol@gmail.com>
 Sergii Pylypenko <x.pelya.x@gmail.com>        pelya <x.pelya.x@gmail.com>
 Shawn Pearce <sop@google.com>                 Shawn O. Pearce <sop@google.com>
 Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>  Ulrik Sjolin <ulrik.sjolin@gmail.com>
 Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>  Ulrik Sjolin <ulrik.sjolin@sonyericsson.com>
 Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>  Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>
--- a/.pylintrc
+++ b/.pylintrc
@ -1,298 +0,0 @@
 # lint Python modules using external checkers.
 #
 # This is the main checker controling the other ones and the reports
 # generation. It is itself both a raw checker and an astng checker in order
 # to:
 # * handle message activation / deactivation at the module level
 # * handle some basic but necessary stats'data (number of classes, methods...)
 #
 [MASTER]
 # Specify a configuration file.
 #rcfile=
 # Python code to execute, usually for sys.path manipulation such as
 # pygtk.require().
 #init-hook=
 # Profiled execution.
 profile=no
 # Add <file or directory> to the black list. It should be a base name, not a
 # path. You may set this option multiple times.
 ignore=SVN
 # Pickle collected data for later comparisons.
 persistent=yes
 # Set the cache size for astng objects.
 cache-size=500
 # List of plugins (as comma separated values of python modules names) to load,
 # usually to register additional checkers.
 load-plugins=
 [MESSAGES CONTROL]
 # Enable only checker(s) with the given id(s). This option conflicts with the
 # disable-checker option
 #enable-checker=
 # Enable all checker(s) except those with the given id(s). This option
 # conflicts with the enable-checker option
 #disable-checker=
 # Enable all messages in the listed categories.
 #enable-msg-cat=
 # Disable all messages in the listed categories.
 #disable-msg-cat=
 # Enable the message(s) with the given id(s).
 enable=RP0004
 # Disable the message(s) with the given id(s).
 disable=R0903,R0912,R0913,R0914,R0915,W0141,C0111,C0103,W0603,W0703,R0911,C0301,C0302,R0902,R0904,W0142,W0212,E1101,E1103,R0201,W0201,W0122,W0232,RP0001,RP0003,RP0101,RP0002,RP0401,RP0701,RP0801,F0401,E0611,R0801,I0011
 [REPORTS]
 # set the output format. Available formats are text, parseable, colorized, msvs
 # (visual studio) and html
 output-format=text
 # Put messages in a separate file for each module / package specified on the
 # command line instead of printing them on stdout. Reports (if any) will be
 # written in a file name "pylint_global.[txt|html]".
 files-output=no
 # Tells whether to display a full report or only the messages
 reports=yes
 # Python expression which should return a note less than 10 (10 is the highest
 # note).You have access to the variables errors warning, statement which
 # respectivly contain the number of errors / warnings messages and the total
 # number of statements analyzed. This is used by the global evaluation report
 # (R0004).
 evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
 # Add a comment according to your evaluation note. This is used by the global
 # evaluation report (R0004).
 comment=no
 # checks for
 # * unused variables / imports
 # * undefined variables
 # * redefinition of variable from builtins or from an outer scope
 # * use of variable before assigment
 #
 [VARIABLES]
 # Tells whether we should check for unused import in __init__ files.
 init-import=no
 # A regular expression matching names used for dummy variables (i.e. not used).
 dummy-variables-rgx=_|dummy
 # List of additional names supposed to be defined in builtins. Remember that
 # you should avoid to define new builtins when possible.
 additional-builtins=
 # try to find bugs in the code using type inference
 #
 [TYPECHECK]
 # Tells whether missing members accessed in mixin class should be ignored. A
 # mixin class is detected if its name ends with "mixin" (case insensitive).
 ignore-mixin-members=yes
 # List of classes names for which member attributes should not be checked
 # (useful for classes with attributes dynamicaly set).
 ignored-classes=SQLObject
 # When zope mode is activated, consider the acquired-members option to ignore
 # access to some undefined attributes.
 zope=no
 # List of members which are usually get through zope's acquisition mecanism and
 # so shouldn't trigger E0201 when accessed (need zope=yes to be considered).
 acquired-members=REQUEST,acl_users,aq_parent
 # checks for :
 # * doc strings
 # * modules / classes / functions / methods / arguments / variables name
 # * number of arguments, local variables, branchs, returns and statements in
 # functions, methods
 # * required module attributes
 # * dangerous default values as arguments
 # * redefinition of function / method / class
 # * uses of the global statement
 #
 [BASIC]
 # Required attributes for module, separated by a comma
 required-attributes=
 # Regular expression which should only match functions or classes name which do
 # not require a docstring
 no-docstring-rgx=_main|__.*__
 # Regular expression which should only match correct module names
 module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
 # Regular expression which should only match correct module level names
 const-rgx=(([A-Z_][A-Z1-9_]*)|(__.*__))|(log)$
 # Regular expression which should only match correct class names
 class-rgx=[A-Z_][a-zA-Z0-9]+$
 # Regular expression which should only match correct function names
 function-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct method names
 method-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct instance attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct argument names
 argument-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct variable names
 variable-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct list comprehension /
 # generator expression variable names
 inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
 # Good variable names which should always be accepted, separated by a comma
 good-names=i,j,k,ex,Run,_,e,d1,d2,v,f,l,d
 # Bad variable names which should always be refused, separated by a comma
 bad-names=foo,bar,baz,toto,tutu,tata
 # List of builtins function names that should not be used, separated by a comma
 bad-functions=map,filter,apply,input
 # checks for sign of poor/misdesign:
 # * number of methods, attributes, local variables...
 # * size, complexity of functions, methods
 #
 [DESIGN]
 # Maximum number of arguments for function / method
 max-args=5
 # Maximum number of locals for function / method body
 max-locals=15
 # Maximum number of return / yield for function / method body
 max-returns=6
 # Maximum number of branch for function / method body
 max-branchs=12
 # Maximum number of statements in function / method body
 max-statements=50
 # Maximum number of parents for a class (see R0901).
 max-parents=7
 # Maximum number of attributes for a class (see R0902).
 max-attributes=20
 # Minimum number of public methods for a class (see R0903).
 min-public-methods=2
 # Maximum number of public methods for a class (see R0904).
 max-public-methods=30
 # checks for
 # * external modules dependencies
 # * relative / wildcard imports
 # * cyclic imports
 # * uses of deprecated modules
 #
 [IMPORTS]
 # Deprecated modules which should not be used, separated by a comma
 deprecated-modules=regsub,string,TERMIOS,Bastion,rexec
 # Create a graph of every (i.e. internal and external) dependencies in the
 # given file (report R0402 must not be disabled)
 import-graph=
 # Create a graph of external dependencies in the given file (report R0402 must
 # not be disabled)
 ext-import-graph=
 # Create a graph of internal dependencies in the given file (report R0402 must
 # not be disabled)
 int-import-graph=
 # checks for :
 # * methods without self as first argument
 # * overridden methods signature
 # * access only to existant members via self
 # * attributes not defined in the __init__ method
 # * supported interfaces implementation
 # * unreachable code
 #
 [CLASSES]
 # List of interface methods to ignore, separated by a comma. This is used for
 # instance to not check methods defines in Zope's Interface base class.
 ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by
 # List of method names used to declare (i.e. assign) instance attributes.
 defining-attr-methods=__init__,__new__,setUp
 # checks for similarities and duplicated code. This computation may be
 # memory / CPU intensive, so you should disable it if you experiments some
 # problems.
 #
 [SIMILARITIES]
 # Minimum lines number of a similarity.
 min-similarity-lines=4
 # Ignore comments when computing similarities.
 ignore-comments=yes
 # Ignore docstrings when computing similarities.
 ignore-docstrings=yes
 # checks for:
 # * warning notes in the code like FIXME, XXX
 # * PEP 263: source code with non ascii character but no encoding declaration
 #
 [MISCELLANEOUS]
 # List of note tags to take in consideration, separated by a comma.
 notes=FIXME,XXX,TODO
 # checks for :
 # * unauthorized constructions
 # * strict indentation
 # * line length
 # * use of <> instead of !=
 #
 [FORMAT]
 # Maximum number of characters on a single line.
 max-line-length=80
 # Maximum number of lines in a module
 max-module-lines=1000
 # String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
 # tab).  In repo it is 2 spaces.
 indent-string='  '
--- a/README.md
+++ b/README.md
@ -0,0 +1,14 @@
 # repo
 Repo is a tool built on top of Git.  Repo helps manage many Git repositories,
 does the uploads to revision control systems, and automates parts of the
 development workflow.  Repo is not meant to replace Git, only to make it
 easier to work with Git.  The repo command is an executable Python script
 that you can put anywhere in your path.
 * Homepage: https://code.google.com/p/git-repo/
 * Bug reports: https://code.google.com/p/git-repo/issues/
 * Source: https://code.google.com/p/git-repo/
 * Overview: https://source.android.com/source/developing.html
 * Docs: https://source.android.com/source/using-repo.html
 * [Submitting patches](./SUBMITTING_PATCHES.md)
--- a/87
+++ b/87
@ -1,87 +0,0 @@
 Short Version:
 - Make small logical changes.
 - Provide a meaningful commit message.
 - Check for coding errors with pylint
 - Make sure all code is under the Apache License, 2.0.
 - Publish your changes for review:
   git push https://gerrit-review.googlesource.com/git-repo HEAD:refs/for/master
 Long Version:
 I wanted a file describing how to submit patches for repo,
 so I started with the one found in the core Git distribution
 (Documentation/SubmittingPatches), which itself was based on the
 patch submission guidelines for the Linux kernel.
 However there are some differences, so please review and familiarize
 yourself with the following relevant bits:
 (1) Make separate commits for logically separate changes.
 Unless your patch is really trivial, you should not be sending
 out a patch that was generated between your working tree and your
 commit head.  Instead, always make a commit with complete commit
 message and generate a series of patches from your repository.
 It is a good discipline.
 Describe the technical detail of the change(s).
 If your description starts to get too long, that's a sign that you
 probably need to split up your commit to finer grained pieces.
 (2) Check for coding errors with pylint
 Run pylint on changed modules using the provided configuration:
  pylint --rcfile=.pylintrc file.py
 (3) Check the license
 repo is licensed under the Apache License, 2.0.
 Because of this licensing model *every* file within the project
 *must* list the license that covers it in the header of the file.
 Any new contributions to an existing file *must* be submitted under
 the current license of that file.  Any new files *must* clearly
 indicate which license they are provided under in the file header.
 Please verify that you are legally allowed and willing to submit your
 changes under the license covering each file *prior* to submitting
 your patch.  It is virtually impossible to remove a patch once it
 has been applied and pushed out.
 (4) Sending your patches.
 Do not email your patches to anyone.
 Instead, login to the Gerrit Code Review tool at:
  https://gerrit-review.googlesource.com/
 Ensure you have completed one of the necessary contributor
 agreements, providing documentation to the project maintainers that
 they have right to redistribute your work under the Apache License:
  https://gerrit-review.googlesource.com/#/settings/agreements
 Ensure you have obtained an HTTP password to authenticate:
  https://gerrit-review.googlesource.com/new-password
 Push your patches over HTTPS to the review server, possibly through
 a remembered remote to make this easier in the future:
   git config remote.review.url https://gerrit-review.googlesource.com/git-repo
   git config remote.review.push HEAD:refs/for/master
   git push review
 You will be automatically emailed a copy of your commits, and any
 comments made by the project maintainers.
--- a/SUBMITTING_PATCHES.md
+++ b/SUBMITTING_PATCHES.md
@ -0,0 +1,135 @@
 # Short Version
 - Make small logical changes.
 - Provide a meaningful commit message.
 - Check for coding errors and style nits with pyflakes and flake8
 - Make sure all code is under the Apache License, 2.0.
 - Publish your changes for review.
 - Make corrections if requested.
 - Verify your changes on gerrit so they can be submitted.
   `git push https://gerrit-review.googlesource.com/git-repo HEAD:refs/for/master`
 # Long Version
 I wanted a file describing how to submit patches for repo,
 so I started with the one found in the core Git distribution
 (Documentation/SubmittingPatches), which itself was based on the
 patch submission guidelines for the Linux kernel.
 However there are some differences, so please review and familiarize
 yourself with the following relevant bits.
 ## Make separate commits for logically separate changes.
 Unless your patch is really trivial, you should not be sending
 out a patch that was generated between your working tree and your
 commit head.  Instead, always make a commit with complete commit
 message and generate a series of patches from your repository.
 It is a good discipline.
 Describe the technical detail of the change(s).
 If your description starts to get too long, that's a sign that you
 probably need to split up your commit to finer grained pieces.
 ## Check for coding errors and style nits with pyflakes and flake8
 ### Coding errors
 Run `pyflakes` on changed modules:
    pyflakes file.py
 Ideally there should be no new errors or warnings introduced.
 ### Style violations
 Run `flake8` on changes modules:
    flake8 file.py
 Note that repo generally follows [Google's python style guide]
 (https://google.github.io/styleguide/pyguide.html) rather than [PEP 8]
 (https://www.python.org/dev/peps/pep-0008/), so it's possible that
 the output of `flake8` will be quite noisy. It's not mandatory to
 avoid all warnings, but at least the maximum line length should be
 followed.
 If there are many occurrences of the same warning that cannot be
 avoided without going against the Google style guide, these may be
 suppressed in the included `.flake8` file.
 ## Check the license
 repo is licensed under the Apache License, 2.0.
 Because of this licensing model *every* file within the project
 *must* list the license that covers it in the header of the file.
 Any new contributions to an existing file *must* be submitted under
 the current license of that file.  Any new files *must* clearly
 indicate which license they are provided under in the file header.
 Please verify that you are legally allowed and willing to submit your
 changes under the license covering each file *prior* to submitting
 your patch.  It is virtually impossible to remove a patch once it
 has been applied and pushed out.
 ## Sending your patches.
 Do not email your patches to anyone.
 Instead, login to the Gerrit Code Review tool at:
  https://gerrit-review.googlesource.com/
 Ensure you have completed one of the necessary contributor
 agreements, providing documentation to the project maintainers that
 they have right to redistribute your work under the Apache License:
  https://gerrit-review.googlesource.com/#/settings/agreements
 Ensure you have obtained an HTTP password to authenticate:
  https://gerrit-review.googlesource.com/new-password
 Ensure that you have the local commit hook installed to automatically
 add a ChangeId to your commits:
    curl -Lo `git rev-parse --git-dir`/hooks/commit-msg https://gerrit-review.googlesource.com/tools/hooks/commit-msg
    chmod +x `git rev-parse --git-dir`/hooks/commit-msg
 If you have already committed your changes you will need to amend the commit
 to get the ChangeId added.
    git commit --amend
 Push your patches over HTTPS to the review server, possibly through
 a remembered remote to make this easier in the future:
    git config remote.review.url https://gerrit-review.googlesource.com/git-repo
    git config remote.review.push HEAD:refs/for/master
    git push review
 You will be automatically emailed a copy of your commits, and any
 comments made by the project maintainers.
 ## Make changes if requested
 The project maintainer who reviews your changes might request changes to your
 commit. If you make the requested changes you will need to amend your commit
 and push it to the review server again.
 ## Verify your changes on gerrit
 After you receive a Code-Review+2 from the maintainer, select the Verified
 button on the gerrit page for the change. This verifies that you have tested
 your changes and notifies the maintainer that they are ready to be submitted.
 The maintainer will then submit your changes to the repository.
--- a/command.py
+++ b/command.py
@ -31,7 +31,7 @@ class Command(object):
  manifest = None
  _optparse = None
-  def WantPager(self, opt):
+  def WantPager(self, _opt):
    return False
  def ReadEnvironmentOptions(self, opts):
@ -63,7 +63,7 @@ class Command(object):
        usage = self.helpUsage.strip().replace('%prog', me)
      except AttributeError:
        usage = 'repo %s' % self.NAME
-      self._optparse = optparse.OptionParser(usage = usage)
+      self._optparse = optparse.OptionParser(usage=usage)
      self._Options(self._optparse)
    return self._optparse
@ -106,19 +106,24 @@ class Command(object):
  def _UpdatePathToProjectMap(self, project):
    self._by_path[project.worktree] = project
-  def _GetProjectByPath(self, path):
+  def _GetProjectByPath(self, manifest, path):
    project = None
    if os.path.exists(path):
      oldpath = None
-      while path \
+      while path and \
-        and path != oldpath \
+            path != oldpath and \
-        and path != self.manifest.topdir:
+            path != manifest.topdir:
        try:
          project = self._by_path[path]
          break
        except KeyError:
          oldpath = path
          path = os.path.dirname(path)
      if not project and path == manifest.topdir:
        try:
          project = self._by_path[path]
        except KeyError:
          pass
    else:
      try:
        project = self._by_path[path]
@ -126,15 +131,19 @@ class Command(object):
        pass
    return project
-  def GetProjects(self, args, missing_ok=False, submodules_ok=False):
+  def GetProjects(self, args, manifest=None, groups='', missing_ok=False,
                  submodules_ok=False):
    """A list of projects that match the arguments.
    """
-    all_projects_list = self.manifest.projects
+    if not manifest:
      manifest = self.manifest
    all_projects_list = manifest.projects
    result = []
-    mp = self.manifest.manifestProject
+    mp = manifest.manifestProject
-    groups = mp.config.GetString('manifest.groups')
+    if not groups:
      groups = mp.config.GetString('manifest.groups')
    if not groups:
      groups = 'default,platform-' + platform.system().lower()
    groups = [x for x in re.split(r'[,\s]+', groups) if x]
@ -147,29 +156,28 @@ class Command(object):
                                  for p in project.GetDerivedSubprojects())
      all_projects_list.extend(derived_projects.values())
      for project in all_projects_list:
-        if ((missing_ok or project.Exists) and
+        if (missing_ok or project.Exists) and project.MatchesGroups(groups):
            project.MatchesGroups(groups)):
          result.append(project)
    else:
      self._ResetPathToProjectMap(all_projects_list)
      for arg in args:
-        projects = self.manifest.GetProjectsWithName(arg)
+        projects = manifest.GetProjectsWithName(arg)
        if not projects:
          path = os.path.abspath(arg).replace('\\', '/')
-          project = self._GetProjectByPath(path)
+          project = self._GetProjectByPath(manifest, path)
          # If it's not a derived project, update path->project mapping and
          # search again, as arg might actually point to a derived subproject.
-          if (project and not project.Derived and
+          if (project and not project.Derived and (submodules_ok or
-              (submodules_ok or project.sync_s)):
+                                                   project.sync_s)):
            search_again = False
            for subproject in project.GetDerivedSubprojects():
              self._UpdatePathToProjectMap(subproject)
              search_again = True
            if search_again:
-              project = self._GetProjectByPath(path) or project
+              project = self._GetProjectByPath(manifest, path) or project
          if project:
            projects = [project]
@ -190,17 +198,24 @@ class Command(object):
    result.sort(key=_getpath)
    return result
-  def FindProjects(self, args):
+  def FindProjects(self, args, inverse=False):
    result = []
    patterns = [re.compile(r'%s' % a, re.IGNORECASE) for a in args]
    for project in self.GetProjects(''):
      for pattern in patterns:
-        if pattern.search(project.name) or pattern.search(project.relpath):
+        match = pattern.search(project.name) or pattern.search(project.relpath)
        if not inverse and match:
          result.append(project)
          break
        if inverse and match:
          break
      else:
        if inverse:
          result.append(project)
    result.sort(key=lambda project: project.relpath)
    return result
 # pylint: disable=W0223
 # Pylint warns that the `InteractiveCommand` and `PagedCommand` classes do not
 # override method `Execute` which is abstract in `Command`.  Since that method
@ -210,19 +225,33 @@ class InteractiveCommand(Command):
  """Command which requires user interaction on the tty and
     must not run within a pager, even if the user asks to.
  """
-  def WantPager(self, opt):
+  def WantPager(self, _opt):
    return False
 class PagedCommand(Command):
  """Command which defaults to output in a pager, as its
     display tends to be larger than one screen full.
  """
-  def WantPager(self, opt):
+  def WantPager(self, _opt):
    return True
 # pylint: enable=W0223
 class MirrorSafeCommand(object):
  """Command permits itself to run within a mirror,
     and does not require a working directory.
  """
 class GitcAvailableCommand(object):
  """Command that requires GITC to be available, but does
     not require the local client to be a GITC client.
  """
 class GitcClientCommand(object):
  """Command that requires the local client to be a GITC
     client.
  """
--- a/docs/manifest-format.txt
+++ b/docs/manifest-format.txt
@ -35,6 +35,7 @@ following DTD:
    <!ATTLIST remote name         ID    #REQUIRED>
    <!ATTLIST remote alias        CDATA #IMPLIED>
    <!ATTLIST remote fetch        CDATA #REQUIRED>
    <!ATTLIST remote pushurl      CDATA #IMPLIED>
    <!ATTLIST remote review       CDATA #IMPLIED>
    <!ATTLIST remote revision     CDATA #IMPLIED>
@ -47,10 +48,12 @@ following DTD:
    <!ATTLIST default sync-s      CDATA #IMPLIED>
    <!ELEMENT manifest-server (EMPTY)>
-    <!ATTLIST url              CDATA #REQUIRED>
+    <!ATTLIST manifest-server url CDATA #REQUIRED>
    <!ELEMENT project (annotation*,
-                       project*)>
+                       project*,
                       copyfile*,
                       linkfile*)>
    <!ATTLIST project name        CDATA #REQUIRED>
    <!ATTLIST project path        CDATA #IMPLIED>
    <!ATTLIST project remote      IDREF #IMPLIED>
@ -68,7 +71,15 @@ following DTD:
    <!ATTLIST annotation value CDATA #REQUIRED>
    <!ATTLIST annotation keep  CDATA "true">
-    <!ELEMENT extend-project>
+    <!ELEMENT copyfile (EMPTY)>
    <!ATTLIST copyfile src  CDATA #REQUIRED>
    <!ATTLIST copyfile dest CDATA #REQUIRED>
    <!ELEMENT linkfile (EMPTY)>
    <!ATTLIST linkfile src CDATA #REQUIRED>
    <!ATTLIST linkfile dest CDATA #REQUIRED>
    <!ELEMENT extend-project (EMPTY)>
    <!ATTLIST extend-project name CDATA #REQUIRED>
    <!ATTLIST extend-project path CDATA #IMPLIED>
    <!ATTLIST extend-project groups CDATA #IMPLIED>
@ -115,6 +126,12 @@ Attribute `fetch`: The Git URL prefix for all projects which use
 this remote.  Each project's name is appended to this prefix to
 form the actual URL used to clone the project.
 Attribute `pushurl`: The Git "push" URL prefix for all projects
 which use this remote.  Each project's name is appended to this
 prefix to form the actual URL used to "git push" the project.
 This attribute is optional; if not specified then "git push"
 will use the same URL as the `fetch` attribute.
 Attribute `review`: Hostname of the Gerrit server where reviews
 are uploaded to by `repo upload`.  This attribute is optional;
 if not specified then `repo upload` will not function.
@ -165,7 +182,8 @@ The manifest server should implement the following RPC methods:
  GetApprovedManifest(branch, target)
 Return a manifest in which each project is pegged to a known good revision
-for the current branch and target.
+for the current branch and target. This is used by repo sync when the
 --smart-sync option is given.
 The target to use is defined by environment variables TARGET_PRODUCT
 and TARGET_BUILD_VARIANT. These variables are used to create a string
@ -177,7 +195,8 @@ should choose a reasonable default target.
  GetManifest(tag)
 Return a manifest in which each project is pegged to the revision at
-the specified tag.
+the specified tag. This is used by repo sync when the --smart-tag option
 is given.
 Element project
@ -285,6 +304,21 @@ prefixed with REPO__.  In addition, there is an optional attribute
 "false".  This attribute determines whether or not the annotation will
 be kept when exported with the manifest subcommand.
 Element copyfile
 ----------------
 Zero or more copyfile elements may be specified as children of a
 project element. Each element describes a src-dest pair of files;
 the "src" file will be copied to the "dest" place during 'repo sync'
 command.
 "src" is project relative, "dest" is relative to the top of the tree.
 Element linkfile
 ----------------
 It's just like copyfile and runs at the same time as copyfile but
 instead of copying it creates a symlink.
 Element remove-project
 ----------------------
--- a/git_command.py
+++ b/git_command.py
@ -168,6 +168,9 @@ class GitCommand(object):
      if p is not None:
        s = p + ' ' + s
      _setenv(env, 'GIT_CONFIG_PARAMETERS', s)
    if 'GIT_ALLOW_PROTOCOL' not in env:
      _setenv(env, 'GIT_ALLOW_PROTOCOL',
              'file:git:http:https:ssh:persistent-http:persistent-https:sso:rpc')
    if project:
      if not cwd:
--- a/git_config.py
+++ b/git_config.py
@ -15,6 +15,8 @@
 from __future__ import print_function
 import contextlib
 import errno
 import json
 import os
 import re
@ -462,9 +464,13 @@ def _open_ssh(host, port=None):
             % (host,port, str(e)), file=sys.stderr)
      return False
    time.sleep(1)
    ssh_died = (p.poll() is not None)
    if ssh_died:
      return False
    _master_processes.append(p)
    _master_keys.add(key)
    time.sleep(1)
    return True
  finally:
    _master_keys_lock.release()
@ -502,6 +508,43 @@ def GetSchemeFromUrl(url):
    return m.group(1)
  return None
@contextlib.contextmanager
 def GetUrlCookieFile(url, quiet):
  if url.startswith('persistent-'):
    try:
      p = subprocess.Popen(
          ['git-remote-persistent-https', '-print_config', url],
          stdin=subprocess.PIPE, stdout=subprocess.PIPE,
          stderr=subprocess.PIPE)
      try:
        cookieprefix = 'http.cookiefile='
        proxyprefix = 'http.proxy='
        cookiefile = None
        proxy = None
        for line in p.stdout:
          line = line.strip()
          if line.startswith(cookieprefix):
            cookiefile = line[len(cookieprefix):]
          if line.startswith(proxyprefix):
            proxy = line[len(proxyprefix):]
        # Leave subprocess open, as cookie file may be transient.
        if cookiefile or proxy:
          yield cookiefile, proxy
          return
      finally:
        p.stdin.close()
        if p.wait():
          err_msg = p.stderr.read()
          if ' -print_config' in err_msg:
            pass  # Persistent proxy doesn't support -print_config.
          elif not quiet:
            print(err_msg, file=sys.stderr)
    except OSError as e:
      if e.errno == errno.ENOENT:
        pass  # No persistent proxy.
      raise
  yield GitConfig.ForUser().GetString('http.cookiefile'), None
 def _preconnect(url):
  m = URI_ALL.match(url)
  if m:
@ -529,6 +572,7 @@ class Remote(object):
    self._config = config
    self.name = name
    self.url = self._Get('url')
    self.pushUrl = self._Get('pushurl')
    self.review = self._Get('review')
    self.projectname = self._Get('projectname')
    self.fetch = list(map(RefSpec.FromString,
@ -655,6 +699,10 @@ class Remote(object):
    """Save this remote to the configuration.
    """
    self._Set('url', self.url)
    if self.pushUrl is not None:
      self._Set('pushurl', self.pushUrl + '/' + self.projectname)
    else:
      self._Set('pushurl', self.pushUrl)
    self._Set('review', self.review)
    self._Set('projectname', self.projectname)
    self._Set('fetch', list(map(str, self.fetch)))
--- a/gitc_utils.py
+++ b/gitc_utils.py
@ -0,0 +1,154 @@
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # 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 os
 import platform
 import re
 import sys
 import time
 import git_command
 import git_config
 import wrapper
 from error import ManifestParseError
 NUM_BATCH_RETRIEVE_REVISIONID = 32
 def get_gitc_manifest_dir():
  return wrapper.Wrapper().get_gitc_manifest_dir()
 def parse_clientdir(gitc_fs_path):
  return wrapper.Wrapper().gitc_parse_clientdir(gitc_fs_path)
 def _set_project_revisions(projects):
  """Sets the revisionExpr for a list of projects.
  Because of the limit of open file descriptors allowed, length of projects
  should not be overly large. Recommend calling this function multiple times
  with each call not exceeding NUM_BATCH_RETRIEVE_REVISIONID projects.
  @param projects: List of project objects to set the revionExpr for.
  """
  # Retrieve the commit id for each project based off of it's current
  # revisionExpr and it is not already a commit id.
  project_gitcmds = [(
      project, git_command.GitCommand(None,
                                      ['ls-remote',
                                       project.remote.url,
                                       project.revisionExpr],
                                      capture_stdout=True, cwd='/tmp'))
      for project in projects if not git_config.IsId(project.revisionExpr)]
  for proj, gitcmd in project_gitcmds:
    if gitcmd.Wait():
      print('FATAL: Failed to retrieve revisionExpr for %s' % proj)
      sys.exit(1)
    revisionExpr = gitcmd.stdout.split('\t')[0]
    if not revisionExpr:
      raise(ManifestParseError('Invalid SHA-1 revision project %s (%s)' %
                               (proj.remote.url, proj.revisionExpr)))
    proj.revisionExpr = revisionExpr
 def _manifest_groups(manifest):
  """Returns the manifest group string that should be synced
  This is the same logic used by Command.GetProjects(), which is used during
  repo sync
  @param manifest: The XmlManifest object
  """
  mp = manifest.manifestProject
  groups = mp.config.GetString('manifest.groups')
  if not groups:
    groups = 'default,platform-' + platform.system().lower()
  return groups
 def generate_gitc_manifest(gitc_manifest, manifest, paths=None):
  """Generate a manifest for shafsd to use for this GITC client.
  @param gitc_manifest: Current gitc manifest, or None if there isn't one yet.
  @param manifest: A GitcManifest object loaded with the current repo manifest.
  @param paths: List of project paths we want to update.
  """
  print('Generating GITC Manifest by fetching revision SHAs for each '
        'project.')
  if paths is None:
    paths = manifest.paths.keys()
  groups = [x for x in re.split(r'[,\s]+', _manifest_groups(manifest)) if x]
  # Convert the paths to projects, and filter them to the matched groups.
  projects = [manifest.paths[p] for p in paths]
  projects = [p for p in projects if p.MatchesGroups(groups)]
  if gitc_manifest is not None:
    for path, proj in manifest.paths.iteritems():
      if not proj.MatchesGroups(groups):
        continue
      if not proj.upstream and not git_config.IsId(proj.revisionExpr):
        proj.upstream = proj.revisionExpr
      if not path in gitc_manifest.paths:
        # Any new projects need their first revision, even if we weren't asked
        # for them.
        projects.append(proj)
      elif not path in paths:
        # And copy revisions from the previous manifest if we're not updating
        # them now.
        gitc_proj = gitc_manifest.paths[path]
        if gitc_proj.old_revision:
          proj.revisionExpr = None
          proj.old_revision = gitc_proj.old_revision
        else:
          proj.revisionExpr = gitc_proj.revisionExpr
  index = 0
  while index < len(projects):
    _set_project_revisions(
        projects[index:(index+NUM_BATCH_RETRIEVE_REVISIONID)])
    index += NUM_BATCH_RETRIEVE_REVISIONID
  if gitc_manifest is not None:
    for path, proj in gitc_manifest.paths.iteritems():
      if proj.old_revision and path in paths:
        # If we updated a project that has been started, keep the old-revision
        # updated.
        repo_proj = manifest.paths[path]
        repo_proj.old_revision = repo_proj.revisionExpr
        repo_proj.revisionExpr = None
  # Convert URLs from relative to absolute.
  for _name, remote in manifest.remotes.iteritems():
    remote.fetchUrl = remote.resolvedFetchUrl
  # Save the manifest.
  save_manifest(manifest)
 def save_manifest(manifest, client_dir=None):
  """Save the manifest file in the client_dir.
  @param client_dir: Client directory to save the manifest in.
  @param manifest: Manifest object to save.
  """
  if not client_dir:
    client_dir = manifest.gitc_client_dir
  with open(os.path.join(client_dir, '.manifest'), 'w') as f:
    manifest.Save(f, groups=_manifest_groups(manifest))
  # TODO(sbasi/jorg): Come up with a solution to remove the sleep below.
  # Give the GITC filesystem time to register the manifest changes.
  time.sleep(3)
--- a/hooks/commit-msg
+++ b/hooks/commit-msg
@ -1,6 +1,7 @@
 #!/bin/sh
 # From Gerrit Code Review 2.12.1
 #
-# Part of Gerrit Code Review (http://code.google.com/p/gerrit/)
+# Part of Gerrit Code Review (https://www.gerritcodereview.com/)
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -19,7 +20,7 @@
 unset GREP_OPTIONS
-CHANGE_ID_AFTER="Bug|Issue"
+CHANGE_ID_AFTER="Bug|Issue|Test"
 MSG="$1"
 # Check for, and add if missing, a unique Change-Id
@ -38,6 +39,12 @@ add_ChangeId() {
 		return
 	fi
 	# Do not add Change-Id to temp commits
 	if echo "$clean_message" | head -1 | grep -q '^\(fixup\|squash\)!'
 	then
 		return
 	fi
 	if test "false" = "`git config --bool --get gerrit.createChangeId`"
 	then
 		return
@ -57,6 +64,10 @@ add_ChangeId() {
 		AWK=/usr/xpg4/bin/awk
 	fi
 	# Get core.commentChar from git config or use default symbol
 	commentChar=`git config --get core.commentChar`
 	commentChar=${commentChar:-#}
 	# How this works:
 	# - parse the commit message as (textLine+ blankLine*)*
 	# - assume textLine+ to be a footer until proven otherwise
@ -75,8 +86,8 @@ add_ChangeId() {
 		blankLines = 0
 	}
-	# Skip lines starting with "#" without any spaces before it.
+	# Skip lines starting with commentChar without any spaces before it.
-	/^#/ { next }
+	/^'"$commentChar"'/ { next }
 	# Skip the line starting with the diff command and everything after it,
 	# up to the end of the file, assuming it is only patch data.
--- a/main.py
+++ b/main.py
@ -42,6 +42,7 @@ from git_command import git, GitCommand
 from git_config import init_ssh, close_ssh
 from command import InteractiveCommand
 from command import MirrorSafeCommand
 from command import GitcAvailableCommand, GitcClientCommand
 from subcmds.version import Version
 from editor import Editor
 from error import DownloadError
@ -51,7 +52,8 @@ from error import ManifestParseError
 from error import NoManifestException
 from error import NoSuchProjectError
 from error import RepoChangedException
-from manifest_xml import XmlManifest
+import gitc_utils
 from manifest_xml import GitcManifest, XmlManifest
 from pager import RunPager
 from wrapper import WrapperPath, Wrapper
@ -129,6 +131,12 @@ class _Repo(object):
    cmd.repodir = self.repodir
    cmd.manifest = XmlManifest(cmd.repodir)
    cmd.gitc_manifest = None
    gitc_client_name = gitc_utils.parse_clientdir(os.getcwd())
    if gitc_client_name:
      cmd.gitc_manifest = GitcManifest(cmd.repodir, gitc_client_name)
      cmd.manifest.isGitcClient = True
    Editor.globalConfig = cmd.manifest.globalConfig
    if not isinstance(cmd, MirrorSafeCommand) and cmd.manifest.IsMirror:
@ -136,6 +144,16 @@ class _Repo(object):
            file=sys.stderr)
      return 1
    if isinstance(cmd, GitcAvailableCommand) and not gitc_utils.get_gitc_manifest_dir():
      print("fatal: '%s' requires GITC to be available" % name,
            file=sys.stderr)
      return 1
    if isinstance(cmd, GitcClientCommand) and not gitc_client_name:
      print("fatal: '%s' requires a GITC client" % name,
            file=sys.stderr)
      return 1
    try:
      copts, cargs = cmd.OptionParser.parse_args(argv)
      copts = cmd.ReadEnvironmentOptions(copts)
@ -361,7 +379,7 @@ class _KerberosAuthHandler(urllib.request.BaseHandler):
    self.context = None
    self.handler_order = urllib.request.BaseHandler.handler_order - 50
-  def http_error_401(self, req, fp, code, msg, headers):
+  def http_error_401(self, req, fp, code, msg, headers): # pylint:disable=unused-argument
    host = req.get_host()
    retry = self.http_error_auth_reqed('www-authenticate', host, req, headers)
    return retry
--- a/manifest_xml.py
+++ b/manifest_xml.py
@ -29,6 +29,7 @@ else:
  urllib = imp.new_module('urllib')
  urllib.parse = urlparse
 import gitc_utils
 from git_config import GitConfig
 from git_refs import R_HEADS, HEAD
 from project import RemoteSpec, Project, MetaProject
@ -63,11 +64,13 @@ class _XmlRemote(object):
               name,
               alias=None,
               fetch=None,
               pushUrl=None,
               manifestUrl=None,
               review=None,
               revision=None):
    self.name = name
    self.fetchUrl = fetch
    self.pushUrl = pushUrl
    self.manifestUrl = manifestUrl
    self.remoteAlias = alias
    self.reviewUrl = review
@ -101,7 +104,11 @@ class _XmlRemote(object):
    remoteName = self.name
    if self.remoteAlias:
      remoteName = self.remoteAlias
-    return RemoteSpec(remoteName, url, self.reviewUrl)
+    return RemoteSpec(remoteName,
                      url=url,
                      pushUrl=self.pushUrl,
                      review=self.reviewUrl,
                      orig_name=self.name)
 class XmlManifest(object):
  """manages the repo configuration file"""
@ -112,6 +119,7 @@ class XmlManifest(object):
    self.manifestFile = os.path.join(self.repodir, MANIFEST_FILE_NAME)
    self.globalConfig = GitConfig.ForUser()
    self.localManifestWarning = False
    self.isGitcClient = False
    self.repoProject = MetaProject(self, 'repo',
      gitdir   = os.path.join(repodir, 'repo/.git'),
@ -155,6 +163,8 @@ class XmlManifest(object):
    root.appendChild(e)
    e.setAttribute('name', r.name)
    e.setAttribute('fetch', r.fetchUrl)
    if r.pushUrl is not None:
      e.setAttribute('pushurl', r.pushUrl)
    if r.remoteAlias is not None:
      e.setAttribute('alias', r.remoteAlias)
    if r.reviewUrl is not None:
@ -165,12 +175,13 @@ class XmlManifest(object):
  def _ParseGroups(self, groups):
    return [x for x in re.split(r'[,\s]+', groups) if x]
-  def Save(self, fd, peg_rev=False, peg_rev_upstream=True):
+  def Save(self, fd, peg_rev=False, peg_rev_upstream=True, groups=None):
    """Write the current manifest out to the given file descriptor.
    """
    mp = self.manifestProject
-    groups = mp.config.GetString('manifest.groups')
+    if groups is None:
      groups = mp.config.GetString('manifest.groups')
    if groups:
      groups = self._ParseGroups(groups)
@ -202,6 +213,9 @@ class XmlManifest(object):
    if d.revisionExpr:
      have_default = True
      e.setAttribute('revision', d.revisionExpr)
    if d.destBranchExpr:
      have_default = True
      e.setAttribute('dest-branch', d.destBranchExpr)
    if d.sync_j > 1:
      have_default = True
      e.setAttribute('sync-j', '%d' % d.sync_j)
@ -243,9 +257,9 @@ class XmlManifest(object):
        e.setAttribute('path', relpath)
      remoteName = None
      if d.remote:
-        remoteName = d.remote.remoteAlias or d.remote.name
+        remoteName = d.remote.name
-      if not d.remote or p.remote.name != remoteName:
+      if not d.remote or p.remote.orig_name != remoteName:
-        remoteName = p.remote.name
+        remoteName = p.remote.orig_name
        e.setAttribute('remote', remoteName)
      if peg_rev:
        if self.IsMirror:
@ -261,12 +275,15 @@ class XmlManifest(object):
            # isn't our value
            e.setAttribute('upstream', p.revisionExpr)
      else:
-        revision = self.remotes[remoteName].revision or d.revisionExpr
+        revision = self.remotes[p.remote.orig_name].revision or d.revisionExpr
        if not revision or revision != p.revisionExpr:
          e.setAttribute('revision', p.revisionExpr)
        if p.upstream and p.upstream != p.revisionExpr:
          e.setAttribute('upstream', p.upstream)
      if p.dest_branch and p.dest_branch != d.destBranchExpr:
        e.setAttribute('dest-branch', p.dest_branch)
      for c in p.copyfiles:
        ce = doc.createElement('copyfile')
        ce.setAttribute('src', c.src)
@ -297,6 +314,11 @@ class XmlManifest(object):
      if p.sync_s:
        e.setAttribute('sync-s', 'true')
      if p.clone_depth:
        e.setAttribute('clone-depth', str(p.clone_depth))
      self._output_manifest_project_extras(p, e)
      if p.subprojects:
        subprojects = set(subp.name for subp in p.subprojects)
        output_projects(p, e, list(sorted(subprojects)))
@ -314,6 +336,10 @@ class XmlManifest(object):
    doc.writexml(fd, '', '  ', '\n', 'UTF-8')
  def _output_manifest_project_extras(self, p, e):
    """Manifests can modify e if they support extra project attributes."""
    pass
  @property
  def paths(self):
    self._Load()
@ -618,6 +644,9 @@ class XmlManifest(object):
    if alias == '':
      alias = None
    fetch = self._reqatt(node, 'fetch')
    pushUrl = node.getAttribute('pushurl')
    if pushUrl == '':
      pushUrl = None
    review = node.getAttribute('review')
    if review == '':
      review = None
@ -625,7 +654,7 @@ class XmlManifest(object):
    if revision == '':
      revision = None
    manifestUrl = self.manifestProject.config.GetString('remote.origin.url')
-    return _XmlRemote(name, alias, fetch, manifestUrl, review, revision)
+    return _XmlRemote(name, alias, fetch, pushUrl, manifestUrl, review, revision)
  def _ParseDefault(self, node):
    """
@ -703,7 +732,7 @@ class XmlManifest(object):
  def _UnjoinName(self, parent_name, name):
    return os.path.relpath(name, parent_name)
-  def _ParseProject(self, node, parent = None):
+  def _ParseProject(self, node, parent = None, **extra_proj_attrs):
    """
    reads a <project> element from the manifest file
    """
@ -798,7 +827,8 @@ class XmlManifest(object):
                      clone_depth = clone_depth,
                      upstream = upstream,
                      parent = parent,
-                      dest_branch = dest_branch)
+                      dest_branch = dest_branch,
                      **extra_proj_attrs)
    for n in node.childNodes:
      if n.nodeName == 'copyfile':
@ -929,3 +959,26 @@ class XmlManifest(object):
      diff['added'].append(toProjects[proj])
    return diff
 class GitcManifest(XmlManifest):
  def __init__(self, repodir, gitc_client_name):
    """Initialize the GitcManifest object."""
    super(GitcManifest, self).__init__(repodir)
    self.isGitcClient = True
    self.gitc_client_name = gitc_client_name
    self.gitc_client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(),
                                        gitc_client_name)
    self.manifestFile = os.path.join(self.gitc_client_dir, '.manifest')
  def _ParseProject(self, node, parent = None):
    """Override _ParseProject and add support for GITC specific attributes."""
    return super(GitcManifest, self)._ParseProject(
        node, parent=parent, old_revision=node.getAttribute('old-revision'))
  def _output_manifest_project_extras(self, p, e):
    """Output GITC Specific Project attributes"""
    if p.old_revision:
      e.setAttribute('old-revision', str(p.old_revision))
--- a/project.py
+++ b/project.py
--- a/221
+++ b/221
@ -1,8 +1,11 @@
 #!/usr/bin/env python
-## repo default configuration
+# repo default configuration
-##
+#
-REPO_URL = 'https://gerrit.googlesource.com/git-repo'
+import os
 REPO_URL = os.environ.get('REPO_URL', None)
 if not REPO_URL:
  REPO_URL = 'https://gerrit.googlesource.com/git-repo'
 REPO_REV = 'stable'
 # Copyright (C) 2008 Google Inc.
@ -20,10 +23,13 @@ REPO_REV = 'stable'
 # limitations under the License.
 # increment this whenever we make important changes to this script
-VERSION = (1, 21)
+VERSION = (1, 23)
 # increment this if the MAINTAINER_KEYS block is modified
 KEYRING_VERSION = (1, 2)
 # Each individual key entry is created by using:
 # gpg --armor --export keyid
 MAINTAINER_KEYS = """
     Repo Maintainer <repo@android.kernel.org>
@ -101,18 +107,19 @@ JuinEP+AwLAUZ1Bsx9ISC0Agpk2VeHXPL3FGhroEmoMvBzO0kTFGyoeT7PR/BfKv
 -----END PGP PUBLIC KEY BLOCK-----
 """
-GIT = 'git'                     # our git command
+GIT = 'git'                      # our git command
-MIN_GIT_VERSION = (1, 7, 2)     # minimum supported git version
+MIN_GIT_VERSION = (1, 7, 2)      # minimum supported git version
-repodir = '.repo'               # name of repo's private directory
+repodir = '.repo'                # name of repo's private directory
-S_repo = 'repo'                 # special repo repository
+S_repo = 'repo'                  # special repo repository
-S_manifests = 'manifests'       # special manifest repository
+S_manifests = 'manifests'        # special manifest repository
-REPO_MAIN = S_repo + '/main.py' # main script
+REPO_MAIN = S_repo + '/main.py'  # main script
-MIN_PYTHON_VERSION = (2, 6)     # minimum supported python version
+MIN_PYTHON_VERSION = (2, 6)      # minimum supported python version
 GITC_CONFIG_FILE = '/gitc/.config'
 GITC_FS_ROOT_DIR = '/gitc/manifest-rw/'
 import errno
 import optparse
 import os
 import re
 import shutil
 import stat
@ -192,6 +199,9 @@ group.add_option('-p', '--platform',
                 help='restrict manifest projects to ones with a specified '
                      'platform group [auto|all|none|linux|darwin|...]',
                 metavar='PLATFORM')
 group.add_option('--no-clone-bundle',
                 dest='no_clone_bundle', action='store_true',
                 help='disable use of /clone.bundle on HTTP/HTTPS')
 # Tool
@ -212,14 +222,69 @@ group.add_option('--config-name',
                 dest='config_name', action="store_true", default=False,
                 help='Always prompt for name/e-mail')
 def _GitcInitOptions(init_optparse_arg):
  init_optparse_arg.set_usage("repo gitc-init -u url -c client [options]")
  g = init_optparse_arg.add_option_group('GITC options')
  g.add_option('-f', '--manifest-file',
               dest='manifest_file',
               help='Optional manifest file to use for this GITC client.')
  g.add_option('-c', '--gitc-client',
               dest='gitc_client',
               help='The name of the gitc_client instance to create or modify.')
 _gitc_manifest_dir = None
 def get_gitc_manifest_dir():
  global _gitc_manifest_dir
  if _gitc_manifest_dir is None:
    _gitc_manifest_dir = ''
    try:
      with open(GITC_CONFIG_FILE, 'r') as gitc_config:
        for line in gitc_config:
          match = re.match('gitc_dir=(?P<gitc_manifest_dir>.*)', line)
          if match:
            _gitc_manifest_dir = match.group('gitc_manifest_dir')
    except IOError:
      pass
  return _gitc_manifest_dir
 def gitc_parse_clientdir(gitc_fs_path):
  """Parse a path in the GITC FS and return its client name.
  @param gitc_fs_path: A subdirectory path within the GITC_FS_ROOT_DIR.
  @returns: The GITC client name
  """
  if gitc_fs_path == GITC_FS_ROOT_DIR:
    return None
  if not gitc_fs_path.startswith(GITC_FS_ROOT_DIR):
    manifest_dir = get_gitc_manifest_dir()
    if manifest_dir == '':
      return None
    if manifest_dir[-1] != '/':
      manifest_dir += '/'
    if gitc_fs_path == manifest_dir:
      return None
    if not gitc_fs_path.startswith(manifest_dir):
      return None
    return gitc_fs_path.split(manifest_dir)[1].split('/')[0]
  return gitc_fs_path.split(GITC_FS_ROOT_DIR)[1].split('/')[0]
 class CloneFailure(Exception):
  """Indicate the remote clone of repo itself failed.
  """
-def _Init(args):
+def _Init(args, gitc_init=False):
  """Installs repo by cloning it over the network.
  """
  if gitc_init:
    _GitcInitOptions(init_optparse)
  opt, args = init_optparse.parse_args(args)
  if args:
    init_optparse.print_usage()
@ -242,6 +307,26 @@ def _Init(args):
    raise CloneFailure()
  try:
    if gitc_init:
      gitc_manifest_dir = get_gitc_manifest_dir()
      if not gitc_manifest_dir:
        _print('fatal: GITC filesystem is not available. Exiting...',
               file=sys.stderr)
        sys.exit(1)
      gitc_client = opt.gitc_client
      if not gitc_client:
        gitc_client = gitc_parse_clientdir(os.getcwd())
      if not gitc_client:
        _print('fatal: GITC client (-c) is required.', file=sys.stderr)
        sys.exit(1)
      client_dir = os.path.join(gitc_manifest_dir, gitc_client)
      if not os.path.exists(client_dir):
        os.makedirs(client_dir)
      os.chdir(client_dir)
      if os.path.exists(repodir):
        # This GITC Client has already initialized repo so continue.
        return
    os.mkdir(repodir)
  except OSError as e:
    if e.errno != errno.EEXIST:
@ -260,7 +345,7 @@ def _Init(args):
      can_verify = True
    dst = os.path.abspath(os.path.join(repodir, S_repo))
-    _Clone(url, dst, opt.quiet)
+    _Clone(url, dst, opt.quiet, not opt.no_clone_bundle)
    if can_verify and not opt.no_repo_verify:
      rev = _Verify(dst, branch, opt.quiet)
@ -353,13 +438,16 @@ def SetupGnuPG(quiet):
      sys.exit(1)
  env = os.environ.copy()
-  env['GNUPGHOME'] = gpg_dir.encode()
+  try:
    env['GNUPGHOME'] = gpg_dir
  except UnicodeEncodeError:
    env['GNUPGHOME'] = gpg_dir.encode()
  cmd = ['gpg', '--import']
  try:
    proc = subprocess.Popen(cmd,
-                            env = env,
+                            env=env,
-                            stdin = subprocess.PIPE)
+                            stdin=subprocess.PIPE)
  except OSError as e:
    if not quiet:
      _print('warning: gpg (GnuPG) is not available.', file=sys.stderr)
@ -385,7 +473,7 @@ def _SetConfig(local, name, value):
  """Set a git configuration option to the specified value.
  """
  cmd = [GIT, 'config', name, value]
-  if subprocess.Popen(cmd, cwd = local).wait() != 0:
+  if subprocess.Popen(cmd, cwd=local).wait() != 0:
    raise CloneFailure()
@ -398,9 +486,9 @@ def _InitHttp():
    n = netrc.netrc()
    for host in n.hosts:
      p = n.hosts[host]
-      mgr.add_password(p[1], 'http://%s/'  % host, p[0], p[2])
+      mgr.add_password(p[1], 'http://%s/' % host, p[0], p[2])
      mgr.add_password(p[1], 'https://%s/' % host, p[0], p[2])
-  except:
+  except:  # pylint: disable=bare-except
    pass
  handlers.append(urllib.request.HTTPBasicAuthHandler(mgr))
  handlers.append(urllib.request.HTTPDigestAuthHandler(mgr))
@ -413,6 +501,7 @@ def _InitHttp():
    handlers.append(urllib.request.HTTPSHandler(debuglevel=1))
  urllib.request.install_opener(urllib.request.build_opener(*handlers))
 def _Fetch(url, local, src, quiet):
  if not quiet:
    _print('Get %s' % url, file=sys.stderr)
@ -427,22 +516,23 @@ def _Fetch(url, local, src, quiet):
  cmd.append('+refs/heads/*:refs/remotes/origin/*')
  cmd.append('refs/tags/*:refs/tags/*')
-  proc = subprocess.Popen(cmd, cwd = local, stderr = err)
+  proc = subprocess.Popen(cmd, cwd=local, stderr=err)
  if err:
    proc.stderr.read()
    proc.stderr.close()
  if proc.wait() != 0:
    raise CloneFailure()
 def _DownloadBundle(url, local, quiet):
  if not url.endswith('/'):
    url += '/'
  url += 'clone.bundle'
  proc = subprocess.Popen(
-    [GIT, 'config', '--get-regexp', 'url.*.insteadof'],
+      [GIT, 'config', '--get-regexp', 'url.*.insteadof'],
-    cwd = local,
+      cwd=local,
-    stdout = subprocess.PIPE)
+      stdout=subprocess.PIPE)
  for line in proc.stdout:
    m = re.compile(r'^url\.(.*)\.insteadof (.*)$').match(line)
    if m:
@ -462,7 +552,7 @@ def _DownloadBundle(url, local, quiet):
    try:
      r = urllib.request.urlopen(url)
    except urllib.error.HTTPError as e:
-      if e.code in [401, 403, 404]:
+      if e.code in [401, 403, 404, 501]:
        return False
      _print('fatal: Cannot get %s' % url, file=sys.stderr)
      _print('fatal: HTTP error %s' % e.code, file=sys.stderr)
@ -484,6 +574,7 @@ def _DownloadBundle(url, local, quiet):
  finally:
    dest.close()
 def _ImportBundle(local):
  path = os.path.join(local, '.git', 'clone.bundle')
  try:
@ -491,7 +582,8 @@ def _ImportBundle(local):
  finally:
    os.remove(path)
-def _Clone(url, local, quiet):
+
 def _Clone(url, local, quiet, clone_bundle):
  """Clones a git repository to a new subdirectory of repodir
  """
  try:
@ -503,14 +595,14 @@ def _Clone(url, local, quiet):
  cmd = [GIT, 'init', '--quiet']
  try:
-    proc = subprocess.Popen(cmd, cwd = local)
+    proc = subprocess.Popen(cmd, cwd=local)
  except OSError as e:
    _print(file=sys.stderr)
    _print("fatal: '%s' is not available" % GIT, file=sys.stderr)
    _print('fatal: %s' % e, file=sys.stderr)
    _print(file=sys.stderr)
    _print('Please make sure %s is installed and in your path.' % GIT,
-          file=sys.stderr)
+           file=sys.stderr)
    raise CloneFailure()
  if proc.wait() != 0:
    _print('fatal: could not create %s' % local, file=sys.stderr)
@ -518,12 +610,12 @@ def _Clone(url, local, quiet):
  _InitHttp()
  _SetConfig(local, 'remote.origin.url', url)
-  _SetConfig(local, 'remote.origin.fetch',
+  _SetConfig(local,
-                    '+refs/heads/*:refs/remotes/origin/*')
+             'remote.origin.fetch',
-  if _DownloadBundle(url, local, quiet):
+             '+refs/heads/*:refs/remotes/origin/*')
  if clone_bundle and _DownloadBundle(url, local, quiet):
    _ImportBundle(local)
-  else:
+  _Fetch(url, local, 'origin', quiet)
    _Fetch(url, local, 'origin', quiet)
 def _Verify(cwd, branch, quiet):
@ -533,7 +625,7 @@ def _Verify(cwd, branch, quiet):
  proc = subprocess.Popen(cmd,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE,
-                          cwd = cwd)
+                          cwd=cwd)
  cur = proc.stdout.read().strip()
  proc.stdout.close()
@ -551,18 +643,21 @@ def _Verify(cwd, branch, quiet):
    if not quiet:
      _print(file=sys.stderr)
      _print("info: Ignoring branch '%s'; using tagged release '%s'"
-            % (branch, cur), file=sys.stderr)
+             % (branch, cur), file=sys.stderr)
      _print(file=sys.stderr)
  env = os.environ.copy()
-  env['GNUPGHOME'] = gpg_dir.encode()
+  try:
    env['GNUPGHOME'] = gpg_dir
  except UnicodeEncodeError:
    env['GNUPGHOME'] = gpg_dir.encode()
  cmd = [GIT, 'tag', '-v', cur]
  proc = subprocess.Popen(cmd,
-                          stdout = subprocess.PIPE,
+                          stdout=subprocess.PIPE,
-                          stderr = subprocess.PIPE,
+                          stderr=subprocess.PIPE,
-                          cwd = cwd,
+                          cwd=cwd,
-                          env = env)
+                          env=env)
  out = proc.stdout.read()
  proc.stdout.close()
@ -582,21 +677,21 @@ def _Checkout(cwd, branch, rev, quiet):
  """Checkout an upstream branch into the repository and track it.
  """
  cmd = [GIT, 'update-ref', 'refs/heads/default', rev]
-  if subprocess.Popen(cmd, cwd = cwd).wait() != 0:
+  if subprocess.Popen(cmd, cwd=cwd).wait() != 0:
    raise CloneFailure()
  _SetConfig(cwd, 'branch.default.remote', 'origin')
  _SetConfig(cwd, 'branch.default.merge', 'refs/heads/%s' % branch)
  cmd = [GIT, 'symbolic-ref', 'HEAD', 'refs/heads/default']
-  if subprocess.Popen(cmd, cwd = cwd).wait() != 0:
+  if subprocess.Popen(cmd, cwd=cwd).wait() != 0:
    raise CloneFailure()
  cmd = [GIT, 'read-tree', '--reset', '-u']
  if not quiet:
    cmd.append('-v')
  cmd.append('HEAD')
-  if subprocess.Popen(cmd, cwd = cwd).wait() != 0:
+  if subprocess.Popen(cmd, cwd=cwd).wait() != 0:
    raise CloneFailure()
@ -608,8 +703,8 @@ def _FindRepo():
  olddir = None
  while curdir != '/' \
-    and curdir != olddir \
+          and curdir != olddir \
-    and not repo:
+          and not repo:
    repo = os.path.join(curdir, repodir, REPO_MAIN)
    if not os.path.isfile(repo):
      repo = None
@ -618,7 +713,7 @@ def _FindRepo():
  return (repo, os.path.join(curdir, repodir))
-class _Options:
+class _Options(object):
  help = False
@ -640,15 +735,20 @@ def _ParseArguments(args):
 def _Usage():
  gitc_usage = ""
  if get_gitc_manifest_dir():
    gitc_usage = "  gitc-init Initialize a GITC Client.\n"
  _print(
-"""usage: repo COMMAND [ARGS]
+      """usage: repo COMMAND [ARGS]
 repo is not yet installed.  Use "repo init" to install it here.
 The most commonly used repo commands are:
  init      Install repo in the current working directory
-  help      Display detailed help on a command
+""" + gitc_usage +
      """  help      Display detailed help on a command
 For access to the full online help, install repo ("repo init").
 """, file=sys.stderr)
@ -660,6 +760,10 @@ def _Help(args):
    if args[0] == 'init':
      init_optparse.print_help()
      sys.exit(0)
    elif args[0] == 'gitc-init':
      _GitcInitOptions(init_optparse)
      init_optparse.print_help()
      sys.exit(0)
    else:
      _print("error: '%s' is not a bootstrap command.\n"
             '        For access to online help, install repo ("repo init").'
@ -705,8 +809,8 @@ def _SetDefaultsTo(gitdir):
                           '--git-dir=%s' % gitdir,
                           'symbolic-ref',
                           'HEAD'],
-                          stdout = subprocess.PIPE,
+                          stdout=subprocess.PIPE,
-                          stderr = subprocess.PIPE)
+                          stderr=subprocess.PIPE)
  REPO_REV = proc.stdout.read().strip()
  proc.stdout.close()
@ -719,12 +823,23 @@ def _SetDefaultsTo(gitdir):
 def main(orig_args):
  repo_main, rel_repo_dir = _FindRepo()
  cmd, opt, args = _ParseArguments(orig_args)
  repo_main, rel_repo_dir = None, None
  # Don't use the local repo copy, make sure to switch to the gitc client first.
  if cmd != 'gitc-init':
    repo_main, rel_repo_dir = _FindRepo()
  wrapper_path = os.path.abspath(__file__)
  my_main, my_git = _RunSelf(wrapper_path)
  cwd = os.getcwd()
  if get_gitc_manifest_dir() and cwd.startswith(get_gitc_manifest_dir()):
    _print('error: repo cannot be used in the GITC local manifest directory.'
           '\nIf you want to work on this GITC client please rerun this '
           'command from the corresponding client under /gitc/',
           file=sys.stderr)
    sys.exit(1)
  if not repo_main:
    if opt.help:
      _Usage()
@ -732,11 +847,11 @@ def main(orig_args):
      _Help(args)
    if not cmd:
      _NotInstalled()
-    if cmd == 'init':
+    if cmd == 'init' or cmd == 'gitc-init':
      if my_git:
        _SetDefaultsTo(my_git)
      try:
-        _Init(args)
+        _Init(args, gitc_init=(cmd == 'gitc-init'))
      except CloneFailure:
        shutil.rmtree(os.path.join(repodir, S_repo), ignore_errors=True)
        sys.exit(1)
--- a/subcmds/diffmanifests.py
+++ b/subcmds/diffmanifests.py
@ -71,6 +71,10 @@ synced and their revisions won't be found.
    p.add_option('--no-color',
                 dest='color', action='store_false', default=True,
                 help='does not display the diff in color.')
    p.add_option('--pretty-format',
                 dest='pretty_format', action='store',
                 metavar='<FORMAT>',
                 help='print the log using a custom git pretty format string')
  def _printRawDiff(self, diff):
    for project in diff['added']:
@ -92,7 +96,7 @@ synced and their revisions won't be found.
                                     otherProject.revisionExpr))
      self.out.nl()
-  def _printDiff(self, diff, color=True):
+  def _printDiff(self, diff, color=True, pretty_format=None):
    if diff['added']:
      self.out.nl()
      self.printText('added projects : \n')
@ -124,7 +128,8 @@ synced and their revisions won't be found.
        self.printText(' to ')
        self.printRevision(otherProject.revisionExpr)
        self.out.nl()
-        self._printLogs(project, otherProject, raw=False, color=color)
+        self._printLogs(project, otherProject, raw=False, color=color,
                        pretty_format=pretty_format)
        self.out.nl()
    if diff['unreachable']:
@ -139,9 +144,13 @@ synced and their revisions won't be found.
        self.printText(' not found')
        self.out.nl()
-  def _printLogs(self, project, otherProject, raw=False, color=True):
+  def _printLogs(self, project, otherProject, raw=False, color=True,
-    logs = project.getAddedAndRemovedLogs(otherProject, oneline=True,
+                 pretty_format=None):
-                                          color=color)
+
    logs = project.getAddedAndRemovedLogs(otherProject,
                                          oneline=(pretty_format is None),
                                          color=color,
                                          pretty_format=pretty_format)
    if logs['removed']:
      removedLogs = logs['removed'].split('\n')
      for log in removedLogs:
@ -192,4 +201,4 @@ synced and their revisions won't be found.
    if opt.raw:
      self._printRawDiff(diff)
    else:
-      self._printDiff(diff, color=opt.color)
+      self._printDiff(diff, color=opt.color, pretty_format=opt.pretty_format)
--- a/subcmds/forall.py
+++ b/subcmds/forall.py
@ -120,6 +120,12 @@ without iterating through the remaining projects.
    p.add_option('-r', '--regex',
                 dest='regex', action='store_true',
                 help="Execute the command only on projects matching regex or wildcard expression")
    p.add_option('-i', '--inverse-regex',
                 dest='inverse_regex', action='store_true',
                 help="Execute the command only on projects not matching regex or wildcard expression")
    p.add_option('-g', '--groups',
                 dest='groups',
                 help="Execute the command only on projects matching the specified groups")
    p.add_option('-c', '--command',
                 help='Command (and arguments) to execute',
                 dest='command',
@ -212,10 +218,12 @@ without iterating through the remaining projects.
    if os.path.isfile(smart_sync_manifest_path):
      self.manifest.Override(smart_sync_manifest_path)
-    if not opt.regex:
+    if opt.regex:
      projects = self.GetProjects(args)
    else:
      projects = self.FindProjects(args)
    elif opt.inverse_regex:
      projects = self.FindProjects(args, inverse=True)
    else:
      projects = self.GetProjects(args, groups=opt.groups)
    os.environ['REPO_COUNT'] = str(len(projects))
@ -237,7 +245,8 @@ without iterating through the remaining projects.
      rc = rc or errno.EINTR
    except Exception as e:
      # Catch any other exceptions raised
-      print('Got an error, terminating the pool: %r' % e,
+      print('Got an error, terminating the pool: %s: %s' %
              (type(e).__name__, e),
            file=sys.stderr)
      pool.terminate()
      rc = rc or getattr(e, 'errno', 1)
@ -251,7 +260,8 @@ without iterating through the remaining projects.
      try:
        project = self._SerializeProject(p)
      except Exception as e:
-        print('Project list error: %r' % e,
+        print('Project list error on project %s: %s: %s' %
                (p.name, type(e).__name__, e),
              file=sys.stderr)
        return
      except KeyboardInterrupt:
--- a/subcmds/gitc_delete.py
+++ b/subcmds/gitc_delete.py
@ -0,0 +1,55 @@
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # 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 os
 import shutil
 import sys
 from command import Command, GitcClientCommand
 import gitc_utils
 from pyversion import is_python3
 if not is_python3():
  # pylint:disable=W0622
  input = raw_input
  # pylint:enable=W0622
 class GitcDelete(Command, GitcClientCommand):
  common = True
  visible_everywhere = False
  helpSummary = "Delete a GITC Client."
  helpUsage = """
 %prog
 """
  helpDescription = """
 This subcommand deletes the current GITC client, deleting the GITC manifest
 and all locally downloaded sources.
 """
  def _Options(self, p):
    p.add_option('-f', '--force',
                 dest='force', action='store_true',
                 help='Force the deletion (no prompt).')
  def Execute(self, opt, args):
    if not opt.force:
      prompt = ('This will delete GITC client: %s\nAre you sure? (yes/no) ' %
                self.gitc_manifest.gitc_client_name)
      response = input(prompt).lower()
      if not response == 'yes':
        print('Response was not "yes"\n Exiting...')
        sys.exit(1)
    shutil.rmtree(self.gitc_manifest.gitc_client_dir)
--- a/subcmds/gitc_init.py
+++ b/subcmds/gitc_init.py
@ -0,0 +1,82 @@
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # 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 os
 import sys
 import gitc_utils
 from command import GitcAvailableCommand
 from manifest_xml import GitcManifest
 from subcmds import init
 import wrapper
 class GitcInit(init.Init, GitcAvailableCommand):
  common = True
  helpSummary = "Initialize a GITC Client."
  helpUsage = """
 %prog [options] [client name]
 """
  helpDescription = """
 The '%prog' command is ran to initialize a new GITC client for use
 with the GITC file system.
 This command will setup the client directory, initialize repo, just
 like repo init does, and then downloads the manifest collection
 and installs it in the .repo/directory of the GITC client.
 Once this is done, a GITC manifest is generated by pulling the HEAD
 SHA for each project and generates the properly formatted XML file
 and installs it as .manifest in the GITC client directory.
 The -c argument is required to specify the GITC client name.
 The optional -f argument can be used to specify the manifest file to
 use for this GITC client.
 """
  def _Options(self, p):
    super(GitcInit, self)._Options(p)
    g = p.add_option_group('GITC options')
    g.add_option('-f', '--manifest-file',
                 dest='manifest_file',
                 help='Optional manifest file to use for this GITC client.')
    g.add_option('-c', '--gitc-client',
                 dest='gitc_client',
                 help='The name of the gitc_client instance to create or modify.')
  def Execute(self, opt, args):
    gitc_client = gitc_utils.parse_clientdir(os.getcwd())
    if not gitc_client or (opt.gitc_client and gitc_client != opt.gitc_client):
      print('fatal: Please update your repo command. See go/gitc for instructions.', file=sys.stderr)
      sys.exit(1)
    self.client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(),
                                   gitc_client)
    super(GitcInit, self).Execute(opt, args)
    manifest_file = self.manifest.manifestFile
    if opt.manifest_file:
      if not os.path.exists(opt.manifest_file):
        print('fatal: Specified manifest file %s does not exist.' %
              opt.manifest_file)
        sys.exit(1)
      manifest_file = opt.manifest_file
    manifest = GitcManifest(self.repodir, gitc_client)
    manifest.Override(manifest_file)
    gitc_utils.generate_gitc_manifest(None, manifest)
    print('Please run `cd %s` to view your GITC client.' %
          os.path.join(wrapper.Wrapper().GITC_FS_ROOT_DIR, gitc_client))
--- a/subcmds/help.py
+++ b/subcmds/help.py
@ -19,7 +19,8 @@ import sys
 from formatter import AbstractFormatter, DumbWriter
 from color import Coloring
-from command import PagedCommand, MirrorSafeCommand
+from command import PagedCommand, MirrorSafeCommand, GitcAvailableCommand, GitcClientCommand
 import gitc_utils
 class Help(PagedCommand, MirrorSafeCommand):
  common = False
@ -54,9 +55,21 @@ Displays detailed usage information about a command.
  def _PrintCommonCommands(self):
    print('usage: repo COMMAND [ARGS]')
    print('The most commonly used repo commands are:')
    def gitc_supported(cmd):
      if not isinstance(cmd, GitcAvailableCommand) and not isinstance(cmd, GitcClientCommand):
        return True
      if self.manifest.isGitcClient:
        return True
      if isinstance(cmd, GitcClientCommand):
        return False
      if gitc_utils.get_gitc_manifest_dir():
        return True
      return False
    commandNames = list(sorted([name
                    for name, command in self.commands.items()
-                    if command.common]))
+                    if command.common and gitc_supported(command)]))
    maxlen = 0
    for name in commandNames:
--- a/subcmds/info.py
+++ b/subcmds/info.py
@ -59,7 +59,8 @@ class Info(PagedCommand):
                      or 'all,-notdefault')
    self.heading("Manifest branch: ")
-    self.headtext(self.manifest.default.revisionExpr)
+    if self.manifest.default.revisionExpr:
        self.headtext(self.manifest.default.revisionExpr)
    self.out.nl()
    self.heading("Manifest merge branch: ")
    self.headtext(mergeBranch)
--- a/subcmds/init.py
+++ b/subcmds/init.py
@ -61,6 +61,11 @@ directory use as much data as possible from the local reference
 directory when fetching from the server. This will make the sync
 go a lot faster by reducing data traffic on the network.
 The --no-clone-bundle option disables any attempt to use
 $URL/clone.bundle to bootstrap a new Git repository from a
 resumeable bundle file on a content delivery network. This
 may be necessary if there are problems with the local Python
 HTTP client or proxy configuration, but the Git binary works.
 Switching Manifest Branches
 ---------------------------
@ -113,6 +118,9 @@ to update the working directory files.
                 help='restrict manifest projects to ones with a specified '
                      'platform group [auto|all|none|linux|darwin|...]',
                 metavar='PLATFORM')
    g.add_option('--no-clone-bundle',
                 dest='no_clone_bundle', action='store_true',
                 help='disable use of /clone.bundle on HTTP/HTTPS')
    # Tool
    g = p.add_option_group('repo Version options')
@ -179,7 +187,7 @@ to update the working directory files.
      r.Save()
    groups = re.split(r'[,\s]+', opt.groups)
-    all_platforms = ['linux', 'darwin']
+    all_platforms = ['linux', 'darwin', 'windows']
    platformize = lambda x: 'platform-' + x
    if opt.platform == 'auto':
      if (not opt.mirror and
@ -188,7 +196,7 @@ to update the working directory files.
    elif opt.platform == 'all':
      groups.extend(map(platformize, all_platforms))
    elif opt.platform in all_platforms:
-      groups.extend(platformize(opt.platform))
+      groups.append(platformize(opt.platform))
    elif opt.platform != 'none':
      print('fatal: invalid platform flag', file=sys.stderr)
      sys.exit(1)
@ -222,7 +230,8 @@ to update the working directory files.
              'in another location.', file=sys.stderr)
        sys.exit(1)
-    if not m.Sync_NetworkHalf(is_new=is_new):
+    if not m.Sync_NetworkHalf(is_new=is_new, quiet=opt.quiet,
        clone_bundle=not opt.no_clone_bundle):
      r = m.GetRemote(m.remote.name)
      print('fatal: cannot obtain manifest %s' % r.url, file=sys.stderr)
--- a/subcmds/list.py
+++ b/subcmds/list.py
@ -35,6 +35,9 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
    p.add_option('-r', '--regex',
                 dest='regex', action='store_true',
                 help="Filter the project list based on regex or wildcard matching of strings")
    p.add_option('-g', '--groups',
                 dest='groups',
                 help="Filter the project list based on the groups the project is in")
    p.add_option('-f', '--fullpath',
                 dest='fullpath', action='store_true',
                 help="Display the full work tree path instead of the relative path")
@ -62,7 +65,7 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
      sys.exit(1)
    if not opt.regex:
-      projects = self.GetProjects(args)
+      projects = self.GetProjects(args, groups=opt.groups)
    else:
      projects = self.FindProjects(args)
--- a/subcmds/rebase.py
+++ b/subcmds/rebase.py
@ -54,6 +54,11 @@ branch but need to incorporate new upstream changes "underneath" them.
    p.add_option('--auto-stash',
                 dest='auto_stash', action='store_true',
                 help='Stash local modifications before starting')
    p.add_option('-m', '--onto-manifest',
                 dest='onto_manifest', action='store_true',
                 help='Rebase onto the manifest version instead of upstream '
                      'HEAD.  This helps to make sure the local tree stays '
                      'consistent if you previously synced to a manifest.')
  def Execute(self, opt, args):
    all_projects = self.GetProjects(args)
@ -106,6 +111,10 @@ branch but need to incorporate new upstream changes "underneath" them.
      if opt.interactive:
        args.append("-i")
      if opt.onto_manifest:
        args.append('--onto')
        args.append(project.revisionExpr)
      args.append(upbranch.LocalMerge)
      print('# %s: rebasing %s -> %s'
--- a/subcmds/start.py
+++ b/subcmds/start.py
@ -14,11 +14,15 @@
 # limitations under the License.
 from __future__ import print_function
 import os
 import sys
 from command import Command
 from git_config import IsId
 from git_command import git
 import gitc_utils
 from progress import Progress
 from project import SyncBuffer
 class Start(Command):
  common = True
@ -50,23 +54,59 @@ revision specified in the manifest.
    if not opt.all:
      projects = args[1:]
      if len(projects) < 1:
-        print("error: at least one project must be specified", file=sys.stderr)
+        projects = ['.',]  # start it in the local project by default
        sys.exit(1)
-    all_projects = self.GetProjects(projects)
+    all_projects = self.GetProjects(projects,
                                    missing_ok=bool(self.gitc_manifest))
    # This must happen after we find all_projects, since GetProjects may need
    # the local directory, which will disappear once we save the GITC manifest.
    if self.gitc_manifest:
      gitc_projects = self.GetProjects(projects, manifest=self.gitc_manifest,
                                       missing_ok=True)
      for project in gitc_projects:
        if project.old_revision:
          project.already_synced = True
        else:
          project.already_synced = False
          project.old_revision = project.revisionExpr
        project.revisionExpr = None
      # Save the GITC manifest.
      gitc_utils.save_manifest(self.gitc_manifest)
      # Make sure we have a valid CWD
      if not os.path.exists(os.getcwd()):
        os.chdir(self.manifest.topdir)
    pm = Progress('Starting %s' % nb, len(all_projects))
    for project in all_projects:
      pm.update()
      if self.gitc_manifest:
        gitc_project = self.gitc_manifest.paths[project.relpath]
        # Sync projects that have not been opened.
        if not gitc_project.already_synced:
          proj_localdir = os.path.join(self.gitc_manifest.gitc_client_dir,
                                       project.relpath)
          project.worktree = proj_localdir
          if not os.path.exists(proj_localdir):
            os.makedirs(proj_localdir)
          project.Sync_NetworkHalf()
          sync_buf = SyncBuffer(self.manifest.manifestProject.config)
          project.Sync_LocalHalf(sync_buf)
          project.revisionId = gitc_project.old_revision
      # If the current revision is a specific SHA1 then we can't push back
      # to it; so substitute with dest_branch if defined, or with manifest
      # default revision instead.
      branch_merge = ''
      if IsId(project.revisionExpr):
        if project.dest_branch:
-          project.revisionExpr = project.dest_branch
+          branch_merge = project.dest_branch
        else:
-          project.revisionExpr = self.manifest.default.revisionExpr
+          branch_merge = self.manifest.default.revisionExpr
-      if not project.StartBranch(nb):
+
      if not project.StartBranch(nb, branch_merge=branch_merge):
        err.append(project)
    pm.end()
--- a/subcmds/sync.py
+++ b/subcmds/sync.py
@ -23,18 +23,26 @@ import shutil
 import socket
 import subprocess
 import sys
 import tempfile
 import time
 from pyversion import is_python3
 if is_python3():
  import http.cookiejar as cookielib
  import urllib.error
  import urllib.parse
  import urllib.request
  import xmlrpc.client
 else:
  import cookielib
  import imp
  import urllib2
  import urlparse
  import xmlrpclib
  urllib = imp.new_module('urllib')
  urllib.error = urllib2
  urllib.parse = urlparse
  urllib.request = urllib2
  xmlrpc = imp.new_module('xmlrpc')
  xmlrpc.client = xmlrpclib
@ -57,7 +65,9 @@ except ImportError:
  multiprocessing = None
 from git_command import GIT, git_require
 from git_config import GetUrlCookieFile
 from git_refs import R_HEADS, HEAD
 import gitc_utils
 from project import Project
 from project import RemoteSpec
 from command import Command, MirrorSafeCommand
@ -65,6 +75,7 @@ from error import RepoChangedException, GitError, ManifestParseError
 from project import SyncBuffer
 from progress import Progress
 from wrapper import Wrapper
 from manifest_xml import GitcManifest
 _ONE_DAY_S = 24 * 60 * 60
@ -119,6 +130,11 @@ credentials.
 The -f/--force-broken option can be used to proceed with syncing
 other projects if a project sync fails.
 The --force-sync option can be used to overwrite existing git
 directories if they have previously been linked to a different
 object direcotry. WARNING: This may cause data to be lost since
 refs may be removed when overwriting.
 The --no-clone-bundle option disables any attempt to use
 $URL/clone.bundle to bootstrap a new Git repository from a
 resumeable bundle file on a content delivery network. This
@ -135,6 +151,9 @@ The --optimized-fetch option can be used to only fetch projects that
 are fixed to a sha1 revision if the sha1 revision does not already
 exist locally.
 The --prune option can be used to remove any refs that no longer
 exist on the remote.
 SSH Connections
 ---------------
@ -174,6 +193,11 @@ later is required to fix a server side protocol bug.
    p.add_option('-f', '--force-broken',
                 dest='force_broken', action='store_true',
                 help="continue sync even if a project fails to sync")
    p.add_option('--force-sync',
                 dest='force_sync', action='store_true',
                 help="overwrite an existing git directory if it needs to "
                      "point to a different object directory. WARNING: this "
                      "may cause loss of data")
    p.add_option('-l', '--local-only',
                 dest='local_only', action='store_true',
                 help="only update working tree, don't fetch")
@ -213,10 +237,12 @@ later is required to fix a server side protocol bug.
    p.add_option('--optimized-fetch',
                 dest='optimized_fetch', action='store_true',
                 help='only fetch projects fixed to sha1 if revision does not exist locally')
    p.add_option('--prune', dest='prune', action='store_true',
                 help='delete refs that no longer exist on the remote')
    if show_smart:
      p.add_option('-s', '--smart-sync',
                   dest='smart_sync', action='store_true',
-                   help='smart sync using manifest from a known good build')
+                   help='smart sync using manifest from the latest known good build')
      p.add_option('-t', '--smart-tag',
                   dest='smart_tag', action='store',
                   help='smart sync using manifest from a known tag')
@ -281,9 +307,11 @@ later is required to fix a server side protocol bug.
        success = project.Sync_NetworkHalf(
          quiet=opt.quiet,
          current_branch_only=opt.current_branch_only,
          force_sync=opt.force_sync,
          clone_bundle=not opt.no_clone_bundle,
          no_tags=opt.no_tags, archive=self.manifest.IsArchive,
-          optimized_fetch=opt.optimized_fetch)
+          optimized_fetch=opt.optimized_fetch,
          prune=opt.prune)
        self._fetch_times.Set(project, time.time() - start)
        # Lock around all the rest of the code, since printing, updating a set
@ -292,6 +320,7 @@ later is required to fix a server side protocol bug.
        did_lock = True
        if not success:
          err_event.set()
          print('error: Cannot fetch %s' % project.name, file=sys.stderr)
          if opt.force_broken:
            print('warn: --force-broken, continuing to sync',
@ -302,8 +331,10 @@ later is required to fix a server side protocol bug.
        fetched.add(project.gitdir)
        pm.update()
      except _FetchError:
-        err_event.set()
+        pass
-      except:
+      except Exception as e:
        print('error: Cannot fetch %s (%s: %s)' \
            % (project.name, type(e).__name__, str(e)), file=sys.stderr)
        err_event.set()
        raise
    finally:
@ -366,9 +397,12 @@ later is required to fix a server side protocol bug.
    return fetched
  def _GCProjects(self, projects):
-    gitdirs = {}
+    gc_gitdirs = {}
    for project in projects:
-      gitdirs[project.gitdir] = project.bare_git
+      if len(project.manifest.GetProjectsWithName(project.name)) > 1:
        print('Shared project %s found, disabling pruning.' % project.name)
        project.bare_git.config('--replace-all', 'gc.pruneExpire', 'never')
      gc_gitdirs[project.gitdir] = project.bare_git
    has_dash_c = git_require((1, 7, 2))
    if multiprocessing and has_dash_c:
@ -378,7 +412,7 @@ later is required to fix a server side protocol bug.
    jobs = min(self.jobs, cpu_count)
    if jobs < 2:
-      for bare_git in gitdirs.values():
+      for bare_git in gc_gitdirs.values():
        bare_git.gc('--auto')
      return
@ -400,7 +434,7 @@ later is required to fix a server side protocol bug.
      finally:
        sem.release()
-    for bare_git in gitdirs.values():
+    for bare_git in gc_gitdirs.values():
      if err_event.isSet():
        break
      sem.acquire()
@ -423,6 +457,59 @@ later is required to fix a server side protocol bug.
    else:
      self.manifest._Unload()
  def _DeleteProject(self, path):
    print('Deleting obsolete path %s' % path, file=sys.stderr)
    # Delete the .git directory first, so we're less likely to have a partially
    # working git repository around. There shouldn't be any git projects here,
    # so rmtree works.
    try:
      shutil.rmtree(os.path.join(path, '.git'))
    except OSError:
      print('Failed to remove %s' % os.path.join(path, '.git'), file=sys.stderr)
      print('error: Failed to delete obsolete path %s' % path, file=sys.stderr)
      print('       remove manually, then run sync again', file=sys.stderr)
      return -1
    # Delete everything under the worktree, except for directories that contain
    # another git project
    dirs_to_remove = []
    failed = False
    for root, dirs, files in os.walk(path):
      for f in files:
        try:
          os.remove(os.path.join(root, f))
        except OSError:
          print('Failed to remove %s' % os.path.join(root, f), file=sys.stderr)
          failed = True
      dirs[:] = [d for d in dirs
                 if not os.path.lexists(os.path.join(root, d, '.git'))]
      dirs_to_remove += [os.path.join(root, d) for d in dirs
                         if os.path.join(root, d) not in dirs_to_remove]
    for d in reversed(dirs_to_remove):
      if len(os.listdir(d)) == 0:
        try:
          os.rmdir(d)
        except OSError:
          print('Failed to remove %s' % os.path.join(root, d), file=sys.stderr)
          failed = True
          continue
    if failed:
      print('error: Failed to delete obsolete path %s' % path, file=sys.stderr)
      print('       remove manually, then run sync again', file=sys.stderr)
      return -1
    # Try deleting parent dirs if they are empty
    project_dir = path
    while project_dir != self.manifest.topdir:
      if len(os.listdir(project_dir)) == 0:
        os.rmdir(project_dir)
      else:
        break
      project_dir = os.path.dirname(project_dir)
    return 0
  def UpdateProjectList(self):
    new_project_paths = []
    for project in self.GetProjects(None, missing_ok=True):
@ -443,8 +530,8 @@ later is required to fix a server side protocol bug.
          continue
        if path not in new_project_paths:
          # If the path has already been deleted, we don't need to do it
-          if os.path.exists(self.manifest.topdir + '/' + path):
+          gitdir = os.path.join(self.manifest.topdir, path, '.git')
-            gitdir = os.path.join(self.manifest.topdir, path, '.git')
+          if os.path.exists(gitdir):
            project = Project(
                           manifest = self.manifest,
                           name = path,
@ -463,18 +550,8 @@ later is required to fix a server side protocol bug.
              print('       commit changes, then run sync again',
                    file=sys.stderr)
              return -1
-            else:
+            elif self._DeleteProject(project.worktree):
-              print('Deleting obsolete path %s' % project.worktree,
+              return -1
                    file=sys.stderr)
              shutil.rmtree(project.worktree)
              # Try deleting parent subdirs if they are empty
              project_dir = os.path.dirname(project.worktree)
              while project_dir != self.manifest.topdir:
                try:
                  os.rmdir(project_dir)
                except OSError:
                  break
                project_dir = os.path.dirname(project_dir)
    new_project_paths.sort()
    fd = open(file_path, 'w')
@ -541,19 +618,18 @@ later is required to fix a server side protocol bug.
          try:
            info = netrc.netrc()
          except IOError:
-            print('.netrc file does not exist or could not be opened',
+            # .netrc file does not exist or could not be opened
-                  file=sys.stderr)
+            pass
          else:
            try:
              parse_result = urllib.parse.urlparse(manifest_server)
              if parse_result.hostname:
-                username, _account, password = \
+                auth = info.authenticators(parse_result.hostname)
-                  info.authenticators(parse_result.hostname)
+                if auth:
-            except TypeError:
+                  username, _account, password = auth
-              # TypeError is raised when the given hostname is not present
+                else:
-              # in the .netrc file.
+                  print('No credentials found for %s in .netrc'
-              print('No credentials found for %s in .netrc'
+                        % parse_result.hostname, file=sys.stderr)
                    % parse_result.hostname, file=sys.stderr)
            except netrc.NetrcParseError as e:
              print('Error parsing .netrc file: %s' % e, file=sys.stderr)
@ -562,8 +638,12 @@ later is required to fix a server side protocol bug.
                                                    (username, password),
                                                    1)
      transport = PersistentTransport(manifest_server)
      if manifest_server.startswith('persistent-'):
        manifest_server = manifest_server[len('persistent-'):]
      try:
-        server = xmlrpc.client.Server(manifest_server)
+        server = xmlrpc.client.Server(manifest_server, transport=transport)
        if opt.smart_sync:
          p = self.manifest.manifestProject
          b = p.GetBranch(p.CurrentBranch)
@ -643,6 +723,42 @@ later is required to fix a server side protocol bug.
      self._ReloadManifest(manifest_name)
      if opt.jobs is None:
        self.jobs = self.manifest.default.sync_j
    if self.gitc_manifest:
      gitc_manifest_projects = self.GetProjects(args,
                                                missing_ok=True)
      gitc_projects = []
      opened_projects = []
      for project in gitc_manifest_projects:
        if project.relpath in self.gitc_manifest.paths and \
           self.gitc_manifest.paths[project.relpath].old_revision:
          opened_projects.append(project.relpath)
        else:
          gitc_projects.append(project.relpath)
      if not args:
        gitc_projects = None
      if gitc_projects != [] and not opt.local_only:
        print('Updating GITC client: %s' % self.gitc_manifest.gitc_client_name)
        manifest = GitcManifest(self.repodir, self.gitc_manifest.gitc_client_name)
        if manifest_name:
          manifest.Override(manifest_name)
        else:
          manifest.Override(self.manifest.manifestFile)
        gitc_utils.generate_gitc_manifest(self.gitc_manifest,
                                          manifest,
                                          gitc_projects)
        print('GITC client successfully synced.')
      # The opened projects need to be synced as normal, therefore we
      # generate a new args list to represent the opened projects.
      # TODO: make this more reliable -- if there's a project name/path overlap,
      # this may choose the wrong project.
      args = [os.path.relpath(self.manifest.paths[p].worktree, os.getcwd())
              for p in opened_projects]
      if not args:
        return
    all_projects = self.GetProjects(args,
                                    missing_ok=True,
                                    submodules_ok=opt.fetch_submodules)
@ -696,7 +812,7 @@ later is required to fix a server side protocol bug.
    for project in all_projects:
      pm.update()
      if project.worktree:
-        project.Sync_LocalHalf(syncbuf)
+        project.Sync_LocalHalf(syncbuf, force_sync=opt.force_sync)
    pm.end()
    print(file=sys.stderr)
    if not syncbuf.Finish():
@ -837,3 +953,100 @@ class _FetchTimes(object):
        os.remove(self._path)
      except OSError:
        pass
 # This is a replacement for xmlrpc.client.Transport using urllib2
 # and supporting persistent-http[s]. It cannot change hosts from
 # request to request like the normal transport, the real url
 # is passed during initialization.
 class PersistentTransport(xmlrpc.client.Transport):
  def __init__(self, orig_host):
    self.orig_host = orig_host
  def request(self, host, handler, request_body, verbose=False):
    with GetUrlCookieFile(self.orig_host, not verbose) as (cookiefile, proxy):
      # Python doesn't understand cookies with the #HttpOnly_ prefix
      # Since we're only using them for HTTP, copy the file temporarily,
      # stripping those prefixes away.
      if cookiefile:
        tmpcookiefile = tempfile.NamedTemporaryFile()
        tmpcookiefile.write("# HTTP Cookie File")
        try:
          with open(cookiefile) as f:
            for line in f:
              if line.startswith("#HttpOnly_"):
                line = line[len("#HttpOnly_"):]
              tmpcookiefile.write(line)
          tmpcookiefile.flush()
          cookiejar = cookielib.MozillaCookieJar(tmpcookiefile.name)
          try:
            cookiejar.load()
          except cookielib.LoadError:
            cookiejar = cookielib.CookieJar()
        finally:
          tmpcookiefile.close()
      else:
        cookiejar = cookielib.CookieJar()
      proxyhandler = urllib.request.ProxyHandler
      if proxy:
        proxyhandler = urllib.request.ProxyHandler({
            "http": proxy,
            "https": proxy })
      opener = urllib.request.build_opener(
          urllib.request.HTTPCookieProcessor(cookiejar),
          proxyhandler)
      url = urllib.parse.urljoin(self.orig_host, handler)
      parse_results = urllib.parse.urlparse(url)
      scheme = parse_results.scheme
      if scheme == 'persistent-http':
        scheme = 'http'
      if scheme == 'persistent-https':
        # If we're proxying through persistent-https, use http. The
        # proxy itself will do the https.
        if proxy:
          scheme = 'http'
        else:
          scheme = 'https'
      # Parse out any authentication information using the base class
      host, extra_headers, _ = self.get_host_info(parse_results.netloc)
      url = urllib.parse.urlunparse((
          scheme,
          host,
          parse_results.path,
          parse_results.params,
          parse_results.query,
          parse_results.fragment))
      request = urllib.request.Request(url, request_body)
      if extra_headers is not None:
        for (name, header) in extra_headers:
          request.add_header(name, header)
      request.add_header('Content-Type', 'text/xml')
      try:
        response = opener.open(request)
      except urllib.error.HTTPError as e:
        if e.code == 501:
          # We may have been redirected through a login process
          # but our POST turned into a GET. Retry.
          response = opener.open(request)
        else:
          raise
      p, u = xmlrpc.client.getparser()
      while 1:
        data = response.read(1024)
        if not data:
          break
        p.feed(data)
      p.close()
      return u.close()
  def close(self):
    pass
--- a/subcmds/upload.py
+++ b/subcmds/upload.py
@ -454,9 +454,15 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
      if avail:
        pending.append((project, avail))
-    if pending and (not opt.bypass_hooks):
+    if not pending:
      print("no branches ready for upload", file=sys.stderr)
      return
    if not opt.bypass_hooks:
      hook = RepoHook('pre-upload', self.manifest.repo_hooks_project,
-                      self.manifest.topdir, abort_if_user_denies=True)
+                      self.manifest.topdir,
                      self.manifest.manifestProject.GetRemote('origin').url,
                      abort_if_user_denies=True)
      pending_proj_names = [project.name for (project, avail) in pending]
      pending_worktrees = [project.worktree for (project, avail) in pending]
      try:
@ -472,9 +478,7 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
      cc = _SplitEmails(opt.cc)
    people = (reviewers, cc)
-    if not pending:
+    if len(pending) == 1 and len(pending[0][1]) == 1:
      print("no branches ready for upload", file=sys.stderr)
    elif len(pending) == 1 and len(pending[0][1]) == 1:
      self._SingleBranch(opt, pending[0][1][0], people)
    else:
      self._MultipleBranches(opt, pending, people)
--- a/tests/fixtures/gitc_config
+++ b/tests/fixtures/gitc_config
@ -0,0 +1 @@
 gitc_dir=/test/usr/local/google/gitc
--- a/tests/test_wrapper.py
+++ b/tests/test_wrapper.py
@ -0,0 +1,75 @@
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # 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.
 import os
 import unittest
 import wrapper
 def fixture(*paths):
  """Return a path relative to tests/fixtures.
  """
  return os.path.join(os.path.dirname(__file__), 'fixtures', *paths)
 class RepoWrapperUnitTest(unittest.TestCase):
  """Tests helper functions in the repo wrapper
  """
  def setUp(self):
    """Load the wrapper module every time
    """
    wrapper._wrapper_module = None
    self.wrapper = wrapper.Wrapper()
  def test_get_gitc_manifest_dir_no_gitc(self):
    """
    Test reading a missing gitc config file
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('missing_gitc_config')
    val = self.wrapper.get_gitc_manifest_dir()
    self.assertEqual(val, '')
  def test_get_gitc_manifest_dir(self):
    """
    Test reading the gitc config file and parsing the directory
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('gitc_config')
    val = self.wrapper.get_gitc_manifest_dir()
    self.assertEqual(val, '/test/usr/local/google/gitc')
  def test_gitc_parse_clientdir_no_gitc(self):
    """
    Test parsing the gitc clientdir without gitc running
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('missing_gitc_config')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/something'), None)
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test'), 'test')
  def test_gitc_parse_clientdir(self):
    """
    Test parsing the gitc clientdir
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('gitc_config')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/something'), None)
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test/'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test/extra'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test/'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test/extra'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/'), None)
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/'), None)
 if __name__ == '__main__':
  unittest.main()