# This is the mercurial setup script.

import ctypes

import logging

import os

import re

import shutil

import ssl

import stat

import subprocess

import sys

import sysconfig

import tempfile

import time

if not ssl.HAS_TLSv1_2:

    error = """

The `ssl` module does not advertise support for TLS 1.2.

Please make sure that your Python installation was compiled against an OpenSSL

version enabling these features (likely this requires the OpenSSL version to

be at least 1.0.1).

"""

    print(error, file=sys.stderr)

    sys.exit(1)

DYLIB_SUFFIX = sysconfig.get_config_vars()['EXT_SUFFIX']

# Solaris Python packaging brain damage

try:

    import hashlib

    sha = hashlib.sha1()

except ImportError:

    try:

        import sha

        del sha  # silence unused import warning

    except ImportError:

        raise SystemExit(

            "Couldn't import standard hashlib (incomplete Python install)."

        )

try:

    import zlib

    del zlib  # silence unused import warning

except ImportError:

    raise SystemExit(

        "Couldn't import standard zlib (incomplete Python install)."

    )

try:

    import bz2

    del bz2  # silence unused import warning

except ImportError:

    raise SystemExit(

        "Couldn't import standard bz2 (incomplete Python install)."

    )

from distutils.command.build_scripts import build_scripts

from distutils.spawn import spawn

from distutils import file_util

from distutils.sysconfig import get_python_inc

def sysstr(s):

    return s.decode('latin-1')

def eprint(*args, **kwargs):

    kwargs['file'] = sys.stderr

    print(*args, **kwargs)

def write_if_changed(path, content):

    """Write content to a file iff the content hasn't changed."""

    if os.path.exists(path):

        with open(path, 'rb') as fh:

            current = fh.read()

    else:

        current = b''

    if current != content:

        with open(path, 'wb') as fh:

            fh.write(content)

scripts = ['hg']

if os.name == 'nt':

    # We remove hg.bat if we are able to build hg.exe.

    scripts.append('contrib/win32/hg.bat')

def cancompile(cc, code):

    tmpdir = tempfile.mkdtemp(prefix='hg-install-')

    oldstderr = None

    try:

        fname = os.path.join(tmpdir, 'testcomp.c')

        with open(fname, 'w') as file:

            file.write(code)

        oldstderr = os.dup(sys.stderr.fileno())

        # Redirect stderr to /dev/null to hide any error messages

        # from the compiler.

        # This will have to be changed if we ever have to check

        # for a function on Windows.

        with open('/dev/null', 'w') as devnull:

            os.dup2(devnull.fileno(), sys.stderr.fileno())

        objects = cc.compile([fname], output_dir=tmpdir)

        cc.link_executable(objects, os.path.join(tmpdir, "a.out"))

        return True

    except Exception:

        return False

    finally:

        if oldstderr is not None:

            os.dup2(oldstderr, sys.stderr.fileno())

        shutil.rmtree(tmpdir)

# simplified version of distutils.ccompiler.CCompiler.has_function

# that actually removes its temporary files.

def hasfunction(cc, funcname):

    code = 'int main(void) { %s(); }\n' % funcname

    return cancompile(cc, code)

def hasheader(cc, headername):

    code = '#include <%s>\nint main(void) { return 0; }\n' % headername

    return cancompile(cc, code)

# py2exe needs to be installed to work

try:

    import py2exe

    py2exe.patch_distutils()

    py2exeloaded = True

    # import py2exe's patched Distribution class

    from distutils.core import Distribution

except ImportError:

    py2exeloaded = False

def runcmd(cmd, env, cwd=None):

    p = subprocess.Popen(

        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd

    )

    out, err = p.communicate()

    return p.returncode, out, err

class hgcommand:

    def __init__(self, cmd, env):

        self.cmd = cmd

        self.env = env

    def __repr__(self):

        return f"<hgcommand cmd={self.cmd} env={self.env}>"

    def run(self, args):

        cmd = self.cmd + args

        returncode, out, err = runcmd(cmd, self.env)

        err = filterhgerr(err)

        if err:

            print("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)

            print(err, file=sys.stderr)

        if returncode != 0:

            print(

                "non zero-return '%s': %d" % (' '.join(cmd), returncode),

                file=sys.stderr,

            )

            return b''

        return out

def filterhgerr(err):

    # If root is executing setup.py, but the repository is owned by

    # another user (as in "sudo python setup.py install") we will get

    # trust warnings since the .hg/hgrc file is untrusted. That is

    # fine, we don't want to load it anyway.  Python may warn about

    # a missing __init__.py in mercurial/locale, we also ignore that.

    err = [

        e

        for e in err.splitlines()

        if (

            not e.startswith(b'not trusting file')

            and not e.startswith(b'warning: Not importing')

            and not (

                e.startswith(b'obsolete feature not enabled')

                or e.startswith(b'"obsolete" feature not enabled')

            )

            and not e.startswith(b'*** failed to import extension')

            and not e.startswith(b'devel-warn:')

            and not (

                e.startswith(b'(third party extension')

                and e.endswith(b'or newer of Mercurial; disabling)')

            )

        )

    ]

    return b'\n'.join(b'  ' + e for e in err)

def findhg():

    """Try to figure out how we should invoke hg for examining the local

    repository contents.

    Returns an hgcommand object."""

    # By default, prefer the "hg" command in the user's path.  This was

    # presumably the hg command that the user used to create this repository.

    #

    # This repository may require extensions or other settings that would not

    # be enabled by running the hg script directly from this local repository.

    hgenv = os.environ.copy()

    # Use HGPLAIN to disable hgrc settings that would change output formatting,

    # and disable localization for the same reasons.

    hgenv['HGPLAIN'] = '1'

    hgenv['LANGUAGE'] = 'C'

    # PYTHONPATH and co can be used for isolated builds, which can break hg

    hgenv.pop("PYTHONNOUSERSITE", None)

    if "PYTHONPATH" in hgenv:

        hgenv["PYTHONPATH"] = os.pathsep.join(

            [

                path

                for path in hgenv["PYTHONPATH"].split(os.pathsep)

                if "-build-env-" not in path

            ]

        )

    hgcmd = ['hg']

    # Run a simple "hg log" command just to see if using hg from the user's

    # path works and can successfully interact with this repository.  Windows

    # gives precedence to hg.exe in the current directory, so fall back to the

    # python invocation of local hg, where pythonXY.dll can always be found.

    check_cmd = ['log', '-r.', '-Ttest']

    attempts = []

    def attempt(cmd, env):

        try:

            retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)

            res = (True, retcode, out, err)

            if retcode == 0 and not filterhgerr(err):

                return True

        except OSError as e:

            res = (False, e)

        attempts.append((cmd, res))

        return False

    if os.name != 'nt' or not os.path.exists("hg.exe"):

        if attempt(hgcmd + check_cmd, hgenv):

            return hgcommand(hgcmd, hgenv)

    # Fall back to trying the local hg installation (pure python)

    repo_hg = os.path.join(os.path.dirname(__file__), 'hg')

    hgenv = localhgenv()

    hgcmd = [sys.executable, repo_hg]

    if attempt(hgcmd + check_cmd, hgenv):

        return hgcommand(hgcmd, hgenv)

    # Fall back to trying the local hg installation (whatever we can)

    hgenv = localhgenv(pure_python=False)

    hgcmd = [sys.executable, repo_hg]

    if attempt(hgcmd + check_cmd, hgenv):

        return hgcommand(hgcmd, hgenv)

    eprint("/!\\")

    eprint(r"/!\ Unable to find a working hg binary")

    eprint(r"/!\ Version cannot be extracted from the repository")

    eprint(r"/!\ Re-run the setup once a first version is built")

    eprint(r"/!\ Attempts:")

    for i, e in enumerate(attempts):

        eprint(r"/!\   attempt #%d:" % (i))

        eprint(r"/!\     cmd:        ", e[0])

        res = e[1]

        if res[0]:

            eprint(r"/!\     return code:", res[1])

            eprint("/!\\     std output:\n%s" % (res[2].decode()), end="")

            eprint("/!\\     std error:\n%s" % (res[3].decode()), end="")

        else:

            eprint(r"/!\     exception:  ", res[1])

    return None

def localhgenv(pure_python=True):

    """Get an environment dictionary to use for invoking or importing

    mercurial from the local repository."""

    # Execute hg out of this directory with a custom environment which takes

    # care to not use any hgrc files and do no localization.

    env = {

        'HGRCPATH': '',

        'LANGUAGE': 'C',

        'PATH': '',

    }  # make pypi modules that use os.environ['PATH'] happy

    if pure_python:

        env['HGMODULEPOLICY'] = 'py'

    if 'LD_LIBRARY_PATH' in os.environ:

        env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']

    if 'SystemRoot' in os.environ:

        # SystemRoot is required by Windows to load various DLLs.  See:

        # https://bugs.python.org/issue13524#msg148850

        env['SystemRoot'] = os.environ['SystemRoot']

    return env

version = ''

def _try_get_version():

    hg = findhg()

    if hg is None:

        return ''

    hgid = None

    numerictags = []

    cmd = ['log', '-r', '.', '--template', '{tags}\n']

    pieces = sysstr(hg.run(cmd)).split()

    numerictags = [t for t in pieces if t[0:1].isdigit()]

    hgid = sysstr(hg.run(['id', '-i'])).strip()

    if hgid.count('+') == 2:

        hgid = hgid.replace("+", ".", 1)

    if not hgid:

        eprint("/!\\")

        eprint(r"/!\ Unable to determine hg version from local repository")

        eprint(r"/!\ Failed to retrieve current revision tags")

        return ''

    if numerictags:  # tag(s) found

        return _version(tag=numerictags[-1], dirty=hgid.endswith('+'))

    else:  # no tag found on the checked out revision

        ltagcmd = ['log', '--rev', 'wdir()', '--template', '{latesttag}']

        ltag = sysstr(hg.run(ltagcmd))

        if not ltag:

            eprint("/!\\")

            eprint(r"/!\ Unable to determine hg version from local repository")

            eprint(

                r"/!\ Failed to retrieve current revision distance to lated tag"

            )

            return ''

        changessincecmd = [

            'log',

            '-T',

            'x\n',

            '-r',

            "only(parents(),'%s')" % ltag,

        ]

        changessince = len(hg.run(changessincecmd).splitlines())

        branch = hg.run(["branch"]).strip()

        return _version(

            tag=ltag,

            branch=branch,

            hgid=hgid.rstrip('+'),

            changes_since=changessince,

            dirty=hgid.endswith('+'),

        )

def _version(

    tag: str,

    branch: str = '',

    hgid: str = '',

    changes_since: int = 0,

    dirty: bool = False,

):

    """compute a version number from available information"""

    version = tag

    if changes_since > 0:

        assert branch

        if branch == b'stable':

            post_nb = 0

        elif branch == b'default':

            # we use 1 here to be greater than 0 to make sure change from

            # default are considered newer than change on stable

            post_nb = 1

        else:

            # what is this branch ? probably a local variant ?

            post_nb = 2

        assert hgid

        # logic of the scheme

        # - '.postX' to mark the version as "above" the tagged version

        #   X is 0 for stable, 1 for default, 2 for anything else

        # - use '.devY'

        #   Y is the number of extra revision compared to the tag. So that

        #   revision with more change are "above" previous ones.

        # - '+hg.NODEID.local.DATE' if there is any uncommitted changes.

        version += '.post%d.dev%d+hg.%s' % (post_nb, changes_since, hgid)

    if dirty:

        version = version[:-1] + '.local.' + time.strftime('%Y%m%d')

    # try to give warning early about bad version if possible

    try:

        from packaging.version import Version

        Version(version)

    except ImportError:

        pass

    except ValueError as exc:

        eprint(r"/!\ generated version is invalid")

        eprint(r"/!\ error: %s" % exc)

    return version

if os.path.isdir('.hg'):

    version = _try_get_version()

elif os.path.exists('.hg_archival.txt'):

    kw = dict(

        [[t.strip() for t in l.split(':', 1)] for l in open('.hg_archival.txt')]

    )

    if 'tag' in kw:

        version = _version(tag=kw['tag'])

    elif 'latesttag' in kw:

        distance = int(kw.get('changessincelatesttag', kw['latesttagdistance']))

        version = _version(

            tag=kw['latesttag'],

            branch=kw['branch'],

            changes_since=distance,

            hgid=kw['node'][:12],

        )

    else:

        version = _version(

            tag='0',

            branch='unknown-source',

            changes_since=1,

            hgid=kw.get('node', 'unknownid')[:12],

            dirty=True,

        )

elif os.path.exists('mercurial/__version__.py'):

    with open('mercurial/__version__.py') as f:

        data = f.read()

    version = re.search('version = b"(.*)"', data).group(1)

if not version:

    if os.environ.get("MERCURIAL_SETUP_MAKE_LOCAL") == "1":

        version = "0.0+0"

        eprint("/!\\")

        eprint(r"/!\ Using '0.0+0' as the default version")

        eprint(r"/!\ Re-run make local once that first version is built")

        eprint("/!\\")

    else:

        eprint("/!\\")

        eprint(r"/!\ Could not determine the Mercurial version")

        eprint(r"/!\ You need to build a local version first")

        eprint(r"/!\ Run `make local` and try again")

        eprint("/!\\")

        msg = "Run `make local` first to get a working local version"

        raise SystemExit(msg)

versionb = version

if not isinstance(versionb, bytes):

    versionb = versionb.encode('ascii')

write_if_changed(

    'mercurial/__version__.py',

    b''.join(

        [

            b'# this file is autogenerated by setup.py\n'

            b'version = b"%s"\n' % versionb,

        ]

    ),

)

class hgbuild(build):

    # Insert hgbuildmo first so that files in mercurial/locale/ are found

    # when build_py is run next.

    sub_commands = [('build_mo', None)] + build.sub_commands

class hgbuildmo(build):

    description = "build translations (.mo files)"