/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: 2018-11-16 23:15:15 UTC
  • mfrom: (7180 work)
  • mto: This revision was merged to the branch mainline in revision 7183.
  • Revision ID: jelmer@jelmer.uk-20181116231515-zqd2yn6kj8lfydyp
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:
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):