# 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

class ui(object):

    def __init__(self, src=None):

        self._buffers = []

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

        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.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, overlay=True):

        if overlay:

            self._ocfg.set(section, name, value)

        self._tcfg.set(section, name, value)

        self._ucfg.set(section, name, value)

        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, name, None)

            if value is not None:

                name = n

                break

        else:

            value = default

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

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

            if uvalue is not None and uvalue != value:

                self.debug("ignoring untrusted configuration option "

                           "%s.%s = %s\n" % (section, name, 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 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] == ','):

                whitespace = True

                offset += 1

            if offset >= len(s):

                return None, parts, offset

            if whitespace:

                parts.append('')

            if s[offset] == '"' and not parts[-1]:

                return _parse_quote, parts, offset + 1

            elif s[offset] == '"' and parts[-1][-1] == '\\':

                parts[-1] = parts[-1][:-1] + s[offset]

                return _parse_plain, parts, offset + 1

            parts[-1] += s[offset]

            return _parse_plain, parts, offset + 1

        def _parse_quote(parts, s, offset):

            if offset < len(s) and s[offset] == '"': # ""

                parts.append('')

                offset += 1

                while offset < len(s) and (s[offset].isspace() or

                        s[offset] == ','):

                    offset += 1

                return _parse_plain, parts, offset

            while offset < len(s) and s[offset] != '"':

                if (s[offset] == '\\' and offset + 1 < len(s)

                        and s[offset + 1] == '"'):

                    offset += 1

                    parts[-1] += '"'

                else:

                    parts[-1] += s[offset]

                offset += 1

            if offset >= len(s):

                real_parts = _configlist(parts[-1])

                if not real_parts:

                    parts[-1] = '"'

                else:

                    real_parts[0] = '"' + real_parts[0]

                    parts = parts[:-1]

                    parts.extend(real_parts)

                return None, parts, offset

            offset += 1

            while offset < len(s) and s[offset] in [' ', ',']:

                offset += 1

            if offset < len(s):

                if offset + 1 == len(s) and s[offset] == '"':

                    parts[-1] += '"'

                    offset += 1

                else:

                    parts.append('')

            else:

                return None, parts, offset

            return _parse_plain, parts, offset

        def _configlist(s):

            s = s.rstrip(' ,')

            if not s:

                return []

            parser, parts, offset = _parse_plain, [''], 0

            while parser:

                parser, parts, offset = parser(parts, s, offset)

            return parts

        result = self.config(section, name, untrusted=untrusted)

        if result is None:

            result = default or []

        if isinstance(result, basestring):

            result = _configlist(result.lstrip(' ,\n'))

            if result is None:

                result = default or []

        return result

    def has_section(self, section, untrusted=False):

        '''tell whether section exists in config.'''

        return section in self._data(untrusted)