# util.py - Mercurial utility functions and platform specfic 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 specfic implementations.

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

hide platform-specific details from the core.

"""

from i18n import _

import error, osutil, encoding

import errno, re, shutil, sys, tempfile, traceback

import os, time, calendar, textwrap, unicodedata, signal

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

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

nulldev = platform.nulldev

openhardlinks = platform.openhardlinks

oslink = platform.oslink

parsepatchoutput = platform.parsepatchoutput

pconvert = platform.pconvert

popen = platform.popen

posixfile = platform.posixfile

quotecommand = platform.quotecommand

realpath = platform.realpath

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

sshargs = platform.sshargs

statfiles = platform.statfiles

termwidth = platform.termwidth

testpid = platform.testpid

umask = platform.umask

unlink = platform.unlink

unlinkpath = platform.unlinkpath

username = platform.username

# Python compatibility

def sha1(s):

    return _fastsha1(s)

_notset = object()

def safehasattr(thing, attr):

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

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)

import __builtin__

if sys.version_info[0] < 3:

    def fakebuffer(sliceable, offset=0):

        return sliceable[offset:]

else:

    def fakebuffer(sliceable, offset=0):

        return memoryview(sliceable)[offset:]

try:

    buffer

except NameError:

    __builtin__.buffer = fakebuffer

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

    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

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

    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

def lrucachefunc(func):

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

    cache = {}

    order = []

    if func.func_code.co_argcount == 1:

        def f(arg):

            if arg not in cache:

                if len(cache) > 20:

                    del cache[order.pop(0)]

                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.pop(0)]

                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)

        setattr(obj, self.name, result)

        return result

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

_hgexecutable = None

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

def hgexecutable():

    """return location of the 'hg' executable.

    Defaults to $HG or 'hg' in the search path.

    """

    if _hgexecutable is None:

        hg = os.environ.get('HG')

        if hg:

            _sethgexecutable(hg)

        elif mainfrozen():

            _sethgexecutable(sys.executable)

        else:

            exe = findexe('hg') or os.path.basename(sys.argv[0])

            _sethgexecutable(exe)

    return _hgexecutable

def _sethgexecutable(path):