return self._repo.head()

        except KeyError:

            return None

    @LazyProperty

    def revisions(self):

        """

        Returns list of revisions' ids, in ascending order.  Being lazy

        attribute allows external tools to inject shas from cache.

        """

        return self._get_all_revisions()

    @classmethod

    def _run_git_command(cls, cmd, **opts):

        """

        Runs given ``cmd`` as git command and returns tuple

        (stdout, stderr).

        :param cmd: git command to be executed

        :param opts: env options to pass into Subprocess command

        """

        if '_bare' in opts:

            _copts = []

            del opts['_bare']

        else:

            _copts = ['-c', 'core.quotepath=false', ]

        safe_call = False

        if '_safe' in opts:

            #no exc on failure

            del opts['_safe']

            safe_call = True

        _str_cmd = False

        if isinstance(cmd, basestring):

            cmd = [cmd]

            _str_cmd = True

        gitenv = os.environ

        # need to clean fix GIT_DIR !

        if 'GIT_DIR' in gitenv:

            del gitenv['GIT_DIR']

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        _git_path = settings.GIT_EXECUTABLE_PATH

        cmd = [_git_path] + _copts + cmd

        if _str_cmd:

            cmd = ' '.join(cmd)

        try:

            _opts = dict(

                env=gitenv,

            )

            _opts.update(opts)

            p = subprocessio.SubprocessIOChunker(cmd, **_opts)

        except (EnvironmentError, OSError), err:

            tb_err = ("Couldn't run git command (%s).\n"

                      "Original error was:%s\n" % (cmd, err))

            log.error(tb_err)

            if safe_call:

                return '', err

            else:

                raise RepositoryError(tb_err)

        return ''.join(p.output), ''.join(p.error)

    def run_git_command(self, cmd):

        opts = {}

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

            opts['cwd'] = self.path

        return self._run_git_command(cmd, **opts)

    @classmethod

    def _check_url(cls, url):

        """

        Functon will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError

        """

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if('+' in url[:url.find('://')]):

            url = url[url.find('+') + 1:]

        handlers = []

        test_uri, authinfo = hg_url(url).authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        if authinfo:

            #create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((httpbasicauthhandler(passmgr),

       slow-yielding subprocess may block the iteration until data shows up. This

       does not block the parallel inpipe reading occurring parallel thread.)

    The purpose of the object is to allow us to wrap subprocess interactions into

    and interable that can be passed to a WSGI server as the application's return

    value. Because of stream-processing-ability, WSGI does not have to read ALL

    of the subprocess's output and buffer it, before handing it to WSGI server for

    HTTP response. Instead, the class initializer reads just a bit of the stream

    to figure out if error ocurred or likely to occur and if not, just hands the

    further iteration over subprocess output to the server for completion of HTTP

    response.

    The real or perceived subprocess error is trapped and raised as one of

    EnvironmentError family of exceptions

    Example usage:

    #    try:

    #        answer = SubprocessIOChunker(

    #            cmd,

    #            input,

    #            buffer_size = 65536,

    #            chunk_size = 4096

    #            )

    #    except (EnvironmentError) as e:

    #        print str(e)

    #        raise e

    #

    #    return answer

    '''

    def __init__(self, cmd, inputstream=None, buffer_size=65536,

                 chunk_size=4096, starting_values=[], **kwargs):

        '''

        Initializes SubprocessIOChunker

        :param cmd: A Subprocess.Popen style "cmd". Can be string or array of strings

        :param inputstream: (Default: None) A file-like, string, or file pointer.

        :param buffer_size: (Default: 65536) A size of total buffer per stream in bytes.

        :param chunk_size: (Default: 4096) A max size of a chunk. Actual chunk may be smaller.

        :param starting_values: (Default: []) An array of strings to put in front of output que.

        '''

        if inputstream:

            input_streamer = StreamFeeder(inputstream)

            input_streamer.start()

            inputstream = input_streamer.output

        if isinstance(cmd, (list, tuple)):

            cmd = ' '.join(cmd)

        kwargs['shell'] = _shell

        _p = subprocess.Popen(cmd,

            bufsize=-1,

            stdin=inputstream,

            stdout=subprocess.PIPE,

            stderr=subprocess.PIPE,

            **kwargs

        bg_out = BufferedGenerator(_p.stdout, buffer_size, chunk_size, starting_values)

        bg_err = BufferedGenerator(_p.stderr, 16000, 1, bottomless=True)

        while not bg_out.done_reading and not bg_out.reading_paused and not bg_err.length:

            # doing this until we reach either end of file, or end of buffer.

            bg_out.data_added_event.wait(1)

            bg_out.data_added_event.clear()

        # at this point it's still ambiguous if we are done reading or just full buffer.

        # Either way, if error (returned by ended process, or implied based on

        # presence of stuff in stderr output) we error out.

        # Else, we are happy.

        _returncode = _p.poll()

        if _returncode or (_returncode == None and bg_err.length):

            try:

                _p.terminate()

            except:

                pass

            bg_out.stop()

            bg_err.stop()

            err = '%s' % ''.join(bg_err)

            if err:

                raise EnvironmentError("Subprocess exited due to an error:\n" + err)

            raise EnvironmentError("Subprocess exited with non 0 ret code:%s" % _returncode)

        self.process = _p

        self.output = bg_out

        self.error = bg_err

    def __iter__(self):

        return self

    def next(self):

        if self.process.poll():

            err = '%s' % ''.join(self.error)

            raise EnvironmentError("Subprocess exited due to an error:\n" + err)

        return self.output.next()

    def throw(self, type, value=None, traceback=None):

        if self.output.length or not self.output.done_reading:

            raise type(value)

    def close(self):

        try:

            self.process.terminate()

        except:

            pass