#

# This is the mercurial setup script.

#

# 'python setup.py install', or

# 'python setup.py --help' for more options

import sys, platform

if getattr(sys, 'version_info', (0, 0, 0)) < (2, 4, 0, 'final'):

    raise SystemExit("Mercurial requires Python 2.4 or later.")

if sys.version_info[0] >= 3:

    def b(s):

        '''A helper function to emulate 2.6+ bytes literals using string

        literals.'''

        return s.encode('latin1')

else:

    def b(s):

        '''A helper function to emulate 2.6+ bytes literals using string

        literals.'''

        return s

# Solaris Python packaging brain damage

try:

    import hashlib

    sha = hashlib.sha1()

except ImportError:

    try:

        import sha

    except ImportError:

        raise SystemExit(

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

try:

    import zlib

except ImportError:

    raise SystemExit(

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

# The base IronPython distribution (as of 2.7.1) doesn't support bz2

isironpython = False

try:

    isironpython = (platform.python_implementation()

                    .lower().find("ironpython") != -1)

except AttributeError:

    pass

if isironpython:

    sys.stderr.write("warning: IronPython detected (no bz2 support)\n")

else:

    try:

        import bz2

    except ImportError:

        raise SystemExit(

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

import os, subprocess, time

import shutil

import tempfile

from distutils import log

from distutils.core import setup, Command, Extension

from distutils.dist import Distribution

from distutils.command.build import build

from distutils.command.build_ext import build_ext

from distutils.command.build_py import build_py

from distutils.command.install_scripts import install_scripts

from distutils.spawn import spawn, find_executable

from distutils.ccompiler import new_compiler

from distutils import cygwinccompiler

from distutils.errors import CCompilerError, DistutilsExecError

from distutils.sysconfig import get_python_inc

from distutils.version import StrictVersion

convert2to3 = '--c2to3' in sys.argv

if convert2to3:

    try:

        from distutils.command.build_py import build_py_2to3 as build_py

        from lib2to3.refactor import get_fixers_from_package as getfixers

    except ImportError:

        if sys.version_info[0] < 3:

            raise SystemExit("--c2to3 is only compatible with python3.")

        raise

    sys.path.append('contrib')

elif sys.version_info[0] >= 3:

    raise SystemExit("setup.py with python3 needs --c2to3 (experimental)")

scripts = ['hg']

if os.name == 'nt':

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

# simplified version of distutils.ccompiler.CCompiler.has_function

# that actually removes its temporary files.

def hasfunction(cc, funcname):

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

    devnull = oldstderr = None

    try:

        try:

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

            f = open(fname, 'w')

            f.write('int main(void) {\n')

            f.write('    %s();\n' % funcname)

            f.write('}\n')

            f.close()

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

            devnull = open('/dev/null', 'w')

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

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

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

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

        except Exception:

            return False

        return True

    finally:

        if oldstderr is not None:

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

        if devnull is not None:

            devnull.close()

        shutil.rmtree(tmpdir)

# py2exe needs to be installed to work

try:

    import py2exe

    py2exeloaded = True

    # import py2exe's patched Distribution class

    from distutils.core import Distribution

except ImportError:

    py2exeloaded = False

def runcmd(cmd, env):

    if sys.platform == 'plan9':

        # subprocess kludge to work around issues in half-baked Python

        # ports, notably bichued/python:

        _, out, err = os.popen3(cmd)

        return str(out), str(err)

    else:

        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE, env=env)

        out, err = p.communicate()

        return out, err

def runhg(cmd, env):

    out, err = runcmd(cmd, env)

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

    if err:

        return ''

    return out

version = ''

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

# includes the pure Python modules in mercurial/pure. We also take

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

pypath = ['mercurial', os.path.join('mercurial', 'pure')]

env = {'PYTHONPATH': os.pathsep.join(pypath),

       'HGRCPATH': '',

       'LANGUAGE': 'C'}

if 'LD_LIBRARY_PATH' in os.environ:

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

if 'SystemRoot' in os.environ:

    # Copy SystemRoot into the custom environment for Python 2.6

    # under Windows. Otherwise, the subprocess will fail with

    # error 0xc0150004. See: http://bugs.python.org/issue3440

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

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

            version += '+'

        cmd = [sys.executable, 'hg', 'parents', '--template',

               '{latesttag}+{latesttagdistance}-']

    if version.endswith('+'):

        version += time.strftime('%Y%m%d')

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 =  kw['tag']

    elif 'latesttag' in kw:

        version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw

    else:

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

if version:

    f = open("mercurial/__version__.py", "w")

    f.write('# this file is autogenerated by setup.py\n')

    f.write('version = "%s"\n' % version)

    f.close()

try:

    from mercurial import __version__

    version = __version__.version

except ImportError:

    version = 'unknown'

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

    # We also need build_ext before build_py. Otherwise, when 2to3 is

    # called (in build_py), it will not find osutil & friends,

    # thinking that those modules are global and, consequently, making

    # a mess, now that all module imports are global.

                    ('build_ext', build.has_ext_modules),

                   ] + build.sub_commands

class hgbuildmo(build):

    description = "build translations (.mo files)"

    def run(self):

        if not find_executable('msgfmt'):

            self.warn("could not find msgfmt executable, no translations "

                     "will be built")

            return

        podir = 'i18n'

        if not os.path.isdir(podir):

            self.warn("could not find %s/ directory" % podir)

            return

        join = os.path.join

        for po in os.listdir(podir):

            if not po.endswith('.po'):

                continue

            pofile = join(podir, po)

            modir = join('locale', po[:-3], 'LC_MESSAGES')

            mofile = join(modir, 'hg.mo')

            mobuildfile = join('mercurial', mofile)

            cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]

            if sys.platform != 'sunos5':

                # msgfmt on Solaris does not know about -c

                cmd.append('-c')

            self.mkpath(join('mercurial', modir))

            self.make_file([pofile], mobuildfile, spawn, (cmd,))

class hgdist(Distribution):

    pure = 0

    global_options = Distribution.global_options + \

                     [('pure', None, "use pure (slow) Python "

                        "code instead of C extensions"),

                      ('c2to3', None, "(experimental!) convert "

                        "code with 2to3"),

                     ]

    def has_ext_modules(self):

        # self.ext_modules is emptied in hgbuildpy.finalize_options which is

        # too late for some cases

        return not self.pure and Distribution.has_ext_modules(self)

class hgbuildext(build_ext):

    def build_extension(self, ext):

        try:

            build_ext.build_extension(self, ext)

        except CCompilerError:

            if not getattr(ext, 'optional', False):

                raise

            log.warn("Failed to build optional extension '%s' (skipping)",

                     ext.name)

class hgbuildpy(build_py):

    if convert2to3:

        fixer_names = sorted(set(getfixers("lib2to3.fixes") +

                                 getfixers("hgfixes")))

    def finalize_options(self):

        build_py.finalize_options(self)

        if self.distribution.pure:

            if self.py_modules is None:

                self.py_modules = []

            for ext in self.distribution.ext_modules:

                if ext.name.startswith("mercurial."):

                    self.py_modules.append("mercurial.pure.%s" % ext.name[10:])

            self.distribution.ext_modules = []

        else:

            if not os.path.exists(os.path.join(get_python_inc(), 'Python.h')):

                raise SystemExit('Python headers are required to build '

                                 'Mercurial')

    def find_modules(self):

        modules = build_py.find_modules(self)

        for module in modules:

            if module[0] == "mercurial.pure":

                if module[1] != "__init__":

                    yield ("mercurial", module[1], module[2])

            else:

                yield module

class buildhgextindex(Command):

    description = 'generate prebuilt index of hgext (for frozen package)'

    user_options = []

    _indexfilename = 'hgext/__index__.py'

    def initialize_options(self):

        pass

    def finalize_options(self):

        pass

    def run(self):

        if os.path.exists(self._indexfilename):

            os.unlink(self._indexfilename)

        # here no extension enabled, disabled() lists up everything

        code = ('import pprint; from mercurial import extensions; '

                'pprint.pprint(extensions.disabled())')

        out, err = runcmd([sys.executable, '-c', code], env)

        if err:

            raise DistutilsExecError(err)

        f = open(self._indexfilename, 'w')

        f.write('# this file is autogenerated by setup.py\n')

        f.write('docs = ')

        f.write(out)

        f.close()

class buildhgexe(build_ext):

    description = 'compile hg.exe from mercurial/exewrapper.c'

    def build_extensions(self):

        if os.name != 'nt':

            return

        if isinstance(self.compiler, HackedMingw32CCompiler):

            self.compiler.compiler_so = self.compiler.compiler # no -mdll

            self.compiler.dll_libraries = [] # no -lmsrvc90

        objects = self.compiler.compile(['mercurial/exewrapper.c'],

                                         output_dir=self.build_temp)

        dir = os.path.dirname(self.get_ext_fullpath('dummy'))

        target = os.path.join(dir, 'hg')

        pythonlib = ("python%d%d" %

               (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))

        self.compiler.link_executable(objects, target,

                                      libraries=[pythonlib],

                                      output_dir=self.build_temp)

class hginstallscripts(install_scripts):

    '''

    This is a specialization of install_scripts that replaces the @LIBDIR@ with

    the configured directory for modules. If possible, the path is made relative

    to the directory for scripts.

    '''

    def initialize_options(self):

        install_scripts.initialize_options(self)

        self.install_lib = None

    def finalize_options(self):

        install_scripts.finalize_options(self)

        self.set_undefined_options('install',

                                   ('install_lib', 'install_lib'))

    def run(self):

        install_scripts.run(self)