# 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

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 _is_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._is_trusted(fp, filename)

        try:

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

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

        value = self._data(untrusted).get(section, name, 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 config file'

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

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

                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)

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

        items = self._data(untrusted).items(section)

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

            for k, v in self._ucfg.items(section):

                if self._tcfg.get(section, k) != v:

                    self.debug("ignoring untrusted configuration option "

                               "%s.%s = %s\n" % (section, k, v))

        return items

    def walkconfig(self, untrusted=False):

        cfg = self._data(untrusted)

        for section in cfg.sections():

            for name, value in self.configitems(section, untrusted):

                yield section, name, value

    def plain(self, feature=None):

        '''is plain mode active?

        Plain mode means that all configuration variables which affect

        the behavior and output of Mercurial should be

        ignored. Additionally, the output should be stable,

        reproducible and suitable for use in scripts or applications.

        The only way to trigger plain mode is by setting either the

        `HGPLAIN' or `HGPLAINEXCEPT' environment variables.