# 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, util, error

_booleans = {'1': True, 'yes': True, 'true': True, 'on': True,

             '0': False, 'no': False, 'false': False, 'off': False}

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._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:

            # shared read-only environment

            self.environ = os.environ

            # we always trust global config files

            for f in util.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('alias'):

                del cfg['alias'][k]

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

                del cfg['defaults'][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):

        # 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 p and "://" not in p and not os.path.isabs(p):

                    c.set("paths", n, os.path.normpath(os.path.join(root, p)))

        # 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.configbool("ui", "report_untrusted", True)

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

        # update trust information

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

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

    def setconfig(self, section, name, value):

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

            cfg.set(section, name, value)

        self.fixconfig()

    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 configbool(self, section, name, default=False, untrusted=False):

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

        if v is None:

            return default

        if isinstance(v, bool):

            return v

        if v.lower() not in _booleans:

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

                                    % (section, name, v))

        return _booleans[v.lower()]

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

        """Return a list of comma/space separated strings"""

        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 None

            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, str(value).replace('\n', '\\n')

    def plain(self):

        '''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 the `HGPLAIN'

        environment variable.

        '''

        return 'HGPLAIN' in os.environ

    def username(self):

        """Return default username to be used in commits.

        Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL

        and stop searching if one of these is set.

        If not found and ui.askusername is True, ask the user, else use

        ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".

        """

        user = os.environ.get("HGUSER")

        if user is None:

            user = self.config("ui", "username")

            if user is not None:

                user = os.path.expandvars(user)

        if user is None:

            user = os.environ.get("EMAIL")

        if user is None and self.configbool("ui", "askusername"):

            user = self.prompt(_("enter a commit username:"), default=None)

        if user is None and not self.interactive():

            try:

                user = '%s@%s' % (util.getuser(), socket.getfqdn())

                self.warn(_("No username found, using '%s' instead\n") % user)

            except KeyError:

                pass

        if not user:

            raise util.Abort(_('no username supplied (see "hg help config")'))

        if "\n" in user:

            raise util.Abort(_("username %s contains a newline\n") % repr(user))

        return user

    def shortuser(self, user):

        """Return a short representation of a user name or email address."""

        if not self.verbose:

            user = util.shortuser(user)

        return user

    def _path(self, loc):

        p = self.config('paths', loc)

        if p:

            if '%%' in p:

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

                          (loc, p, self.configsource('paths', loc)))

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

            p = util.expandpath(p)

        return p

    def expandpath(self, loc, default=None):

        """Return repository location relative to cwd or from [paths]"""

        if "://" in loc or os.path.isdir(os.path.join(loc, '.hg')):

            return loc

        path = self._path(loc)

        if not path and default is not None:

            path = self._path(default)

        return path or loc

    def pushbuffer(self):

        self._buffers.append([])

    def popbuffer(self, labeled=False):

        '''pop the last buffer and return the buffered output

        If labeled is True, any labels associated with buffered

        output will be handled. By default, this has no effect

        on the output returned, but extensions and GUI tools may

        handle this argument and returned styled output. If output

        is being buffered so it can be captured and parsed or

        processed, labeled should not be set to True.

        '''

        return "".join(self._buffers.pop())

    def write(self, *args, **opts):

        '''write args to output

        By default, this method simply writes to the buffer or stdout,

        but extensions or GUI tools may override this method,

        write_err(), popbuffer(), and label() to style output from

        various parts of hg.

        An optional keyword argument, "label", can be passed in.