"""

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, 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 os, stat, threading, time, calendar, ConfigParser, locale, glob, osutil

import imp, unicodedata

# Python compatibility

try:

    set = set

    frozenset = frozenset

except NameError:

    from sets import Set as set, ImmutableSet as frozenset

_md5 = None

def md5(s):

    global _md5

    if _md5 is None:

        try:

            import hashlib

            _md5 = hashlib.md5

        except ImportError:

            import md5

            _md5 = md5.md5

    return _md5(s)

_sha1 = None

def sha1(s):

    global _sha1

    if _sha1 is None:

        try:

            import hashlib

            _sha1 = hashlib.sha1

        except ImportError:

            import sha

            _sha1 = sha.sha

    return _sha1(s)

try:

    import subprocess

    subprocess.Popen  # trigger ImportError early

    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 Popen3(cmd, capturestderr=False, bufsize=-1):

        stderr = capturestderr and subprocess.PIPE or None

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

                             close_fds=closefds,

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

                             stderr=stderr)

        p.fromchild = p.stdout

        p.tochild = p.stdin

        p.childerr = p.stderr

        return p

except ImportError:

    subprocess = None

    from popen2 import Popen3

    popen2 = os.popen2

    popen3 = os.popen3

_encodingfixup = {'646': 'ascii', 'ANSI_X3.4-1968': 'ascii'}

try:

    _encoding = os.environ.get("HGENCODING")

    if sys.platform == 'darwin' and not _encoding:

        # On darwin, getpreferredencoding ignores the locale environment and

        # always returns mac-roman. We override this if the environment is

        # not C (has been customized by the user).

        locale.setlocale(locale.LC_CTYPE, '')

        _encoding = locale.getlocale()[1]

    if not _encoding:

        _encoding = locale.getpreferredencoding() or 'ascii'

        _encoding = _encodingfixup.get(_encoding, _encoding)

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

    HGENCODINGMODE, 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 colwidth(s):

    "Find the column width of a UTF-8 string for display"

    d = s.decode(_encoding, 'replace')

    if hasattr(unicodedata, 'east_asian_width'):

        w = unicodedata.east_asian_width

        return sum([w(c) in 'WF' and 2 or 1 for c in d])

    return len(d)

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

    )

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

    (pin, pout) = popen2(cmd, '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 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"""

    if s and '\0' in s:

        return True

    return False

def unique(g):

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

    return dict.fromkeys(g).keys()

def sort(l):

    if not isinstance(l, list):

        l = list(l)

    l.sort()

    return l

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)

class Abort(Exception):

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

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