← 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-11 17:43:12 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20051111174312-1c627d82a07bf8fd
Added patch for tab-in-patch-filename support

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell.py
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.branch import Branch
28
 
from bzrlib.commands import get_cmd_object, get_all_cmds, get_alias
 
23
from itertools import chain
29
24
from bzrlib.errors import BzrError
30
 
from bzrlib.workingtree import WorkingTree
31
 
 
32
 
import terminal
33
 
 
 
25
from bzrlib.commands import get_cmd_object, get_all_cmds
34
26
 
35
27
SHELL_BLACKLIST = set(['rm', 'ls'])
36
28
COMPLETION_BLACKLIST = set(['shell'])
37
29
 
38
 
 
39
30
class BlackListedCommand(BzrError):
40
31
    def __init__(self, command):
41
32
        BzrError.__init__(self, "The command %s is blacklisted for shell use" %
42
33
                          command)
43
34
 
44
 
 
45
35
class CompletionContext(object):
46
36
    def __init__(self, text, command=None, prev_opt=None, arg_pos=None):
47
37
        self.text = text
50
40
        self.arg_pos = None
51
41
 
52
42
    def get_completions(self):
53
 
        try:
54
 
            return self.get_completions_or_raise()
55
 
        except Exception, e:
56
 
            print e, type(e)
57
 
            return []
58
 
 
59
 
    def get_option_completions(self):
60
 
        try:
61
 
            command_obj = get_cmd_object(self.command)
62
 
        except BzrError:
63
 
            return []
64
 
        opts = [o+" " for o in iter_opt_completions(command_obj)]
65
 
        return list(filter_completions(opts, self.text))
66
 
 
67
 
    def get_completions_or_raise(self):
68
 
        if self.command is None:
69
 
            if '/' in self.text:
70
 
                iter = iter_executables(self.text)
71
 
            else:
72
 
                iter = (c+" " for c in iter_command_names() if
73
 
                        c not in COMPLETION_BLACKLIST)
74
 
            return list(filter_completions(iter, self.text))
75
 
        if self.prev_opt is None:
76
 
            completions = self.get_option_completions()
77
 
            if self.command == "cd":
78
 
                iter = iter_dir_completions(self.text)
79
 
                completions.extend(list(filter_completions(iter, self.text)))
80
 
            else:
81
 
                iter = iter_file_completions(self.text)
82
 
                completions.extend(filter_completions(iter, self.text))
83
 
            return completions 
 
43
        if not command:
 
44
            iter = (c for c in iter_command_names() if
 
45
                    c not in COMPLETION_BLACKLIST)
 
46
            try:
 
47
                iter = list(filter_completions(iter, text))
 
48
            except Exception, e:
 
49
                print e, type(e)
 
50
 
84
51
 
85
52
 
86
53
class PromptCmd(cmd.Cmd):
88
55
        cmd.Cmd.__init__(self)
89
56
        self.prompt = "bzr> "
90
57
        try:
91
 
            self.tree = WorkingTree.open_containing('.')[0]
 
58
            self.tree = arch.tree_root(".")
92
59
        except:
93
60
            self.tree = None
94
61
        self.set_title()
122
89
    def set_prompt(self):
123
90
        if self.tree is not None:
124
91
            try:
125
 
                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(), 
126
 
                               self.tree.relpath('.'))
127
 
                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)
128
97
            except:
129
98
                prompt = ""
130
99
        else:
133
102
 
134
103
    def set_title(self, command=None):
135
104
        try:
136
 
            b = Branch.open_containing('.')[0]
137
 
            version = "%s:%d" % (b.nick, b.revno())
 
105
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
 
106
                                             full=False)
138
107
        except:
139
108
            version = "[no version]"
140
109
        if command is None:
156
125
        except Exception, e:
157
126
            print e
158
127
        try:
159
 
            self.tree = WorkingTree.open_containing(".")[0]
 
128
            self.tree = arch.tree_root(".")
160
129
        except:
161
130
            self.tree = None
162
131
 
164
133
        self.default("help "+line)
165
134
 
166
135
    def default(self, line):
167
 
        args = shlex.split(line)
168
 
        alias_args = get_alias(args[0])
169
 
        if alias_args is not None:
170
 
            args[0] = alias_args.pop(0)
171
 
            
 
136
        args = line.split()
172
137
        commandname = args.pop(0)
173
138
        for char in ('|', '<', '>'):
174
139
            commandname = commandname.split(char)[0]
185
150
            if too_complicated(line):
186
151
                return os.system("bzr "+line)
187
152
            else:
188
 
                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)
 
153
                return (cmd_obj.run_argv(args) or 0)
189
154
        except BzrError, e:
190
155
            print e
191
156
        except KeyboardInterrupt, e:
196
161
 
197
162
 
198
163
    def completenames(self, text, line, begidx, endidx):
199
 
        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)
200
177
 
201
178
    def completedefault(self, text, line, begidx, endidx):
202
179
        """Perform completion for native commands.
212
189
        """
213
190
        (cmd, args, foo) = self.parseline(line)
214
191
        if cmd == "bzr":
215
 
            cmd = None
216
 
        return CompletionContext(text, command=cmd).get_completions()
217
 
 
 
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
218
221
 
219
222
def run_shell():
220
223
    try:
226
229
    except StopIteration:
227
230
        pass
228
231
 
229
 
 
230
232
def iter_opt_completions(command_obj):
231
233
    for option_name, option in command_obj.options().items():
232
234
        yield "--" + option_name
234
236
        if short_name:
235
237
            yield "-" + short_name
236
238
 
237
 
 
238
239
def iter_file_completions(arg, only_dirs = False):
239
240
    """Generate an iterator that iterates through filename completions.
240
241
 
263
264
                userfile+='/'
264
265
                yield userfile
265
266
            elif not only_dirs:
266
 
                yield userfile + ' '
 
267
                yield userfile
267
268
 
268
269
 
269
270
def iter_dir_completions(arg):
274
275
    """
275
276
    return iter_file_completions(arg, True)
276
277
 
277
 
 
278
278
def iter_command_names(hidden=False):
279
279
    for real_cmd_name, cmd_class in get_all_cmds():
280
280
        if not hidden and cmd_class.hidden:
284
284
            if name == real_cmd_name or not real_cmd_name.startswith(name):
285
285
                yield name
286
286
 
287
 
 
288
 
def iter_executables(path):
289
 
    dirname, partial = os.path.split(path)
290
 
    for filename in os.listdir(dirname):
291
 
        if not filename.startswith(partial):
292
 
            continue
293
 
        fullpath = os.path.join(dirname, filename)
294
 
        mode=os.lstat(fullpath)[stat.ST_MODE]
295
 
        if stat.S_ISREG(mode) and 0111 & mode:
296
 
            yield fullpath + ' '
297
 
 
298
 
 
299
287
def filter_completions(iter, arg):
300
288
    return (c for c in iter if c.startswith(arg))
301
289
 
302
 
 
303
290
def iter_munged_completions(iter, arg, text):
304
291
    for completion in iter:
305
292
        completion = str(completion)
306
293
        if completion.startswith(arg):
307
294
            yield completion[len(arg)-len(text):]+" "
308
295
 
309
 
 
310
296
def too_complicated(line):
311
 
    for char in '|<>*?':
 
297
    for char in '|<>"\"*?':
312
298
        if char in line:
313
299
            return True
314
300
    return False