← 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-11-21 14:29:35 UTC
  • mfrom: (288 bzrtools)
  • mto: (147.4.24 trunk)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: abentley@panoramicfeedback.com-20051121142935-96c67761f8d04a12
Updated from mainline bzrtools

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
26
27
 
27
28
SHELL_BLACKLIST = set(['rm', 'ls'])
28
29
COMPLETION_BLACKLIST = set(['shell'])
40
41
        self.arg_pos = None
41
42
 
42
43
    def get_completions(self):
43
 
        if not command:
44
 
            iter = (c for c in iter_command_names() if
 
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
45
61
                    c not in COMPLETION_BLACKLIST)
46
 
            try:
47
 
                iter = list(filter_completions(iter, text))
48
 
            except Exception, e:
49
 
                print e, type(e)
50
 
 
 
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 
51
73
 
52
74
 
53
75
class PromptCmd(cmd.Cmd):
55
77
        cmd.Cmd.__init__(self)
56
78
        self.prompt = "bzr> "
57
79
        try:
58
 
            self.tree = arch.tree_root(".")
 
80
            self.branch = Branch.open_containing('.')[0]
59
81
        except:
60
 
            self.tree = None
 
82
            self.branch = None
61
83
        self.set_title()
62
84
        self.set_prompt()
63
85
        self.identchars += '-'
87
109
        self.set_prompt()
88
110
 
89
111
    def set_prompt(self):
90
 
        if self.tree is not None:
 
112
        if self.branch is not None:
91
113
            try:
92
 
                prompt = pylon.alias_or_version(self.tree.tree_version, 
93
 
                                                self.tree, 
94
 
                                                full=False)
95
 
                if prompt is not None:
96
 
                    prompt = " " + prompt +":"+ pylon.tree_cwd(self.tree)
 
114
                prompt_data = (self.branch.nick, self.branch.revno(), 
 
115
                               self.branch.working_tree().relpath('.'))
 
116
                prompt = " %s:%d/%s" % prompt_data
97
117
            except:
98
118
                prompt = ""
99
119
        else:
102
122
 
103
123
    def set_title(self, command=None):
104
124
        try:
105
 
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
106
 
                                             full=False)
 
125
            b = Branch.open_containing('.')[0]
 
126
            version = "%s:%d" % (b.nick, b.revno())
107
127
        except:
108
128
            version = "[no version]"
109
129
        if command is None:
125
145
        except Exception, e:
126
146
            print e
127
147
        try:
128
 
            self.tree = arch.tree_root(".")
 
148
            self.branch = Branch.open_containing(".")[0]
129
149
        except:
130
 
            self.tree = None
 
150
            self.branch = None
131
151
 
132
152
    def do_help(self, line):
133
153
        self.default("help "+line)
161
181
 
162
182
 
163
183
    def completenames(self, text, line, begidx, endidx):
164
 
        from bzrlib.trace import mutter
165
 
        completions = []
166
 
        iter = (c for c in iter_command_names() if
167
 
                c not in COMPLETION_BLACKLIST)
168
 
        try:
169
 
            if len(line) > 0:
170
 
                arg = line.split()[-1]
171
 
            else:
172
 
                arg = ""
173
 
            iter = filter_completions(iter, arg)
174
 
        except Exception, e:
175
 
            print e, type(e)
176
 
        return list(iter)
 
184
        return CompletionContext(text).get_completions()
177
185
 
178
186
    def completedefault(self, text, line, begidx, endidx):
179
187
        """Perform completion for native commands.
189
197
        """
190
198
        (cmd, args, foo) = self.parseline(line)
191
199
        if cmd == "bzr":
192
 
            try:
193
 
                return self.completenames(text, line, begidx, endidx)
194
 
            except Exception, e:
195
 
                print e
196
 
        try:
197
 
            command_obj = get_cmd_object(cmd)
198
 
        except BzrError:
199
 
            command_obj = None
200
 
        try:
201
 
            if command_obj is not None:
202
 
                opts = list(iter_opt_completions(command_obj))
203
 
                files = list(iter_file_completions(text))
204
 
                return list(filter_completions(opts+files, text))
205
 
            elif cmd == "cd":
206
 
                if len(args) > 0:
207
 
                    arg = args.split()[-1]
208
 
                else:
209
 
                    arg = ""
210
 
                iter = iter_dir_completions(text)
211
 
                iter = filter_completions(iter, text)
212
 
                return list(iter)
213
 
            elif len(args)>0:
214
 
                arg = args.split()[-1]
215
 
                iter = iter_file_completions(arg)
216
 
                return list(iter_munged_completions(iter, arg, text))
217
 
            else:
218
 
                return self.completenames(text, line, begidx, endidx)
219
 
        except Exception, e:
220
 
            print e
 
200
            cmd = None
 
201
        return CompletionContext(text, command=cmd).get_completions()
221
202
 
222
203
def run_shell():
223
204
    try: