← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to shell.py

  • Committer: Daniel Silverstone
  • Date: 2005-11-10 20:06:23 UTC
  • mto: This revision was merged to the branch mainline in revision 279.
  • Revision ID: daniel.silverstone@canonical.com-20051110200623-77479964cab3c166
Fix up fetch_ghosts to lock the branches, and to invoke bzr fix if it fetches any ghosts into the tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell.py
22
22
import string
23
23
from itertools import chain
24
24
from bzrlib.errors import BzrError
25
 
from bzrlib.commands import get_cmd_object, get_all_cmds, get_alias
26
 
from bzrlib.branch import Branch
 
25
from bzrlib.commands import get_cmd_object, get_all_cmds
27
26
 
28
27
SHELL_BLACKLIST = set(['rm', 'ls'])
29
28
COMPLETION_BLACKLIST = set(['shell'])
41
40
        self.arg_pos = None
42
41
 
43
42
    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
 
43
        if not command:
 
44
            iter = (c for c in iter_command_names() if
61
45
                    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 
 
46
            try:
 
47
                iter = list(filter_completions(iter, text))
 
48
            except Exception, e:
 
49
                print e, type(e)
 
50
 
73
51
 
74
52
 
75
53
class PromptCmd(cmd.Cmd):
77
55
        cmd.Cmd.__init__(self)
78
56
        self.prompt = "bzr> "
79
57
        try:
80
 
            self.tree = WorkingTree.open_containing('.')[0]
 
58
            self.tree = arch.tree_root(".")
81
59
        except:
82
60
            self.tree = None
83
61
        self.set_title()
111
89
    def set_prompt(self):
112
90
        if self.tree is not None:
113
91
            try:
114
 
                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(), 
115
 
                               self.tree.branch.relpath('.'))
116
 
                prompt = " %s:%d/%s" % prompt_data
 
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)
117
97
            except:
118
98
                prompt = ""
119
99
        else:
122
102
 
123
103
    def set_title(self, command=None):
124
104
        try:
125
 
            b = Branch.open_containing('.')[0]
126
 
            version = "%s:%d" % (b.nick, b.revno())
 
105
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
 
106
                                             full=False)
127
107
        except:
128
108
            version = "[no version]"
129
109
        if command is None:
145
125
        except Exception, e:
146
126
            print e
147
127
        try:
148
 
            self.tree = WorkingTree.open_containing(".")[0]
 
128
            self.tree = arch.tree_root(".")
149
129
        except:
150
130
            self.tree = None
151
131
 
154
134
 
155
135
    def default(self, line):
156
136
        args = line.split()
157
 
        alias_args = get_alias(args[0])
158
 
        if alias_args is not None:
159
 
            args[0] = alias_args.pop(0)
160
 
            
161
137
        commandname = args.pop(0)
162
138
        for char in ('|', '<', '>'):
163
139
            commandname = commandname.split(char)[0]
174
150
            if too_complicated(line):
175
151
                return os.system("bzr "+line)
176
152
            else:
177
 
                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)
 
153
                return (cmd_obj.run_argv(args) or 0)
178
154
        except BzrError, e:
179
155
            print e
180
156
        except KeyboardInterrupt, e:
185
161
 
186
162
 
187
163
    def completenames(self, text, line, begidx, endidx):
188
 
        return CompletionContext(text).get_completions()
 
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)
189
177
 
190
178
    def completedefault(self, text, line, begidx, endidx):
191
179
        """Perform completion for native commands.
201
189
        """
202
190
        (cmd, args, foo) = self.parseline(line)
203
191
        if cmd == "bzr":
204
 
            cmd = None
205
 
        return CompletionContext(text, command=cmd).get_completions()
 
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
206
221
 
207
222
def run_shell():
208
223
    try: