# util.py - Mercurial utility functions and platform specific implementations

#

#  Copyright 2005 K. Thananchayan <thananck@yahoo.com>

#  Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#  Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

"""Mercurial utility functions and platform specific implementations.

This contains helper routines that are independent of the SCM core and

hide platform-specific details from the core.

"""

import i18n

_ = i18n._

import error, osutil, encoding, parsers

import errno, shutil, sys, tempfile, traceback

import re as remod

import os, time, datetime, calendar, textwrap, signal, collections

import stat

import imp, socket, urllib

import gc

import bz2

import zlib

if os.name == 'nt':

    import windows as platform

else:

    import posix as platform

cachestat = platform.cachestat

checkexec = platform.checkexec

checklink = platform.checklink

copymode = platform.copymode

executablepath = platform.executablepath

expandglobs = platform.expandglobs

explainexit = platform.explainexit

findexe = platform.findexe

gethgcmd = platform.gethgcmd

getuser = platform.getuser

groupmembers = platform.groupmembers

groupname = platform.groupname

hidewindow = platform.hidewindow

isexec = platform.isexec

isowner = platform.isowner

localpath = platform.localpath

lookupreg = platform.lookupreg

makedir = platform.makedir

nlinks = platform.nlinks

normpath = platform.normpath

normcase = platform.normcase

normcasespec = platform.normcasespec

normcasefallback = platform.normcasefallback

openhardlinks = platform.openhardlinks

oslink = platform.oslink

parsepatchoutput = platform.parsepatchoutput

pconvert = platform.pconvert

poll = platform.poll

popen = platform.popen

posixfile = platform.posixfile

quotecommand = platform.quotecommand

readpipe = platform.readpipe

rename = platform.rename

removedirs = platform.removedirs

samedevice = platform.samedevice

samefile = platform.samefile

samestat = platform.samestat

setbinary = platform.setbinary

setflags = platform.setflags

setsignalhandler = platform.setsignalhandler

shellquote = platform.shellquote

spawndetached = platform.spawndetached

split = platform.split

sshargs = platform.sshargs

statfiles = getattr(osutil, 'statfiles', platform.statfiles)

statisexec = platform.statisexec

statislink = platform.statislink

termwidth = platform.termwidth

testpid = platform.testpid

umask = platform.umask

unlink = platform.unlink

unlinkpath = platform.unlinkpath

username = platform.username

# Python compatibility

_notset = object()

def safehasattr(thing, attr):

    return getattr(thing, attr, _notset) is not _notset

def sha1(s=''):

    '''

    Low-overhead wrapper around Python's SHA support

    >>> f = _fastsha1

    >>> a = sha1()

    >>> a = f()

    >>> a.hexdigest()

    'da39a3ee5e6b4b0d3255bfef95601890afd80709'

    '''

    return _fastsha1(s)

def _fastsha1(s=''):

    # This function will import sha1 from hashlib or sha (whichever is

    # available) and overwrite itself with it on the first call.

    # Subsequent calls will go directly to the imported function.

    if sys.version_info >= (2, 5):

        from hashlib import sha1 as _sha1

    else:

        from sha import sha as _sha1

    global _fastsha1, sha1

    _fastsha1 = sha1 = _sha1

    return _sha1(s)

def md5(s=''):

    try:

        from hashlib import md5 as _md5

    except ImportError:

        from md5 import md5 as _md5

    global md5

    md5 = _md5

    return _md5(s)

DIGESTS = {

    'md5': md5,

    'sha1': sha1,

}

# List of digest types from strongest to weakest

DIGESTS_BY_STRENGTH = ['sha1', 'md5']

try:

    import hashlib

    DIGESTS.update({

        'sha512': hashlib.sha512,

    })

    DIGESTS_BY_STRENGTH.insert(0, 'sha512')

except ImportError:

    pass

for k in DIGESTS_BY_STRENGTH:

    assert k in DIGESTS

class digester(object):

    """helper to compute digests.

    This helper can be used to compute one or more digests given their name.

    >>> d = digester(['md5', 'sha1'])

    >>> d.update('foo')

    >>> [k for k in sorted(d)]

    ['md5', 'sha1']

    >>> d['md5']

    'acbd18db4cc2f85cedef654fccc4a4d8'

    >>> d['sha1']

    '0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33'

    >>> digester.preferred(['md5', 'sha1'])

    'sha1'

    """

    def __init__(self, digests, s=''):

        self._hashes = {}

        for k in digests:

            if k not in DIGESTS:

                raise Abort(_('unknown digest type: %s') % k)

            self._hashes[k] = DIGESTS[k]()

        if s:

            self.update(s)

    def update(self, data):

        for h in self._hashes.values():

            h.update(data)

    def __getitem__(self, key):

        if key not in DIGESTS:

            raise Abort(_('unknown digest type: %s') % k)

        return self._hashes[key].hexdigest()

    def __iter__(self):

        return iter(self._hashes)

    @staticmethod

    def preferred(supported):

        """returns the strongest digest type in both supported and DIGESTS."""

        for k in DIGESTS_BY_STRENGTH:

            if k in supported:

                return k

        return None

class digestchecker(object):

    """file handle wrapper that additionally checks content against a given

    size and digests.

        d = digestchecker(fh, size, {'md5': '...'})

    When multiple digests are given, all of them are validated.

    """

    def __init__(self, fh, size, digests):

        self._fh = fh

        self._size = size

        self._got = 0

        self._digests = dict(digests)

        self._digester = digester(self._digests.keys())

    def read(self, length=-1):

        content = self._fh.read(length)

        self._digester.update(content)

        self._got += len(content)

        return content

    def validate(self):

        if self._size != self._got:

            raise Abort(_('size mismatch: expected %d, got %d') %

                (self._size, self._got))

        for k, v in self._digests.items():

            if v != self._digester[k]:

                # i18n: first parameter is a digest name

                raise Abort(_('%s mismatch: expected %s, got %s') %

                    (k, v, self._digester[k]))

try:

    buffer = buffer

except NameError:

    if sys.version_info[0] < 3:

        def buffer(sliceable, offset=0):

            return sliceable[offset:]

    else:

        def buffer(sliceable, offset=0):

            return memoryview(sliceable)[offset:]

import subprocess

closefds = os.name == 'posix'

_chunksize = 4096

class bufferedinputpipe(object):

    """a manually buffered input pipe

    Python will not let us use buffered IO and lazy reading with 'polling' at

    the same time. We cannot probe the buffer state and select will not detect

    that data are ready to read if they are already buffered.

    This class let us work around that by implementing its own buffering

    (allowing efficient readline) while offering a way to know if the buffer is

    empty from the output (allowing collaboration of the buffer with polling).

    This class lives in the 'util' module because it makes use of the 'os'

    module from the python stdlib.

    """

    def __init__(self, input):

        self._input = input

        self._buffer = []

        self._eof = False

        self._lenbuf = 0

    @property

    def hasbuffer(self):

        """True is any data is currently buffered

        This will be used externally a pre-step for polling IO. If there is

        already data then no polling should be set in place."""

        return bool(self._buffer)

    @property

    def closed(self):

        return self._input.closed

    def fileno(self):

        return self._input.fileno()

    def close(self):

        return self._input.close()

    def read(self, size):

        while (not self._eof) and (self._lenbuf < size):

            self._fillbuffer()

        return self._frombuffer(size)

    def readline(self, *args, **kwargs):

        if 1 < len(self._buffer):

            # this should not happen because both read and readline end with a

            # _frombuffer call that collapse it.

            self._buffer = [''.join(self._buffer)]

            self._lenbuf = len(self._buffer[0])

        lfi = -1

        if self._buffer:

            lfi = self._buffer[-1].find('\n')

        while (not self._eof) and lfi < 0:

            self._fillbuffer()

            if self._buffer:

                lfi = self._buffer[-1].find('\n')

        size = lfi + 1

        if lfi < 0: # end of file

            size = self._lenbuf

        elif 1 < len(self._buffer):

            # we need to take previous chunks into account

            size += self._lenbuf - len(self._buffer[-1])

        return self._frombuffer(size)

    def _frombuffer(self, size):

        """return at most 'size' data from the buffer

        The data are removed from the buffer."""

        if size == 0 or not self._buffer:

            return ''

        buf = self._buffer[0]

        if 1 < len(self._buffer):

            buf = ''.join(self._buffer)

        data = buf[:size]

        buf = buf[len(data):]

        if buf:

            self._buffer = [buf]

            self._lenbuf = len(buf)

        else:

            self._buffer = []

            self._lenbuf = 0

        return data

    def _fillbuffer(self):

        """read data to the buffer"""

        data = os.read(self._input.fileno(), _chunksize)

        if not data:

            self._eof = True

        else:

            self._lenbuf += len(data)

            self._buffer.append(data)

def popen2(cmd, env=None, newlines=False):

    # Setting bufsize to -1 lets the system decide the buffer size.

    # The default for bufsize is 0, meaning unbuffered. This leads to

    # poor performance on Mac OS X: http://bugs.python.org/issue4194

    p = subprocess.Popen(cmd, shell=True, bufsize=-1,

                         close_fds=closefds,

                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,

                         universal_newlines=newlines,

                         env=env)

    return p.stdin, p.stdout

def popen3(cmd, env=None, newlines=False):

    stdin, stdout, stderr, p = popen4(cmd, env, newlines)

    return stdin, stdout, stderr

def popen4(cmd, env=None, newlines=False, bufsize=-1):

    p = subprocess.Popen(cmd, shell=True, bufsize=bufsize,

                         close_fds=closefds,

                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,

                         stderr=subprocess.PIPE,

                         universal_newlines=newlines,

                         env=env)

    return p.stdin, p.stdout, p.stderr, p

def version():

    """Return version information if available."""

    try:

        import __version__

        return __version__.version

    except ImportError:

        return 'unknown'

# used by parsedate

defaultdateformats = (

    '%Y-%m-%d %H:%M:%S',

    '%Y-%m-%d %I:%M:%S%p',

    '%Y-%m-%d %H:%M',

    '%Y-%m-%d %I:%M%p',

    '%Y-%m-%d',

    '%m-%d',

    '%m/%d',

    '%m/%d/%y',

    '%m/%d/%Y',

    '%a %b %d %H:%M:%S %Y',

    '%a %b %d %I:%M:%S%p %Y',

    '%a, %d %b %Y %H:%M:%S',        #  GNU coreutils "/bin/date --rfc-2822"

    '%b %d %H:%M:%S %Y',

    '%b %d %I:%M:%S%p %Y',

    '%b %d %H:%M:%S',

    '%b %d %I:%M:%S%p',

    '%b %d %H:%M',

    '%b %d %I:%M%p',