/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/plugins/bash_completion/bashcomp.py

  • Committer: Jelmer Vernooij
  • Date: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/bash_completion/bashcomp.py
60
60
shopt -s progcomp
61
61
%(function)s
62
62
complete -F %(function_name)s -o default brz
63
 
"""     % {
 
63
""" % {
64
64
            "function_name": self.function_name,
65
65
            "function": self.function(),
66
66
            "brz_version": self.brz_version(),
70
70
        return ("""\
71
71
%(function_name)s ()
72
72
{
73
 
        local cur cmds cmdIdx cmd cmdOpts fixedWords i globalOpts
74
 
        local curOpt optEnums
75
 
        local IFS=$' \\n'
76
 
 
77
 
        COMPREPLY=()
78
 
        cur=${COMP_WORDS[COMP_CWORD]}
79
 
 
80
 
        cmds='%(cmds)s'
81
 
        globalOpts=( %(global_options)s )
82
 
 
83
 
        # do ordinary expansion if we are anywhere after a -- argument
84
 
        for ((i = 1; i < COMP_CWORD; ++i)); do
85
 
                [[ ${COMP_WORDS[i]} == "--" ]] && return 0
86
 
        done
87
 
 
88
 
        # find the command; it's the first word not starting in -
89
 
        cmd=
90
 
        for ((cmdIdx = 1; cmdIdx < ${#COMP_WORDS[@]}; ++cmdIdx)); do
91
 
                if [[ ${COMP_WORDS[cmdIdx]} != -* ]]; then
92
 
                        cmd=${COMP_WORDS[cmdIdx]}
93
 
                        break
94
 
                fi
95
 
        done
96
 
 
97
 
        # complete command name if we are not already past the command
98
 
        if [[ $COMP_CWORD -le cmdIdx ]]; then
99
 
                COMPREPLY=( $( compgen -W "$cmds ${globalOpts[*]}" -- $cur ) )
100
 
                return 0
101
 
        fi
102
 
 
103
 
        # find the option for which we want to complete a value
104
 
        curOpt=
105
 
        if [[ $cur != -* ]] && [[ $COMP_CWORD -gt 1 ]]; then
106
 
                curOpt=${COMP_WORDS[COMP_CWORD - 1]}
107
 
                if [[ $curOpt == = ]]; then
108
 
                        curOpt=${COMP_WORDS[COMP_CWORD - 2]}
109
 
                elif [[ $cur == : ]]; then
110
 
                        cur=
111
 
                        curOpt="$curOpt:"
112
 
                elif [[ $curOpt == : ]]; then
113
 
                        curOpt=${COMP_WORDS[COMP_CWORD - 2]}:
114
 
                fi
115
 
        fi
 
73
    local cur cmds cmdIdx cmd cmdOpts fixedWords i globalOpts
 
74
    local curOpt optEnums
 
75
    local IFS=$' \\n'
 
76
 
 
77
    COMPREPLY=()
 
78
    cur=${COMP_WORDS[COMP_CWORD]}
 
79
 
 
80
    cmds='%(cmds)s'
 
81
    globalOpts=( %(global_options)s )
 
82
 
 
83
    # do ordinary expansion if we are anywhere after a -- argument
 
84
    for ((i = 1; i < COMP_CWORD; ++i)); do
 
85
        [[ ${COMP_WORDS[i]} == "--" ]] && return 0
 
86
    done
 
87
 
 
88
    # find the command; it's the first word not starting in -
 
89
    cmd=
 
90
    for ((cmdIdx = 1; cmdIdx < ${#COMP_WORDS[@]}; ++cmdIdx)); do
 
91
        if [[ ${COMP_WORDS[cmdIdx]} != -* ]]; then
 
92
            cmd=${COMP_WORDS[cmdIdx]}
 
93
            break
 
94
        fi
 
95
    done
 
96
 
 
97
    # complete command name if we are not already past the command
 
98
    if [[ $COMP_CWORD -le cmdIdx ]]; then
 
99
        COMPREPLY=( $( compgen -W "$cmds ${globalOpts[*]}" -- $cur ) )
 
100
        return 0
 
101
    fi
 
102
 
 
103
    # find the option for which we want to complete a value
 
104
    curOpt=
 
105
    if [[ $cur != -* ]] && [[ $COMP_CWORD -gt 1 ]]; then
 
106
        curOpt=${COMP_WORDS[COMP_CWORD - 1]}
 
107
        if [[ $curOpt == = ]]; then
 
108
            curOpt=${COMP_WORDS[COMP_CWORD - 2]}
 
109
        elif [[ $cur == : ]]; then
 
110
            cur=
 
111
            curOpt="$curOpt:"
 
112
        elif [[ $curOpt == : ]]; then
 
113
            curOpt=${COMP_WORDS[COMP_CWORD - 2]}:
 
114
        fi
 
115
    fi
116
116
%(debug)s
117
 
        cmdOpts=( )
118
 
        optEnums=( )
119
 
        fixedWords=( )
120
 
        case $cmd in
 
117
    cmdOpts=( )
 
118
    optEnums=( )
 
119
    fixedWords=( )
 
120
    case $cmd in
121
121
%(cases)s\
122
 
        *)
123
 
                cmdOpts=(--help -h)
124
 
                ;;
125
 
        esac
126
 
 
127
 
        IFS=$'\\n'
128
 
        if [[ ${#fixedWords[@]} -eq 0 ]] && [[ ${#optEnums[@]} -eq 0 ]] && [[ $cur != -* ]]; then
129
 
                case $curOpt in
130
 
                        tag:|*..tag:)
131
 
                                fixedWords=( $(brz tags 2>/dev/null | sed 's/  *[^ ]*$//; s/ /\\\\\\\\ /g;') )
132
 
                                ;;
133
 
                esac
134
 
                case $cur in
135
 
                        [\\"\\']tag:*)
136
 
                                fixedWords=( $(brz tags 2>/dev/null | sed 's/  *[^ ]*$//; s/^/tag:/') )
137
 
                                ;;
138
 
                        [\\"\\']*..tag:*)
139
 
                                fixedWords=( $(brz tags 2>/dev/null | sed 's/  *[^ ]*$//') )
140
 
                                fixedWords=( $(for i in "${fixedWords[@]}"; do echo "${cur%%..tag:*}..tag:${i}"; done) )
141
 
                                ;;
142
 
                esac
143
 
        elif [[ $cur == = ]] && [[ ${#optEnums[@]} -gt 0 ]]; then
144
 
                # complete directly after "--option=", list all enum values
145
 
                COMPREPLY=( "${optEnums[@]}" )
146
 
                return 0
147
 
        else
148
 
                fixedWords=( "${cmdOpts[@]}"
149
 
                             "${globalOpts[@]}"
150
 
                             "${optEnums[@]}"
151
 
                             "${fixedWords[@]}" )
152
 
        fi
153
 
 
154
 
        if [[ ${#fixedWords[@]} -gt 0 ]]; then
155
 
                COMPREPLY=( $( compgen -W "${fixedWords[*]}" -- $cur ) )
156
 
        fi
157
 
 
158
 
        return 0
 
122
    *)
 
123
        cmdOpts=(--help -h)
 
124
        ;;
 
125
    esac
 
126
 
 
127
    IFS=$'\\n'
 
128
    if [[ ${#fixedWords[@]} -eq 0 ]] && [[ ${#optEnums[@]} -eq 0 ]] && [[ $cur != -* ]]; then
 
129
        case $curOpt in
 
130
            tag:|*..tag:)
 
131
                fixedWords=( $(brz tags 2>/dev/null | sed 's/  *[^ ]*$//; s/ /\\\\\\\\ /g;') )
 
132
                ;;
 
133
        esac
 
134
        case $cur in
 
135
            [\\"\\']tag:*)
 
136
                fixedWords=( $(brz tags 2>/dev/null | sed 's/  *[^ ]*$//; s/^/tag:/') )
 
137
                ;;
 
138
            [\\"\\']*..tag:*)
 
139
                fixedWords=( $(brz tags 2>/dev/null | sed 's/  *[^ ]*$//') )
 
140
                fixedWords=( $(for i in "${fixedWords[@]}"; do echo "${cur%%..tag:*}..tag:${i}"; done) )
 
141
                ;;
 
142
        esac
 
143
    elif [[ $cur == = ]] && [[ ${#optEnums[@]} -gt 0 ]]; then
 
144
        # complete directly after "--option=", list all enum values
 
145
        COMPREPLY=( "${optEnums[@]}" )
 
146
        return 0
 
147
    else
 
148
        fixedWords=( "${cmdOpts[@]}"
 
149
                     "${globalOpts[@]}"
 
150
                     "${optEnums[@]}"
 
151
                     "${fixedWords[@]}" )
 
152
    fi
 
153
 
 
154
    if [[ ${#fixedWords[@]} -gt 0 ]]; then
 
155
        COMPREPLY=( $( compgen -W "${fixedWords[*]}" -- $cur ) )
 
156
    fi
 
157
 
 
158
    return 0
159
159
}
160
 
"""     % {
 
160
""" % {
161
161
            "cmds": self.command_names(),
162
162
            "function_name": self.function_name,
163
163
            "cases": self.command_cases(),
174
174
            return ''
175
175
        else:
176
176
            return (r"""
177
 
        # Debugging code enabled using the --debug command line switch.
178
 
        # Will dump some variables to the top portion of the terminal.
179
 
        echo -ne '\e[s\e[H'
180
 
        for (( i=0; i < ${#COMP_WORDS[@]}; ++i)); do
181
 
                echo "\$COMP_WORDS[$i]='${COMP_WORDS[i]}'"$'\e[K'
182
 
        done
183
 
        for i in COMP_CWORD COMP_LINE COMP_POINT COMP_TYPE COMP_KEY cur curOpt; do
184
 
                echo "\$${i}=\"${!i}\""$'\e[K'
185
 
        done
186
 
        echo -ne '---\e[K\e[u'
 
177
    # Debugging code enabled using the --debug command line switch.
 
178
    # Will dump some variables to the top portion of the terminal.
 
179
    echo -ne '\e[s\e[H'
 
180
    for (( i=0; i < ${#COMP_WORDS[@]}; ++i)); do
 
181
        echo "\$COMP_WORDS[$i]='${COMP_WORDS[i]}'"$'\e[K'
 
182
    done
 
183
    for i in COMP_CWORD COMP_LINE COMP_POINT COMP_TYPE COMP_KEY cur curOpt; do
 
184
        echo "\$${i}=\"${!i}\""$'\e[K'
 
185
    done
 
186
    echo -ne '---\e[K\e[u'
187
187
""")
188
188
 
189
189
    def brz_version(self):
303
303
            self.selected_plugins = None
304
304
        else:
305
305
            self.selected_plugins = {x.replace('-', '_')
306
 
                                         for x in selected_plugins}
 
306
                                     for x in selected_plugins}
307
307
 
308
308
    def collect(self):
309
309
        self.global_options()
337
337
        plugin_name = cmd.plugin_name()
338
338
        if plugin_name is not None:
339
339
            if (self.selected_plugins is not None and
340
 
                plugin not in self.selected_plugins):
 
340
                    plugin not in self.selected_plugins):
341
341
                return None
342
342
            plugin_data = self.data.plugins.get(plugin_name)
343
343
            if plugin_data is None:
352
352
        # ones while maintaining the actual command name unchanged.
353
353
        cmd_data.aliases.extend(cmd.aliases)
354
354
        cmd_data.aliases.extend(sorted([useralias
355
 
            for cmdalias in cmd_data.aliases
356
 
            if cmdalias in self.user_aliases
357
 
            for useralias in self.user_aliases[cmdalias]
358
 
            if useralias not in cmd_data.aliases]))
 
355
                                        for cmdalias in cmd_data.aliases
 
356
                                        if cmdalias in self.user_aliases
 
357
                                        for useralias in self.user_aliases[cmdalias]
 
358
                                        if useralias not in cmd_data.aliases]))
359
359
 
360
360
        opts = cmd.options()
361
361
        for optname, opt in sorted(opts.items()):
363
363
 
364
364
        if 'help' == name or 'help' in cmd.aliases:
365
365
            cmd_data.fixed_words = ('($cmds %s)' %
366
 
                " ".join(sorted(help_topics.topic_registry.keys())))
 
366
                                    " ".join(sorted(help_topics.topic_registry.keys())))
367
367
 
368
368
        return cmd_data
369
369
 
394
394
 
395
395
    def wrap_parser(self, optswitches, parser):
396
396
        orig_add_option_group = parser.add_option_group
 
397
 
397
398
        def tweaked_add_option_group(*opts, **attrs):
398
399
            return self.wrap_container(optswitches,
399
 
                orig_add_option_group(*opts, **attrs))
 
400
                                       orig_add_option_group(*opts, **attrs))
400
401
        parser.add_option_group = tweaked_add_option_group
401
402
        return self.wrap_container(optswitches, parser)
402
403
 
404
405
def bash_completion_function(out, function_name="_brz", function_only=False,
405
406
                             debug=False,
406
407
                             no_plugins=False, selected_plugins=None):
407
 
    dc = DataCollector(no_plugins=no_plugins, selected_plugins=selected_plugins)
 
408
    dc = DataCollector(no_plugins=no_plugins,
 
409
                       selected_plugins=selected_plugins)
408
410
    data = dc.collect()
409
411
    cg = BashCodeGen(data, function_name=function_name, debug=debug)
410
412
    if function_only:
420
422
    This command generates a shell function which can be used by bash to
421
423
    automatically complete the currently typed command when the user presses
422
424
    the completion key (usually tab).
423
 
    
 
425
 
424
426
    Commonly used like this:
425
427
        eval "`brz bash-completion`"
426
428
    """
427
429
 
428
430
    takes_options = [
429
431
        option.Option("function-name", short_name="f", type=text_type, argname="name",
430
 
               help="Name of the generated function (default: _brz)"),
 
432
                      help="Name of the generated function (default: _brz)"),
431
433
        option.Option("function-only", short_name="o", type=None,
432
 
               help="Generate only the shell function, don't enable it"),
 
434
                      help="Generate only the shell function, don't enable it"),
433
435
        option.Option("debug", type=None, hidden=True,
434
 
               help="Enable shell code useful for debugging"),
 
436
                      help="Enable shell code useful for debugging"),
435
437
        option.ListOption("plugin", type=text_type, argname="name",
436
 
                # param_name="selected_plugins", # doesn't work, bug #387117
437
 
                help="Enable completions for the selected plugin"
438
 
                + " (default: all plugins)"),
 
438
                          # param_name="selected_plugins", # doesn't work, bug #387117
 
439
                          help="Enable completions for the selected plugin"
 
440
                          + " (default: all plugins)"),
439
441
        ]
440
442
 
441
443
    def run(self, **kwargs):