# ui.py - user interface bits for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from i18n import _

import errno, getpass, os, socket, sys, tempfile, traceback

import config, scmutil, util, error, formatter

from node import hex

samplehgrcs = {

    'user':

"""# example user config (see "hg help config" for more info)

[ui]

# name and email, e.g.

# username = Jane Doe <jdoe@example.com>

username =

[extensions]

# uncomment these lines to enable some popular extensions

# (see "hg help extensions" for more info)

#

# pager =

# progress =

# color =""",

    'cloned':

"""# example repository config (see "hg help config" for more info)

[paths]

default = %s

# path aliases to other clones of this repo in URLs or filesystem paths

# (see "hg help config.paths" for more info)

#

# default-push = ssh://jdoe@example.net/hg/jdoes-fork

# my-fork      = ssh://jdoe@example.net/hg/jdoes-fork

# my-clone     = /home/jdoe/jdoes-clone

[ui]

# name and email (local to this repository, optional), e.g.

# username = Jane Doe <jdoe@example.com>

""",

    'local':

"""# example repository config (see "hg help config" for more info)

[paths]

# path aliases to other clones of this repo in URLs or filesystem paths

# (see "hg help config.paths" for more info)

#

# default      = http://example.com/hg/example-repo

# default-push = ssh://jdoe@example.net/hg/jdoes-fork

# my-fork      = ssh://jdoe@example.net/hg/jdoes-fork

# my-clone     = /home/jdoe/jdoes-clone

[ui]

# name and email (local to this repository, optional), e.g.

# username = Jane Doe <jdoe@example.com>

""",

    'global':

"""# example system-wide hg config (see "hg help config" for more info)

[extensions]

# uncomment these lines to enable some popular extensions

# (see "hg help extensions" for more info)

#

# blackbox =

# progress =

# color =

# pager =""",

}

class ui(object):

    def __init__(self, src=None):

        # _buffers: used for temporary capture of output

        self._buffers = []

        # _bufferstates: Should the temporary capture includes stderr

        self._bufferstates = []

        self.quiet = self.verbose = self.debugflag = self.tracebackflag = False

        self._reportuntrusted = True

        self._ocfg = config.config() # overlay

        self._tcfg = config.config() # trusted

        self._ucfg = config.config() # untrusted

        self._trustusers = set()

        self._trustgroups = set()

        self.callhooks = True

        if src:

            self.fout = src.fout

            self.ferr = src.ferr

            self.fin = src.fin

            self._tcfg = src._tcfg.copy()

            self._ucfg = src._ucfg.copy()

            self._ocfg = src._ocfg.copy()

            self._trustusers = src._trustusers.copy()

            self._trustgroups = src._trustgroups.copy()

            self.environ = src.environ

            self.callhooks = src.callhooks

            self.fixconfig()

        else:

            self.fout = sys.stdout

            self.ferr = sys.stderr

            self.fin = sys.stdin

            # shared read-only environment

            self.environ = os.environ

            # we always trust global config files

            for f in scmutil.rcpath():

                self.readconfig(f, trust=True)

    def copy(self):

        return self.__class__(self)

    def formatter(self, topic, opts):

        return formatter.formatter(self, topic, opts)

    def _trusted(self, fp, f):

        st = util.fstat(fp)

        if util.isowner(st):

            return True

        tusers, tgroups = self._trustusers, self._trustgroups

        if '*' in tusers or '*' in tgroups:

            return True

        user = util.username(st.st_uid)

        group = util.groupname(st.st_gid)

        if user in tusers or group in tgroups or user == util.username():

            return True

        if self._reportuntrusted:

            self.warn(_('not trusting file %s from untrusted '

                        'user %s, group %s\n') % (f, user, group))

        return False

    def readconfig(self, filename, root=None, trust=False,

                   sections=None, remap=None):

        try:

            fp = open(filename)

        except IOError:

            if not sections: # ignore unless we were looking for something

                return

            raise

        cfg = config.config()

        trusted = sections or trust or self._trusted(fp, filename)

        try:

            cfg.read(filename, fp, sections=sections, remap=remap)

            fp.close()

        except error.ConfigError, inst:

            if trusted:

                raise

            self.warn(_("ignored: %s\n") % str(inst))

        if self.plain():

            for k in ('debug', 'fallbackencoding', 'quiet', 'slash',

                      'logtemplate', 'style',

                      'traceback', 'verbose'):

                if k in cfg['ui']:

                    del cfg['ui'][k]

            for k, v in cfg.items('defaults'):

                del cfg['defaults'][k]

        # Don't remove aliases from the configuration if in the exceptionlist

        if self.plain('alias'):

            for k, v in cfg.items('alias'):

                del cfg['alias'][k]

        if trusted:

            self._tcfg.update(cfg)

            self._tcfg.update(self._ocfg)

        self._ucfg.update(cfg)

        self._ucfg.update(self._ocfg)

        if root is None:

            root = os.path.expanduser('~')

        self.fixconfig(root=root)

    def fixconfig(self, root=None, section=None):

        if section in (None, 'paths'):

            # expand vars and ~

            # translate paths relative to root (or home) into absolute paths

            root = root or os.getcwd()

            for c in self._tcfg, self._ucfg, self._ocfg:

                for n, p in c.items('paths'):

                    if not p:

                        continue

                    if '%%' in p:

                        self.warn(_("(deprecated '%%' in path %s=%s from %s)\n")

                                  % (n, p, self.configsource('paths', n)))

                        p = p.replace('%%', '%')

                    p = util.expandpath(p)

                    if not util.hasscheme(p) and not os.path.isabs(p):

                        p = os.path.normpath(os.path.join(root, p))

                    c.set("paths", n, p)

        if section in (None, 'ui'):

            # update ui options

            self.debugflag = self.configbool('ui', 'debug')

            self.verbose = self.debugflag or self.configbool('ui', 'verbose')

            self.quiet = not self.debugflag and self.configbool('ui', 'quiet')

            if self.verbose and self.quiet:

                self.quiet = self.verbose = False

            self._reportuntrusted = self.debugflag or self.configbool("ui",

                "report_untrusted", True)

            self.tracebackflag = self.configbool('ui', 'traceback', False)

        if section in (None, 'trusted'):

            # update trust information

            self._trustusers.update(self.configlist('trusted', 'users'))

            self._trustgroups.update(self.configlist('trusted', 'groups'))

    def backupconfig(self, section, item):

        return (self._ocfg.backup(section, item),

                self._tcfg.backup(section, item),

                self._ucfg.backup(section, item),)

    def restoreconfig(self, data):

        self._ocfg.restore(data[0])

        self._tcfg.restore(data[1])

        self._ucfg.restore(data[2])

    def setconfig(self, section, name, value, source=''):

        for cfg in (self._ocfg, self._tcfg, self._ucfg):

            cfg.set(section, name, value, source)

        self.fixconfig(section=section)

    def _data(self, untrusted):

        return untrusted and self._ucfg or self._tcfg

    def configsource(self, section, name, untrusted=False):

        return self._data(untrusted).source(section, name) or 'none'

    def config(self, section, name, default=None, untrusted=False):

        if isinstance(name, list):

            alternates = name

        else:

            alternates = [name]

        for n in alternates:

            value = self._data(untrusted).get(section, n, None)

            if value is not None:

                name = n

                break

        else:

            value = default

        if self.debugflag and not untrusted and self._reportuntrusted:

            for n in alternates:

                uvalue = self._ucfg.get(section, n)

                if uvalue is not None and uvalue != value:

                    self.debug("ignoring untrusted configuration option "

                               "%s.%s = %s\n" % (section, n, uvalue))

        return value

    def configpath(self, section, name, default=None, untrusted=False):

        'get a path config item, expanded relative to repo root or config file'

        v = self.config(section, name, default, untrusted)

        if v is None:

            return None

        if not os.path.isabs(v) or "://" not in v:

            src = self.configsource(section, name, untrusted)

            if ':' in src:

                base = os.path.dirname(src.rsplit(':')[0])

                v = os.path.join(base, os.path.expanduser(v))

        return v

    def configbool(self, section, name, default=False, untrusted=False):

        """parse a configuration element as a boolean

        >>> u = ui(); s = 'foo'

        >>> u.setconfig(s, 'true', 'yes')

        >>> u.configbool(s, 'true')

        True

        >>> u.setconfig(s, 'false', 'no')

        >>> u.configbool(s, 'false')

        False

        >>> u.configbool(s, 'unknown')

        False

        >>> u.configbool(s, 'unknown', True)

        True

        >>> u.setconfig(s, 'invalid', 'somevalue')

        >>> u.configbool(s, 'invalid')

        Traceback (most recent call last):

            ...

        ConfigError: foo.invalid is not a boolean ('somevalue')

        """

        v = self.config(section, name, None, untrusted)

        if v is None:

            return default

        if isinstance(v, bool):

            return v

        b = util.parsebool(v)

        if b is None:

            raise error.ConfigError(_("%s.%s is not a boolean ('%s')")

                                    % (section, name, v))

        return b

    def configint(self, section, name, default=None, untrusted=False):

        """parse a configuration element as an integer

        >>> u = ui(); s = 'foo'

        >>> u.setconfig(s, 'int1', '42')

        >>> u.configint(s, 'int1')

        42

        >>> u.setconfig(s, 'int2', '-42')

        >>> u.configint(s, 'int2')

        -42

        >>> u.configint(s, 'unknown', 7)

        7

        >>> u.setconfig(s, 'invalid', 'somevalue')

        >>> u.configint(s, 'invalid')

        Traceback (most recent call last):

            ...

        ConfigError: foo.invalid is not an integer ('somevalue')

        """

        v = self.config(section, name, None, untrusted)

        if v is None:

            return default

        try:

            return int(v)

        except ValueError:

            raise error.ConfigError(_("%s.%s is not an integer ('%s')")

                                    % (section, name, v))

    def configbytes(self, section, name, default=0, untrusted=False):

        """parse a configuration element as a quantity in bytes

        Units can be specified as b (bytes), k or kb (kilobytes), m or

        mb (megabytes), g or gb (gigabytes).

        >>> u = ui(); s = 'foo'

        >>> u.setconfig(s, 'val1', '42')

        >>> u.configbytes(s, 'val1')

        42

        >>> u.setconfig(s, 'val2', '42.5 kb')

        >>> u.configbytes(s, 'val2')

        43520

        >>> u.configbytes(s, 'unknown', '7 MB')

        7340032

        >>> u.setconfig(s, 'invalid', 'somevalue')

        >>> u.configbytes(s, 'invalid')

        Traceback (most recent call last):

            ...

        ConfigError: foo.invalid is not a byte quantity ('somevalue')

        """

        value = self.config(section, name)

        if value is None:

            if not isinstance(default, str):

                return default

            value = default

        try:

            return util.sizetoint(value)

        except error.ParseError:

            raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')")

                                    % (section, name, value))

    def configlist(self, section, name, default=None, untrusted=False):

        """parse a configuration element as a list of comma/space separated

        strings

        >>> u = ui(); s = 'foo'

        >>> u.setconfig(s, 'list1', 'this,is "a small" ,test')

        >>> u.configlist(s, 'list1')

        ['this', 'is', 'a small', 'test']

        """

        def _parse_plain(parts, s, offset):

            whitespace = False

            while offset < len(s) and (s[offset].isspace() or s[offset] == ','):