forked from Zaryob/preprocess
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Makefile.py
452 lines (392 loc) · 16.8 KB
/
Makefile.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
"""Makefile for the preprocess project.
${common_task_list}
See `mk -h' for options.
"""
import sys
import os
from os.path import join, dirname, normpath, abspath, exists, basename
import re
import webbrowser
from mklib.common import MkError
from mklib import Task
from mklib import sh
class bugs(Task):
"""Open bug database page."""
def make(self):
webbrowser.open("http://code.google.com/p/preprocess/issues/list")
class site(Task):
"""Open the Google Code project page."""
def make(self):
webbrowser.open("http://code.google.com/p/preprocess/")
class play(Task):
def make(self):
sh.run("python setup.py install")
sh.run("/Library/Frameworks/Python.framework/Versions/2.5/bin/preprocess foo.txt")
class clean(Task):
"""Clean generated files and dirs."""
def make(self):
patterns = [
"dist",
"build",
"MANIFEST",
"*.pyc",
"lib/*.pyc",
]
for pattern in patterns:
p = join(self.dir, pattern)
for path in glob(p):
sh.rm(path, log=self.log)
class test(Task):
"""Run all tests (except known failures)."""
def make(self):
for ver, python in self._gen_pythons():
if ver < (2,3):
# Don't support Python < 2.3.
continue
elif ver >= (3,0):
# Don't (yet) support Python 3.
continue
ver_str = "%s.%s" % ver
print("-- test with Python %s (%s)" % (ver_str, python))
assert ' ' not in python
sh.run_in_dir("%s test.py" % python,
join(self.dir, "test"))
def _python_ver_from_python(self, python):
assert ' ' not in python
o = os.popen('''%s -c "import sys; print(sys.version)"''' % python)
ver_str = o.read().strip()
ver_bits = re.split("\.|[^\d]", ver_str, 2)[:2]
ver = tuple(map(int, ver_bits))
return ver
def _gen_python_names(self):
yield "python"
for ver in [(2,3), (2,4), (2,5), (2,6), (2,7), (3,0), (3,1)]:
yield "python%d.%d" % ver
def _gen_pythons(self):
sys.path.insert(0, join(self.dir, "externals", "which"))
import which
python_from_ver = {}
for name in self._gen_python_names():
for python in which.whichall(name):
ver = self._python_ver_from_python(python)
if ver not in python_from_ver:
python_from_ver[ver] = python
for ver, python in sorted(python_from_ver.items()):
yield ver, python
class sdist(Task):
"""python setup.py sdist"""
def make(self):
sh.run_in_dir("%spython setup.py sdist -f --formats zip"
% _setup_command_prefix(),
self.dir, self.log.debug)
class webdist(Task):
"""Build a web dist package for trentm.com/projects/
"Web dist" packages are zip files with '.web' extension. All files in
the zip must be under a dir named after the project. There must be a
webinfo.xml file at <projname>/webinfo.xml. This file is "defined"
by the parsing in trentm.com/build.py.
"""
deps = ["docs"]
def results(self):
yield join(self.dir, "dist", "preprocess-%s.web" % _get_version())
def make(self):
assert sys.platform != "win32", "'webdist' not implemented for win32"
build_dir = join(self.dir, "build", "webdist")
zip_dir = join(build_dir, "preprocess")
if exists(build_dir):
sh.rm(build_dir)
os.makedirs(zip_dir)
# Copy the webdist bits to the build tree.
manifest = [
"src/trentm.com/project-info.xml",
"src/trentm.com/index.markdown",
"LICENSE.txt",
"lib/preprocess.py",
"src/trentm.com/logo.gif",
]
for src in manifest:
sh.cp(src, dstdir=zip_dir, log=self.log.info)
# Zip up the webdist contents.
dist_dir = join(self.dir, "dist")
bit = abspath(join(dist_dir, "preprocess-%s.web" % _get_version()))
if exists(bit):
os.remove(bit)
if not exists(dist_dir):
os.makedirs(dist_dir)
sh.run_in_dir("zip -r %s preprocess" % bit, build_dir, self.log.info)
class pypi_upload(Task):
"""Upload release to pypi."""
def make(self):
tasks = (sys.platform == "win32"
and "sdist --formats zip bdist_wininst upload"
or "sdist --formats zip upload")
sh.run_in_dir("%spython setup.py %s" % (_setup_command_prefix(), tasks),
self.dir, self.log.debug)
sys.path.insert(0, join(self.dir, "lib"))
url = "http://pypi.python.org/pypi/preprocess/"
import webbrowser
webbrowser.open_new(url)
class googlecode_upload(Task):
"""Upload sdist to Google Code project site."""
deps = ["sdist"]
def make(self):
helper_in_cwd = exists(join(self.dir, "googlecode_upload.py"))
if helper_in_cwd:
sys.path.insert(0, self.dir)
try:
import googlecode_upload
except ImportError:
raise MkError("couldn't import `googlecode_upload` (get it from http://support.googlecode.com/svn/trunk/scripts/googlecode_upload.py)")
if helper_in_cwd:
del sys.path[0]
ver = _get_version()
sdist_path = join(self.dir, "dist", "preprocess-%s.zip" % ver)
status, reason, url = googlecode_upload.upload_find_auth(
sdist_path,
"preprocess", # project_name
"preprocess %s source package" % ver, # summary
["Featured", "Type-Archive"]) # labels
if not url:
raise MkError("couldn't upload sdist to Google Code: %s (%s)"
% (reason, status))
self.log.info("uploaded sdist to `%s'", url)
project_url = "http://code.google.com/p/preprocess/"
import webbrowser
webbrowser.open_new(project_url)
class trentm_com_upload(Task):
"""Upload webdist to trentm.com bits (in prep for updating trentm.com)."""
deps = ["webdist"]
def make(self):
ver = _get_version()
dist_dir = join(self.dir, "dist")
paths = [join(dist_dir, "preprocess-%s%s" % (ver, ext))
for ext in [".web"]]
# Upload the bits.
user = "trentm"
host = "trentm.com"
remote_dir = "~/data/bits/preprocess/%s" % _get_version()
if sys.platform == "win32":
ssh = "plink"
scp = "pscp -unsafe"
else:
ssh = "ssh"
scp = "scp"
sh.run("%s %s@%s 'mkdir -p %s'" % (ssh, user, host, remote_dir),
self.log.info)
for path in paths:
sh.run("%s %s %s@%s:%s" % (scp, path, user, host, remote_dir),
self.log.info)
class todo(Task):
"""Print out todo's and xxx's in the docs area."""
def make(self):
for path in _paths_from_path_patterns(['.'],
excludes=[".svn", "*.pyc", "TO""DO.txt", "Makefile.py",
"*.png", "*.gif", "*.pprint", "*.prof",
"tmp-*"]):
self._dump_pattern_in_path("TO\DO\\|XX\X", path)
path = join(self.dir, "TO""DO.txt")
todos = re.compile("^- ", re.M).findall(open(path, 'r').read())
print("(plus %d TODOs from TO""DO.txt)" % len(todos))
def _dump_pattern_in_path(self, pattern, path):
os.system("grep -nH '%s' '%s'" % (pattern, path))
class gow(Task):
"""Build the Windows 'gow.exe' launcher exe for DQSD integration."""
def make(self):
assert sys.platform == "win32", "can only build `gow.exe' on Windows"
sh.run_in_dir("nmake -f Makefile.win", join("src", "dqsd"))
class docs(Task):
"""Regenerate some doc bits from project-info.xml."""
deps = ["src/trentm.com/project-info.xml"]
results = [
"README.txt",
"src/trentm.com/index.markdown"
]
def make(self):
project_info_xml = join("src", "trentm.com", "project-info.xml")
index_markdown = join("src", "trentm.com", "index.markdown")
sh.run_in_dir("projinfo -f %s -R -o README.txt --force"
% project_info_xml, self.dir)
sh.run_in_dir("projinfo -f %s --index-markdown -o %s --force"
% (project_info_xml, index_markdown), self.dir)
class check_version(Task):
"""grep for version strings in source code
List all things that look like version strings in the source code.
Used for checking that versioning is updated across the board.
"""
sources = [
"lib/preprocess.py",
"src/trentm.com/project-info.xml",
]
def make(self):
pattern = r'[0-9]\+\(\.\|, \)[0-9]\+\(\.\|, \)[0-9]\+'
sh.run_in_dir('grep -n "%s" %s' % (pattern, ' '.join(self.sources)),
self.dir)
#---- internal support stuff
# Recipe: paths_from_path_patterns (0.3.7)
def _should_include_path(path, includes, excludes):
"""Return True iff the given path should be included."""
from os.path import basename
from fnmatch import fnmatch
base = basename(path)
if includes:
for include in includes:
if fnmatch(base, include):
try:
log.debug("include `%s' (matches `%s')", path, include)
except (NameError, AttributeError):
pass
break
else:
try:
log.debug("exclude `%s' (matches no includes)", path)
except (NameError, AttributeError):
pass
return False
for exclude in excludes:
if fnmatch(base, exclude):
try:
log.debug("exclude `%s' (matches `%s')", path, exclude)
except (NameError, AttributeError):
pass
return False
return True
_NOT_SPECIFIED = ("NOT", "SPECIFIED")
def _paths_from_path_patterns(path_patterns, files=True, dirs="never",
recursive=True, includes=[], excludes=[],
on_error=_NOT_SPECIFIED):
"""_paths_from_path_patterns([<path-patterns>, ...]) -> file paths
Generate a list of paths (files and/or dirs) represented by the given path
patterns.
"path_patterns" is a list of paths optionally using the '*', '?' and
'[seq]' glob patterns.
"files" is boolean (default True) indicating if file paths
should be yielded
"dirs" is string indicating under what conditions dirs are
yielded. It must be one of:
never (default) never yield dirs
always yield all dirs matching given patterns
if-not-recursive only yield dirs for invocations when
recursive=False
See use cases below for more details.
"recursive" is boolean (default True) indicating if paths should
be recursively yielded under given dirs.
"includes" is a list of file patterns to include in recursive
searches.
"excludes" is a list of file and dir patterns to exclude.
(Note: This is slightly different than GNU grep's --exclude
option which only excludes *files*. I.e. you cannot exclude
a ".svn" dir.)
"on_error" is an error callback called when a given path pattern
matches nothing:
on_error(PATH_PATTERN)
If not specified, the default is look for a "log" global and
call:
log.error("`%s': No such file or directory")
Specify None to do nothing.
Typically this is useful for a command-line tool that takes a list
of paths as arguments. (For Unix-heads: the shell on Windows does
NOT expand glob chars, that is left to the app.)
Use case #1: like `grep -r`
{files=True, dirs='never', recursive=(if '-r' in opts)}
script FILE # yield FILE, else call on_error(FILE)
script DIR # yield nothing
script PATH* # yield all files matching PATH*; if none,
# call on_error(PATH*) callback
script -r DIR # yield files (not dirs) recursively under DIR
script -r PATH* # yield files matching PATH* and files recursively
# under dirs matching PATH*; if none, call
# on_error(PATH*) callback
Use case #2: like `file -r` (if it had a recursive option)
{files=True, dirs='if-not-recursive', recursive=(if '-r' in opts)}
script FILE # yield FILE, else call on_error(FILE)
script DIR # yield DIR, else call on_error(DIR)
script PATH* # yield all files and dirs matching PATH*; if none,
# call on_error(PATH*) callback
script -r DIR # yield files (not dirs) recursively under DIR
script -r PATH* # yield files matching PATH* and files recursively
# under dirs matching PATH*; if none, call
# on_error(PATH*) callback
Use case #3: kind of like `find .`
{files=True, dirs='always', recursive=(if '-r' in opts)}
script FILE # yield FILE, else call on_error(FILE)
script DIR # yield DIR, else call on_error(DIR)
script PATH* # yield all files and dirs matching PATH*; if none,
# call on_error(PATH*) callback
script -r DIR # yield files and dirs recursively under DIR
# (including DIR)
script -r PATH* # yield files and dirs matching PATH* and recursively
# under dirs; if none, call on_error(PATH*)
# callback
"""
from os.path import basename, exists, isdir, join
from glob import glob
assert not isinstance(path_patterns, str), \
"'path_patterns' must be a sequence, not a string: %r" % path_patterns
GLOB_CHARS = '*?['
for path_pattern in path_patterns:
# Determine the set of paths matching this path_pattern.
for glob_char in GLOB_CHARS:
if glob_char in path_pattern:
paths = glob(path_pattern)
break
else:
paths = exists(path_pattern) and [path_pattern] or []
if not paths:
if on_error is None:
pass
elif on_error is _NOT_SPECIFIED:
try:
log.error("`%s': No such file or directory", path_pattern)
except (NameError, AttributeError):
pass
else:
on_error(path_pattern)
for path in paths:
if isdir(path):
# 'includes' SHOULD affect whether a dir is yielded.
if (dirs == "always"
or (dirs == "if-not-recursive" and not recursive)
) and _should_include_path(path, includes, excludes):
yield path
# However, if recursive, 'includes' should NOT affect
# whether a dir is recursed into. Otherwise you could
# not:
# script -r --include="*.py" DIR
if recursive and _should_include_path(path, [], excludes):
for dirpath, dirnames, filenames in os.walk(path):
dir_indeces_to_remove = []
for i, dirname in enumerate(dirnames):
d = join(dirpath, dirname)
if dirs == "always" \
and _should_include_path(d, includes, excludes):
yield d
if not _should_include_path(d, [], excludes):
dir_indeces_to_remove.append(i)
for i in reversed(dir_indeces_to_remove):
del dirnames[i]
if files:
for filename in sorted(filenames):
f = join(dirpath, filename)
if _should_include_path(f, includes, excludes):
yield f
elif files and _should_include_path(path, includes, excludes):
yield path
_g_version = None
def _get_version():
global _g_version
if _g_version is None:
sys.path.insert(0, join(dirname(__file__), "lib"))
try:
import preprocess
_g_version = preprocess.__version__
finally:
del sys.path[0]
return _g_version
def _setup_command_prefix():
prefix = ""
if sys.platform == "darwin":
# http://forums.macosxhints.com/archive/index.php/t-43243.html
# This is an Apple customization to `tar` to avoid creating
# '._foo' files for extended-attributes for archived files.
prefix = "COPY_EXTENDED_ATTRIBUTES_DISABLE=1 "
return prefix