# 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, incorporated herein by reference.

"""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 cStringIO, errno, re, shutil, sys, tempfile, traceback, error

import os, stat, threading, time, calendar, glob, osutil, random

import imp

# Python compatibility

def sha1(s):

    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.

    try:

        from hashlib import sha1 as _sha1

    except ImportError:

        from sha import sha as _sha1

    return _sha1(s)

import subprocess

closefds = os.name == 'posix'

def popen2(cmd, mode='t', bufsize=-1):

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

                         close_fds=closefds,

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

    return p.stdin, p.stdout

def popen3(cmd, mode='t', bufsize=-1):

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

                         close_fds=closefds,

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

                         stderr=subprocess.PIPE)

    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:%SP',

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

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, explain_exit(code)))

        return open(outname, 'rb').read()

    finally:

        try:

            if inname: os.unlink(inname)

        except: pass

        try:

            if outname: os.unlink(outname)

        except: 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 patkind(name, default):

    """Split a string into an optional pattern kind prefix and the

    actual pattern."""

    for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':

        if name.startswith(prefix + ':'): return name.split(':', 1)

    return default, name

def globre(pat, head='^', tail='$'):

    "convert a glob pattern into a regexp"

    i, n = 0, len(pat)

    res = ''

    group = 0

    def peek(): return i < n and pat[i]

    while i < n:

        c = pat[i]

        i = i+1

        if c == '*':

            if peek() == '*':

                i += 1

                res += '.*'

            else:

                res += '[^/]*'

        elif c == '?':

            res += '.'

        elif c == '[':

            j = i

            if j < n and pat[j] in '!]':

                j += 1

            while j < n and pat[j] != ']':

                j += 1

            if j >= n:

                res += '\\['

            else:

                stuff = pat[i:j].replace('\\','\\\\')

                i = j + 1

                if stuff[0] == '!':

                    stuff = '^' + stuff[1:]

                elif stuff[0] == '^':

                    stuff = '\\' + stuff

                res = '%s[%s]' % (res, stuff)

        elif c == '{':

            group += 1

            res += '(?:'

        elif c == '}' and group:

            res += ')'

            group -= 1

        elif c == ',' and group:

            res += '|'

        elif c == '\\':

            p = peek()

            if p:

                i += 1

                res += re.escape(p)

            else:

                res += re.escape(c)

        else:

            res += re.escape(c)

    return head + res + tail

_globchars = {'[': 1, '{': 1, '*': 1, '?': 1}

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 canonpath(root, cwd, myname):

    """return the canonical path of myname, given cwd and root"""

    if root == os.sep:

        rootsep = os.sep

    elif endswithsep(root):

        rootsep = root

    else:

        rootsep = root + os.sep

    name = myname

    if not os.path.isabs(name):

        name = os.path.join(root, cwd, name)

    name = os.path.normpath(name)

    audit_path = path_auditor(root)

    if name != rootsep and name.startswith(rootsep):

        name = name[len(rootsep):]

        audit_path(name)

        return pconvert(name)

    elif name == root:

        return ''

    else:

        # Determine whether `name' is in the hierarchy at or beneath `root',

        # by iterating name=dirname(name) until that causes no change (can't

        # check name == '/', because that doesn't work on windows).  For each

        # `name', compare dev/inode numbers.  If they match, the list `rel'

        # holds the reversed list of components making up the relative file

        # name we want.

        root_st = os.stat(root)

        rel = []

        while True:

            try:

                name_st = os.stat(name)

            except OSError:

                break

            if samestat(name_st, root_st):

                if not rel:

                    # name was actually the same as root (maybe a symlink)

                    return ''

                rel.reverse()

                name = os.path.join(*rel)

                audit_path(name)

                return pconvert(name)

            dirname, basename = os.path.split(name)

            rel.append(basename)

            if dirname == name:

                break

            name = dirname

        raise Abort('%s not under root' % myname)

def matcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None, dflt_pat='glob'):

    """build a function to match a set of file patterns

    arguments:

    canonroot - the canonical root of the tree you're matching against

    cwd - the current working directory, if relevant

    names - patterns to find

    inc - patterns to include

    exc - patterns to exclude

    dflt_pat - if a pattern in names has no explicit type, assume this one

    src - where these patterns came from (e.g. .hgignore)

    a pattern is one of:

    'glob:<glob>' - a glob relative to cwd

    're:<regexp>' - a regular expression

    'path:<path>' - a path relative to canonroot

    'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs)

    'relpath:<path>' - a path relative to cwd

    'relre:<regexp>' - a regexp that doesn't have to match the start of a name

    '<something>' - one of the cases above, selected by the dflt_pat argument

    returns:

    a 3-tuple containing

    - list of roots (places where one should start a recursive walk of the fs);

      this often matches the explicit non-pattern names passed in, but also

      includes the initial part of glob: patterns that has no glob characters

    - a bool match(filename) function

    - a bool indicating if any patterns were passed in

    """

    # a common case: no patterns at all

    if not names and not inc and not exc:

        return [], always, False

    def contains_glob(name):