def test_simple_package(self): bento_info = """\ Name: foo Version: 1.0 ExtraSourceFiles: yeah.info Library: Packages: foo, foo.bar Modules: fubar """ archive_list = [op.join("foo-1.0", f) for f in ["yeah.info", op.join("foo", "__init__.py"), op.join("foo", "bar", "__init__.py"), "fubar.py"]] create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) sdist.run(context) sdist.shutdown(context) context.shutdown() archive = self.run_node.find_node(op.join("dist", "foo.zip")) z = zipfile.ZipFile(archive.abspath(), "r") for f in archive_list: if not f in z.namelist(): self.failUnless(op.join("foo-1.0", f) in files)
def _run_configure_and_build(self, bento_info, install_prefix): top_node = self.top_node create_fake_package_from_bento_info(top_node, bento_info) context = GlobalContext(None) options = PackageOptions.from_string(bento_info) context.register_package_options(options) cmd_argv = ["--prefix=%s" % install_prefix, "--exec-prefix=%s" % install_prefix] conf, configure = prepare_configure(top_node, bento_info, ConfigureYakuContext, cmd_argv) context.register_command("configure", configure) options_context = OptionsContext.from_command(configure) if not context.is_options_context_registered("configure"): context.register_options_context("configure", options_context) context.save_command_argv("configure", cmd_argv) run_command_in_context(conf, configure) bld, build = prepare_build(top_node, bento_info) run_command_in_context(bld, build) return context, conf, configure, bld, build
def register_options(global_context, cmd_name): """Register options for the given command.""" cmd = global_context.retrieve_command(cmd_name) context = OptionsContext.from_command(cmd) if not global_context.is_options_context_registered(cmd_name): global_context.register_options_context(cmd_name, context)
def test_extra_source_registration(self): bento_info = """\ Name: foo Version: 1.0 Library: Modules: fubar """ archive_list = [ op.join("foo-1.0", f) for f in ["fubar.py", "yeah.info", "PKG_INFO"] ] extra_node = self.top_node.make_node("yeah.info") extra_node.write("") create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) context.register_source_node(self.top_node.find_node("yeah.info")) run_command_in_context(context, sdist) self._assert_archive_equality(op.join("dist", "foo.zip"), archive_list)
def test_extra_source_registration(self): bento_info = """\ Name: foo Version: 1.0 Library: Modules: fubar """ archive_list = [op.join("foo-1.0", f) for f in ["fubar.py", "yeah.info"]] extra_node = self.top_node.make_node("yeah.info") extra_node.write("") create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) context.register_source_node(self.top_node.find_node("yeah.info")) sdist.run(context) sdist.shutdown(context) context.shutdown() archive = self.run_node.find_node(op.join("dist", "foo.zip")) z = zipfile.ZipFile(archive.abspath(), "r") for f in archive_list: if not f in z.namelist(): self.failUnless(op.join("foo-1.0", f) in files)
def test_template_filling(self): bento_info = """\ Name: foo Version: 1.0 MetaTemplateFiles: release.py.in Library: Modules: fubar """ archive_list = [ op.join("foo-1.0", f) for f in ["fubar.py", "release.py.in", "release.py", "PKG_INFO"] ] template = self.top_node.make_node("release.py.in") template.write("""\ NAME = $NAME VERSION = $VERSION """) create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) run_command_in_context(context, sdist) self._assert_archive_equality(op.join("dist", "foo.zip"), archive_list)
def test_simple_package(self): bento_info = """\ Name: foo Version: 1.0 ExtraSourceFiles: yeah.info Library: Packages: foo, foo.bar Modules: fubar """ archive_list = [ op.join("foo-1.0", f) for f in [ "yeah.info", "PKG_INFO", op.join("foo", "__init__.py"), op.join("foo", "bar", "__init__.py"), "fubar.py" ] ] create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) run_command_in_context(context, sdist) self._assert_archive_equality(op.join("dist", "foo.zip"), archive_list)
def test_template_filling(self): bento_info = """\ Name: foo Version: 1.0 MetaTemplateFile: release.py.in Library: Modules: fubar """ archive_list = [op.join("foo-1.0", f) for f in ["fubar.py", "release.py.in", "release.py"]] template = self.top_node.make_node("release.py.in") template.write("""\ NAME = $NAME VERSION = $VERSION """) create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) sdist.run(context) sdist.shutdown(context) context.shutdown() archive = self.run_node.find_node(op.join("dist", "foo.zip")) z = zipfile.ZipFile(archive.abspath(), "r") for f in archive_list: if not f in z.namelist(): self.fail("File %s not found in archive" % (f,))
def _run_configure_and_build(self, bento_info, install_prefix): top_node = self.top_node create_fake_package_from_bento_info(top_node, bento_info) context = GlobalContext(None) options = PackageOptions.from_string(bento_info) context.register_package_options(options) cmd_argv = [ "--prefix=%s" % install_prefix, "--exec-prefix=%s" % install_prefix ] conf, configure = prepare_configure(top_node, bento_info, ConfigureYakuContext, cmd_argv) context.register_command("configure", configure) options_context = OptionsContext.from_command(configure) if not context.is_options_context_registered("configure"): context.register_options_context("configure", options_context) context.save_command_argv("configure", cmd_argv) run_command_in_context(conf, configure) bld, build = prepare_build(top_node, bento_info) run_command_in_context(bld, build) return context, conf, configure, bld, build
def register_options(global_context, cmd_name): """Register options for the given command.""" cmd = global_context.retrieve_command(cmd_name) context = OptionsContext.from_command(cmd) if not global_context.is_options_context_registered(cmd_name): global_context.register_options_context(cmd_name, context)
def test_simple_package(self): bento_info = """\ Name: foo Version: 1.0 ExtraSourceFiles: yeah.info Library: Packages: foo, foo.bar Modules: fubar """ archive_list = [op.join("foo-1.0", f) for f in ["yeah.info", op.join("foo", "__init__.py"), op.join("foo", "bar", "__init__.py"), "fubar.py"]] create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) run_command_in_context(context, sdist) self._assert_archive_equality(op.join("dist", "foo.zip"), archive_list)
def test_template_filling(self): bento_info = """\ Name: foo Version: 1.0 MetaTemplateFile: release.py.in Library: Modules: fubar """ archive_list = [op.join("foo-1.0", f) for f in ["fubar.py", "release.py.in", "release.py"]] template = self.top_node.make_node("release.py.in") template.write("""\ NAME = $NAME VERSION = $VERSION """) create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) run_command_in_context(context, sdist) self._assert_archive_equality(op.join("dist", "foo.zip"), archive_list)
def test_compiled_library(self): from bento.backends.distutils_backend import DistutilsBuildContext r_full_name = "lib/_foo" bento_info = """\ Name: foo Library: CompiledLibrary: lib/_foo Sources: foo.c """ package = PackageDescription.from_string(bento_info) create_fake_package_from_bento_info(self.top_node, bento_info) options = OptionsContext.from_command(BuildCommand()) context = DistutilsBuildContext(None, [], options, package, self.run_node) context.pre_recurse(self.top_node) try: def builder(a): self.assertEqual(a.name, r_full_name) builder.is_called = True builder.is_called = False context.register_compiled_library_builder("lib/_foo", builder) finally: context.post_recurse() context.compile() self.assertTrue(builder.is_called, "registered builder not called")
def test_extra_source_registration(self): bento_info = """\ Name: foo Version: 1.0 Library: Modules: fubar """ archive_list = [op.join("foo-1.0", f) for f in ["fubar.py", "yeah.info"]] extra_node = self.top_node.make_node("yeah.info") extra_node.write("") create_fake_package_from_bento_info(self.top_node, bento_info) package = PackageDescription.from_string(bento_info) sdist = SdistCommand() opts = OptionsContext.from_command(sdist) cmd_argv = ["--output-file=foo.zip", "--format=zip"] context = SdistContext(None, cmd_argv, opts, package, self.run_node) context.register_source_node(self.top_node.find_node("yeah.info")) run_command_in_context(context, sdist) self._assert_archive_equality(op.join("dist", "foo.zip"), archive_list)
def test_compiled_library(self): from bento.backends.distutils_backend import DistutilsBuildContext r_full_name = "lib/_foo" bento_info = """\ Name: foo Library: CompiledLibrary: lib/_foo Sources: foo.c """ package = PackageDescription.from_string(bento_info) create_fake_package_from_bento_info(self.top_node, bento_info) options = OptionsContext.from_command(BuildCommand()) context = DistutilsBuildContext(None, [], options, package, self.run_node) context.pre_recurse(self.top_node) try: def builder(a): self.assertEqual(a.name, r_full_name) builder.is_called = True builder.is_called = False context.register_compiled_library_builder("lib/_foo", builder) finally: context.post_recurse() context.compile() self.assertTrue(builder.is_called, "registered builder not called")
def prepare_options(cmd_name, cmd, context_klass): opts = OptionsContext.from_command(cmd) g_context = FakeGlobalContext() g_context._cmd_opts[cmd_name] = opts # FIXME: the way new options are registered for custom contexts sucks: # there should be a context class independent way to do it if context_klass.__name__ == "BuildWafContext": from bento.commands.extras.waf import register_options register_options(g_context) return opts
def _test_dry_run(self, bento_info): install_prefix = tempfile.mkdtemp() try: context, conf, configure, bld, build = self._run_configure_and_build(bento_info, install_prefix) install = InstallCommand() opts = OptionsContext.from_command(install) inst = ContextWithBuildDirectory(context, ["--list-files"], opts, conf.pkg, self.top_node) run_command_in_context(inst, install) finally: shutil.rmtree(install_prefix)
def _test_run(self, bento_info): install_prefix = tempfile.mkdtemp() try: conf, configure, bld, build = self._run_configure_and_build(bento_info, install_prefix) install = InstallCommand() opts = OptionsContext.from_command(install) inst = CmdContext(None, [], opts, conf.pkg, self.top_node) install.run(inst) finally: shutil.rmtree(install_prefix)
def test_simple_distutils(self): top_node = self.top_node create_fake_package_from_bento_info(top_node, BENTO_INFO_WITH_EXT) conf, configure = prepare_configure(top_node, BENTO_INFO_WITH_EXT, DistutilsConfigureContext) run_command_in_context(conf, configure) build = BuildCommand() opts = OptionsContext.from_command(build) bld = DistutilsBuildContext(None, [], opts, conf.pkg, top_node) run_command_in_context(bld, build)
def test_simple_distutils(self): top_node = self.top_node create_fake_package_from_bento_info(top_node, BENTO_INFO_WITH_EXT) conf, configure = prepare_configure(top_node, BENTO_INFO_WITH_EXT, DistutilsConfigureContext) run_command_in_context(conf, configure) build = BuildCommand() opts = OptionsContext.from_command(build) bld = DistutilsBuildContext(None, [], opts, conf.pkg, top_node) run_command_in_context(bld, build)
def test_simple_yaku(self): top_node = self.top_node create_fake_package_from_bento_info(top_node, BENTO_INFO_WITH_EXT) conf, configure = prepare_configure(top_node, BENTO_INFO_WITH_EXT, ConfigureYakuContext) configure.run(conf) conf.shutdown() build = BuildCommand() opts = OptionsContext.from_command(build) bld = BuildYakuContext([], opts, conf.pkg, top_node) build.run(bld)
def test_simple(self): root = self.root top_node = root.find_node(self.d) create_fake_package_from_bento_info(top_node, BENTO_INFO) conf, configure = prepare_configure(top_node, BENTO_INFO, ConfigureYakuContext) configure.run(conf) conf.shutdown() build = BuildCommand() opts = OptionsContext.from_command(build) bld = BuildYakuContext([], opts, conf.pkg, top_node) build.run(bld)
def _run_convert_command(top_node, run_node, setup_py, bento_info, cmd_argv): setup_node = top_node.make_node("setup.py") setup_node.safe_write(setup_py) create_fake_package_from_bento_info(top_node, bento_info) package = PackageDescription.from_string(bento_info) cmd = ConvertCommand() opts = OptionsContext.from_command(cmd) context = CmdContext(None, cmd_argv, opts, package, run_node) cmd.run(context) cmd.finish(context) context.finish()
def _run_command(self): setup_node = self.top_node.make_node("setup.py") setup_node.safe_write("") create_fake_package_from_bento_info(self.top_node, "") package = PackageDescription.from_string("") cmd = DetectTypeCommand() opts = OptionsContext.from_command(cmd) context = CmdContext(None, [], opts, package, self.run_node) cmd.run(context) cmd.finish(context) context.finish()
def _run_convert_command(top_node, run_node, setup_py, bento_info, cmd_argv): setup_node = top_node.make_node("setup.py") setup_node.safe_write(setup_py) create_fake_package_from_bento_info(top_node, bento_info) package = PackageDescription.from_string(bento_info) cmd = ConvertCommand() opts = OptionsContext.from_command(cmd) context = CmdContext(None, cmd_argv, opts, package, run_node) cmd.run(context) cmd.finish(context) context.finish()
def _test_dry_run(self, bento_info): install_prefix = tempfile.mkdtemp() try: context, conf, configure, bld, build = self._run_configure_and_build( bento_info, install_prefix) install = InstallCommand() opts = OptionsContext.from_command(install) inst = ContextWithBuildDirectory(context, ["--list-files"], opts, conf.pkg, self.top_node) run_command_in_context(inst, install) finally: shutil.rmtree(install_prefix)
def _run_command(self): setup_node = self.top_node.make_node("setup.py") setup_node.safe_write("") create_fake_package_from_bento_info(self.top_node, "") package = PackageDescription.from_string("") cmd = DetectTypeCommand() opts = OptionsContext.from_command(cmd) context = CmdContext(None, [], opts, package, self.run_node) cmd.run(context) cmd.finish(context) context.finish()
def global_context_factory(package_options): # FIXME: factor this out with the similar code in bentomakerlib global_context = GlobalContext(None) global_context.register_package_options(package_options) register_commands(global_context) register_command_contexts(global_context) for cmd_name in global_context.command_names(): cmd = global_context.retrieve_command(cmd_name) options_context = OptionsContext.from_command(cmd) if not global_context.is_options_context_registered(cmd_name): global_context.register_options_context(cmd_name, options_context) return global_context
def global_context_factory(package_options): # FIXME: factor this out with the similar code in bentomakerlib global_context = GlobalContext(None) global_context.register_package_options(package_options) register_commands(global_context) register_command_contexts(global_context) for cmd_name in global_context.command_names(): cmd = global_context.retrieve_command(cmd_name) options_context = OptionsContext.from_command(cmd) if not global_context.is_options_context_registered(cmd_name): global_context.register_options_context(cmd_name, options_context) return global_context
def _setup_hooks(self, package, global_context, mods): if package.use_backends: if len(package.use_backends) > 1: raise ValueError("Only up to one backend supported for now") else: assert global_context.backend is None global_context.backend = load_backend( package.use_backends[0])() startup_hooks = find_startup_hooks(mods) option_hooks = find_options_hooks(mods) shutdown_hooks = find_shutdown_hooks(mods) if startup_hooks: # FIXME: there should be an error or a warning if startup defined in # mods beyond the first one startup_hooks[0](global_context) if global_context.backend: global_context.backend.register_command_contexts(global_context) for command in find_command_hooks(mods): global_context.register_command(command.name, command) if global_context.backend: global_context.backend.register_options_contexts(global_context) if option_hooks: # FIXME: there should be an error or a warning if shutdown defined in # mods beyond the first one option_hooks[0](global_context) # FIXME: this registered options for new commands registered in hook. It # should be made all in one place (hook and non-hook) for cmd_name in global_context.command_names(public_only=False): if not global_context.is_options_context_registered(cmd_name): # FIXME: this should be supported in global context directly # (redundant with bentomakerlib) cmd = global_context.retrieve_command(cmd_name) context = OptionsContext.from_command(cmd) if not global_context.is_options_context_registered(cmd_name): global_context.register_options_context(cmd_name, context) for cmd_name in global_context.command_names(): for hook in find_pre_hooks(mods, cmd_name): global_context.add_pre_hook(hook, cmd_name) for hook in find_post_hooks(mods, cmd_name): global_context.add_post_hook(hook, cmd_name)
def test_simple(self): n = self.top_node.make_node("doc/conf.py") n.parent.mkdir() n.write("") n = self.top_node.make_node("doc/contents.rst") n.write("") bento_info = "Name: foo" package = PackageDescription.from_string(bento_info) sphinx = SphinxCommand() opts = OptionsContext.from_command(sphinx) context = ContextWithBuildDirectory(None, [], opts, package, self.run_node) run_command_in_context(context, sphinx)
def test_simple(self): n = self.top_node.make_node("doc/conf.py") n.parent.mkdir() n.write("") n = self.top_node.make_node("doc/contents.rst") n.write("") bento_info = "Name: foo" package = PackageDescription.from_string(bento_info) sphinx = SphinxCommand() opts = OptionsContext.from_command(sphinx) context = ContextWithBuildDirectory(None, [], opts, package, self.run_node) run_command_in_context(context, sphinx)
def _setup_hooks(self, package, global_context, mods): if package.use_backends: if len(package.use_backends) > 1: raise ValueError("Only up to one backend supported for now") else: assert global_context.backend is None global_context.backend = load_backend(package.use_backends[0])() startup_hooks = find_startup_hooks(mods) option_hooks = find_options_hooks(mods) shutdown_hooks = find_shutdown_hooks(mods) if startup_hooks: # FIXME: there should be an error or a warning if startup defined in # mods beyond the first one startup_hooks[0](global_context) if global_context.backend: global_context.backend.register_command_contexts(global_context) for command in find_command_hooks(mods): global_context.register_command(command.name, command) if global_context.backend: global_context.backend.register_options_contexts(global_context) if option_hooks: # FIXME: there should be an error or a warning if shutdown defined in # mods beyond the first one option_hooks[0](global_context) # FIXME: this registered options for new commands registered in hook. It # should be made all in one place (hook and non-hook) for cmd_name in global_context.command_names(public_only=False): if not global_context.is_options_context_registered(cmd_name): # FIXME: this should be supported in global context directly # (redundant with bentomakerlib) cmd = global_context.retrieve_command(cmd_name) context = OptionsContext.from_command(cmd) if not global_context.is_options_context_registered(cmd_name): global_context.register_options_context(cmd_name, context) for cmd_name in global_context.command_names(): for hook in find_pre_hooks(mods, cmd_name): global_context.add_pre_hook(hook, cmd_name) for hook in find_post_hooks(mods, cmd_name): global_context.add_post_hook(hook, cmd_name)
def _prepare_command(run_node, bento_info, cmd_klass, context_klass, cmd_argv): top_node = run_node._ctx.srcnode top_node.make_node("bento.info").safe_write(bento_info) package = PackageDescription.from_string(bento_info) package_options = PackageOptions.from_string(bento_info) cmd = cmd_klass() options_context = OptionsContext.from_command(cmd) cmd.register_options(options_context, package_options) global_context = GlobalContext(None) global_context.register_package_options(package_options) context = context_klass(global_context, cmd_argv, options_context, package, run_node) return context, cmd
def _prepare_command(run_node, bento_info, cmd_klass, context_klass, cmd_argv): top_node = run_node._ctx.srcnode top_node.make_node("bento.info").safe_write(bento_info) package = PackageDescription.from_string(bento_info) package_options = PackageOptions.from_string(bento_info) cmd = cmd_klass() options_context = OptionsContext.from_command(cmd) cmd.register_options(options_context, package_options) global_context = GlobalContext(None) global_context.register_package_options(package_options) context = context_klass(global_context, cmd_argv, options_context, package, run_node) return context, cmd
def write_record(self): dist = self.distribution install = InstallCommand() options_context = OptionsContext.from_command(install) context = CmdContext([], options_context, dist.pkg, dist.run_node) if self.record: n = context.build_node.make_node(IPKG_PATH) ipkg = InstalledPkgDescription.from_file(n.abspath()) scheme = context.get_paths_scheme() ipkg.update_paths(scheme) file_sections = ipkg.resolve_paths(src_root_dir=context.build_node.abspath()) fid = open(self.record, "w") try: for kind, source, target in iter_files(file_sections): fid.write("%s\n" % target) finally: fid.close()
def global_context_factory(package_options): # FIXME: factor this out with the similar code in bentomakerlib options_registry = OptionsRegistry() # This is a dummy for now, to fulfill global_context API cmd_scheduler = CommandScheduler() commands_registry = CommandRegistry() register_commands(commands_registry) register_command_contexts() for cmd_name in commands_registry.command_names(): if not options_registry.is_registered(cmd_name): cmd = commands_registry.retrieve(cmd_name) options_context = OptionsContext.from_command(cmd) options_registry.register(cmd_name, options_context) configure_options_context = options_registry.retrieve("configure") _setup_options_parser(configure_options_context, package_options) global_context = GlobalContext(commands_registry, CONTEXT_REGISTRY, options_registry, cmd_scheduler) return global_context
def prepare_configure(run_node, bento_info, context_klass=ConfigureYakuContext, cmd_argv=None): if cmd_argv is None: cmd_argv = [] top_node = run_node._ctx.srcnode top_node.make_node("bento.info").safe_write(bento_info) package = PackageDescription.from_string(bento_info) package_options = PackageOptions.from_string(bento_info) configure = ConfigureCommand() opts = OptionsContext.from_command(configure) # FIXME: this emulates the big ugly hack inside bentomaker. _setup_options_parser(opts, package_options) context = context_klass(None, cmd_argv, opts, package, run_node) context.package_options = package_options return context, configure
def test_simple(self): root = self.root top_node = self.top_node run_node = self.run_node bento_info = """\ Name: foo Recurse: bar """ bento_info2 = """\ Recurse: foo Library: Modules: fubar Extension: _foo Sources: foo.c """ bento_info3 = """\ Library: Modules: foufoufou Packages: sub2 """ bentos = {"bento.info": bento_info, os.path.join("bar", "bento.info"): bento_info2, os.path.join("bar", "foo", "bento.info"): bento_info3} create_fake_package_from_bento_infos(run_node, bentos) conf, configure = prepare_configure(run_node, bento_info, ConfigureYakuContext) configure.run(conf) conf.shutdown() build = BuildCommand() opts = OptionsContext.from_command(build) cmd_argv = [] bld = BuildYakuContext(cmd_argv, opts, conf.pkg, run_node) build.run(bld)
def create_global_context(package, package_options, backend=None): if backend is None: backend = YakuBackend() global_context = GlobalContext(None) global_context.register_package_options(package_options) if backend: global_context.backend = backend build = BuildCommand() configure = ConfigureCommand() commands = (("configure", configure), ("build", build)) for cmd_name, cmd in commands: global_context.register_command(cmd_name, cmd) options_context = OptionsContext.from_command(cmd) global_context.register_options_context(cmd_name, options_context) global_context.backend.register_command_contexts(global_context) global_context.backend.register_options_contexts(global_context) return global_context
def create_global_context(package, package_options, backend=None): if backend is None: backend = YakuBackend() global_context = GlobalContext(None) global_context.register_package_options(package_options) if backend: global_context.backend = backend build = BuildCommand() configure = ConfigureCommand() commands = (("configure", configure), ("build", build)) for cmd_name, cmd in commands: global_context.register_command(cmd_name, cmd) options_context = OptionsContext.from_command(cmd) global_context.register_options_context(cmd_name, options_context) global_context.backend.register_command_contexts(global_context) global_context.backend.register_options_contexts(global_context) return global_context
def _test_run(self, bento_info): top_node = self.top_node create_fake_package_from_bento_info(top_node, bento_info) install_dir = tempfile.mkdtemp() cmd_argv = ["--prefix=%s" % install_dir, "--exec-prefix=%s" % install_dir] conf, configure = prepare_configure(top_node, bento_info, ConfigureYakuContext, cmd_argv) configure.run(conf) conf.shutdown() bld, build = prepare_build(top_node, conf.pkg) build.run(bld) build.shutdown(bld) install = InstallCommand() opts = OptionsContext.from_command(install) inst = CmdContext(["--list-files"], opts, conf.pkg, top_node) try: install.run(inst) finally: shutil.rmtree(install_dir)
def register_options(cmd_name): cmd_klass = COMMANDS_REGISTRY.get_command(cmd_name) usage = cmd_klass.long_descr.splitlines()[1] context = OptionsContext.from_command(cmd_klass, usage=usage) OPTIONS_REGISTRY.register_command(cmd_name, context)
def register_options(global_context, cmd_name): cmd_klass = global_context.retrieve_command(cmd_name) usage = cmd_klass.long_descr.splitlines()[1] context = OptionsContext.from_command(cmd_klass, usage=usage) OPTIONS_REGISTRY.register(cmd_name, context)