# Copyright (C) 2009, 2010 Canonical Ltd # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA from ... import ( cmdline, commands, config, help_topics, option, plugin, ) import breezy import re import sys class ZshCodeGen(object): """Generate a zsh script for given completion data.""" def __init__(self, data, function_name='_brz', debug=False): self.data = data self.function_name = function_name self.debug = debug def script(self): return ("""\ #compdef brz bzr %(function_name)s () { local ret=1 local -a args args+=( %(global-options)s ) _arguments $args[@] && ret=0 return ret } %(function_name)s """ % { 'global-options': self.global_options(), 'function_name': self.function_name}) def global_options(self): lines = [] for (long, short, help) in self.data.global_options: lines.append( ' \'(%s%s)%s[%s]\'' % ( (short + ' ') if short else '', long, long, help)) return "\n".join(lines) class CompletionData(object): def __init__(self): self.plugins = {} self.global_options = [] self.commands = [] def all_command_aliases(self): for c in self.commands: for a in c.aliases: yield a class CommandData(object): def __init__(self, name): self.name = name self.aliases = [name] self.plugin = None self.options = [] self.fixed_words = None class PluginData(object): def __init__(self, name, version=None): if version is None: try: version = breezy.plugin.plugins()[name].__version__ except: version = 'unknown' self.name = name self.version = version def __str__(self): if self.version == 'unknown': return self.name return '%s %s' % (self.name, self.version) class OptionData(object): def __init__(self, name): self.name = name self.registry_keys = None self.error_messages = [] def __str__(self): return self.name def __cmp__(self, other): return cmp(self.name, other.name) def __lt__(self, other): return self.name < other.name class DataCollector(object): def __init__(self, no_plugins=False, selected_plugins=None): self.data = CompletionData() self.user_aliases = {} if no_plugins: self.selected_plugins = set() elif selected_plugins is None: self.selected_plugins = None else: self.selected_plugins = {x.replace('-', '_') for x in selected_plugins} def collect(self): self.global_options() self.aliases() self.commands() return self.data def global_options(self): for name, item in option.Option.OPTIONS.items(): self.data.global_options.append( ('--' + item.name, '-' + item.short_name() if item.short_name() else None, item.help.rstrip())) def aliases(self): for alias, expansion in config.GlobalConfig().get_aliases().items(): for token in cmdline.split(expansion): if not token.startswith("-"): self.user_aliases.setdefault(token, set()).add(alias) break def commands(self): for name in sorted(commands.all_command_names()): self.command(name) def command(self, name): cmd = commands.get_cmd_object(name) cmd_data = CommandData(name) plugin_name = cmd.plugin_name() if plugin_name is not None: if (self.selected_plugins is not None and plugin not in self.selected_plugins): return None plugin_data = self.data.plugins.get(plugin_name) if plugin_data is None: plugin_data = PluginData(plugin_name) self.data.plugins[plugin_name] = plugin_data cmd_data.plugin = plugin_data self.data.commands.append(cmd_data) # Find all aliases to the command; both cmd-defined and user-defined. # We assume a user won't override one command with a different one, # but will choose completely new names or add options to existing # ones while maintaining the actual command name unchanged. cmd_data.aliases.extend(cmd.aliases) cmd_data.aliases.extend(sorted([useralias for cmdalias in cmd_data.aliases if cmdalias in self.user_aliases for useralias in self.user_aliases[cmdalias] if useralias not in cmd_data.aliases])) opts = cmd.options() for optname, opt in sorted(opts.items()): cmd_data.options.extend(self.option(opt)) if 'help' == name or 'help' in cmd.aliases: cmd_data.fixed_words = ('($cmds %s)' % " ".join(sorted(help_topics.topic_registry.keys()))) return cmd_data def option(self, opt): optswitches = {} parser = option.get_optparser([opt]) parser = self.wrap_parser(optswitches, parser) optswitches.clear() opt.add_option(parser, opt.short_name()) if isinstance(opt, option.RegistryOption) and opt.enum_switch: enum_switch = '--%s' % opt.name enum_data = optswitches.get(enum_switch) if enum_data: try: enum_data.registry_keys = opt.registry.keys() except ImportError as e: enum_data.error_messages.append( "ERROR getting registry keys for '--%s': %s" % (opt.name, str(e).split('\n')[0])) return sorted(optswitches.values()) def wrap_container(self, optswitches, parser): def tweaked_add_option(*opts, **attrs): for name in opts: optswitches[name] = OptionData(name) parser.add_option = tweaked_add_option return parser def wrap_parser(self, optswitches, parser): orig_add_option_group = parser.add_option_group def tweaked_add_option_group(*opts, **attrs): return self.wrap_container(optswitches, orig_add_option_group(*opts, **attrs)) parser.add_option_group = tweaked_add_option_group return self.wrap_container(optswitches, parser) def zsh_completion_function(out, function_name="_brz", debug=False, no_plugins=False, selected_plugins=None): dc = DataCollector(no_plugins=no_plugins, selected_plugins=selected_plugins) data = dc.collect() cg = ZshCodeGen(data, function_name=function_name, debug=debug) res = cg.script() out.write(res) class cmd_zsh_completion(commands.Command): __doc__ = """Generate a shell function for zsh command line completion. This command generates a shell function which can be used by zsh to automatically complete the currently typed command when the user presses the completion key (usually tab). Commonly used like this: eval "`brz zsh -completion`" """ takes_options = [ option.Option("function-name", short_name="f", type=str, argname="name", help="Name of the generated function (default: _brz)"), option.Option("debug", type=None, hidden=True, help="Enable shell code useful for debugging"), option.ListOption("plugin", type=str, argname="name", # param_name="selected_plugins", # doesn't work, bug #387117 help="Enable completions for the selected plugin" + " (default: all plugins)"), ] def run(self, **kwargs): if 'plugin' in kwargs: # work around bug #387117 which prevents us from using param_name if len(kwargs['plugin']) > 0: kwargs['selected_plugins'] = kwargs['plugin'] del kwargs['plugin'] zsh_completion_function(sys.stdout, **kwargs)