def build_compiled_library(self, library):
import distutils.errors
dist = self._dist
dist.libraries = [to_dist_compiled_library(library)]
bld_cmd, compiler = self._setup_clib()
base, filename = os.path.split(self._compiled_library_filename(library.name, compiler))
old_build_clib = bld_cmd.build_clib
if base:
# workaround for a distutils issue: distutils put all C libraries
# in the same directory, and we cannot control the output directory
# from the name - we need to hack build_clib directory
bld_cmd.build_clib = os.path.join(old_build_clib, base)
try:
try:
# workaround for yet another bug in distutils: distutils f***s up when
# building a static library if the target alread exists on at least mac
# os x.
target = os.path.join(old_build_clib, base, filename)
try:
os.remove(target)
except OSError:
e = extract_exception()
if e.errno != errno.ENOENT:
raise
bld_cmd.run()
return [relpath(target, self._build_base)]
except distutils.errors.DistutilsError:
e = extract_exception()
raise BuildError(str(e))
finally:
bld_cmd.build_clib = old_build_clib
def noexc_main(argv=None):
def _print_debug():
if BENTOMAKER_DEBUG:
tb = sys.exc_info()[2]
traceback.print_tb(tb)
def _print_error(msg):
pprint('RED', msg)
pprint('RED', "(You can see the traceback by setting the " \
"BENTOMAKER_DEBUG=1 environment variable)")
try:
ret = main(argv)
except UsageException:
_print_debug()
e = extract_exception()
_print_error(str(e))
sys.exit(1)
except ParseError:
_print_debug()
e = extract_exception()
_print_error(str(e))
sys.exit(2)
except ConvertionError:
_print_debug()
e = extract_exception()
_print_error("".join(e.args))
sys.exit(3)
except CommandExecutionFailure:
_print_debug()
e = extract_exception()
_print_error("".join(e.args))
sys.exit(4)
except bento.core.errors.ConfigurationError:
_print_debug()
e = extract_exception()
_print_error(e)
sys.exit(8)
except bento.core.errors.BuildError:
_print_debug()
e = extract_exception()
_print_error(e)
sys.exit(16)
except bento.core.errors.InvalidPackage:
_print_debug()
e = extract_exception()
_print_error(e)
sys.exit(32)
except Exception:
msg = """\
%s: Error: %s crashed (uncaught exception %s: %s).
Please report this on bento issue tracker:
http://github.com/cournape/bento/issues"""
if not BENTOMAKER_DEBUG:
msg += "\nYou can get a full traceback by setting BENTOMAKER_DEBUG=1"
else:
_print_debug()
e = extract_exception()
pprint('RED', msg % (SCRIPT_NAME, SCRIPT_NAME, e.__class__, str(e)))
sys.exit(1)
sys.exit(ret)
def get_package(self, bento_info, user_flags=None):
try:
return self._get_package(bento_info, user_flags)
except Exception:
e = extract_exception()
warnings.warn("Resetting invalid cache (error was %r)" % e)
self._reset()
return self._get_package(bento_info, user_flags)
def get_options(self, bento_info):
try:
return self._get_options(bento_info)
except Exception:
e = extract_exception()
warnings.warn("Resetting invalid cache (error was %r)" % e)
self._reset()
return self._get_options(bento_info)
def raw_parse(data, filename=None):
try:
ret = _parse(data)
return ret
except ParseError:
e = extract_exception()
e.filename = filename
raise
def build_compiled_library(bld, clib, env=None):
builder = bld.builders["ctasks"]
try:
for p in clib.include_dirs:
builder.env["CPPPATH"].insert(0, p)
outputs = builder.static_library(clib.name, clib.sources, env)
return [n.bldpath() for n in outputs]
except RuntimeError:
e = extract_exception()
msg = "Building library %s failed: %s" % (clib.name, str(e))
raise CommandExecutionFailure(msg)
def test_simple(self):
text = """\
NName: foo
"""
self.assertRaises(ParseError, lambda : PackageDescription.from_string(text))
try:
PackageDescription.from_string(text)
raise AssertionError("Should raise here !")
except ParseError:
e = extract_exception()
self.assertEqual(str(e), "yacc: Syntax error at line 1, Token(WORD, 'NName')")
def setup(self):
extensions = get_extensions(self.pkg, self.run_node)
libraries = get_compiled_libraries(self.pkg, self.run_node)
yaku_ctx = self.yaku_context
if extensions or libraries:
for t in ["ctasks", "pyext"]:
try:
yaku_ctx.use_tools([t])
except yaku.errors.ConfigurationFailure:
e = extract_exception()
raise ConfigurationError(str(e))
def __init__(self, db_location):
self._location = db_location
self._first_time = False
if not os.path.exists(db_location):
ensure_dir(db_location)
self._reset()
else:
try:
self.db = self._load_existing_cache(db_location)
except Exception:
e = extract_exception()
warnings.warn("Resetting invalid cached db: (reason: %r)" % e)
self._reset()
def makedirs(self, name, mode=MODE_777):
head, tail = os.path.split(name)
if not tail:
head, tail = os.path.split(head)
if head and tail and not os.path.exists(head):
try:
self.makedirs(head, mode)
except OSError:
e = extract_exception()
if e.errno != errno.EEXIST:
raise
if tail == os.curdir:
return
self.mkdir(name, mode)
def test_error_string(self):
f = self.f
f.write("NName: foo")
f.flush()
try:
PackageDescription.from_file(f.name)
raise AssertionError("Should raise here !")
except ParseError:
e = extract_exception()
self.assertEqual(str(e), """\
File "%s", line 1
NName: foo
^
Syntax error""" % f.name)
def _rollback_operation(line):
operation, arg = line.split()
if operation == "MKDIR":
try:
os.rmdir(arg)
except OSError:
e = extract_exception()
# FIXME: hardcoded errno !!
if e.errno != 66:
raise
elif operation == "COPY":
os.remove(arg)
else:
raise ValueError("Unknown operation: %s" % operation)
def run(self, ctx):
argv = ctx.get_command_arguments()
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
if len(a) < 1:
filename = "bento.info"
else:
filename = a[0]
if not os.path.exists(filename):
raise UsageException("%s: error: file %s does not exist" % "bentomaker")
f = open(filename, "r")
try:
data = f.read()
try:
parsed = build_ast_from_data(data)
except ParseError:
e = extract_exception()
msg = "Error while parsing file %s\n" % filename
e.args = (msg,) + e.args
raise e
if o.flags:
try:
flags = parsed["flags"]
for flag in flags:
print(flags[flag])
except KeyError:
pass
elif o.path:
try:
paths = parsed["paths"]
for path in paths:
print(paths[path])
except KeyError:
pass
elif o.meta_field:
try:
print(parsed[o.meta_field])
except KeyError:
raise ValueError("Field %s not found in metadata" % o.meta_field)
else:
pprint(parsed)
finally:
f.close()
def build_extension(self, extension):
import distutils.errors
dist = self._dist
dist.ext_modules = [toyext_to_distext(extension)]
bld_cmd, compiler = self._setup_ext()
try:
bld_cmd.run()
base, filename = os.path.split(self._extension_filename(extension.name, bld_cmd))
fullname = os.path.join(bld_cmd.build_lib, base, filename)
return [relpath(fullname, self._build_base)]
except distutils.errors.DistutilsError:
e = extract_exception()
raise BuildError(str(e))
def build_extension(bld, extension, env=None):
builder = bld.builders["pyext"]
try:
if env is None:
env = {"PYEXT_CPPPATH": extension.include_dirs}
else:
val = env.get("PYEXT_CPPPATH", [])
val.extend(extension.include_dirs)
tasks = builder.extension(extension.name, extension.sources, env)
if len(tasks) > 1:
outputs = tasks[0].gen.outputs
else:
outputs = []
return [n.bldpath() for n in outputs]
except RuntimeError:
e = extract_exception()
msg = "Building extension %s failed: %s" % \
(extension.name, str(e))
raise CommandExecutionFailure(msg)
def _test_impl(self, data, ref):
res = []
while True:
tok = self.lexer.token()
if not tok:
break
res.append(tok.type)
if is_string(ref):
ref = split(ref)
try:
assert_equal(res, ref)
except AssertionError:
e = extract_exception()
cnt = 0
for i, j in zip(res, ref):
if not i == j:
break
cnt += 1
print("Break at index %d" % cnt)
raise e
def analyse_setup_py(filename, setup_args):
pprint('PINK', "======================================================")
pprint('PINK', " Analysing %s (running %s) .... " % (filename, filename))
# exec_globals contains the globals used to execute the setup.py
exec_globals = {}
exec_globals.update(globals())
# Some setup.py files call setup from their main, so execute them as if
# they were the main script
exec_globals["__name__"] = "__main__"
exec_globals["__file__"] = os.path.abspath(filename)
_saved_argv = sys.argv[:]
_saved_sys_path = sys.path
try:
try:
sys.argv = [filename] + setup_args + ["build_py"]
# XXX: many packages import themselves to get version at build
# time, and setuptools screw this up by inserting stuff first. Is
# there a better way ?
sys.path.insert(0, os.path.dirname(filename))
execfile(filename, exec_globals)
if type == "distutils" and "setuptools" in sys.modules:
pprint("YELLOW", "Setuptools detected in distutils mode !!!")
except Exception:
e = extract_exception()
pprint('RED', "Got exception: %s" % e)
raise e
finally:
sys.argv = _saved_argv
sys.path = _saved_sys_path
if not "dist" in LIVE_OBJECTS:
raise ValueError("setup monkey-patching failed")
dist = LIVE_OBJECTS["dist"]
pprint('PINK', " %s analyse done " % filename)
pprint('PINK', "======================================================")
return dist
def build_egg(ipkg, ctx, source_root, path=None):
meta = PackageMetadata.from_ipkg(ipkg)
egg_info = EggInfo.from_ipkg(ipkg, ctx.build_node)
# FIXME: fix egg name
if path is None:
egg = egg_filename(os.path.join("dist", meta.fullname))
else:
egg = egg_filename(os.path.join(path, meta.fullname))
ensure_dir(egg)
zid = compat.ZipFile(egg, "w", compat.ZIP_DEFLATED)
try:
ipkg.update_paths({"prefix": source_root.abspath(),
"eprefix": source_root.abspath(),
"sitedir": source_root.abspath()})
for filename, cnt in egg_info.iter_meta(ctx.build_node):
zid.writestr(os.path.join("EGG-INFO", filename), cnt)
file_sections = ipkg.resolve_paths(source_root)
for kind, source, target in iter_files(file_sections):
if not kind in ["executables"]:
zid.write(source.abspath(), target.path_from(source_root))
pprint("PINK", "Byte-compiling ...")
for kind, source, target in iter_files(file_sections):
if kind in ["pythonfiles"]:
try:
bytecode = bcompile(source.abspath())
except PyCompileError:
e = extract_exception()
warnings.warn("Error byte-compiling %r" % source.abspath())
else:
zid.writestr("%sc" % target.path_from(source_root), bcompile(source.abspath()))
finally:
zid.close()
return
def to_pat(s):
lst = to_list(s)
ret = []
for x in lst:
x = x.replace('\\', '/').replace('//', '/')
if x.endswith('/'):
x += '**'
lst2 = x.split('/')
accu = []
for k in lst2:
if k == '**':
accu.append(k)
else:
k = k.replace('.', '[.]').replace('*','.*').replace('?', '.').replace('+', '\\+')
k = '^%s$' % k
try:
#print "pattern", k
accu.append(re.compile(k))
except Exception:
e = extract_exception()
raise ValueError("Invalid pattern: %s" % k, e)
ret.append(accu)
return ret
def create_hook_module(target):
import imp
safe_name = SAFE_MODULE_NAME.sub("_", target, len(target))
module_name = "bento_hook_%s" % safe_name
main_file = os.path.abspath(target)
module = imp.new_module(module_name)
module.__file__ = main_file
code = open(main_file).read()
sys.path.insert(0, os.path.dirname(main_file))
try:
try:
exec(compile(code, main_file, 'exec'), module.__dict__)
sys.modules[module_name] = module
except SyntaxError:
e = extract_exception()
raise SyntaxError("Invalid syntax in hook file %s, line %s" % (main_file, e.lineno))
finally:
sys.path.pop(0)
module.root_path = main_file
if not "startup" in __INIT_FUNCS:
module.startup = dummy_startup
else:
module.startup = __INIT_FUNCS["startup"]
if not "options" in __INIT_FUNCS:
module.options = dummy_options
else:
module.options = __INIT_FUNCS["options"]
if not "shutdown" in __INIT_FUNCS:
module.shutdown = dummy_shutdown
else:
module.shutdown = __INIT_FUNCS["shutdown"]
return module
def run(self, ctx):
argv = ctx.get_command_arguments()
p = ctx.options_context.parser
o, a = p.parse_args(argv)
if o.help:
p.print_help()
return
if len(a) < 1:
filename = "setup.py"
else:
filename = a[0]
if not os.path.exists(filename):
raise ValueError("file %s not found" % filename)
output = o.output_filename
if os.path.exists(output):
raise UsageException("file %s exists, not overwritten" % output)
if o.verbose:
show_output = True
else:
show_output = False
if o.setup_args:
setup_args = comma_list_split(o.setup_args)
else:
setup_args = ["-q", "-n"]
tp = o.type
convert_log = "convert.log"
log = open(convert_log, "w")
try:
try:
if tp == "automatic":
try:
pprint("PINK",
"Catching monkey (this may take a while) ...")
tp = detect_monkeys(filename, show_output, log)
pprint("PINK", "Detected mode: %s" % tp)
except ValueError:
e = extract_exception()
raise UsageException("Error while detecting setup.py type " \
"(original error: %s)" % str(e))
monkey_patch(tp, filename)
# analyse_setup_py put results in LIVE_OBJECTS
dist = analyse_setup_py(filename, setup_args)
pkg, options = build_pkg(dist, LIVE_OBJECTS, ctx.top_node)
out = static_representation(pkg, options)
if output == '-':
for line in out.splitlines():
pprint("YELLOW", line)
else:
fid = open(output, "w")
try:
fid.write(out)
finally:
fid.close()
except ConvertionError:
raise
except Exception:
e = extract_exception()
log.write("Error while converting - traceback:\n")
tb = sys.exc_info()[2]
traceback.print_tb(tb, file=log)
msg = "Error while converting %s - you may look at %s for " \
"details (Original exception: %s %s)"
raise ConvertionError(msg % (filename, convert_log, type(e), str(e)))
finally:
log.flush()
log.close()
