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

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__()

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

    def __getitem__(self, key):

        value = self._cache[key]

        self._order.remove(key)

        self._order.append(key)

        return value

    def __setitem__(self, key, value):

        if key not in self._cache:

            if len(self._cache) >= self._maxsize:

                del self._cache[self._order.popleft()]

        else:

            self._order.remove(key)

        self._cache[key] = value

        self._order.append(key)

    def __contains__(self, key):

        return key in self._cache

    def clear(self):

        self._cache.clear()

        self._order = deque()

def lrucachefunc(func):

    '''cache most recent results of function calls'''

    cache = {}

    order = deque()

    if func.func_code.co_argcount == 1:

        def f(arg):

            if arg not in cache:

                if len(cache) > 20:

                    del cache[order.popleft()]

                cache[arg] = func(arg)

            else:

                order.remove(arg)

            order.append(arg)

            return cache[arg]

    else:

        def f(*args):

            if args not in cache:

                if len(cache) > 20:

                    del cache[order.popleft()]

                cache[args] = func(*args)

            else:

                order.remove(args)

            order.append(args)

            return cache[args]

    return f

class propertycache(object):

    def __init__(self, func):

        self.func = func

        self.name = func.__name__

    def __get__(self, obj, type=None):

        result = self.func(obj)

        self.cachevalue(obj, result)

        return result

    def cachevalue(self, obj, value):

        # __dict__ assignment required to bypass __setattr__ (eg: repoview)

        obj.__dict__[self.name] = value

def pipefilter(s, cmd):

    '''filter string S through command CMD, returning its output'''

    p = subprocess.Popen(cmd, shell=True, close_fds=closefds,

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

    pout, perr = p.communicate(s)

    return pout

def tempfilter(s, cmd):

    '''filter string S through a pair of temporary files with CMD.

    CMD is used as a template to create the real command to be run,

    with the strings INFILE and OUTFILE replaced by the real names of

    the temporary files generated.'''

    inname, outname = None, None

    try:

        infd, inname = tempfile.mkstemp(prefix='hg-filter-in-')

        fp = os.fdopen(infd, 'wb')

        fp.write(s)

        fp.close()

        outfd, outname = tempfile.mkstemp(prefix='hg-filter-out-')

        os.close(outfd)

        cmd = cmd.replace('INFILE', inname)

        cmd = cmd.replace('OUTFILE', outname)

        code = os.system(cmd)

        if sys.platform == 'OpenVMS' and code & 1:

            code = 0

        if code:

            raise Abort(_("command '%s' failed: %s") %

                        (cmd, explainexit(code)))

        fp = open(outname, 'rb')

        r = fp.read()

        fp.close()

        return r

    finally:

        try:

            if inname:

                os.unlink(inname)

        except OSError:

            pass

        try:

            if outname:

                os.unlink(outname)

        except OSError:

            pass

filtertable = {

    'tempfile:': tempfilter,

    'pipe:': pipefilter,

    }

def filter(s, cmd):

    "filter a string through a command that transforms its input to its output"

    for name, fn in filtertable.iteritems():

        if cmd.startswith(name):

            return fn(s, cmd[len(name):].lstrip())

    return pipefilter(s, cmd)

def binary(s):

    """return true if a string is binary data"""

    return bool(s and '\0' in s)

def increasingchunks(source, min=1024, max=65536):

    '''return no less than min bytes per chunk while data remains,

    doubling min after each chunk until it reaches max'''

    def log2(x):

        if not x:

            return 0

        i = 0

        while x:

            x >>= 1

            i += 1

        return i - 1

    buf = []

    blen = 0

    for chunk in source:

        buf.append(chunk)

        blen += len(chunk)

        if blen >= min:

            if min < max:

                min = min << 1

                nmin = 1 << log2(blen)

                if nmin > min:

                    min = nmin

                if min > max:

                    min = max

            yield ''.join(buf)

            blen = 0

            buf = []

    if buf:

        yield ''.join(buf)

Abort = error.Abort

def always(fn):

    return True

def never(fn):

    return False

def pathto(root, n1, n2):

    '''return the relative path from one place to another.

    root should use os.sep to separate directories

    n1 should use os.sep to separate directories

    n2 should use "/" to separate directories

    returns an os.sep-separated path.

    If n1 is a relative path, it's assumed it's

    relative to root.

    n2 should always be relative to root.

    '''

    if not n1:

        return localpath(n2)

    if os.path.isabs(n1):

        if os.path.splitdrive(root)[0] != os.path.splitdrive(n1)[0]:

            return os.path.join(root, localpath(n2))

        n2 = '/'.join((pconvert(root), n2))

    a, b = splitpath(n1), n2.split('/')

    a.reverse()

    b.reverse()

    while a and b and a[-1] == b[-1]:

        a.pop()

        b.pop()

    b.reverse()

    return os.sep.join((['..'] * len(a)) + b) or '.'

def mainfrozen():

    """return True if we are a frozen executable.

    The code supports py2exe (most common, Windows only) and tools/freeze

    (portable, not much used).

    """

    return (safehasattr(sys, "frozen") or # new py2exe

            safehasattr(sys, "importers") or # old py2exe

            imp.is_frozen("__main__")) # tools/freeze

# the location of data files matching the source code

if mainfrozen():

    # executable version (py2exe) doesn't support __file__

    datapath = os.path.dirname(sys.executable)

else:

    datapath = os.path.dirname(__file__)