# 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

import errno, shutil, sys, tempfile, traceback

import re as remod

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

import imp, socket, urllib

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

openhardlinks = platform.openhardlinks

oslink = platform.oslink

parsepatchoutput = platform.parsepatchoutput

pconvert = platform.pconvert

popen = platform.popen

posixfile = platform.posixfile

quotecommand = platform.quotecommand

readpipe = platform.readpipe

rename = platform.rename

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'

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):

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

                         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',

    '%b %d %Y',

    '%b %d',

    '%H:%M:%S',

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

    '%H:%M',

    '%I:%M%p',

)

extendeddateformats = defaultdateformats + (

    "%Y",

    "%Y-%m",

    "%b",

    "%b %Y",

    )

def cachefunc(func):

    '''cache the result of function calls'''

    # XXX doesn't handle keywords args

    if func.func_code.co_argcount == 0:

        cache = []

        def f():

            if len(cache) == 0:

                cache.append(func())

            return cache[0]

        return f

    cache = {}

    if func.func_code.co_argcount == 1:

        # we gain a small amount of time because

        # we don't need to pack/unpack the list

        def f(arg):

            if arg not in cache:

                cache[arg] = func(arg)

            return cache[arg]

    else:

        def f(*args):

            if args not in cache:

                cache[args] = func(*args)

            return cache[args]

    return f

try:

    collections.deque.remove

    deque = collections.deque

except AttributeError:

    # python 2.4 lacks deque.remove

    class deque(collections.deque):

        def remove(self, val):

            for i, v in enumerate(self):

                if v == val:

                    del self[i]

                    break

class sortdict(dict):

    '''a simple sorted dictionary'''

    def __init__(self, data=None):

        self._list = []

        if data:

            self.update(data)

    def copy(self):

        return sortdict(self)

    def __setitem__(self, key, val):

        if key in self:

            self._list.remove(key)

        self._list.append(key)

        dict.__setitem__(self, key, val)

    def __iter__(self):

        return self._list.__iter__()

    def update(self, src):

        for k in src:

            self[k] = src[k]

    def clear(self):

        dict.clear(self)

        self._list = []

    def items(self):

        return [(k, self[k]) for k in self._list]

    def __delitem__(self, key):

        dict.__delitem__(self, key)

        self._list.remove(key)

    def pop(self, key, *args, **kwargs):

        dict.pop(self, key, *args, **kwargs)

        try:

            self._list.remove(key)

        except ValueError:

            pass

    def keys(self):

        return self._list

    def iterkeys(self):

        return self._list.__iter__()

    def iteritems(self):

        for k in self._list:

            yield k, self[k]

    def insert(self, index, key, val):

        self._list.insert(index, key)

        dict.__setitem__(self, key, val)

class lrucachedict(object):

    '''cache most recent gets from or sets to this dictionary'''

    def __init__(self, maxsize):

        self._cache = {}

        self._maxsize = maxsize

        self._order = deque()