← 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, all_command_names, 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')
102
 
        whitespace = ''.join(c for c in string.whitespace if c < chr(127))
103
 
        readline.set_completer_delims(whitespace)
 
37
        self.history_file = os.path.expanduser("~/.bazaar/shell-history")
 
38
        readline.set_completer_delims(string.whitespace)
104
39
        if os.access(self.history_file, os.R_OK) and \
105
40
            os.path.isfile(self.history_file):
106
41
            readline.read_history_file(self.history_file)
111
46
 
112
47
    def do_quit(self, args):
113
48
        self.write_history()
114
 
        raise StopIteration
 
49
        sys.exit(0)
115
50
 
116
51
    def do_exit(self, args):
117
52
        self.do_quit(args)
127
62
    def set_prompt(self):
128
63
        if self.tree is not None:
129
64
            try:
130
 
                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(),
131
 
                               self.tree.relpath('.'))
132
 
                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)
133
70
            except:
134
71
                prompt = ""
135
72
        else:
138
75
 
139
76
    def set_title(self, command=None):
140
77
        try:
141
 
            b = Branch.open_containing('.')[0]
142
 
            version = "%s:%d" % (b.nick, b.revno())
 
78
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
 
79
                                             full=False)
143
80
        except:
144
81
            version = "[no version]"
145
82
        if command is None:
161
98
        except Exception, e:
162
99
            print e
163
100
        try:
164
 
            self.tree = WorkingTree.open_containing(".")[0]
 
101
            self.tree = arch.tree_root(".")
165
102
        except:
166
103
            self.tree = None
167
104
 
168
105
    def do_help(self, line):
169
 
        self.default("help "+line)
 
106
        Help()(line)
170
107
 
171
108
    def default(self, line):
172
 
        try:
173
 
            args = shlex.split(line)
174
 
        except ValueError, e:
175
 
            print 'Parse error:', e
176
 
            return
177
 
 
178
 
        alias_args = get_alias(args[0])
179
 
        if alias_args is not None:
180
 
            args[0] = alias_args.pop(0)
181
 
 
 
109
        args = line.split()
182
110
        commandname = args.pop(0)
183
 
        for char in ('|', '<', '>'):
184
 
            commandname = commandname.split(char)[0]
185
 
        if commandname[-1] in ('|', '<', '>'):
186
 
            commandname = commandname[:-1]
187
111
        try:
188
 
            if commandname in SHELL_BLACKLIST:
189
 
                raise BlackListedCommand(commandname)
190
112
            cmd_obj = get_cmd_object(commandname)
191
 
        except (BlackListedCommand, BzrError):
 
113
        except BzrError:
192
114
            return os.system(line)
193
115
 
 
116
 
194
117
        try:
195
 
            if too_complicated(line):
196
 
                return os.system("bzr "+line)
197
 
            else:
198
 
                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)
 
118
            return (cmd_obj.run_argv(args) or 0)
199
119
        except BzrError, e:
200
120
            print e
201
121
        except KeyboardInterrupt, e:
206
126
 
207
127
 
208
128
    def completenames(self, text, line, begidx, endidx):
209
 
        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)
210
140
 
211
141
    def completedefault(self, text, line, begidx, endidx):
212
142
        """Perform completion for native commands.
213
 
 
 
143
        
214
144
        :param text: The text to complete
215
145
        :type text: str
216
146
        :param line: The entire line to complete
220
150
        :param endidx: The end of the text in the line
221
151
        :type endidx: int
222
152
        """
223
 
        (cmd, args, foo) = self.parseline(line)
224
 
        if cmd == "bzr":
225
 
            cmd = None
226
 
        return CompletionContext(text, command=cmd).get_completions()
227
 
 
 
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
228
189
 
229
190
def run_shell():
 
191
    prompt = PromptCmd()
230
192
    try:
231
 
        prompt = PromptCmd()
232
 
        while True:
233
 
            try:
234
 
                try:
235
 
                    prompt.cmdloop()
236
 
                except KeyboardInterrupt:
237
 
                    print
238
 
            finally:
239
 
                prompt.write_history()
240
 
    except StopIteration:
241
 
        pass
242
 
 
243
 
 
244
 
def iter_opt_completions(command_obj):
245
 
    for option_name, option in command_obj.options().items():
246
 
        yield "--" + option_name
247
 
        short_name = option.short_name()
248
 
        if short_name:
249
 
            yield "-" + short_name
250
 
 
 
193
        prompt.cmdloop()
 
194
    finally:
 
195
        prompt.write_history()
251
196
 
252
197
def iter_file_completions(arg, only_dirs = False):
253
198
    """Generate an iterator that iterates through filename completions.
267
212
        listingdir = os.path.expanduser(dir)
268
213
    else:
269
214
        listingdir = cwd
270
 
    for file in chain(os.listdir(listingdir), extras):
 
215
    for file in iter_combine([os.listdir(listingdir), extras]):
271
216
        if dir != "":
272
217
            userfile = dir+'/'+file
273
218
        else:
277
222
                userfile+='/'
278
223
                yield userfile
279
224
            elif not only_dirs:
280
 
                yield userfile + ' '
 
225
                yield userfile
281
226
 
282
227
 
283
228
def iter_dir_completions(arg):
287
232
    :type arg: str
288
233
    """
289
234
    return iter_file_completions(arg, True)
290
 
 
291
 
 
292
 
def iter_command_names(hidden=False):
293
 
    for real_cmd_name in all_command_names():
294
 
        cmd_obj = get_cmd_object(real_cmd_name)
295
 
        if not hidden and cmd_obj.hidden:
296
 
            continue
297
 
        for name in [real_cmd_name] + cmd_obj.aliases:
298
 
            # Don't complete on aliases that are prefixes of the canonical name
299
 
            if name == real_cmd_name or not real_cmd_name.startswith(name):
300
 
                yield name
301
 
 
302
 
 
303
 
def iter_executables(path):
304
 
    dirname, partial = os.path.split(path)
305
 
    for filename in os.listdir(dirname):
306
 
        if not filename.startswith(partial):
307
 
            continue
308
 
        fullpath = os.path.join(dirname, filename)
309
 
        mode=os.lstat(fullpath)[stat.ST_MODE]
310
 
        if stat.S_ISREG(mode) and 0111 & mode:
311
 
            yield fullpath + ' '
312
 
 
313
 
 
314
 
def filter_completions(iter, arg):
315
 
    return (c for c in iter if c.startswith(arg))
316
 
 
317
 
 
318
 
def iter_munged_completions(iter, arg, text):
319
 
    for completion in iter:
320
 
        completion = str(completion)
321
 
        if completion.startswith(arg):
322
 
            yield completion[len(arg)-len(text):]+" "
323
 
 
324
 
 
325
 
def too_complicated(line):
326
 
    for char in '|<>*?':
327
 
        if char in line:
328
 
            return True
329
 
    return False