← 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-29 18:40:48 UTC
  • mto: This revision was merged to the branch mainline in revision 263.
  • Revision ID: abentley@panoramicfeedback.com-20051029184048-88c7e2e0fc56481f
Updated GPL notices

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell.py
23
23
from itertools import chain
24
24
from bzrlib.errors import BzrError
25
25
from bzrlib.commands import get_cmd_object, get_all_cmds
26
 
from bzrlib.branch import Branch
27
26
 
28
27
SHELL_BLACKLIST = set(['rm', 'ls'])
29
28
COMPLETION_BLACKLIST = set(['shell'])
33
32
        BzrError.__init__(self, "The command %s is blacklisted for shell use" %
34
33
                          command)
35
34
 
36
 
class CompletionContext(object):
37
 
    def __init__(self, text, command=None, prev_opt=None, arg_pos=None):
38
 
        self.text = text
39
 
        self.command = command
40
 
        self.prev_opt = prev_opt
41
 
        self.arg_pos = None
42
 
 
43
 
    def get_completions(self):
44
 
        try:
45
 
            return self.get_completions_or_raise()
46
 
        except Exception, e:
47
 
            print e, type(e)
48
 
            return []
49
 
 
50
 
    def get_option_completions(self):
51
 
        try:
52
 
            command_obj = get_cmd_object(self.command)
53
 
        except BzrError:
54
 
            return []
55
 
        opts = [o+" " for o in iter_opt_completions(command_obj)]
56
 
        return list(filter_completions(opts, self.text))
57
 
 
58
 
    def get_completions_or_raise(self):
59
 
        if self.command is None:
60
 
            iter = (c+" " for c in iter_command_names() if
61
 
                    c not in COMPLETION_BLACKLIST)
62
 
            return list(filter_completions(iter, self.text))
63
 
        if self.prev_opt is None:
64
 
            completions = self.get_option_completions()
65
 
            if self.command == "cd":
66
 
                iter = iter_dir_completions(self.text)
67
 
                completions.extend(list(filter_completions(iter, self.text)))
68
 
            else:
69
 
                iter = iter_file_completions(self.text)
70
 
                completions.extend([f+" " for f in 
71
 
                                    filter_completions(iter, self.text)])
72
 
            return completions 
73
 
 
74
 
 
75
35
class PromptCmd(cmd.Cmd):
76
36
    def __init__(self):
77
37
        cmd.Cmd.__init__(self)
78
38
        self.prompt = "bzr> "
79
39
        try:
80
 
            self.branch = Branch.open_containing('.')[0]
 
40
            self.tree = arch.tree_root(".")
81
41
        except:
82
 
            self.branch = None
 
42
            self.tree = None
83
43
        self.set_title()
84
44
        self.set_prompt()
85
45
        self.identchars += '-'
109
69
        self.set_prompt()
110
70
 
111
71
    def set_prompt(self):
112
 
        if self.branch is not None:
 
72
        if self.tree is not None:
113
73
            try:
114
 
                prompt_data = (self.branch.nick, self.branch.revno(), 
115
 
                               self.branch.working_tree().relpath('.'))
116
 
                prompt = " %s:%d/%s" % prompt_data
 
74
                prompt = pylon.alias_or_version(self.tree.tree_version, 
 
75
                                                self.tree, 
 
76
                                                full=False)
 
77
                if prompt is not None:
 
78
                    prompt = " " + prompt +":"+ pylon.tree_cwd(self.tree)
117
79
            except:
118
80
                prompt = ""
119
81
        else:
122
84
 
123
85
    def set_title(self, command=None):
124
86
        try:
125
 
            b = Branch.open_containing('.')[0]
126
 
            version = "%s:%d" % (b.nick, b.revno())
 
87
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
 
88
                                             full=False)
127
89
        except:
128
90
            version = "[no version]"
129
91
        if command is None:
145
107
        except Exception, e:
146
108
            print e
147
109
        try:
148
 
            self.branch = Branch.open_containing(".")[0]
 
110
            self.tree = arch.tree_root(".")
149
111
        except:
150
 
            self.branch = None
 
112
            self.tree = None
151
113
 
152
114
    def do_help(self, line):
153
115
        self.default("help "+line)
181
143
 
182
144
 
183
145
    def completenames(self, text, line, begidx, endidx):
184
 
        return CompletionContext(text).get_completions()
 
146
        completions = []
 
147
        iter = (c for c in iter_command_names() if
 
148
                c not in COMPLETION_BLACKLIST)
 
149
        try:
 
150
            if len(line) > 0:
 
151
                arg = line.split()[-1]
 
152
            else:
 
153
                arg = ""
 
154
            iter = list(iter_munged_completions(iter, arg, text))
 
155
        except Exception, e:
 
156
            print e, type(e)
 
157
        return list(iter)
185
158
 
186
159
    def completedefault(self, text, line, begidx, endidx):
187
160
        """Perform completion for native commands.
197
170
        """
198
171
        (cmd, args, foo) = self.parseline(line)
199
172
        if cmd == "bzr":
200
 
            cmd = None
201
 
        return CompletionContext(text, command=cmd).get_completions()
 
173
            try:
 
174
                return self.completenames(text, line, begidx, endidx)
 
175
            except Exception, e:
 
176
                print e
 
177
        try:
 
178
            command_obj = get_cmd_object(cmd)
 
179
        except BzrError:
 
180
            command_obj = None
 
181
        try:
 
182
            if command_obj is not None:
 
183
                opts = []
 
184
                for option_name, option in command_obj.options().items():
 
185
                    opts.append("--" + option_name)
 
186
                    short_name = option.short_name()
 
187
                    if short_name:
 
188
                        opts.append("-" + short_name)
 
189
                q = list(iter_munged_completions(opts, args, text))
 
190
                return list(iter_munged_completions(opts, args, text))
 
191
            elif cmd == "cd":
 
192
                if len(args) > 0:
 
193
                    arg = args.split()[-1]
 
194
                else:
 
195
                    arg = ""
 
196
                iter = iter_dir_completions(arg)
 
197
                iter = iter_munged_completions(iter, arg, text)
 
198
                return list(iter)
 
199
            elif len(args)>0:
 
200
                arg = args.split()[-1]
 
201
                iter = iter_file_completions(arg)
 
202
                return list(iter_munged_completions(iter, arg, text))
 
203
            else:
 
204
                return self.completenames(text, line, begidx, endidx)
 
205
        except Exception, e:
 
206
            print e
202
207
 
203
208
def run_shell():
204
209
    try:
210
215
    except StopIteration:
211
216
        pass
212
217
 
213
 
def iter_opt_completions(command_obj):
214
 
    for option_name, option in command_obj.options().items():
215
 
        yield "--" + option_name
216
 
        short_name = option.short_name()
217
 
        if short_name:
218
 
            yield "-" + short_name
219
 
 
220
218
def iter_file_completions(arg, only_dirs = False):
221
219
    """Generate an iterator that iterates through filename completions.
222
220
 
265
263
            if name == real_cmd_name or not real_cmd_name.startswith(name):
266
264
                yield name
267
265
 
268
 
def filter_completions(iter, arg):
269
 
    return (c for c in iter if c.startswith(arg))
270
 
 
271
266
def iter_munged_completions(iter, arg, text):
272
267
    for completion in iter:
273
268
        completion = str(completion)
275
270
            yield completion[len(arg)-len(text):]+" "
276
271
 
277
272
def too_complicated(line):
278
 
    for char in '|<>"\"*?':
 
273
    for char in '|<>"\"':
279
274
        if char in line:
280
275
            return True
281
276
    return False