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

import contextlib

import errno

import getpass

import inspect

import os

import re

import signal

import socket

import subprocess

import sys

import tempfile

import traceback

from .i18n import _

from .node import hex

from . import (

    color,

    config,

    encoding,

    error,

    formatter,

    progress,

    pycompat,

    rcutil,

    scmutil,

    util,

)

urlreq = util.urlreq

# for use with str.translate(None, _keepalnum), to keep just alphanumerics

_keepalnum = ''.join(c for c in map(pycompat.bytechr, range(256))

                     if not c.isalnum())

# The config knobs that will be altered (if unset) by ui.tweakdefaults.

tweakrc = """

[ui]

# The rollback command is dangerous. As a rule, don't use it.

rollback = False

[commands]

# Make `hg status` emit cwd-relative paths by default.

status.relative = yes

[diff]

git = 1

"""

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 =

# uncomment to disable color in command output

# (see 'hg help color' for details)

# color = never

# uncomment to disable command output pagination

# (see 'hg help pager' for details)

# paginate = never

[extensions]

# uncomment these lines to enable some popular extensions

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

#

# churn =

""",

    '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:pushurl = 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:pushurl = 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)

[ui]

# uncomment to disable color in command output

# (see 'hg help color' for details)

# color = never

# uncomment to disable command output pagination

# (see 'hg help pager' for details)

# paginate = never

[extensions]

# uncomment these lines to enable some popular extensions

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

#

# blackbox =

# churn =

""",

}

class httppasswordmgrdbproxy(object):

    """Delays loading urllib2 until it's needed."""

    def __init__(self):

        self._mgr = None

    def _get_mgr(self):

        if self._mgr is None:

            self._mgr = urlreq.httppasswordmgrwithdefaultrealm()

        return self._mgr

    def add_password(self, *args, **kwargs):

        return self._get_mgr().add_password(*args, **kwargs)

    def find_user_password(self, *args, **kwargs):

        return self._get_mgr().find_user_password(*args, **kwargs)

def _catchterm(*args):

    raise error.SignalInterrupt

class ui(object):

    def __init__(self, src=None):

        """Create a fresh new ui object if no src given

        Use uimod.ui.load() to create a ui which knows global and user configs.

        In most cases, you should use ui.copy() to create a copy of an existing

        ui object.

        """

        # _buffers: used for temporary capture of output

        self._buffers = []

        # _exithandlers: callbacks run at the end of a request

        self._exithandlers = []

        # 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

        # Insecure server connections requested.

        self.insecureconnections = False

        # Blocked time

        self.logblockedtimes = False

        # color mode: see mercurial/color.py for possible value

        self._colormode = None

        self._terminfoparams = {}

        self._styles = {}

        if src:

            self._exithandlers = src._exithandlers

            self.fout = src.fout

            self.ferr = src.ferr

            self.fin = src.fin

            self.pageractive = src.pageractive

            self._disablepager = src._disablepager

            self._tweaked = src._tweaked

            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.insecureconnections = src.insecureconnections

            self._colormode = src._colormode

            self._terminfoparams = src._terminfoparams.copy()

            self._styles = src._styles.copy()

            self.fixconfig()

            self.httppasswordmgrdb = src.httppasswordmgrdb

            self._blockedtimes = src._blockedtimes

        else:

            self.fout = util.stdout

            self.ferr = util.stderr

            self.fin = util.stdin

            self.pageractive = False

            self._disablepager = False

            self._tweaked = False

            # shared read-only environment

            self.environ = encoding.environ

            self.httppasswordmgrdb = httppasswordmgrdbproxy()

            self._blockedtimes = collections.defaultdict(int)

        allowed = self.configlist('experimental', 'exportableenviron')

        if '*' in allowed:

            self._exportableenviron = self.environ

        else:

            self._exportableenviron = {}

            for k in allowed:

                if k in self.environ:

                    self._exportableenviron[k] = self.environ[k]

    @classmethod

    def load(cls):

        """Create a ui and load global and user configs"""

        u = cls()

        # we always trust global config files and environment variables

        for t, f in rcutil.rccomponents():

            if t == 'path':

                u.readconfig(f, trust=True)

            elif t == 'items':

                sections = set()

                for section, name, value, source in f:

                    # do not set u._ocfg

                    # XXX clean this up once immutable config object is a thing

                    u._tcfg.set(section, name, value, source)

                    u._ucfg.set(section, name, value, source)

                    sections.add(section)

                for section in sections:

                    u.fixconfig(section=section)

            else:

                raise error.ProgrammingError('unknown rctype: %s' % t)

        u._maybetweakdefaults()

        return u

    def _maybetweakdefaults(self):

        if not self.configbool('ui', 'tweakdefaults'):

            return

        if self._tweaked or self.plain('tweakdefaults'):

            return

        # Note: it is SUPER IMPORTANT that you set self._tweaked to

        # True *before* any calls to setconfig(), otherwise you'll get

        # infinite recursion between setconfig and this method.

        #

        # TODO: We should extract an inner method in setconfig() to

        # avoid this weirdness.

        self._tweaked = True

        tmpcfg = config.config()

        tmpcfg.parse('<tweakdefaults>', tweakrc)

        for section in tmpcfg:

            for name, value in tmpcfg.items(section):

                if not self.hasconfig(section, name):

                    self.setconfig(section, name, value, "<tweakdefaults>")

    def copy(self):

        return self.__class__(self)

    def resetstate(self):

        """Clear internal state that shouldn't persist across commands"""

        if self._progbar:

            self._progbar.resetstate()  # reset last-print time of progress bar

        self.httppasswordmgrdb = httppasswordmgrdbproxy()

    @contextlib.contextmanager

    def timeblockedsection(self, key):

        # this is open-coded below - search for timeblockedsection to find them

        starttime = util.timer()

        try:

            yield

        finally:

            self._blockedtimes[key + '_blocked'] += \

                (util.timer() - starttime) * 1000

    def formatter(self, topic, opts):

        return formatter.formatter(self, 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, u'rb')

        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]

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

                del cfg['commands'][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 pycompat.getcwd()

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

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

                    # Ignore sub-options.

                    if ':' in n: