|
1 #!/usr/bin/env python |
|
2 # |
|
3 # This is an experimental py3k-enabled mercurial setup script. |
|
4 # |
|
5 # 'python setup.py install', or |
|
6 # 'python setup.py --help' for more options |
|
7 |
|
8 from distutils.command.build_py import build_py_2to3 |
|
9 from lib2to3.refactor import get_fixers_from_package as getfixers |
|
10 |
|
11 import sys |
|
12 if not hasattr(sys, 'version_info') or sys.version_info < (2, 4, 0, 'final'): |
|
13 raise SystemExit("Mercurial requires Python 2.4 or later.") |
|
14 |
|
15 if sys.version_info[0] >= 3: |
|
16 def b(s): |
|
17 '''A helper function to emulate 2.6+ bytes literals using string |
|
18 literals.''' |
|
19 return s.encode('latin1') |
|
20 else: |
|
21 def b(s): |
|
22 '''A helper function to emulate 2.6+ bytes literals using string |
|
23 literals.''' |
|
24 return s |
|
25 |
|
26 # Solaris Python packaging brain damage |
|
27 try: |
|
28 import hashlib |
|
29 sha = hashlib.sha1() |
|
30 except: |
|
31 try: |
|
32 import sha |
|
33 except: |
|
34 raise SystemExit( |
|
35 "Couldn't import standard hashlib (incomplete Python install).") |
|
36 |
|
37 try: |
|
38 import zlib |
|
39 except: |
|
40 raise SystemExit( |
|
41 "Couldn't import standard zlib (incomplete Python install).") |
|
42 |
|
43 try: |
|
44 import bz2 |
|
45 except: |
|
46 raise SystemExit( |
|
47 "Couldn't import standard bz2 (incomplete Python install).") |
|
48 |
|
49 import os, subprocess, time |
|
50 import shutil |
|
51 import tempfile |
|
52 from distutils import log |
|
53 from distutils.core import setup, Extension |
|
54 from distutils.dist import Distribution |
|
55 from distutils.command.build import build |
|
56 from distutils.command.build_ext import build_ext |
|
57 from distutils.command.build_py import build_py |
|
58 from distutils.spawn import spawn, find_executable |
|
59 from distutils.ccompiler import new_compiler |
|
60 from distutils.errors import CCompilerError |
|
61 |
|
62 scripts = ['hg'] |
|
63 if os.name == 'nt': |
|
64 scripts.append('contrib/win32/hg.bat') |
|
65 |
|
66 # simplified version of distutils.ccompiler.CCompiler.has_function |
|
67 # that actually removes its temporary files. |
|
68 def hasfunction(cc, funcname): |
|
69 tmpdir = tempfile.mkdtemp(prefix='hg-install-') |
|
70 devnull = oldstderr = None |
|
71 try: |
|
72 try: |
|
73 fname = os.path.join(tmpdir, 'funcname.c') |
|
74 f = open(fname, 'w') |
|
75 f.write('int main(void) {\n') |
|
76 f.write(' %s();\n' % funcname) |
|
77 f.write('}\n') |
|
78 f.close() |
|
79 # Redirect stderr to /dev/null to hide any error messages |
|
80 # from the compiler. |
|
81 # This will have to be changed if we ever have to check |
|
82 # for a function on Windows. |
|
83 devnull = open('/dev/null', 'w') |
|
84 oldstderr = os.dup(sys.stderr.fileno()) |
|
85 os.dup2(devnull.fileno(), sys.stderr.fileno()) |
|
86 objects = cc.compile([fname], output_dir=tmpdir) |
|
87 cc.link_executable(objects, os.path.join(tmpdir, "a.out")) |
|
88 except: |
|
89 return False |
|
90 return True |
|
91 finally: |
|
92 if oldstderr is not None: |
|
93 os.dup2(oldstderr, sys.stderr.fileno()) |
|
94 if devnull is not None: |
|
95 devnull.close() |
|
96 shutil.rmtree(tmpdir) |
|
97 |
|
98 # py2exe needs to be installed to work |
|
99 try: |
|
100 import py2exe |
|
101 py2exeloaded = True |
|
102 |
|
103 # Help py2exe to find win32com.shell |
|
104 try: |
|
105 import modulefinder |
|
106 import win32com |
|
107 for p in win32com.__path__[1:]: # Take the path to win32comext |
|
108 modulefinder.AddPackagePath("win32com", p) |
|
109 pn = "win32com.shell" |
|
110 __import__(pn) |
|
111 m = sys.modules[pn] |
|
112 for p in m.__path__[1:]: |
|
113 modulefinder.AddPackagePath(pn, p) |
|
114 except ImportError: |
|
115 pass |
|
116 |
|
117 except ImportError: |
|
118 py2exeloaded = False |
|
119 pass |
|
120 |
|
121 def runcmd(cmd, env): |
|
122 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, |
|
123 stderr=subprocess.PIPE, env=env) |
|
124 out, err = p.communicate() |
|
125 # If root is executing setup.py, but the repository is owned by |
|
126 # another user (as in "sudo python setup.py install") we will get |
|
127 # trust warnings since the .hg/hgrc file is untrusted. That is |
|
128 # fine, we don't want to load it anyway. Python may warn about |
|
129 # a missing __init__.py in mercurial/locale, we also ignore that. |
|
130 err = [e for e in err.splitlines() |
|
131 if not e.startswith(b('Not trusting file')) \ |
|
132 and not e.startswith(b('warning: Not importing'))] |
|
133 if err: |
|
134 return '' |
|
135 return out |
|
136 |
|
137 version = '' |
|
138 |
|
139 if os.path.isdir('.hg'): |
|
140 # Execute hg out of this directory with a custom environment which |
|
141 # includes the pure Python modules in mercurial/pure. We also take |
|
142 # care to not use any hgrc files and do no localization. |
|
143 pypath = ['mercurial', os.path.join('mercurial', 'pure')] |
|
144 env = {'PYTHONPATH': os.pathsep.join(pypath), |
|
145 'HGRCPATH': '', |
|
146 'LANGUAGE': 'C'} |
|
147 if 'LD_LIBRARY_PATH' in os.environ: |
|
148 env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH'] |
|
149 if 'SystemRoot' in os.environ: |
|
150 # Copy SystemRoot into the custom environment for Python 2.6 |
|
151 # under Windows. Otherwise, the subprocess will fail with |
|
152 # error 0xc0150004. See: http://bugs.python.org/issue3440 |
|
153 env['SystemRoot'] = os.environ['SystemRoot'] |
|
154 cmd = [sys.executable, 'hg', 'id', '-i', '-t'] |
|
155 l = runcmd(cmd, env).split() |
|
156 while len(l) > 1 and l[-1][0].isalpha(): # remove non-numbered tags |
|
157 l.pop() |
|
158 if len(l) > 1: # tag found |
|
159 version = l[-1] |
|
160 if l[0].endswith('+'): # propagate the dirty status to the tag |
|
161 version += '+' |
|
162 elif len(l) == 1: # no tag found |
|
163 cmd = [sys.executable, 'hg', 'parents', '--template', |
|
164 '{latesttag}+{latesttagdistance}-'] |
|
165 version = runcmd(cmd, env) + l[0] |
|
166 if version.endswith('+'): |
|
167 version += time.strftime('%Y%m%d') |
|
168 elif os.path.exists('.hg_archival.txt'): |
|
169 kw = dict([[t.strip() for t in l.split(':', 1)] |
|
170 for l in open('.hg_archival.txt')]) |
|
171 if 'tag' in kw: |
|
172 version = kw['tag'] |
|
173 elif 'latesttag' in kw: |
|
174 version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw |
|
175 else: |
|
176 version = kw.get('node', '')[:12] |
|
177 |
|
178 if version: |
|
179 f = open("mercurial/__version__.py", "w") |
|
180 f.write('# this file is autogenerated by setup.py\n') |
|
181 f.write('version = "%s"\n' % version) |
|
182 f.close() |
|
183 |
|
184 |
|
185 try: |
|
186 from mercurial import __version__ |
|
187 version = __version__.version |
|
188 except ImportError: |
|
189 version = 'unknown' |
|
190 |
|
191 class hgbuildmo(build): |
|
192 |
|
193 description = "build translations (.mo files)" |
|
194 |
|
195 def run(self): |
|
196 if not find_executable('msgfmt'): |
|
197 self.warn("could not find msgfmt executable, no translations " |
|
198 "will be built") |
|
199 return |
|
200 |
|
201 podir = 'i18n' |
|
202 if not os.path.isdir(podir): |
|
203 self.warn("could not find %s/ directory" % podir) |
|
204 return |
|
205 |
|
206 join = os.path.join |
|
207 for po in os.listdir(podir): |
|
208 if not po.endswith('.po'): |
|
209 continue |
|
210 pofile = join(podir, po) |
|
211 modir = join('locale', po[:-3], 'LC_MESSAGES') |
|
212 mofile = join(modir, 'hg.mo') |
|
213 mobuildfile = join('mercurial', mofile) |
|
214 cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile] |
|
215 if sys.platform != 'sunos5': |
|
216 # msgfmt on Solaris does not know about -c |
|
217 cmd.append('-c') |
|
218 self.mkpath(join('mercurial', modir)) |
|
219 self.make_file([pofile], mobuildfile, spawn, (cmd,)) |
|
220 |
|
221 # Insert hgbuildmo first so that files in mercurial/locale/ are found |
|
222 # when build_py is run next. |
|
223 build.sub_commands.insert(0, ('build_mo', None)) |
|
224 # We also need build_ext before build_py. Otherwise, when 2to3 is called (in |
|
225 # build_py), it will not find osutil & friends, thinking that those modules are |
|
226 # global and, consequently, making a mess, now that all module imports are |
|
227 # global. |
|
228 build.sub_commands.insert(1, ('build_ext', None)) |
|
229 |
|
230 Distribution.pure = 0 |
|
231 Distribution.global_options.append(('pure', None, "use pure (slow) Python " |
|
232 "code instead of C extensions")) |
|
233 |
|
234 class hgbuildext(build_ext): |
|
235 |
|
236 def build_extension(self, ext): |
|
237 try: |
|
238 build_ext.build_extension(self, ext) |
|
239 except CCompilerError: |
|
240 if not hasattr(ext, 'optional') or not ext.optional: |
|
241 raise |
|
242 log.warn("Failed to build optional extension '%s' (skipping)", |
|
243 ext.name) |
|
244 |
|
245 class hgbuildpy(build_py_2to3): |
|
246 fixer_names = sorted(set(getfixers("lib2to3.fixes") + |
|
247 getfixers("hgfixes"))) |
|
248 |
|
249 def finalize_options(self): |
|
250 build_py.finalize_options(self) |
|
251 |
|
252 if self.distribution.pure: |
|
253 if self.py_modules is None: |
|
254 self.py_modules = [] |
|
255 for ext in self.distribution.ext_modules: |
|
256 if ext.name.startswith("mercurial."): |
|
257 self.py_modules.append("mercurial.pure.%s" % ext.name[10:]) |
|
258 self.distribution.ext_modules = [] |
|
259 |
|
260 def find_modules(self): |
|
261 modules = build_py.find_modules(self) |
|
262 for module in modules: |
|
263 if module[0] == "mercurial.pure": |
|
264 if module[1] != "__init__": |
|
265 yield ("mercurial", module[1], module[2]) |
|
266 else: |
|
267 yield module |
|
268 |
|
269 def run(self): |
|
270 # In the build_py_2to3 class, self.updated_files = [], but I couldn't |
|
271 # see when that variable was updated to point to the updated files, as |
|
272 # its names suggests. Thus, I decided to just find_all_modules and feed |
|
273 # them to 2to3. Unfortunately, subsequent calls to setup3k.py will |
|
274 # incur in 2to3 analysis overhead. |
|
275 self.updated_files = [i[2] for i in self.find_all_modules()] |
|
276 |
|
277 # Base class code |
|
278 if self.py_modules: |
|
279 self.build_modules() |
|
280 if self.packages: |
|
281 self.build_packages() |
|
282 self.build_package_data() |
|
283 |
|
284 # 2to3 |
|
285 self.run_2to3(self.updated_files) |
|
286 |
|
287 # Remaining base class code |
|
288 self.byte_compile(self.get_outputs(include_bytecode=0)) |
|
289 |
|
290 cmdclass = {'build_mo': hgbuildmo, |
|
291 'build_ext': hgbuildext, |
|
292 'build_py': hgbuildpy} |
|
293 |
|
294 packages = ['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert', |
|
295 'hgext.highlight', 'hgext.zeroconf'] |
|
296 |
|
297 pymodules = [] |
|
298 |
|
299 extmodules = [ |
|
300 Extension('mercurial.base85', ['mercurial/base85.c']), |
|
301 Extension('mercurial.bdiff', ['mercurial/bdiff.c']), |
|
302 Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c']), |
|
303 Extension('mercurial.mpatch', ['mercurial/mpatch.c']), |
|
304 Extension('mercurial.parsers', ['mercurial/parsers.c']), |
|
305 ] |
|
306 |
|
307 # disable osutil.c under windows + python 2.4 (issue1364) |
|
308 if sys.platform == 'win32' and sys.version_info < (2, 5, 0, 'final'): |
|
309 pymodules.append('mercurial.pure.osutil') |
|
310 else: |
|
311 extmodules.append(Extension('mercurial.osutil', ['mercurial/osutil.c'])) |
|
312 |
|
313 if sys.platform == 'linux2' and os.uname()[2] > '2.6': |
|
314 # The inotify extension is only usable with Linux 2.6 kernels. |
|
315 # You also need a reasonably recent C library. |
|
316 # In any case, if it fails to build the error will be skipped ('optional'). |
|
317 cc = new_compiler() |
|
318 if hasfunction(cc, 'inotify_add_watch'): |
|
319 inotify = Extension('hgext.inotify.linux._inotify', |
|
320 ['hgext/inotify/linux/_inotify.c'], |
|
321 ['mercurial']) |
|
322 inotify.optional = True |
|
323 extmodules.append(inotify) |
|
324 packages.extend(['hgext.inotify', 'hgext.inotify.linux']) |
|
325 |
|
326 packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo', |
|
327 'help/*.txt']} |
|
328 |
|
329 def ordinarypath(p): |
|
330 return p and p[0] != '.' and p[-1] != '~' |
|
331 |
|
332 for root in ('templates',): |
|
333 for curdir, dirs, files in os.walk(os.path.join('mercurial', root)): |
|
334 curdir = curdir.split(os.sep, 1)[1] |
|
335 dirs[:] = filter(ordinarypath, dirs) |
|
336 for f in filter(ordinarypath, files): |
|
337 f = os.path.join(curdir, f) |
|
338 packagedata['mercurial'].append(f) |
|
339 |
|
340 datafiles = [] |
|
341 setupversion = version |
|
342 extra = {} |
|
343 |
|
344 if py2exeloaded: |
|
345 extra['console'] = [ |
|
346 {'script':'hg', |
|
347 'copyright':'Copyright (C) 2005-2010 Matt Mackall and others', |
|
348 'product_version':version}] |
|
349 |
|
350 if os.name == 'nt': |
|
351 # Windows binary file versions for exe/dll files must have the |
|
352 # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535 |
|
353 setupversion = version.split('+', 1)[0] |
|
354 |
|
355 setup(name='mercurial', |
|
356 version=setupversion, |
|
357 author='Matt Mackall', |
|
358 author_email='mpm@selenic.com', |
|
359 url='http://mercurial.selenic.com/', |
|
360 description='Scalable distributed SCM', |
|
361 license='GNU GPLv2+', |
|
362 scripts=scripts, |
|
363 packages=packages, |
|
364 py_modules=pymodules, |
|
365 ext_modules=extmodules, |
|
366 data_files=datafiles, |
|
367 package_data=packagedata, |
|
368 cmdclass=cmdclass, |
|
369 options=dict(py2exe=dict(packages=['hgext', 'email']), |
|
370 bdist_mpkg=dict(zipdist=True, |
|
371 license='COPYING', |
|
372 readme='contrib/macosx/Readme.html', |
|
373 welcome='contrib/macosx/Welcome.html')), |
|
374 **extra) |