def test_iter_source_nodes(self):
r_files = set([op.join("src", "foo.c"),
op.join("src", "bar.c"),
op.join("src", "fubar.c"),
op.join("foo", "__init__.py"),
op.join("foo", "bar", "__init__.py"),
"fu.py", "foo.1"])
bento_info = """\
Name: foo
DataFiles: foo
TargetDir: $sharedir
Files: foo.1
Library:
Extension: _foo
Sources: src/foo.c, src/bar.c
CompiledLibrary: fubar
Sources: src/fubar.c
Packages: foo, foo.bar
Modules: fu
"""
create_fake_package_from_bento_info(self.top_node, bento_info)
package = PackageDescription.from_string(bento_info)
node_package = NodeRepresentation(self.top_node, self.top_node)
node_package.update_package(package)
files = set(n.path_from(self.top_node) for n in node_package.iter_source_nodes())
self.assertEqual(files, r_files)
class SdistContext(ContextWithBuildDirectory):
def __init__(self, global_context, cmd_args, option_context, pkg,
run_node):
super(SdistContext, self).__init__(global_context, cmd_args,
option_context, pkg, run_node)
self._meta = {}
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
def register_metadata(self, name, value):
self._meta[name] = value
def register_source_node(self, node, archive_name=None):
"""Register a node into the source distribution.
archive_name is an optional string which will be used for the file name
in the archive."""
self._node_pkg._extra_source_nodes.append(node)
if archive_name:
self._node_pkg._aliased_source_nodes[node] = archive_name
def configure(self):
if self.pkg.meta_template_files:
for template in self.pkg.meta_template_files:
output = write_template(self.top_node, template, self.pkg,
self._meta)
self.register_source_node(output, output.bldpath())
class SdistContext(CmdContext):
def __init__(self, global_context, cmd_args, option_context, pkg, run_node):
super(SdistContext, self).__init__(global_context, cmd_args, option_context, pkg, run_node)
self._meta = {}
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
def register_metadata(self, name, value):
self._meta[name] = value
def register_source_node(self, node, archive_name=None):
"""Register a node into the source distribution.
archive_name is an optional string which will be used for the file name
in the archive."""
self._node_pkg._extra_source_nodes.append(node)
if archive_name:
self._node_pkg._aliased_source_nodes[node] = archive_name
def configure(self):
if self.pkg.meta_template_files:
for template in self.pkg.meta_template_files:
output = write_template(self.top_node, template, self.pkg, self._meta)
self.register_source_node(output, output.bldpath())
def test_iter_source_nodes(self):
r_files = set([
op.join("src", "foo.c"),
op.join("src", "bar.c"),
op.join("src", "fubar.c"),
op.join("foo", "__init__.py"),
op.join("foo", "bar", "__init__.py"), "fu.py", "foo.1"
])
bento_info = """\
Name: foo
DataFiles: foo
TargetDir: $sharedir
Files: foo.1
Library:
Extension: _foo
Sources: src/foo.c, src/bar.c
CompiledLibrary: fubar
Sources: src/fubar.c
Packages: foo, foo.bar
Modules: fu
"""
create_fake_package_from_bento_info(self.top_node, bento_info)
package = PackageDescription.from_string(bento_info)
node_package = NodeRepresentation(self.top_node, self.top_node)
node_package.update_package(package)
files = set(
n.path_from(self.top_node)
for n in node_package.iter_source_nodes())
self.assertEqual(files, r_files)
def __init__(self, global_context, cmd_args, option_context, pkg,
run_node):
super(SdistContext, self).__init__(global_context, cmd_args,
option_context, pkg, run_node)
self._meta = {}
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
def _create_package_and_reference(self, bento_info, r_bento_info):
pkg = PackageDescription.from_string(bento_info)
node_pkg = NodeRepresentation(self.run_node, self.top_node)
node_pkg.update_package(pkg)
r_pkg = PackageDescription.from_string(r_bento_info)
r_node_pkg = NodeRepresentation(self.run_node, self.top_node)
r_node_pkg.update_package(r_pkg)
return node_pkg, r_node_pkg
def __init__(self, global_context, cmd_args, option_context, pkg, run_node):
super(SdistContext, self).__init__(global_context, cmd_args, option_context, pkg, run_node)
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
if self.pkg.meta_template_file:
output = write_template(self.top_node, pkg)
self.register_source_node(output, output.bldpath())
def __init__(self, global_context, cmd_argv, options_context, pkg, run_node):
super(BuildContext, self).__init__(global_context, cmd_argv, options_context, pkg, run_node)
self.builder_registry = BuilderRegistry()
self.section_writer = SectionWriter()
o, a = self.options_context.parser.parse_args(cmd_argv)
if o.inplace:
self.inplace = True
else:
self.inplace = False
# Builders signature:
# - first argument: name, str. Name of the entity to be built
# - second argument: object. Value returned by
# NodePackage.iter_category for this category
# TODO: # Refactor builders so that they directoy register outputs
# instead of returning stuff to be registered (to allow for "delayed"
# registration)
def data_section_builder(name, section):
return name, section.nodes, section.ref_node, section.target_dir
def package_builder(name, nodes):
return name, nodes, self.top_node, "$sitedir"
def module_builder(name, node):
return name, [node], self.top_node, "$sitedir"
def script_builder(name, executable):
scripts_node = self.build_node.make_node("scripts-%s" % sys.version[:3])
scripts_node.mkdir()
if sys.platform == "win32":
nodes = create_win32_script(name, executable, scripts_node)
else:
nodes = create_posix_script(name, executable, scripts_node)
return name, nodes, scripts_node, "$bindir"
self.builder_registry.register_category("datafiles", data_section_builder)
self.builder_registry.register_category("packages", package_builder)
self.builder_registry.register_category("modules", module_builder)
self.builder_registry.register_category("scripts", script_builder)
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
categories = (("packages", "pythonfiles"), ("modules", "pythonfiles"), ("datafiles", "datafiles"),
("scripts", "executables"), ("extensions", "extensions"),
("compiled_libraries", "compiled_libraries"))
self.outputs_registry = OutputRegistry(categories)
self.isection_registry = ISectionRegistry()
self.isection_registry.register_category("extensions", _generic_iregistrer)
self.isection_registry.register_category("compiled_libraries", _generic_iregistrer)
self.isection_registry.register_category("packages", _generic_iregistrer)
self.isection_registry.register_category("modules", _generic_iregistrer)
self.isection_registry.register_category("datafiles", _generic_iregistrer)
self.isection_registry.register_category("scripts", _generic_iregistrer)
def test_sources_glob(self):
bento_info = """\
Name: foo
Library:
Extension: _foo
Sources: src/foo.c, src/bar.c
"""
create_fake_package_from_bento_info(self.top_node, bento_info)
bento_info = """\
Name: foo
Library:
Extension: _foo
Sources: src/*.c
"""
pkg = PackageDescription.from_string(bento_info)
node_pkg = NodeRepresentation(self.top_node, self.top_node)
node_pkg.update_package(pkg)
extensions = dict(node_pkg.iter_category("extensions"))
self.assertEqual(len(extensions), 1)
self.assertEqual(len(extensions["_foo"].nodes), 2)
def test_sources_glob(self):
bento_info = """\
Name: foo
Library:
Extension: _foo
Sources: src/foo.c, src/bar.c
"""
create_fake_package_from_bento_info(self.top_node, bento_info)
bento_info = """\
Name: foo
Library:
Extension: _foo
Sources: src/*.c
"""
pkg = PackageDescription.from_string(bento_info)
node_pkg = NodeRepresentation(self.top_node, self.top_node)
node_pkg.update_package(pkg)
extensions = dict(node_pkg.iter_category("extensions"))
self.assertEqual(len(extensions), 1)
self.assertEqual(len(extensions["_foo"].nodes), 2)
def _create_package_and_reference(self, bento_info, r_bento_info):
pkg = PackageDescription.from_string(bento_info)
node_pkg = NodeRepresentation(self.run_node, self.top_node)
node_pkg.update_package(pkg)
r_pkg = PackageDescription.from_string(r_bento_info)
r_node_pkg = NodeRepresentation(self.run_node, self.top_node)
r_node_pkg.update_package(r_pkg)
return node_pkg, r_node_pkg
def __init__(self, global_context, command_argv, options_context, pkg,
run_node):
super(BuildContext, self).__init__(global_context, command_argv,
options_context, pkg, run_node)
self.builder_registry = BuilderRegistry()
self.section_writer = SectionWriter()
o, a = self.options_context.parser.parse_args(command_argv)
if o.inplace:
self.inplace = True
else:
self.inplace = False
# Builders signature:
# - first argument: name, str. Name of the entity to be built
# - second argument: object. Value returned by
# NodePackage.iter_category for this category
# TODO: # Refactor builders so that they directoy register outputs
# instead of returning stuff to be registered (to allow for "delayed"
# registration)
def data_section_builder(name, section):
return name, section.nodes, section.ref_node, section.target_dir
def package_builder(name, node_py_package):
return name, node_py_package.nodes, self.top_or_sub_directory_node, "$sitedir"
def module_builder(name, node):
return name, [node], self.top_or_sub_directory_node, "$sitedir"
def script_builder(name, executable):
scripts_node = self.build_node.make_node("scripts-%s" %
sys.version[:3])
scripts_node.mkdir()
if sys.platform == "win32":
nodes = create_win32_script(name, executable, scripts_node)
else:
nodes = create_posix_script(name, executable, scripts_node)
return name, nodes, scripts_node, "$bindir"
self.builder_registry.register_category("datafiles",
data_section_builder)
self.builder_registry.register_category("packages", package_builder)
self.builder_registry.register_category("modules", module_builder)
self.builder_registry.register_category("scripts", script_builder)
if self.pkg.sub_directory is not None:
sub_directory_node = self.top_node.find_node(
self.pkg.sub_directory)
else:
sub_directory_node = None
self._node_pkg = NodeRepresentation(run_node, self.top_node,
sub_directory_node)
self._node_pkg.update_package(pkg)
categories = (("packages", "pythonfiles"), ("modules", "pythonfiles"),
("datafiles", "datafiles"), ("scripts", "executables"),
("extensions", "extensions"), ("compiled_libraries",
"compiled_libraries"))
self.outputs_registry = OutputRegistry(categories)
self.isection_registry = ISectionRegistry()
self.isection_registry.register_category("extensions",
_generic_iregistrer)
self.isection_registry.register_category("compiled_libraries",
_generic_iregistrer)
self.isection_registry.register_category("packages",
_generic_iregistrer)
self.isection_registry.register_category("modules",
_generic_iregistrer)
self.isection_registry.register_category("datafiles",
_generic_iregistrer)
self.isection_registry.register_category("scripts",
_generic_iregistrer)
self._current_default_section = 0
self._meta = {}
class BuildContext(ContextWithBuildDirectory):
def __init__(self, global_context, command_argv, options_context, pkg,
run_node):
super(BuildContext, self).__init__(global_context, command_argv,
options_context, pkg, run_node)
self.builder_registry = BuilderRegistry()
self.section_writer = SectionWriter()
o, a = self.options_context.parser.parse_args(command_argv)
if o.inplace:
self.inplace = True
else:
self.inplace = False
# Builders signature:
# - first argument: name, str. Name of the entity to be built
# - second argument: object. Value returned by
# NodePackage.iter_category for this category
# TODO: # Refactor builders so that they directoy register outputs
# instead of returning stuff to be registered (to allow for "delayed"
# registration)
def data_section_builder(name, section):
return name, section.nodes, section.ref_node, section.target_dir
def package_builder(name, node_py_package):
return name, node_py_package.nodes, self.top_or_sub_directory_node, "$sitedir"
def module_builder(name, node):
return name, [node], self.top_or_sub_directory_node, "$sitedir"
def script_builder(name, executable):
scripts_node = self.build_node.make_node("scripts-%s" %
sys.version[:3])
scripts_node.mkdir()
if sys.platform == "win32":
nodes = create_win32_script(name, executable, scripts_node)
else:
nodes = create_posix_script(name, executable, scripts_node)
return name, nodes, scripts_node, "$bindir"
self.builder_registry.register_category("datafiles",
data_section_builder)
self.builder_registry.register_category("packages", package_builder)
self.builder_registry.register_category("modules", module_builder)
self.builder_registry.register_category("scripts", script_builder)
if self.pkg.sub_directory is not None:
sub_directory_node = self.top_node.find_node(
self.pkg.sub_directory)
else:
sub_directory_node = None
self._node_pkg = NodeRepresentation(run_node, self.top_node,
sub_directory_node)
self._node_pkg.update_package(pkg)
categories = (("packages", "pythonfiles"), ("modules", "pythonfiles"),
("datafiles", "datafiles"), ("scripts", "executables"),
("extensions", "extensions"), ("compiled_libraries",
"compiled_libraries"))
self.outputs_registry = OutputRegistry(categories)
self.isection_registry = ISectionRegistry()
self.isection_registry.register_category("extensions",
_generic_iregistrer)
self.isection_registry.register_category("compiled_libraries",
_generic_iregistrer)
self.isection_registry.register_category("packages",
_generic_iregistrer)
self.isection_registry.register_category("modules",
_generic_iregistrer)
self.isection_registry.register_category("datafiles",
_generic_iregistrer)
self.isection_registry.register_category("scripts",
_generic_iregistrer)
self._current_default_section = 0
self._meta = {}
def register_metadata(self, name, value):
self._meta[name] = value
def register_category(self, category_name, category_type="pythonfiles"):
self.outputs_registry.register_category(category_name, category_type)
self.isection_registry.register_category(category_name,
_generic_iregistrer)
def register_outputs_simple(self,
nodes,
from_node=None,
target_dir='$sitedir'):
category_name = "hook_registered"
section_name = "hook_registered%d" % self._current_default_section
if not category_name in self.outputs_registry.categories:
self.register_category(category_name)
self.register_outputs(category_name, section_name, nodes, from_node,
target_dir)
self._current_default_section += 1
def register_outputs(self,
category_name,
section_name,
nodes,
from_node=None,
target_dir="$sitedir"):
if from_node is None:
from_node = self.build_node
self.outputs_registry.register_outputs(category_name, section_name,
nodes, from_node, target_dir)
def _compute_extension_name(self, extension_name):
if self.local_node is None:
raise ValueError("Forgot to call pre_recurse ?")
if self.local_node != self.top_node:
parent = self.local_node.srcpath().split(os.path.sep)
return ".".join(parent + [extension_name])
else:
return extension_name
def register_builder(self, extension_name, builder):
full_name = self._compute_extension_name(extension_name)
self.builder_registry.register_callback("extensions", full_name,
builder)
def default_builder(self, extension, **kw):
return self.builder_registry.default_callback("extensions", extension,
**kw)
def tweak_extension(self, extension_name, **kw):
def _builder(extension):
return self.default_builder(extension, **kw)
full_name = self._compute_extension_name(extension_name)
return self.builder_registry.register_callback("extensions", full_name,
_builder)
def tweak_library(self, lib_name, **kw):
def _builder(lib_name):
return self.default_library_builder(lib_name, **kw)
full_name = self._compute_extension_name(lib_name)
return self.builder_registry.register_callback("compiled_libraries",
full_name, _builder)
def default_library_builder(self, library, **kw):
return self.builder_registry.default_callback("compiled_libraries",
library, **kw)
def disable_extension(self, extension_name):
def nobuild(extension):
pass
self.register_builder(extension_name, nobuild)
def register_compiled_library_builder(self, clib_name, builder):
full_name = self._compute_extension_name(clib_name)
self.builder_registry.register_callback("compiled_libraries",
full_name, builder)
def compile(self):
for category in ("packages", "modules", "datafiles"):
for name, value in self._node_pkg.iter_category(category):
builder = self.builder_registry.builder(category, name)
name, nodes, from_node, target_dir = builder(name, value)
self.outputs_registry.register_outputs(category, name, nodes,
from_node, target_dir)
category = "scripts"
for name, executable in self.pkg.executables.items():
builder = self.builder_registry.builder(category, name)
name, nodes, from_node, target_dir = builder(name, executable)
self.outputs_registry.register_outputs(category, name, nodes,
from_node, target_dir)
if self.pkg.config_py:
content = _config_content(self.retrieve_configured_scheme())
target_node = self.build_node.make_node(self.pkg.config_py)
target_node.parent.mkdir()
target_node.safe_write(content)
self.outputs_registry.register_outputs("modules", "bento_config",
[target_node],
self.build_node, "$sitedir")
if self.pkg.meta_template_files:
target_nodes = []
for template in self.pkg.meta_template_files:
target_node = write_template(self.top_node, template, self.pkg,
self._meta)
target_nodes.append(target_node)
self.outputs_registry.register_outputs("modules",
"meta_from_template",
target_nodes,
self.build_node, "$sitedir")
def post_compile(self):
# Do the output_registry -> installed sections registry convertion
section_writer = self.section_writer
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category(
):
installed_category = self.outputs_registry.installed_categories[
category]
if installed_category in section_writer.sections:
sections = section_writer.sections[installed_category]
else:
sections = section_writer.sections[installed_category] = {}
registrer = self.isection_registry.registrer(category, name)
sections[name] = registrer(installed_category, name, nodes,
from_node, target_dir)
# FIXME: this is quite stupid.
if self.inplace:
scheme = self.retrieve_scheme()
scheme["prefix"] = scheme["eprefix"] = self.run_node.abspath()
scheme["sitedir"] = self.run_node.abspath()
if self.pkg.config_py:
target_node = self.build_node.find_node(self.pkg.config_py)
else:
target_node = None
def _install_node(category, node, from_node, target_dir):
installed_path = subst_vars(target_dir, scheme)
target = os.path.join(installed_path,
node.path_from(from_node))
copy_installer(node.path_from(self.run_node), target, category)
intree = (self.top_node == self.run_node)
if intree:
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category(
):
for node in nodes:
if node != target_node and node.is_bld():
_install_node(category, node, from_node,
target_dir)
else:
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category(
):
for node in nodes:
if node != target_node:
_install_node(category, node, from_node,
target_dir)
class BuildContext(_ContextWithBuildDirectory):
def __init__(self, cmd_argv, options_context, pkg, run_node):
super(BuildContext, self).__init__(cmd_argv, options_context, pkg, run_node)
self.builder_registry = BuilderRegistry()
self.section_writer = SectionWriter()
# Builders signature:
# - first argument: name, str. Name of the entity to be built
# - second argument: object. Value returned by
# NodePackage.iter_category for this category
# TODO: # Refactor builders so that they directoy register outputs
# instead of returning stuff to be registered (to allow for "delayed"
# registration)
def data_section_builder(name, section):
return name, section.nodes, section.ref_node, section.target_dir
def package_builder(name, nodes):
return name, nodes, self.top_node, "$sitedir"
def module_builder(name, node):
return name, [node], self.top_node, "$sitedir"
def script_builder(name, executable):
scripts_node = self.build_node.make_node("scripts-%s" % sys.version[:3])
scripts_node.mkdir()
if sys.platform == "win32":
nodes = create_win32_script(name, executable, scripts_node)
else:
nodes = create_posix_script(name, executable, scripts_node)
return name, nodes, scripts_node, "$bindir"
self.builder_registry.register_category("datafiles", data_section_builder)
self.builder_registry.register_category("packages", package_builder)
self.builder_registry.register_category("modules", module_builder)
self.builder_registry.register_category("scripts", script_builder)
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
categories = (("packages", "pythonfiles"), ("modules", "pythonfiles"), ("datafiles", "datafiles"),
("scripts", "executables"), ("extensions", "extensions"),
("compiled_libraries", "compiled_libraries"))
self.outputs_registry = OutputRegistry(categories)
self.isection_registry = ISectionRegistry()
self.isection_registry.register_category("extensions", _generic_iregistrer)
self.isection_registry.register_category("compiled_libraries", _generic_iregistrer)
self.isection_registry.register_category("packages", _generic_iregistrer)
self.isection_registry.register_category("modules", _generic_iregistrer)
self.isection_registry.register_category("datafiles", _generic_iregistrer)
self.isection_registry.register_category("scripts", _generic_iregistrer)
def register_category(self, category_name, category_type="pythonfiles"):
self.outputs_registry.register_category(category_name, category_type)
self.isection_registry.register_category(category_name, _generic_iregistrer)
def register_outputs(self, category_name, section_name, nodes, from_node=None, target_dir="$sitedir"):
if from_node is None:
from_node = self.build_node
self.outputs_registry.register_outputs(category_name, section_name, nodes, from_node, target_dir)
def shutdown(self):
CmdContext.shutdown(self)
def _compute_extension_name(self, extension_name):
if self.local_node is None:
raise ValueError("Forgot to call pre_recurse ?")
if self.local_node != self.top_node:
parent = self.local_node.srcpath().split(os.path.sep)
return ".".join(parent + [extension_name])
else:
return extension_name
def register_builder(self, extension_name, builder):
full_name = self._compute_extension_name(extension_name)
self.builder_registry.register_callback("extensions", full_name, builder)
def disable_extension(self, extension_name):
def nobuild(extension):
pass
self.register_builder(extension_name, nobuild)
def register_compiled_library_builder(self, clib_name, builder):
relpos = self.local_node.path_from(self.top_node)
full_name = os.path.join(relpos, clib_name).replace(os.sep, ".")
self.builder_registry.register_callback("compiled_libraries", full_name, builder)
def compile(self):
for category in ("packages", "modules", "datafiles"):
for name, value in self._node_pkg.iter_category(category):
builder = self.builder_registry.builder(category, name)
name, nodes, from_node, target_dir = builder(name, value)
self.outputs_registry.register_outputs(category, name, nodes, from_node, target_dir)
category = "scripts"
for name, executable in self.pkg.executables.iteritems():
builder = self.builder_registry.builder(category, name)
name, nodes, from_node, target_dir = builder(name, executable)
self.outputs_registry.register_outputs(category, name, nodes, from_node, target_dir)
if self.pkg.config_py:
content = _config_content(self.get_paths_scheme())
target_node = self.build_node.make_node(self.pkg.config_py)
target_node.parent.mkdir()
target_node.safe_write(content)
self.outputs_registry.register_outputs("modules", "bento_config", [target_node],
self.build_node, "$sitedir")
def post_compile(self):
# Do the output_registry -> installed sections registry convertion
section_writer = self.section_writer
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category():
installed_category = self.outputs_registry.installed_categories[category]
if installed_category in section_writer.sections:
sections = section_writer.sections[installed_category]
else:
sections = section_writer.sections[installed_category] = {}
registrer = self.isection_registry.registrer(category, name)
sections[name] = registrer(installed_category, name, nodes, from_node, target_dir)
def __init__(self, global_context, cmd_args, option_context, pkg, run_node):
super(SdistContext, self).__init__(global_context, cmd_args, option_context, pkg, run_node)
self._meta = {}
self._node_pkg = NodeRepresentation(run_node, self.top_node)
self._node_pkg.update_package(pkg)
class BuildContext(ContextWithBuildDirectory):
def __init__(self, global_context, command_argv, options_context, pkg, run_node):
super(BuildContext, self).__init__(global_context, command_argv, options_context, pkg, run_node)
self.builder_registry = BuilderRegistry()
self.section_writer = SectionWriter()
o, a = self.options_context.parser.parse_args(command_argv)
if o.inplace:
self.inplace = True
else:
self.inplace = False
# Builders signature:
# - first argument: name, str. Name of the entity to be built
# - second argument: object. Value returned by
# NodePackage.iter_category for this category
# TODO: # Refactor builders so that they directoy register outputs
# instead of returning stuff to be registered (to allow for "delayed"
# registration)
def data_section_builder(name, section):
return name, section.nodes, section.ref_node, section.target_dir
def package_builder(name, node_py_package):
return name, node_py_package.nodes, self.top_or_sub_directory_node, "$sitedir"
def module_builder(name, node):
return name, [node], self.top_or_sub_directory_node, "$sitedir"
def script_builder(name, executable):
scripts_node = self.build_node.make_node("scripts-%s" % sys.version[:3])
scripts_node.mkdir()
if sys.platform == "win32":
nodes = create_win32_script(name, executable, scripts_node)
else:
nodes = create_posix_script(name, executable, scripts_node)
return name, nodes, scripts_node, "$bindir"
self.builder_registry.register_category("datafiles", data_section_builder)
self.builder_registry.register_category("packages", package_builder)
self.builder_registry.register_category("modules", module_builder)
self.builder_registry.register_category("scripts", script_builder)
if self.pkg.sub_directory is not None:
sub_directory_node = self.top_node.find_node(self.pkg.sub_directory)
else:
sub_directory_node = None
self._node_pkg = NodeRepresentation(run_node, self.top_node, sub_directory_node)
self._node_pkg.update_package(pkg)
categories = (("packages", "pythonfiles"), ("modules", "pythonfiles"), ("datafiles", "datafiles"),
("scripts", "executables"), ("extensions", "extensions"),
("compiled_libraries", "compiled_libraries"))
self.outputs_registry = OutputRegistry(categories)
self.isection_registry = ISectionRegistry()
self.isection_registry.register_category("extensions", _generic_iregistrer)
self.isection_registry.register_category("compiled_libraries", _generic_iregistrer)
self.isection_registry.register_category("packages", _generic_iregistrer)
self.isection_registry.register_category("modules", _generic_iregistrer)
self.isection_registry.register_category("datafiles", _generic_iregistrer)
self.isection_registry.register_category("scripts", _generic_iregistrer)
self._current_default_section = 0
self._meta = {}
def register_metadata(self, name, value):
self._meta[name] = value
def register_category(self, category_name, category_type="pythonfiles"):
self.outputs_registry.register_category(category_name, category_type)
self.isection_registry.register_category(category_name, _generic_iregistrer)
def register_outputs_simple(self, nodes, from_node=None, target_dir='$sitedir'):
category_name = "hook_registered"
section_name = "hook_registered%d" % self._current_default_section
if not category_name in self.outputs_registry.categories:
self.register_category(category_name)
self.register_outputs(category_name, section_name, nodes, from_node, target_dir)
self._current_default_section += 1
def register_outputs(self, category_name, section_name, nodes, from_node=None, target_dir="$sitedir"):
if from_node is None:
from_node = self.build_node
self.outputs_registry.register_outputs(category_name, section_name, nodes, from_node, target_dir)
def _compute_extension_name(self, extension_name):
if self.local_node is None:
raise ValueError("Forgot to call pre_recurse ?")
if self.local_node != self.top_node:
parent = self.local_node.srcpath().split(os.path.sep)
return ".".join(parent + [extension_name])
else:
return extension_name
def register_builder(self, extension_name, builder):
full_name = self._compute_extension_name(extension_name)
self.builder_registry.register_callback("extensions", full_name, builder)
def default_builder(self, extension, **kw):
return self.builder_registry.default_callback(
"extensions",
extension,
**kw)
def tweak_extension(self, extension_name, **kw):
def _builder(extension):
return self.default_builder(extension, **kw)
full_name = self._compute_extension_name(extension_name)
return self.builder_registry.register_callback("extensions", full_name, _builder)
def tweak_library(self, lib_name, **kw):
def _builder(lib_name):
return self.default_library_builder(lib_name, **kw)
relpos = self.local_node.path_from(self.top_node)
full_name = os.path.join(relpos, lib_name).replace(os.sep, ".")
return self.builder_registry.register_callback("compiled_libraries", full_name, _builder)
def default_library_builder(self, library, **kw):
return self.builder_registry.default_callback(
"compiled_libraries",
library,
**kw)
def disable_extension(self, extension_name):
def nobuild(extension):
pass
self.register_builder(extension_name, nobuild)
def register_compiled_library_builder(self, clib_name, builder):
relpos = self.local_node.path_from(self.top_node)
full_name = os.path.join(relpos, clib_name).replace(os.sep, ".")
self.builder_registry.register_callback("compiled_libraries", full_name, builder)
def compile(self):
for category in ("packages", "modules", "datafiles"):
for name, value in self._node_pkg.iter_category(category):
builder = self.builder_registry.builder(category, name)
name, nodes, from_node, target_dir = builder(name, value)
self.outputs_registry.register_outputs(category, name, nodes, from_node, target_dir)
category = "scripts"
for name, executable in self.pkg.executables.items():
builder = self.builder_registry.builder(category, name)
name, nodes, from_node, target_dir = builder(name, executable)
self.outputs_registry.register_outputs(category, name, nodes, from_node, target_dir)
if self.pkg.config_py:
content = _config_content(self.retrieve_configured_scheme())
target_node = self.build_node.make_node(self.pkg.config_py)
target_node.parent.mkdir()
target_node.safe_write(content)
self.outputs_registry.register_outputs("modules", "bento_config", [target_node],
self.build_node, "$sitedir")
if self.pkg.meta_template_files:
target_nodes = []
for template in self.pkg.meta_template_files:
target_node = write_template(self.top_node, template, self.pkg, self._meta)
target_nodes.append(target_node)
self.outputs_registry.register_outputs("modules", "meta_from_template", target_nodes,
self.build_node, "$sitedir")
def post_compile(self):
# Do the output_registry -> installed sections registry convertion
section_writer = self.section_writer
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category():
installed_category = self.outputs_registry.installed_categories[category]
if installed_category in section_writer.sections:
sections = section_writer.sections[installed_category]
else:
sections = section_writer.sections[installed_category] = {}
registrer = self.isection_registry.registrer(category, name)
sections[name] = registrer(installed_category, name, nodes, from_node, target_dir)
# FIXME: this is quite stupid.
if self.inplace:
scheme = self.retrieve_scheme()
scheme["prefix"] = scheme["eprefix"] = self.run_node.abspath()
scheme["sitedir"] = self.run_node.abspath()
if self.pkg.config_py:
target_node = self.build_node.find_node(self.pkg.config_py)
else:
target_node = None
def _install_node(category, node, from_node, target_dir):
installed_path = subst_vars(target_dir, scheme)
target = os.path.join(installed_path, node.path_from(from_node))
copy_installer(node.path_from(self.run_node), target, category)
intree = (self.top_node == self.run_node)
if intree:
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category():
for node in nodes:
if node != target_node and node.is_bld():
_install_node(category, node, from_node, target_dir)
else:
for category, name, nodes, from_node, target_dir in self.outputs_registry.iter_over_category():
for node in nodes:
if node != target_node:
_install_node(category, node, from_node, target_dir)
