"""

util.py - Mercurial utility functions and platform specfic implementations

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

 Copyright 2005, 2006 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, incorporated herein by reference.

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, getpass, popen2, re, shutil, sys, tempfile

import os, threading, time, calendar, ConfigParser, locale, glob

try:

    _encoding = os.environ.get("HGENCODING") or locale.getpreferredencoding() \

                or "ascii"

except locale.Error:

    _encoding = 'ascii'

_encodingmode = os.environ.get("HGENCODINGMODE", "strict")

_fallbackencoding = 'ISO-8859-1'

def tolocal(s):

    """

    Convert a string from internal UTF-8 to local encoding

    All internal strings should be UTF-8 but some repos before the

    implementation of locale support may contain latin1 or possibly

    other character sets. We attempt to decode everything strictly

    using UTF-8, then Latin-1, and failing that, we use UTF-8 and

    replace unknown characters.

    """

    for e in ('UTF-8', _fallbackencoding):

        try:

            u = s.decode(e) # attempt strict decoding

            return u.encode(_encoding, "replace")

        except LookupError, k:

            raise Abort(_("%s, please check your locale settings") % k)

        except UnicodeDecodeError:

            pass

    u = s.decode("utf-8", "replace") # last ditch

    return u.encode(_encoding, "replace")

def fromlocal(s):

    """

    Convert a string from the local character encoding to UTF-8

    We attempt to decode strings using the encoding mode set by

    HG_ENCODINGMODE, which defaults to 'strict'. In this mode, unknown

    characters will cause an error message. Other modes include

    'replace', which replaces unknown characters with a special

    Unicode character, and 'ignore', which drops the character.

    """

    try:

        return s.decode(_encoding, _encodingmode).encode("utf-8")

    except UnicodeDecodeError, inst:

        sub = s[max(0, inst.start-10):inst.start+10]

        raise Abort("decoding near '%s': %s!" % (sub, inst))

    except LookupError, k:

        raise Abort(_("%s, please check your locale settings") % k)

def locallen(s):

    """Find the length in characters of a local string"""

    return len(s.decode(_encoding, "replace"))

def localsub(s, a, b=None):

    try:

        u = s.decode(_encoding, _encodingmode)

        if b is not None:

            u = u[a:b]

        else:

            u = u[:a]

        return u.encode(_encoding, _encodingmode)

    except UnicodeDecodeError, inst:

        sub = s[max(0, inst.start-10), inst.start+10]

        raise Abort(_("decoding near '%s': %s!\n") % (sub, inst))

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

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

    )

class SignalInterrupt(Exception):

    """Exception raised on SIGTERM and SIGHUP."""

# differences from SafeConfigParser:

# - case-sensitive keys

# - allows values that are not strings (this means that you may not

#   be able to save the configuration to a file)

class configparser(ConfigParser.SafeConfigParser):

    def optionxform(self, optionstr):

        return optionstr

    def set(self, section, option, value):

        return ConfigParser.ConfigParser.set(self, section, option, value)

    def _interpolate(self, section, option, rawval, vars):

        if not isinstance(rawval, basestring):

            return rawval

        return ConfigParser.SafeConfigParser._interpolate(self, section,

                                                          option, rawval, vars)

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 pipefilter(s, cmd):

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

    (pout, pin) = popen2.popen2(cmd, -1, 'b')

    def writer():

        try:

            pin.write(s)

            pin.close()

        except IOError, inst:

            if inst.errno != errno.EPIPE:

                raise

    # we should use select instead on UNIX, but this will work on most

    # systems, including Windows

    w = threading.Thread(target=writer)

    w.start()

    f = pout.read()

    pout.close()

    w.join()

    return f

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 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 find_in_path(name, path, default=None):

    '''find name in search path. path can be string (will be split

    with os.pathsep), or iterable thing that returns strings.  if name

    found, return path to name. else return default.'''

    if isinstance(path, str):

        path = path.split(os.pathsep)

    for p in path:

        p_name = os.path.join(p, name)

        if os.path.exists(p_name):

            return p_name

    return default

def binary(s):

    """return true if a string is binary data using diff's heuristic"""

    if s and '\0' in s[:4096]:

        return True

    return False

def unique(g):

    """return the uniq elements of iterable g"""

    seen = {}

    l = []

    for f in g:

        if f not in seen:

            seen[f] = 1

            l.append(f)

    return l

class Abort(Exception):

    """Raised if a command needs to print an error and exit."""

class UnexpectedOutput(Abort):

    """Raised to print an error with part of output and exit."""

def always(fn): return True

def never(fn): return False

def expand_glob(pats):

    '''On Windows, expand the implicit globs in a list of patterns'''

    if os.name != 'nt':

        return list(pats)

    ret = []

    for p in pats:

        kind, name = patkind(p, None)

        if kind is None:

            globbed = glob.glob(name)

            if globbed:

                ret.extend(globbed)

                continue

            # if we couldn't expand the glob, just keep it around

        ret.append(p)

    return ret

def patkind(name, dflt_pat='glob'):

    """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 dflt_pat, name

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

    "convert a glob pattern into a regexp"

    i, n = 0, len(pat)

    res = ''

    group = False

    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 = True

            res += '(?:'

        elif c == '}' and group:

            res += ')'

            group = False

        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(n1, n2):

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

    n1 should use os.sep to separate directories

    n2 should use "/" to separate directories

    returns an os.sep-separated path.

    '''

    if not n1: return localpath(n2)

    a, b = n1.split(os.sep), 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)

def canonpath(root, cwd, myname):

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

    if root == os.sep:

        rootsep = os.sep

    elif root.endswith(os.sep):

        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)

    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)