1
=== modified file 'NEWS'
2
--- NEWS	2010-05-04 22:02:05 +0000
3
+++ NEWS	2010-05-05 08:10:48 +0000
4
@@ -36,6 +36,11 @@
5
36
  re-sign, unbind, unknowns.
36
  re-sign, unbind, unknowns.
6
37
  (Martin von Gagern, #527878)
37
  (Martin von Gagern, #527878)
7
38
38
8
39
* The bash_completion plugin from the bzr-bash-completion project has
9
40
  been merged into the tree. It provides a bash-completion command and
10
41
  replaces the outdated ``contrib/bash/bzr`` script with a version
11
42
  using the plugin. (Martin von Gagern, #560030)
12
43
13
39
Bug Fixes
44
Bug Fixes
14
40
*********
45
*********
15
41
46
16
42
47
17
=== added directory 'bzrlib/plugins/bash_completion'
18
=== added file 'bzrlib/plugins/bash_completion/README.txt'
19
--- bzrlib/plugins/bash_completion/README.txt	1970-01-01 00:00:00 +0000
20
+++ bzrlib/plugins/bash_completion/README.txt	2010-05-05 08:10:48 +0000
21
@@ -0,0 +1,201 @@
22
1
.. comment
23
2
24
3
  Copyright (C) 2010 Canonical Ltd
25
4
26
5
  This file is part of bzr-bash-completion
27
6
28
7
  bzr-bash-completion free software: you can redistribute it and/or
29
8
  modify it under the terms of the GNU General Public License as
30
9
  published by the Free Software Foundation, either version 2 of the
31
10
  License, or (at your option) any later version.
32
11
33
12
  bzr-bash-completion is distributed in the hope that it will be
34
13
  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
35
14
  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
36
15
  General Public License for more details.
37
16
38
17
  You should have received a copy of the GNU General Public License
39
18
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
40
19
41
20
=====================================
42
21
bzr bash-completion script and plugin
43
22
=====================================
44
23
45
24
This script generates a shell function which can be used by bash to
46
25
automatically complete the currently typed command when the user
47
26
presses the completion key (usually tab).
48
27
49
28
It is intended as a bzr plugin, but can be used to some extend as a
50
29
standalone python script as well.
51
30
52
31
| Copyright (C) 2009, 2010 Canonical Ltd
53
32
54
33
.. contents::
55
34
56
35
----------
57
36
Installing
58
37
----------
59
38
60
39
You only need to do this if you want to use the script as a bzr
61
40
plugin.  Otherwise simply grab the bashcomp.py and place it wherever
62
41
you want.
63
42
64
43
Installing from bzr repository
65
44
------------------------------
66
45
67
46
To check out the current code from launchpad, use the following commands::
68
47
69
48
  mkdir -p ~/.bazaar/plugins
70
49
  cd ~/.bazaar/plugins
71
50
  bzr checkout lp:bzr-bash-completion bash_completion
72
51
73
52
To update such an installation, execute this command::
74
53
75
54
  bzr update ~/.bazaar/plugins/bash_completion
76
55
77
56
Installing using easy_install
78
57
-----------------------------
79
58
80
59
The following command should install the latest release of the plugin
81
60
on your system::
82
61
83
62
  easy_install bzr-bash-completion
84
63
85
64
To use this method, you need to have `Easy Install`_ installed and
86
65
also have write access to the required directories. So maybe you
87
66
should execute this command as root or through sudo_. Or you want to
88
67
`install to a different location`_.
89
68
90
69
.. _Easy Install: http://peak.telecommunity.com/DevCenter/EasyInstall
91
70
.. _sudo: http://linux.die.net/man/8/sudo
92
71
.. _install to a different location:
93
72
   http://peak.telecommunity.com/DevCenter/EasyInstall#non-root-installation
94
73
95
74
Installing from tarball
96
75
-----------------------
97
76
98
77
If you have grabbed a source code tarball, or want to install from a
99
78
bzr checkout in a different place than your bazaar plugins directory,
100
79
then you should use the ``setup.py`` script shipped with the code::
101
80
102
81
  ./setup.py install
103
82
104
83
If you want to install the plugin only for your own user account, you
105
84
might wish to pass the option ``--user`` or ``--home=$HOME`` to that
106
85
command. For further information please read the manuals of distutils_
107
86
as well as setuptools_ or distribute_, whatever is available on your
108
87
system, or have a look at the command line help::
109
88
110
89
  ./setup.py install --help
111
90
112
91
.. _distutils: http://docs.python.org/install/index.html
113
92
.. _setuptools: http://peak.telecommunity.com/DevCenter/setuptools#what-your-users-should-know
114
93
.. _distribute: http://packages.python.org/distribute/setuptools.html#what-your-users-should-know
115
94
116
95
-----
117
96
Using
118
97
-----
119
98
120
99
Using as a plugin
121
100
-----------------
122
101
123
102
This is the preferred method of generating the completion function, as
124
103
it will ensure proper bzr initialization.
125
104
126
105
::
127
106
128
107
  eval "`bzr bash-completion`"
129
108
130
109
Lazy initialization
131
110
-------------------
132
111
133
112
Running the above command automatically from your ``~/.bashrc`` file
134
113
or similar can cause annoying delays in the startup of your shell.
135
114
To avoid this problem, you can delay the generation of the completion
136
115
function until you actually need it.
137
116
138
117
To do so, source the file ``lazy.sh`` shipped with this package from
139
118
your ``~/.bashrc`` file or add it to your ``~/.bash_completion`` if
140
119
your setup uses such a file. On a system-wide installation, the
141
120
directory ``/usr/share/bash-completion/`` might contain such bash
142
121
completion scripts.
143
122
144
123
If you installed bzr-bash-completion from the repository or a source
145
124
tarball, you find the ``lazy.sh`` script in the root of the source
146
125
tree. If you installed the plugin using easy_install, you should grab
147
126
the script manually from the bzr repository, e.g. through the bazaar
148
127
web interface on launchpad.
149
128
150
129
Note that the full completion function is generated only once per
151
130
shell session. If you update your bzr installation or change the set
152
131
of installed plugins, then you might wish to regenerate the completion
153
132
function manually as described above in order for completion to take
154
133
these changes into account.
155
134
156
135
Using as a script
157
136
-----------------
158
137
159
138
As an alternative, if bzrlib is available to python scripts, the
160
139
following invocation should yield the same results without requiring
161
140
you to add a plugin::
162
141
163
142
  eval "`./bashcomp.py`"
164
143
165
144
This approach might have some issues, though, and provides less
166
145
options than the bzr plugin. Therefore if you have the choice, go for
167
146
the plugin setup.
168
147
169
148
--------------
170
149
Design concept
171
150
--------------
172
151
173
152
The plugin (or script) is designed to generate a completion function
174
153
containing all the required information about the possible
175
154
completions. This is usually only done once when bash
176
155
initializes. After that, no more invocations of bzr are required. This
177
156
makes the function much faster than a possible implementation talking
178
157
to bzr for each and every completion. On the other hand, this has the
179
158
effect that updates to bzr or its plugins won't show up in the
180
159
completions immediately, but only after the completion function has
181
160
been regenerated.
182
161
183
162
-------
184
163
License
185
164
-------
186
165
187
166
As this is built upon a bash completion script originally included in
188
167
the bzr source tree, and as the bzr sources are covered by the GPL 2,
189
168
this script here is licensed under these same terms.
190
169
191
170
If you require a more liberal license, you'll have to contact all
192
171
those who contributed code to this plugin, be it for bash or for
193
172
python.
194
173
195
174
.. cut long_description here
196
175
197
176
-------
198
177
History
199
178
-------
200
179
201
180
The plugin was created by Martin von Gagern in 2009, building on a
202
181
static completion function of very limited scope distributed together
203
182
with bzr.
204
183
205
184
----------
206
185
References
207
186
----------
208
187
209
188
Plugin homepages
210
189
  | https://launchpad.net/bzr-bash-completion
211
190
  | http://pypi.python.org/pypi/bzr-bash-completion
212
191
Bazaar homepage
213
192
  | http://bazaar.canonical.com/
214
193
215
194
216
195
217
196
.. vim: ft=rst
218
197
219
198
.. emacs
220
199
   Local Variables:
221
200
   mode: rst
222
201
   End:
223
0
202
224
=== added file 'bzrlib/plugins/bash_completion/__init__.py'
225
--- bzrlib/plugins/bash_completion/__init__.py	1970-01-01 00:00:00 +0000
226
+++ bzrlib/plugins/bash_completion/__init__.py	2010-05-05 08:10:48 +0000
227
@@ -0,0 +1,39 @@
228
1
# Copyright (C) 2009, 2010 Canonical Ltd
229
2
#
230
3
# This program is free software; you can redistribute it and/or modify
231
4
# it under the terms of the GNU General Public License as published by
232
5
# the Free Software Foundation; either version 2 of the License, or
233
6
# (at your option) any later version.
234
7
#
235
8
# This program is distributed in the hope that it will be useful,
236
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
237
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
238
11
# GNU General Public License for more details.
239
12
#
240
13
# You should have received a copy of the GNU General Public License
241
14
# along with this program; if not, write to the Free Software
242
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
243
16
244
17
__doc__ = """Generate a shell function for bash command line completion.
245
18
246
19
This plugin provides a command called bash-completion that generates a
247
20
bash completion function for bzr. See its documentation for details.
248
21
"""
249
22
250
23
from bzrlib import commands, version_info
251
24
252
25
253
26
bzr_plugin_name = 'bash_completion'
254
27
bzr_commands = [ 'bash-completion' ]
255
28
256
29
commands.plugin_cmds.register_lazy('cmd_bash_completion', [],
257
30
                                   'bzrlib.plugins.bash_completion.bashcomp')
258
31
259
32
260
33
def load_tests(basic_tests, module, loader):
261
34
    testmod_names = [
262
35
        'tests',
263
36
        ]
264
37
    basic_tests.addTest(loader.loadTestsFromModuleNames(
265
38
            ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
266
39
    return basic_tests
267
0
40
268
=== added file 'bzrlib/plugins/bash_completion/bashcomp.py'
269
--- bzrlib/plugins/bash_completion/bashcomp.py	1970-01-01 00:00:00 +0000
270
+++ bzrlib/plugins/bash_completion/bashcomp.py	2010-05-05 08:10:48 +0000
271
@@ -0,0 +1,463 @@
272
1
#!/usr/bin/env python
273
2
274
3
# Copyright (C) 2009, 2010 Canonical Ltd
275
4
#
276
5
# This program is free software; you can redistribute it and/or modify
277
6
# it under the terms of the GNU General Public License as published by
278
7
# the Free Software Foundation; either version 2 of the License, or
279
8
# (at your option) any later version.
280
9
#
281
10
# This program is distributed in the hope that it will be useful,
282
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
283
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
284
13
# GNU General Public License for more details.
285
14
#
286
15
# You should have received a copy of the GNU General Public License
287
16
# along with this program; if not, write to the Free Software
288
17
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
289
18
290
19
from bzrlib import (
291
20
    commands,
292
21
    config,
293
22
    help_topics,
294
23
    option,
295
24
    plugin,
296
25
)
297
26
import bzrlib
298
27
import re
299
28
300
29
301
30
class BashCodeGen(object):
302
31
    """Generate a bash script for given completion data."""
303
32
304
33
    def __init__(self, data, function_name='_bzr', debug=False):
305
34
        self.data = data
306
35
        self.function_name = function_name
307
36
        self.debug = debug
308
37
309
38
    def script(self):
310
39
        return ("""\
311
40
# Programmable completion for the Bazaar-NG bzr command under bash.
312
41
# Known to work with bash 2.05a as well as bash 4.1.2, and probably
313
42
# all versions in between as well.
314
43
315
44
# Based originally on the svn bash completition script.
316
45
# Customized by Sven Wilhelm/Icecrash.com
317
46
# Adjusted for automatic generation by Martin von Gagern
318
47
319
48
# Generated using the bash_completion plugin.
320
49
# See https://launchpad.net/bzr-bash-completion for details.
321
50
322
51
# Commands and options of bzr %(bzr_version)s
323
52
324
53
shopt -s progcomp
325
54
%(function)s
326
55
complete -F %(function_name)s -o default bzr
327
56
"""     % {
328
57
            "function_name": self.function_name,
329
58
            "function": self.function(),
330
59
            "bzr_version": self.bzr_version(),
331
60
        })
332
61
333
62
    def function(self):
334
63
        return ("""\
335
64
%(function_name)s ()
336
65
{
337
66
	local cur cmds cmdIdx cmd cmdOpts fixedWords i globalOpts
338
67
	local curOpt optEnums
339
68
340
69
	COMPREPLY=()
341
70
	cur=${COMP_WORDS[COMP_CWORD]}
342
71
343
72
	cmds='%(cmds)s'
344
73
	globalOpts='%(global_options)s'
345
74
346
75
	# do ordinary expansion if we are anywhere after a -- argument
347
76
	for ((i = 1; i < COMP_CWORD; ++i)); do
348
77
		[[ ${COMP_WORDS[i]} == "--" ]] && return 0
349
78
	done
350
79
351
80
	# find the command; it's the first word not starting in -
352
81
	cmd=
353
82
	for ((cmdIdx = 1; cmdIdx < ${#COMP_WORDS[@]}; ++cmdIdx)); do
354
83
		if [[ ${COMP_WORDS[cmdIdx]} != -* ]]; then
355
84
			cmd=${COMP_WORDS[cmdIdx]}
356
85
			break
357
86
		fi
358
87
	done
359
88
360
89
	# complete command name if we are not already past the command
361
90
	if [[ $COMP_CWORD -le cmdIdx ]]; then
362
91
		COMPREPLY=( $( compgen -W "$cmds $globalOpts" -- $cur ) )
363
92
		return 0
364
93
	fi
365
94
366
95
	# find the option for which we want to complete a value
367
96
	curOpt=
368
97
	if [[ $cur != -* ]] && [[ $COMP_CWORD -gt 1 ]]; then
369
98
		curOpt=${COMP_WORDS[COMP_CWORD - 1]}
370
99
		if [[ $curOpt == = ]]; then
371
100
			curOpt=${COMP_WORDS[COMP_CWORD - 2]}
372
101
		elif [[ $cur == : ]]; then
373
102
			cur=
374
103
			curOpt="$curOpt:"
375
104
		elif [[ $curOpt == : ]]; then
376
105
			curOpt=${COMP_WORDS[COMP_CWORD - 2]}:
377
106
		fi
378
107
	fi
379
108
%(debug)s
380
109
	cmdOpts=
381
110
	optEnums=
382
111
	fixedWords=
383
112
	case $cmd in
384
113
%(cases)s\
385
114
	*)
386
115
		cmdOpts='--help -h'
387
116
		;;
388
117
	esac
389
118
390
119
	if [[ -z $fixedWords ]] && [[ -z $optEnums ]] && [[ $cur != -* ]]; then
391
120
		case $curOpt in
392
121
			tag:*)
393
122
				fixedWords="$(bzr tags 2>/dev/null | sed 's/  *[^ ]*$//')"
394
123
				;;
395
124
		esac
396
125
	elif [[ $cur == = ]] && [[ -n $optEnums ]]; then
397
126
		# complete directly after "--option=", list all enum values
398
127
		COMPREPLY=( $optEnums )
399
128
		return 0
400
129
	else
401
130
		fixedWords="$cmdOpts $globalOpts $optEnums $fixedWords"
402
131
	fi
403
132
404
133
	if [[ -n $fixedWords ]]; then
405
134
		COMPREPLY=( $( compgen -W "$fixedWords" -- $cur ) )
406
135
	fi
407
136
408
137
	return 0
409
138
}
410
139
"""     % {
411
140
            "cmds": self.command_names(),
412
141
            "function_name": self.function_name,
413
142
            "cases": self.command_cases(),
414
143
            "global_options": self.global_options(),
415
144
            "debug": self.debug_output(),
416
145
        })
417
146
418
147
    def command_names(self):
419
148
        return " ".join(self.data.all_command_aliases())
420
149
421
150
    def debug_output(self):
422
151
        if not self.debug:
423
152
            return ''
424
153
        else:
425
154
            return (r"""
426
155
	# Debugging code enabled using the --debug command line switch.
427
156
	# Will dump some variables to the top portion of the terminal.
428
157
	echo -ne '\e[s\e[H'
429
158
	for (( i=0; i < ${#COMP_WORDS[@]}; ++i)); do
430
159
		echo "\$COMP_WORDS[$i]='${COMP_WORDS[i]}'"$'\e[K'
431
160
	done
432
161
	for i in COMP_CWORD COMP_LINE COMP_POINT COMP_TYPE COMP_KEY cur curOpt; do
433
162
		echo "\$${i}=\"${!i}\""$'\e[K'
434
163
	done
435
164
	echo -ne '---\e[K\e[u'
436
165
""")
437
166
438
167
    def bzr_version(self):
439
168
        bzr_version = bzrlib.version_string
440
169
        if not self.data.plugins:
441
170
            bzr_version += "."
442
171
        else:
443
172
            bzr_version += " and the following plugins:"
444
173
            for name, plugin in sorted(self.data.plugins.iteritems()):
445
174
                bzr_version += "\n# %s" % plugin
446
175
        return bzr_version
447
176
448
177
    def global_options(self):
449
178
        return " ".join(sorted(self.data.global_options))
450
179
451
180
    def command_cases(self):
452
181
        cases = ""
453
182
        for command in self.data.commands:
454
183
            cases += self.command_case(command)
455
184
        return cases
456
185
457
186
    def command_case(self, command):
458
187
        case = "\t%s)\n" % "|".join(command.aliases)
459
188
        if command.plugin:
460
189
            case += "\t\t# plugin \"%s\"\n" % command.plugin
461
190
        options = []
462
191
        enums = []
463
192
        for option in command.options:
464
193
            for message in option.error_messages:
465
194
                case += "\t\t# %s\n" % message
466
195
            if option.registry_keys:
467
196
                for key in option.registry_keys:
468
197
                    options.append("%s=%s" % (option, key))
469
198
                enums.append("%s) optEnums='%s' ;;" %
470
199
                             (option, ' '.join(option.registry_keys)))
471
200
            else:
472
201
                options.append(str(option))
473
202
        case += "\t\tcmdOpts='%s'\n" % " ".join(options)
474
203
        if command.fixed_words:
475
204
            fixed_words = command.fixed_words
476
205
            if isinstance(fixed_words, list):
477
206
                fixed_words = "'%s'" + ' '.join(fixed_words)
478
207
            case += "\t\tfixedWords=%s\n" % fixed_words
479
208
        if enums:
480
209
            case += "\t\tcase $curOpt in\n\t\t\t"
481
210
            case += "\n\t\t\t".join(enums)
482
211
            case += "\n\t\tesac\n"
483
212
        case += "\t\t;;\n"
484
213
        return case
485
214
486
215
487
216
class CompletionData(object):
488
217
489
218
    def __init__(self):
490
219
        self.plugins = {}
491
220
        self.global_options = set()
492
221
        self.commands = []
493
222
494
223
    def all_command_aliases(self):
495
224
        for c in self.commands:
496
225
            for a in c.aliases:
497
226
                yield a
498
227
499
228
500
229
class CommandData(object):
501
230
502
231
    def __init__(self, name):
503
232
        self.name = name
504
233
        self.aliases = [name]
505
234
        self.plugin = None
506
235
        self.options = []
507
236
        self.fixed_words = None
508
237
509
238
510
239
class PluginData(object):
511
240
512
241
    def __init__(self, name, version=None):
513
242
        if version is None:
514
243
            version = bzrlib.plugin.plugins()[name].__version__
515
244
        self.name = name
516
245
        self.version = version
517
246
518
247
    def __str__(self):
519
248
        if self.version == 'unknown':
520
249
            return self.name
521
250
        return '%s %s' % (self.name, self.version)
522
251
523
252
524
253
class OptionData(object):
525
254
526
255
    def __init__(self, name):
527
256
        self.name = name
528
257
        self.registry_keys = None
529
258
        self.error_messages = []
530
259
531
260
    def __str__(self):
532
261
        return self.name
533
262
534
263
    def __cmp__(self, other):
535
264
        return cmp(self.name, other.name)
536
265
537
266
538
267
class DataCollector(object):
539
268
540
269
    def __init__(self, no_plugins=False, selected_plugins=None):
541
270
        self.data = CompletionData()
542
271
        self.user_aliases = {}
543
272
        if no_plugins:
544
273
            self.selected_plugins = set()
545
274
        elif selected_plugins is None:
546
275
            self.selected_plugins = None
547
276
        else:
548
277
            self.selected_plugins = set([x.replace('-', '_')
549
278
                                         for x in selected_plugins])
550
279
551
280
    def collect(self):
552
281
        self.global_options()
553
282
        self.aliases()
554
283
        self.commands()
555
284
        return self.data
556
285
557
286
    def global_options(self):
558
287
        re_switch = re.compile(r'\n(--[A-Za-z0-9-_]+)(?:, (-\S))?\s')
559
288
        help_text = help_topics.topic_registry.get_detail('global-options')
560
289
        for long, short in re_switch.findall(help_text):
561
290
            self.data.global_options.add(long)
562
291
            if short:
563
292
                self.data.global_options.add(short)
564
293
565
294
    def aliases(self):
566
295
        for alias, expansion in config.GlobalConfig().get_aliases().iteritems():
567
296
            for token in commands.shlex_split_unicode(expansion):
568
297
                if not token.startswith("-"):
569
298
                    self.user_aliases.setdefault(token, set()).add(alias)
570
299
                    break
571
300
572
301
    def commands(self):
573
302
        for name in sorted(commands.all_command_names()):
574
303
            self.command(name)
575
304
576
305
    def command(self, name):
577
306
        cmd = commands.get_cmd_object(name)
578
307
        cmd_data = CommandData(name)
579
308
580
309
        plugin_name = cmd.plugin_name()
581
310
        if plugin_name is not None:
582
311
            if (self.selected_plugins is not None and
583
312
                plugin not in self.selected_plugins):
584
313
                return None
585
314
            plugin_data = self.data.plugins.get(plugin_name)
586
315
            if plugin_data is None:
587
316
                plugin_data = PluginData(plugin_name)
588
317
                self.data.plugins[plugin_name] = plugin_data
589
318
            cmd_data.plugin = plugin_data
590
319
        self.data.commands.append(cmd_data)
591
320
592
321
        # Find all aliases to the command; both cmd-defined and user-defined.
593
322
        # We assume a user won't override one command with a different one,
594
323
        # but will choose completely new names or add options to existing
595
324
        # ones while maintaining the actual command name unchanged.
596
325
        cmd_data.aliases.extend(cmd.aliases)
597
326
        cmd_data.aliases.extend(sorted([useralias
598
327
            for cmdalias in cmd_data.aliases
599
328
            if cmdalias in self.user_aliases
600
329
            for useralias in self.user_aliases[cmdalias]
601
330
            if useralias not in cmd_data.aliases]))
602
331
603
332
        opts = cmd.options()
604
333
        for optname, opt in sorted(opts.iteritems()):
605
334
            cmd_data.options.extend(self.option(opt))
606
335
607
336
        if 'help' == name or 'help' in cmd.aliases:
608
337
            cmd_data.fixed_words = ('"$cmds %s"' %
609
338
                " ".join(sorted(help_topics.topic_registry.keys())))
610
339
611
340
        return cmd_data
612
341
613
342
    def option(self, opt):
614
343
        optswitches = {}
615
344
        parser = option.get_optparser({opt.name: opt})
616
345
        parser = self.wrap_parser(optswitches, parser)
617
346
        optswitches.clear()
618
347
        opt.add_option(parser, opt.short_name())
619
348
        if isinstance(opt, option.RegistryOption) and opt.enum_switch:
620
349
            enum_switch = '--%s' % opt.name
621
350
            enum_data = optswitches.get(enum_switch)
622
351
            if enum_data:
623
352
                try:
624
353
                    enum_data.registry_keys = opt.registry.keys()
625
354
                except ImportError, e:
626
355
                    enum_data.error_messages.append(
627
356
                        "ERROR getting registry keys for '--%s': %s"
628
357
                        % (opt.name, str(e).split('\n')[0]))
629
358
        return sorted(optswitches.values())
630
359
631
360
    def wrap_container(self, optswitches, parser):
632
361
        def tweaked_add_option(*opts, **attrs):
633
362
            for name in opts:
634
363
                optswitches[name] = OptionData(name)
635
364
        parser.add_option = tweaked_add_option
636
365
        return parser
637
366
638
367
    def wrap_parser(self, optswitches, parser):
639
368
        orig_add_option_group = parser.add_option_group
640
369
        def tweaked_add_option_group(*opts, **attrs):
641
370
            return self.wrap_container(optswitches,
642
371
                orig_add_option_group(*opts, **attrs))
643
372
        parser.add_option_group = tweaked_add_option_group
644
373
        return self.wrap_container(optswitches, parser)
645
374
646
375
647
376
def bash_completion_function(out, function_name="_bzr", function_only=False,
648
377
                             debug=False,
649
378
                             no_plugins=False, selected_plugins=None):
650
379
    dc = DataCollector(no_plugins=no_plugins, selected_plugins=selected_plugins)
651
380
    data = dc.collect()
652
381
    cg = BashCodeGen(data, function_name=function_name, debug=debug)
653
382
    if function_only:
654
383
        res = cg.function()
655
384
    else:
656
385
        res = cg.script()
657
386
    out.write(res)
658
387
659
388
660
389
class cmd_bash_completion(commands.Command):
661
390
    __doc__ = """Generate a shell function for bash command line completion.
662
391
663
392
    This command generates a shell function which can be used by bash to
664
393
    automatically complete the currently typed command when the user presses
665
394
    the completion key (usually tab).
666
395
    
667
396
    Commonly used like this:
668
397
        eval "`bzr bash-completion`"
669
398
    """
670
399
671
400
    takes_options = [
672
401
        option.Option("function-name", short_name="f", type=str, argname="name",
673
402
               help="Name of the generated function (default: _bzr)"),
674
403
        option.Option("function-only", short_name="o", type=None,
675
404
               help="Generate only the shell function, don't enable it"),
676
405
        option.Option("debug", type=None, hidden=True,
677
406
               help="Enable shell code useful for debugging"),
678
407
        option.ListOption("plugin", type=str, argname="name",
679
408
                # param_name="selected_plugins", # doesn't work, bug #387117
680
409
                help="Enable completions for the selected plugin"
681
410
                + " (default: all plugins)"),
682
411
        ]
683
412
684
413
    def run(self, **kwargs):
685
414
        import sys
686
415
        from bashcomp import bash_completion_function
687
416
        if 'plugin' in kwargs:
688
417
            # work around bug #387117 which prevents us from using param_name
689
418
            if len(kwargs['plugin']) > 0:
690
419
                kwargs['selected_plugins'] = kwargs['plugin']
691
420
            del kwargs['plugin']
692
421
        bash_completion_function(sys.stdout, **kwargs)
693
422
694
423
695
424
if __name__ == '__main__':
696
425
697
426
    import sys
698
427
    import locale
699
428
    import optparse
700
429
701
430
    def plugin_callback(option, opt, value, parser):
702
431
        values = parser.values.selected_plugins
703
432
        if value == '-':
704
433
            del values[:]
705
434
        else:
706
435
            values.append(value)
707
436
708
437
    parser = optparse.OptionParser(usage="%prog [-f NAME] [-o]")
709
438
    parser.add_option("--function-name", "-f", metavar="NAME",
710
439
                      help="Name of the generated function (default: _bzr)")
711
440
    parser.add_option("--function-only", "-o", action="store_true",
712
441
                      help="Generate only the shell function, don't enable it")
713
442
    parser.add_option("--debug", action="store_true",
714
443
                      help=optparse.SUPPRESS_HELP)
715
444
    parser.add_option("--no-plugins", action="store_true",
716
445
                      help="Don't load any bzr plugins")
717
446
    parser.add_option("--plugin", metavar="NAME", type="string",
718
447
                      dest="selected_plugins", default=[],
719
448
                      action="callback", callback=plugin_callback,
720
449
                      help="Enable completions for the selected plugin"
721
450
                      + " (default: all plugins)")
722
451
    (opts, args) = parser.parse_args()
723
452
    if args:
724
453
        parser.error("script does not take positional arguments")
725
454
    kwargs = dict()
726
455
    for name, value in opts.__dict__.iteritems():
727
456
        if value is not None:
728
457
            kwargs[name] = value
729
458
730
459
    locale.setlocale(locale.LC_ALL, '')
731
460
    if not kwargs.get('no_plugins', False):
732
461
        plugin.load_plugins()
733
462
    commands.install_bzr_command_hooks()
734
463
    bash_completion_function(sys.stdout, **kwargs)
735
0
464
736
=== added directory 'bzrlib/plugins/bash_completion/tests'
737
=== added file 'bzrlib/plugins/bash_completion/tests/__init__.py'
738
--- bzrlib/plugins/bash_completion/tests/__init__.py	1970-01-01 00:00:00 +0000
739
+++ bzrlib/plugins/bash_completion/tests/__init__.py	2010-05-05 08:10:48 +0000
740
@@ -0,0 +1,23 @@
741
1
# Copyright (C) 2010 by Canonical Ltd
742
2
#
743
3
# This program is free software; you can redistribute it and/or modify
744
4
# it under the terms of the GNU General Public License as published by
745
5
# the Free Software Foundation; either version 2 of the License, or
746
6
# (at your option) any later version.
747
7
#
748
8
# This program is distributed in the hope that it will be useful,
749
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
750
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
751
11
# GNU General Public License for more details.
752
12
#
753
13
# You should have received a copy of the GNU General Public License
754
14
# along with this program; if not, write to the Free Software
755
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
756
16
757
17
def load_tests(basic_tests, module, loader):
758
18
    testmod_names = [
759
19
        'test_bashcomp',
760
20
        ]
761
21
    basic_tests.addTest(loader.loadTestsFromModuleNames(
762
22
            ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
763
23
    return basic_tests
764
0
24
765
=== added file 'bzrlib/plugins/bash_completion/tests/test_bashcomp.py'
766
--- bzrlib/plugins/bash_completion/tests/test_bashcomp.py	1970-01-01 00:00:00 +0000
767
+++ bzrlib/plugins/bash_completion/tests/test_bashcomp.py	2010-05-05 08:10:48 +0000
768
@@ -0,0 +1,318 @@
769
1
# Copyright (C) 2010 by Canonical Ltd
770
2
#
771
3
# This program is free software; you can redistribute it and/or modify
772
4
# it under the terms of the GNU General Public License as published by
773
5
# the Free Software Foundation; either version 2 of the License, or
774
6
# (at your option) any later version.
775
7
#
776
8
# This program is distributed in the hope that it will be useful,
777
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
778
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
779
11
# GNU General Public License for more details.
780
12
#
781
13
# You should have received a copy of the GNU General Public License
782
14
# along with this program; if not, write to the Free Software
783
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
784
16
785
17
import bzrlib
786
18
from bzrlib import commands, tests
787
19
from bzrlib.plugins.bash_completion.bashcomp import *
788
20
789
21
import os
790
22
import subprocess
791
23
792
24
793
25
class _BashFeature(tests.Feature):
794
26
    """Feature testing whether a bash executable is available."""
795
27
796
28
    bash_paths = ['/bin/bash', '/usr/bin/bash']
797
29
798
30
    def __init__(self):
799
31
        super(_BashFeature, self).__init__()
800
32
        self.bash_path = None
801
33
802
34
    def available(self):
803
35
        if self.bash_path is not None:
804
36
            return self.bash_path is not False
805
37
        for path in self.bash_paths:
806
38
            if os.access(path, os.X_OK):
807
39
                self.bash_path = path
808
40
                return True
809
41
        self.bash_path = False
810
42
        return False
811
43
812
44
    def feature_name(self):
813
45
        return 'bash'
814
46
815
47
BashFeature = _BashFeature()
816
48
817
49
818
50
class BashCompletionMixin(object):
819
51
    """Component for testing execution of a bash completion script."""
820
52
821
53
    _test_needs_features = [BashFeature]
822
54
823
55
    def complete(self, words, cword=-1):
824
56
        """Perform a bash completion.
825
57
826
58
        :param words: a list of words representing the current command.
827
59
        :param cword: the current word to complete, defaults to the last one.
828
60
        """
829
61
        if self.script is None:
830
62
            self.script = self.get_script()
831
63
        proc = subprocess.Popen([BashFeature.bash_path, '--noprofile'],
832
64
                                stdin=subprocess.PIPE,
833
65
                                stdout=subprocess.PIPE,
834
66
                                stderr=subprocess.PIPE)
835
67
        if cword < 0:
836
68
            cword = len(words) + cword
837
69
        input = '%s\n' % self.script
838
70
        input += ('COMP_WORDS=( %s )\n' %
839
71
                  ' '.join(["'"+w.replace("'", "'\\''")+"'" for w in words]))
840
72
        input += 'COMP_CWORD=%d\n' % cword
841
73
        input += '%s\n' % getattr(self, 'script_name', '_bzr')
842
74
        input += 'echo ${#COMPREPLY[*]}\n'
843
75
        input += "IFS=$'\\n'\n"
844
76
        input += 'echo "${COMPREPLY[*]}"\n'
845
77
        (out, err) = proc.communicate(input)
846
78
        if '' != err:
847
79
            raise AssertionError('Unexpected error message:\n%s' % err)
848
80
        self.assertEqual('', err, 'No messages to standard error')
849
81
        #import sys
850
82
        #print >>sys.stdout, '---\n%s\n---\n%s\n---\n' % (input, out)
851
83
        lines = out.split('\n')
852
84
        nlines = int(lines[0])
853
85
        del lines[0]
854
86
        self.assertEqual('', lines[-1], 'Newline at end')
855
87
        del lines[-1]
856
88
        if nlines == 0 and len(lines) == 1 and lines[0] == '':
857
89
            del lines[0]
858
90
        self.assertEqual(nlines, len(lines), 'No newlines in generated words')
859
91
        self.completion_result = set(lines)
860
92
        return self.completion_result
861
93
862
94
    def assertCompletionEquals(self, *words):
863
95
        self.assertEqual(set(words), self.completion_result)
864
96
865
97
    def assertCompletionContains(self, *words):
866
98
        missing = set(words) - self.completion_result
867
99
        if missing:
868
100
            raise AssertionError('Completion should contain %r but it has %r'
869
101
                                 % (missing, self.completion_result))
870
102
871
103
    def assertCompletionOmits(self, *words):
872
104
        surplus = set(words) & self.completion_result
873
105
        if surplus:
874
106
            raise AssertionError('Completion should omit %r but it has %r'
875
107
                                 % (surplus, res, self.completion_result))
876
108
877
109
    def get_script(self):
878
110
        commands.install_bzr_command_hooks()
879
111
        dc = DataCollector()
880
112
        data = dc.collect()
881
113
        cg = BashCodeGen(data)
882
114
        res = cg.function()
883
115
        return res
884
116
885
117
886
118
class TestBashCompletion(tests.TestCase, BashCompletionMixin):
887
119
    """Test bash completions that don't execute bzr."""
888
120
889
121
    def __init__(self, methodName='testMethod'):
890
122
        super(TestBashCompletion, self).__init__(methodName)
891
123
        self.script = None
892
124
893
125
    def test_simple_scipt(self):
894
126
        """Ensure that the test harness works as expected"""
895
127
        self.script = """
896
128
_bzr() {
897
129
    COMPREPLY=()
898
130
    # add all words in reverse order, with some markup around them
899
131
    for ((i = ${#COMP_WORDS[@]}; i > 0; --i)); do
900
132
        COMPREPLY+=( "-${COMP_WORDS[i-1]}+" )
901
133
    done
902
134
    # and append the current word
903
135
    COMPREPLY+=( "+${COMP_WORDS[COMP_CWORD]}-" )
904
136
}
905
137
"""
906
138
        self.complete(['foo', '"bar', "'baz"], cword=1)
907
139
        self.assertCompletionEquals("-'baz+", '-"bar+', '-foo+', '+"bar-')
908
140
909
141
    def test_cmd_ini(self):
910
142
        self.complete(['bzr', 'ini'])
911
143
        self.assertCompletionContains('init', 'init-repo', 'init-repository')
912
144
        self.assertCompletionOmits('commit')
913
145
914
146
    def test_init_opts(self):
915
147
        self.complete(['bzr', 'init', '-'])
916
148
        self.assertCompletionContains('-h', '--2a', '--format=2a')
917
149
918
150
    def test_global_opts(self):
919
151
        self.complete(['bzr', '-', 'init'], cword=1)
920
152
        self.assertCompletionContains('--no-plugins', '--builtin')
921
153
922
154
    def test_commit_dashm(self):
923
155
        self.complete(['bzr', 'commit', '-m'])
924
156
        self.assertCompletionEquals('-m')
925
157
926
158
    def test_status_negated(self):
927
159
        self.complete(['bzr', 'status', '--n'])
928
160
        self.assertCompletionContains('--no-versioned', '--no-verbose')
929
161
930
162
    def test_init_format_any(self):
931
163
        self.complete(['bzr', 'init', '--format', '=', 'directory'], cword=3)
932
164
        self.assertCompletionContains('1.9', '2a')
933
165
934
166
    def test_init_format_2(self):
935
167
        self.complete(['bzr', 'init', '--format', '=', '2', 'directory'],
936
168
                      cword=4)
937
169
        self.assertCompletionContains('2a')
938
170
        self.assertCompletionOmits('1.9')
939
171
940
172
941
173
class TestBashCompletionInvoking(tests.TestCaseWithTransport,
942
174
                                 BashCompletionMixin):
943
175
    """Test bash completions that might execute bzr.
944
176
945
177
    Only the syntax ``$(bzr ...`` is supported so far. The bzr command
946
178
    will be replaced by the bzr instance running this selftest.
947
179
    """
948
180
949
181
    def __init__(self, methodName='testMethod'):
950
182
        super(TestBashCompletionInvoking, self).__init__(methodName)
951
183
        self.script = None
952
184
953
185
    def get_script(self):
954
186
        s = super(TestBashCompletionInvoking, self).get_script()
955
187
        return s.replace("$(bzr ", "$('%s' " % self.get_bzr_path())
956
188
957
189
    def test_revspec_tag_all(self):
958
190
        wt = self.make_branch_and_tree('.', format='dirstate-tags')
959
191
        wt.branch.tags.set_tag('tag1', 'null:')
960
192
        wt.branch.tags.set_tag('tag2', 'null:')
961
193
        wt.branch.tags.set_tag('3tag', 'null:')
962
194
        self.complete(['bzr', 'log', '-r', 'tag', ':'])
963
195
        self.assertCompletionEquals('tag1', 'tag2', '3tag')
964
196
965
197
    def test_revspec_tag_prefix(self):
966
198
        wt = self.make_branch_and_tree('.', format='dirstate-tags')
967
199
        wt.branch.tags.set_tag('tag1', 'null:')
968
200
        wt.branch.tags.set_tag('tag2', 'null:')
969
201
        wt.branch.tags.set_tag('3tag', 'null:')
970
202
        self.complete(['bzr', 'log', '-r', 'tag', ':', 't'])
971
203
        self.assertCompletionEquals('tag1', 'tag2')
972
204
973
205
974
206
class TestBashCodeGen(tests.TestCase):
975
207
976
208
    def test_command_names(self):
977
209
        data = CompletionData()
978
210
        bar = CommandData('bar')
979
211
        bar.aliases.append('baz')
980
212
        data.commands.append(bar)
981
213
        data.commands.append(CommandData('foo'))
982
214
        cg = BashCodeGen(data)
983
215
        self.assertEqual('bar baz foo', cg.command_names())
984
216
985
217
    def test_debug_output(self):
986
218
        data = CompletionData()
987
219
        self.assertEqual('', BashCodeGen(data, debug=False).debug_output())
988
220
        self.assertTrue(BashCodeGen(data, debug=True).debug_output())
989
221
990
222
    def test_bzr_version(self):
991
223
        data = CompletionData()
992
224
        cg = BashCodeGen(data)
993
225
        self.assertEqual('%s.' % bzrlib.version_string, cg.bzr_version())
994
226
        data.plugins['foo'] = PluginData('foo', '1.0')
995
227
        data.plugins['bar'] = PluginData('bar', '2.0')
996
228
        cg = BashCodeGen(data)
997
229
        self.assertEqual('''\
998
230
%s and the following plugins:
999
231
# bar 2.0
1000
232
# foo 1.0''' % bzrlib.version_string, cg.bzr_version())
1001
233
1002
234
    def test_global_options(self):
1003
235
        data = CompletionData()
1004
236
        data.global_options.add('--foo')
1005
237
        data.global_options.add('--bar')
1006
238
        cg = BashCodeGen(data)
1007
239
        self.assertEqual('--bar --foo', cg.global_options())
1008
240
1009
241
    def test_command_cases(self):
1010
242
        data = CompletionData()
1011
243
        bar = CommandData('bar')
1012
244
        bar.aliases.append('baz')
1013
245
        bar.options.append(OptionData('--opt'))
1014
246
        data.commands.append(bar)
1015
247
        data.commands.append(CommandData('foo'))
1016
248
        cg = BashCodeGen(data)
1017
249
        self.assertEqualDiff('''\
1018
250
\tbar|baz)
1019
251
\t\tcmdOpts='--opt'
1020
252
\t\t;;
1021
253
\tfoo)
1022
254
\t\tcmdOpts=''
1023
255
\t\t;;
1024
256
''', cg.command_cases())
1025
257
1026
258
    def test_command_case(self):
1027
259
        cmd = CommandData('cmd')
1028
260
        cmd.plugin = PluginData('plugger', '1.0')
1029
261
        bar = OptionData('--bar')
1030
262
        bar.registry_keys = ['that', 'this']
1031
263
        bar.error_messages.append('Some error message')
1032
264
        cmd.options.append(bar)
1033
265
        cmd.options.append(OptionData('--foo'))
1034
266
        data = CompletionData()
1035
267
        data.commands.append(cmd)
1036
268
        cg = BashCodeGen(data)
1037
269
        self.assertEqualDiff('''\
1038
270
\tcmd)
1039
271
\t\t# plugin "plugger 1.0"
1040
272
\t\t# Some error message
1041
273
\t\tcmdOpts='--bar=that --bar=this --foo'
1042
274
\t\tcase $curOpt in
1043
275
\t\t\t--bar) optEnums='that this' ;;
1044
276
\t\tesac
1045
277
\t\t;;
1046
278
''', cg.command_case(cmd))
1047
279
1048
280
1049
281
class TestDataCollector(tests.TestCase):
1050
282
1051
283
    def setUp(self):
1052
284
        super(TestDataCollector, self).setUp()
1053
285
        commands.install_bzr_command_hooks()
1054
286
1055
287
    def test_global_options(self):
1056
288
        dc = DataCollector()
1057
289
        dc.global_options()
1058
290
        self.assertSubset(['--no-plugins', '--builtin'],
1059
291
                           dc.data.global_options)
1060
292
1061
293
    def test_commands(self):
1062
294
        dc = DataCollector()
1063
295
        dc.commands()
1064
296
        self.assertSubset(['init', 'init-repo', 'init-repository'],
1065
297
                           dc.data.all_command_aliases())
1066
298
1067
299
    def test_commit_dashm(self):
1068
300
        dc = DataCollector()
1069
301
        cmd = dc.command('commit')
1070
302
        self.assertSubset(['-m'],
1071
303
                           [str(o) for o in cmd.options])
1072
304
1073
305
    def test_status_negated(self):
1074
306
        dc = DataCollector()
1075
307
        cmd = dc.command('status')
1076
308
        self.assertSubset(['--no-versioned', '--no-verbose'],
1077
309
                           [str(o) for o in cmd.options])
1078
310
1079
311
    def test_init_format(self):
1080
312
        dc = DataCollector()
1081
313
        cmd = dc.command('init')
1082
314
        for opt in cmd.options:
1083
315
            if opt.name == '--format':
1084
316
                self.assertSubset(['2a'], opt.registry_keys)
1085
317
                return
1086
318
        raise AssertionError('Option --format not found')
1087
0
319
1088
=== added file 'contrib/bash/bzr'
1089
--- contrib/bash/bzr	1970-01-01 00:00:00 +0000
1090
+++ contrib/bash/bzr	2010-05-05 08:10:48 +0000
1091
@@ -0,0 +1,40 @@
1092
1
# Copyright (C) 2010 Canonical Ltd
1093
2
#
1094
3
# This program is free software; you can redistribute it and/or modify
1095
4
# it under the terms of the GNU General Public License as published by
1096
5
# the Free Software Foundation; either version 2 of the License, or
1097
6
# (at your option) any later version.
1098
7
#
1099
8
# This program is distributed in the hope that it will be useful,
1100
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1101
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1102
11
# GNU General Public License for more details.
1103
12
#
1104
13
# You should have received a copy of the GNU General Public License
1105
14
# along with this program; if not, write to the Free Software
1106
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1107
16
1108
17
# Programmable completion for the Bazaar-NG bzr command under bash.
1109
18
# Source this file (or add it to your ~/.bash_completion or ~/.bashrc
1110
19
# file, depending on your system configuration, and start a new shell)
1111
20
# and bash's completion mechanism will know all about bzr's options!
1112
21
#
1113
22
# This completion function assumes you have the bzr-bash-completion
1114
23
# plugin installed as a bzr plugin. It will generate the full
1115
24
# completion function at first invocation, thus avoiding long delays
1116
25
# for every shell you start.
1117
26
1118
27
shopt -s progcomp
1119
28
_bzr_lazy ()
1120
29
{
1121
30
	unset _bzr
1122
31
	eval "$(bzr bash-completion)"
1123
32
	if [[ $(type -t _bzr) == function ]]; then
1124
33
		unset _bzr_lazy
1125
34
		_bzr
1126
35
		return $?
1127
36
	else
1128
37
		return 1
1129
38
	fi
1130
39
}
1131
40
complete -F _bzr_lazy -o default bzr
1132
0
41
1133
=== removed file 'contrib/bash/bzr'
1134
--- contrib/bash/bzr	2005-09-19 06:05:19 +0000
1135
+++ contrib/bash/bzr	1970-01-01 00:00:00 +0000
1136
@@ -1,104 +0,0 @@
1137
1
# Programmable completion for the Bazaar-NG bzr command under bash. Source
1138
2
# this file (or on some systems add it to ~/.bash_completion and start a new
1139
3
# shell) and bash's completion mechanism will know all about bzr's options!
1140
4
1141
5
# Known to work with bash 2.05a with programmable completion and extended
1142
6
# pattern matching enabled (use 'shopt -s extglob progcomp' to enable
1143
7
# these if they are not already enabled).
1144
8
1145
9
# Based originally on the svn bash completition script.
1146
10
# Customized by Sven Wilhelm/Icecrash.com
1147
11
1148
12
_bzr ()
1149
13
{
1150
14
	local cur cmds cmdOpts opt helpCmds optBase i
1151
15
1152
16
	COMPREPLY=()
1153
17
	cur=${COMP_WORDS[COMP_CWORD]}
1154
18
1155
19
	cmds='status diff commit ci checkin move remove log info check ignored'
1156
20
1157
21
	if [[ $COMP_CWORD -eq 1 ]] ; then
1158
22
		COMPREPLY=( $( compgen -W "$cmds" -- $cur ) )
1159
23
		return 0
1160
24
	fi
1161
25
1162
26
	# if not typing an option, or if the previous option required a
1163
27
	# parameter, then fallback on ordinary filename expansion
1164
28
	helpCmds='help|--help|h|\?'
1165
29
	if [[ ${COMP_WORDS[1]} != @($helpCmds) ]] && \
1166
30
	   [[ "$cur" != -* ]] ; then
1167
31
		return 0
1168
32
	fi
1169
33
1170
34
	cmdOpts=
1171
35
	case ${COMP_WORDS[1]} in
1172
36
	status)
1173
37
		cmdOpts="--all --show-ids"
1174
38
		;;
1175
39
	diff)
1176
40
		cmdOpts="-r --revision --diff-options"
1177
41
		;;
1178
42
	commit|ci|checkin)
1179
43
		cmdOpts="-r --message -F --file -v --verbose"
1180
44
		;;
1181
45
	move)
1182
46
		cmdOpts=""
1183
47
		;;
1184
48
	remove)
1185
49
		cmdOpts="-v --verbose"
1186
50
		;;
1187
51
	log)
1188
52
		cmdOpts="--forward --timezone -v --verbose --show-ids -r --revision"
1189
53
		;;
1190
54
	info)
1191
55
		cmdOpts=""
1192
56
		;;
1193
57
	ignored)
1194
58
		cmdOpts=""
1195
59
		;;
1196
60
	check)
1197
61
		cmdOpts=""
1198
62
		;;
1199
63
	help|h|\?)
1200
64
		cmdOpts="$cmds $qOpts"
1201
65
		;;
1202
66
	*)
1203
67
		;;
1204
68
	esac
1205
69
1206
70
	cmdOpts="$cmdOpts --help -h"
1207
71
1208
72
	# take out options already given
1209
73
	for (( i=2; i<=$COMP_CWORD-1; ++i )) ; do
1210
74
		opt=${COMP_WORDS[$i]}
1211
75
1212
76
		case $opt in
1213
77
		--*)    optBase=${opt/=*/} ;;
1214
78
		-*)     optBase=${opt:0:2} ;;
1215
79
		esac
1216
80
1217
81
		cmdOpts=" $cmdOpts "
1218
82
		cmdOpts=${cmdOpts/ ${optBase} / }
1219
83
1220
84
		# take out alternatives
1221
85
		case $optBase in
1222
86
		-v)              cmdOpts=${cmdOpts/ --verbose / } ;;
1223
87
		--verbose)       cmdOpts=${cmdOpts/ -v / } ;;
1224
88
		-h)              cmdOpts=${cmdOpts/ --help / } ;;
1225
89
		--help)          cmdOpts=${cmdOpts/ -h / } ;;
1226
90
		-r)              cmdOpts=${cmdOpts/ --revision / } ;;
1227
91
		--revision)      cmdOpts=${cmdOpts/ -r / } ;;
1228
92
		esac
1229
93
1230
94
		# skip next option if this one requires a parameter
1231
95
		if [[ $opt == @($optsParam) ]] ; then
1232
96
			((++i))
1233
97
		fi
1234
98
	done
1235
99
1236
100
	COMPREPLY=( $( compgen -W "$cmdOpts" -- $cur ) )
1237
101
1238
102
	return 0
1239
103
}
1240
104
complete -F _bzr -o default bzr
1241
105
0
1242
=== removed file 'contrib/bash/bzr.simple'
1243
--- contrib/bash/bzr.simple	2007-06-06 19:44:39 +0000
1244
+++ contrib/bash/bzr.simple	1970-01-01 00:00:00 +0000
1245
@@ -1,28 +0,0 @@
1246
1
# -*- shell-script -*-
1247
2
1248
3
# experimental bzr bash completion
1249
4
1250
5
# author: Martin Pool
1251
6
1252
7
_bzr_commands() 
1253
8
{
1254
9
     bzr help commands | sed -r 's/^([-[:alnum:]]*).*/\1/' | grep '^[[:alnum:]]' 
1255
10
}
1256
11
1257
12
_bzr() 
1258
13
{
1259
14
    cur=${COMP_WORDS[COMP_CWORD]}
1260
15
    prev=${COMP_WORDS[COMP_CWORD-1]}
1261
16
    if [ $COMP_CWORD -eq 1 ]; then
1262
17
        COMPREPLY=( $( compgen -W "$(_bzr_commands)" $cur ) )
1263
18
    elif [ $COMP_CWORD -eq 2 ]; then
1264
19
        case "$prev" in 
1265
20
        help)
1266
21
            COMPREPLY=( $( compgen -W "$(_bzr_commands) commands" $cur ) )
1267
22
            ;;
1268
23
        esac
1269
24
    fi 
1270
25
}
1271
26
1272
27
complete -F _bzr -o default bzr
1273
28
Reviewer	Date Requested	Status
John A Meinel	2010-05-13	Approve on 2010-05-18
Vincent Ladeuil	2010-04-22	Approve on 2010-05-05
Review via email: mp+23912@code.launchpad.net