← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to shell.py

  • Committer: Aaron Bentley
  • Date: 2005-10-27 04:45:06 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20051027044506-45f616c07537a1da
Got the shell basics working properly

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell.py
1
1
# Copyright (C) 2004, 2005 Aaron Bentley
2
 
# <aaron@aaronbentley.com>
 
2
# <aaron.bentley@utoronto.ca>
3
3
#
4
4
#    This program is free software; you can redistribute it and/or modify
5
5
#    it under the terms of the GNU General Public License as published by
14
14
#    You should have received a copy of the GNU General Public License
15
15
#    along with this program; if not, write to the Free Software
16
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
17
import cmd
19
 
from itertools import chain
 
18
import sys
20
19
import os
 
20
import terminal
21
21
import readline
22
 
import shlex
23
 
import stat
24
22
import string
25
 
import sys
26
 
 
27
 
from bzrlib import osutils
28
 
from bzrlib.branch import Branch
29
 
from bzrlib.config import config_dir, ensure_config_dir_exists
30
 
from bzrlib.commands import get_cmd_object, get_all_cmds, get_alias
31
23
from bzrlib.errors import BzrError
32
 
from bzrlib.workingtree import WorkingTree
33
 
 
34
 
import terminal
35
 
 
36
 
 
37
 
SHELL_BLACKLIST = set(['rm', 'ls'])
38
 
COMPLETION_BLACKLIST = set(['shell'])
39
 
 
40
 
 
41
 
class BlackListedCommand(BzrError):
42
 
    def __init__(self, command):
43
 
        BzrError.__init__(self, "The command %s is blacklisted for shell use" %
44
 
                          command)
45
 
 
46
 
 
47
 
class CompletionContext(object):
48
 
    def __init__(self, text, command=None, prev_opt=None, arg_pos=None):
49
 
        self.text = text
50
 
        self.command = command
51
 
        self.prev_opt = prev_opt
52
 
        self.arg_pos = None
53
 
 
54
 
    def get_completions(self):
55
 
        try:
56
 
            return self.get_completions_or_raise()
57
 
        except Exception, e:
58
 
            print e, type(e)
59
 
            return []
60
 
 
61
 
    def get_option_completions(self):
62
 
        try:
63
 
            command_obj = get_cmd_object(self.command)
64
 
        except BzrError:
65
 
            return []
66
 
        opts = [o+" " for o in iter_opt_completions(command_obj)]
67
 
        return list(filter_completions(opts, self.text))
68
 
 
69
 
    def get_completions_or_raise(self):
70
 
        if self.command is None:
71
 
            if '/' in self.text:
72
 
                iter = iter_executables(self.text)
73
 
            else:
74
 
                iter = (c+" " for c in iter_command_names() if
75
 
                        c not in COMPLETION_BLACKLIST)
76
 
            return list(filter_completions(iter, self.text))
77
 
        if self.prev_opt is None:
78
 
            completions = self.get_option_completions()
79
 
            if self.command == "cd":
80
 
                iter = iter_dir_completions(self.text)
81
 
                completions.extend(list(filter_completions(iter, self.text)))
82
 
            else:
83
 
                iter = iter_file_completions(self.text)
84
 
                completions.extend(filter_completions(iter, self.text))
85
 
            return completions
86
 
 
 
24
from bzrlib.commands import get_cmd_object
87
25
 
88
26
class PromptCmd(cmd.Cmd):
89
 
 
90
27
    def __init__(self):
91
28
        cmd.Cmd.__init__(self)
92
29
        self.prompt = "bzr> "
93
30
        try:
94
 
            self.tree = WorkingTree.open_containing('.')[0]
 
31
            self.tree = arch.tree_root(".")
95
32
        except:
96
33
            self.tree = None
97
34
        self.set_title()
98
35
        self.set_prompt()
99
36
        self.identchars += '-'
100
 
        ensure_config_dir_exists()
101
 
        self.history_file = osutils.pathjoin(config_dir(), 'shell-history')
 
37
        self.history_file = os.path.expanduser("~/.bazaar/shell-history")
102
38
        readline.set_completer_delims(string.whitespace)
103
39
        if os.access(self.history_file, os.R_OK) and \
104
40
            os.path.isfile(self.history_file):
110
46
 
111
47
    def do_quit(self, args):
112
48
        self.write_history()
113
 
        raise StopIteration
 
49
        sys.exit(0)
114
50
 
115
51
    def do_exit(self, args):
116
52
        self.do_quit(args)
126
62
    def set_prompt(self):
127
63
        if self.tree is not None:
128
64
            try:
129
 
                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(),
130
 
                               self.tree.relpath('.'))
131
 
                prompt = " %s:%d/%s" % prompt_data
 
65
                prompt = pylon.alias_or_version(self.tree.tree_version, 
 
66
                                                self.tree, 
 
67
                                                full=False)
 
68
                if prompt is not None:
 
69
                    prompt = " " + prompt +":"+ pylon.tree_cwd(self.tree)
132
70
            except:
133
71
                prompt = ""
134
72
        else:
137
75
 
138
76
    def set_title(self, command=None):
139
77
        try:
140
 
            b = Branch.open_containing('.')[0]
141
 
            version = "%s:%d" % (b.nick, b.revno())
 
78
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
 
79
                                             full=False)
142
80
        except:
143
81
            version = "[no version]"
144
82
        if command is None:
160
98
        except Exception, e:
161
99
            print e
162
100
        try:
163
 
            self.tree = WorkingTree.open_containing(".")[0]
 
101
            self.tree = arch.tree_root(".")
164
102
        except:
165
103
            self.tree = None
166
104
 
167
105
    def do_help(self, line):
168
 
        self.default("help "+line)
 
106
        Help()(line)
169
107
 
170
108
    def default(self, line):
171
 
        args = shlex.split(line)
172
 
        alias_args = get_alias(args[0])
173
 
        if alias_args is not None:
174
 
            args[0] = alias_args.pop(0)
175
 
 
 
109
        args = line.split()
176
110
        commandname = args.pop(0)
177
 
        for char in ('|', '<', '>'):
178
 
            commandname = commandname.split(char)[0]
179
 
        if commandname[-1] in ('|', '<', '>'):
180
 
            commandname = commandname[:-1]
181
111
        try:
182
 
            if commandname in SHELL_BLACKLIST:
183
 
                raise BlackListedCommand(commandname)
184
112
            cmd_obj = get_cmd_object(commandname)
185
 
        except (BlackListedCommand, BzrError):
 
113
        except BzrError:
186
114
            return os.system(line)
187
115
 
 
116
 
188
117
        try:
189
 
            if too_complicated(line):
190
 
                return os.system("bzr "+line)
191
 
            else:
192
 
                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)
 
118
            return (cmd_obj.run_argv(args) or 0)
193
119
        except BzrError, e:
194
120
            print e
195
121
        except KeyboardInterrupt, e:
200
126
 
201
127
 
202
128
    def completenames(self, text, line, begidx, endidx):
203
 
        return CompletionContext(text).get_completions()
 
129
        completions = []
 
130
        iter = iter_command_names(self.fake_aba)
 
131
        try:
 
132
            if len(line) > 0:
 
133
                arg = line.split()[-1]
 
134
            else:
 
135
                arg = ""
 
136
            iter = cmdutil.iter_munged_completions(iter, arg, text)
 
137
        except Exception, e:
 
138
            print e
 
139
        return list(iter)
204
140
 
205
141
    def completedefault(self, text, line, begidx, endidx):
206
142
        """Perform completion for native commands.
207
 
 
 
143
        
208
144
        :param text: The text to complete
209
145
        :type text: str
210
146
        :param line: The entire line to complete
214
150
        :param endidx: The end of the text in the line
215
151
        :type endidx: int
216
152
        """
217
 
        (cmd, args, foo) = self.parseline(line)
218
 
        if cmd == "bzr":
219
 
            cmd = None
220
 
        return CompletionContext(text, command=cmd).get_completions()
221
 
 
 
153
        try:
 
154
            (cmd, args, foo) = self.parseline(line)
 
155
            command_obj=find_command(cmd)
 
156
            if command_obj is not None:
 
157
                return command_obj.complete(args.split(), text)
 
158
            elif not self.fake_aba.is_command(cmd) and \
 
159
                cmdutil.is_tla_command(cmd):
 
160
                iter = cmdutil.iter_supported_switches(cmd)
 
161
                if len(args) > 0:
 
162
                    arg = args.split()[-1]
 
163
                else:
 
164
                    arg = ""
 
165
                if arg.startswith("-"):
 
166
                    return list(cmdutil.iter_munged_completions(iter, arg, 
 
167
                                                                text))
 
168
                else:
 
169
                    return list(cmdutil.iter_munged_completions(
 
170
                        cmdutil.iter_file_completions(arg), arg, text))
 
171
 
 
172
 
 
173
            elif cmd == "cd":
 
174
                if len(args) > 0:
 
175
                    arg = args.split()[-1]
 
176
                else:
 
177
                    arg = ""
 
178
                iter = cmdutil.iter_dir_completions(arg)
 
179
                iter = cmdutil.iter_munged_completions(iter, arg, text)
 
180
                return list(iter)
 
181
            elif len(args)>0:
 
182
                arg = args.split()[-1]
 
183
                iter = cmdutil.iter_file_completions(arg)
 
184
                return list(cmdutil.iter_munged_completions(iter, arg, text))
 
185
            else:
 
186
                return self.completenames(text, line, begidx, endidx)
 
187
        except Exception, e:
 
188
            print e
222
189
 
223
190
def run_shell():
 
191
    prompt = PromptCmd()
224
192
    try:
225
 
        prompt = PromptCmd()
226
 
        try:
227
 
            prompt.cmdloop()
228
 
        finally:
229
 
            prompt.write_history()
230
 
    except StopIteration:
231
 
        pass
232
 
 
233
 
 
234
 
def iter_opt_completions(command_obj):
235
 
    for option_name, option in command_obj.options().items():
236
 
        yield "--" + option_name
237
 
        short_name = option.short_name()
238
 
        if short_name:
239
 
            yield "-" + short_name
240
 
 
 
193
        prompt.cmdloop()
 
194
    finally:
 
195
        prompt.write_history()
241
196
 
242
197
def iter_file_completions(arg, only_dirs = False):
243
198
    """Generate an iterator that iterates through filename completions.
257
212
        listingdir = os.path.expanduser(dir)
258
213
    else:
259
214
        listingdir = cwd
260
 
    for file in chain(os.listdir(listingdir), extras):
 
215
    for file in iter_combine([os.listdir(listingdir), extras]):
261
216
        if dir != "":
262
217
            userfile = dir+'/'+file
263
218
        else:
267
222
                userfile+='/'
268
223
                yield userfile
269
224
            elif not only_dirs:
270
 
                yield userfile + ' '
 
225
                yield userfile
271
226
 
272
227
 
273
228
def iter_dir_completions(arg):
277
232
    :type arg: str
278
233
    """
279
234
    return iter_file_completions(arg, True)
280
 
 
281
 
 
282
 
def iter_command_names(hidden=False):
283
 
    for real_cmd_name, cmd_class in get_all_cmds():
284
 
        if not hidden and cmd_class.hidden:
285
 
            continue
286
 
        for name in [real_cmd_name] + cmd_class.aliases:
287
 
            # Don't complete on aliases that are prefixes of the canonical name
288
 
            if name == real_cmd_name or not real_cmd_name.startswith(name):
289
 
                yield name
290
 
 
291
 
 
292
 
def iter_executables(path):
293
 
    dirname, partial = os.path.split(path)
294
 
    for filename in os.listdir(dirname):
295
 
        if not filename.startswith(partial):
296
 
            continue
297
 
        fullpath = os.path.join(dirname, filename)
298
 
        mode=os.lstat(fullpath)[stat.ST_MODE]
299
 
        if stat.S_ISREG(mode) and 0111 & mode:
300
 
            yield fullpath + ' '
301
 
 
302
 
 
303
 
def filter_completions(iter, arg):
304
 
    return (c for c in iter if c.startswith(arg))
305
 
 
306
 
 
307
 
def iter_munged_completions(iter, arg, text):
308
 
    for completion in iter:
309
 
        completion = str(completion)
310
 
        if completion.startswith(arg):
311
 
            yield completion[len(arg)-len(text):]+" "
312
 
 
313
 
 
314
 
def too_complicated(line):
315
 
    for char in '|<>*?':
316
 
        if char in line:
317
 
            return True
318
 
    return False