# 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 __future__ import absolute_import

import errno

import getpass

import inspect

import os

import re

import socket

import sys

import tempfile

import traceback

from .i18n import _

from .node import hex

from . import (

    config,

    error,

    formatter,

    progress,

    scmutil,

    util,

)

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 =

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

# color =

# pager =""",

}

class ui(object):

    def __init__(self, src=None):

        # _buffers: used for temporary capture of output

        self._buffers = []

        # 3-tuple describing how each buffer in the stack behaves.

        # Values are (capture stderr, capture subprocesses, apply labels).

        self._bufferstates = []

        # When a buffer is active, defines whether we are expanding labels.

        # This exists to prevent an extra list lookup.

        self._bufferapplylabels = None

        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 as inst:

            if trusted:

                raise

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

        if self.plain():

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

                      'logtemplate', 'statuscopies', '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 self.plain('revsetalias'):

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

                del cfg['revsetalias'][k]

        if self.plain('templatealias'):

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

                del cfg['templatealias'][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 configsuboptions(self, section, name, default=None, untrusted=False):

        """Get a config option and all sub-options.

        Some config options have sub-options that are declared with the

        format "key:opt = value". This method is used to return the main

        option and all its declared sub-options.

        Returns a 2-tuple of ``(option, sub-options)``, where `sub-options``

        is a dict of defined sub-options where keys and values are strings.

        """

        data = self._data(untrusted)

        main = data.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 != main:

                self.debug('ignoring untrusted configuration option '

                           '%s.%s = %s\n' % (section, name, uvalue))

        sub = {}

        prefix = '%s:' % name

        for k, v in data.items(section):

            if k.startswith(prefix):

                sub[k[len(prefix):]] = v

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

            for k, v in sub.items():

                uvalue = self._ucfg.get(section, '%s:%s' % (name, k))

                if uvalue is not None and uvalue != v:

                    self.debug('ignoring untrusted configuration option '

                               '%s:%s.%s = %s\n' % (section, name, k, uvalue))

        return main, sub

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