Add git-map and git-short-map to depot_tools.

git_common.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Monkeypatch IMapIterator so that Ctrl-C can kill everything properly.
 # Derived from https://gist.github.com/aljungberg/626518
 import multiprocessing.pool
 from multiprocessing.pool import IMapIterator
 def wrapper(func):
   def wrap(self, timeout=None):
     return func(self, timeout=timeout or 1e100)
   return wrap
 IMapIterator.next = wrapper(IMapIterator.next)
 IMapIterator.__next__ = IMapIterator.next
 # TODO(iannucci): Monkeypatch all other 'wait' methods too.
 
 
 import binascii
 import contextlib
 import functools
 import logging
 import signal
 import sys
 import tempfile
 import threading
 
 import subprocess2
 
 
+class DEFAULT(object):

[agable, 2014/02/28 19:54:58]

Why? This is so completely unnecessary. Maybe kinda elegant, but generally
obtuse and irrelevant.

[iannucci, 2014/03/06 00:18:39]

*sigh* going back to useless-mode. lcd for the win :(

+  def __init__(self, constructor):
+    self.constructor = constructor
+
+  @staticmethod
+  def get_from(inst_or_obj):
+    if isinstance(inst_or_obj, DEFAULT):
+      return inst_or_obj.constructor()
+    else:
+      return inst_or_obj
+
+
 GIT_EXE = 'git.bat' if sys.platform.startswith('win') else 'git'
 
+NO_BRANCH = ('* (no branch)', '* (detached from ')
+
 
 class BadCommitRefException(Exception):
   def __init__(self, refs):
     msg = ('one of %s does not seem to be a valid commitref.' %
            str(refs))
     super(BadCommitRefException, self).__init__(msg)
 
 
 def memoize_one(**kwargs):
   """Memoizes a single-argument pure function.
@@ skipping 150 matching lines @@
     return self.inc
 
   def __exit__(self, _exc_type, _exc_value, _traceback):
     self._dead = True
     with self._dead_cond:
       self._dead_cond.notifyAll()
     self._thread.join()
     del self._thread
 
 
+def abbrev(ref):
+  return run('rev-parse', '--abbrev-ref', ref)
+
+
+def branches(*args):
+  for line in run('branch', *args).splitlines():
+    if line.startswith(NO_BRANCH):
+      continue
+    yield line.split()[-1]
+
+
+def config_list(option, default=DEFAULT(list)):

[agable, 2014/02/28 19:54:58]

default=None
if default is None: default=[]

Let's stick with the classics, here. Especially since nothing actually calls
this method with a default= kwarg.

[iannucci, 2014/03/06 00:18:39]

sometimes I hate python. The =None idiom is so uninformative :(.

I just got rid of default for the time being.

[agable, 2014/03/06 18:09:07]

I know, and I totally agree. But I don't think this is the place to get fancy
and introduce new non-idioms.

+  try:
+    return run('config', '--get-all', option).split()
+  except subprocess2.CalledProcessError:
+    return DEFAULT.get_from(default)
+
+
+def current_branch():
+  return abbrev('HEAD')
+
+
 def parse_commitrefs(*commitrefs):
   """Returns binary encoded commit hashes for one or more commitrefs.
 
   A commitref is anything which can resolve to a commit. Popular examples:
     * 'HEAD'
     * 'origin/master'
     * 'cool_branch~2'
   """
   try:
-    return map(binascii.unhexlify, hashes(*commitrefs))
+    return map(binascii.unhexlify, hash_multi(*commitrefs))
   except subprocess2.CalledProcessError:
     raise BadCommitRefException(commitrefs)
 
 
 def run(*cmd, **kwargs):
   """Runs a git command. Returns stdout as a string.
 
   If logging is DEBUG, we'll print the command before we run it.
 
   kwargs
     autostrip (bool) - Strip the output. Defaults to True.
   Output string is always strip()'d.
   """
   autostrip = kwargs.pop('autostrip', True)
   cmd = (GIT_EXE,) + cmd
   logging.debug('Running %s', ' '.join(repr(tok) for tok in cmd))
   ret = subprocess2.check_output(cmd, stderr=subprocess2.PIPE, **kwargs)
   if autostrip:
     ret = (ret or '').strip()
   return ret
 
 
-def hashes(*reflike):
+def hash_one(reflike):
+  return run('rev-parse', reflike)
+
+
+def hash_multi(*reflike):

[agable, 2014/02/28 19:54:58]

This should be "*reflikes" (cf. "*args").

[iannucci, 2014/03/06 00:18:39]

Done.

   return run('rev-parse', *reflike).splitlines()
 
 
 def intern_f(f, kind='blob'):
   """Interns a file object into the git object store.
 
   Args:
     f (file-like object) - The file-like object to intern
     kind (git object type) - One of 'blob', 'commit', 'tree', 'tag'.
 
   Returns the git hash of the interned object (hex encoded).
   """
   ret = run('hash-object', '-t', kind, '-w', '--stdin', stdin=f)
   f.close()
   return ret
 
 
+def tags(*args):
+  for line in run('tag', *args).splitlines():
+    if line.startswith(NO_BRANCH):
+      continue
+    yield line.split()[-1]
+
+
 def tree(treeref, recurse=False):
   """Returns a dict representation of a git tree object.
 
   Args:
     treeref (str) - a git ref which resolves to a tree (commits count as trees).
     recurse (bool) - include all of the tree's decendants too. File names will
       take the form of 'some/path/to/file'.
 
   Return format:
     { 'file_name': (mode, type, ref) }
@@ skipping 17 matching lines @@
   opts.append(treeref)
   try:
     for line in run(*opts).splitlines():
       mode, typ, ref, name = line.split(None, 3)
       ret[name] = (mode, typ, ref)
   except subprocess2.CalledProcessError:
     return None
   return ret
 
 
+def upstream(branch):
+  try:
+    return run('rev-parse', '--abbrev-ref', '--symbolic-full-name',
+               branch+'@{upstream}')
+  except subprocess2.CalledProcessError:
+    return None
+
+
 def mktree(treedict):
   """Makes a git tree object and returns its hash.
 
   See |tree()| for the values of mode, type, and ref.
 
   Args:
     treedict - { name: (mode, type, ref) }
   """
   with tempfile.TemporaryFile() as f:
     for name, (mode, typ, ref) in treedict.iteritems():
       f.write('%s %s %s\t%s\0' % (mode, typ, ref, name))
     f.seek(0)
     return run('mktree', '-z', stdin=f)