← 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-31 05:45:24 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20051031054524-292328b623bd775c
0.6.1 release

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
                if len(line) > 0:
 
48
                    arg = line.split()[-1]
 
49
                else:
 
50
                    arg = ""
 
51
                iter = list(iter_munged_completions(iter, arg, text))
 
52
            except Exception, e:
 
53
                print e, type(e)
 
54
 
84
55
 
85
56
 
86
57
class PromptCmd(cmd.Cmd):
88
59
        cmd.Cmd.__init__(self)
89
60
        self.prompt = "bzr> "
90
61
        try:
91
 
            self.tree = WorkingTree.open_containing('.')[0]
 
62
            self.tree = arch.tree_root(".")
92
63
        except:
93
64
            self.tree = None
94
65
        self.set_title()
122
93
    def set_prompt(self):
123
94
        if self.tree is not None:
124
95
            try:
125
 
                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(), 
126
 
                               self.tree.relpath('.'))
127
 
                prompt = " %s:%d/%s" % prompt_data
 
96
                prompt = pylon.alias_or_version(self.tree.tree_version, 
 
97
                                                self.tree, 
 
98
                                                full=False)
 
99
                if prompt is not None:
 
100
                    prompt = " " + prompt +":"+ pylon.tree_cwd(self.tree)
128
101
            except:
129
102
                prompt = ""
130
103
        else:
133
106
 
134
107
    def set_title(self, command=None):
135
108
        try:
136
 
            b = Branch.open_containing('.')[0]
137
 
            version = "%s:%d" % (b.nick, b.revno())
 
109
            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 
 
110
                                             full=False)
138
111
        except:
139
112
            version = "[no version]"
140
113
        if command is None:
156
129
        except Exception, e:
157
130
            print e
158
131
        try:
159
 
            self.tree = WorkingTree.open_containing(".")[0]
 
132
            self.tree = arch.tree_root(".")
160
133
        except:
161
134
            self.tree = None
162
135
 
164
137
        self.default("help "+line)
165
138
 
166
139
    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
 
            
 
140
        args = line.split()
172
141
        commandname = args.pop(0)
173
142
        for char in ('|', '<', '>'):
174
143
            commandname = commandname.split(char)[0]
185
154
            if too_complicated(line):
186
155
                return os.system("bzr "+line)
187
156
            else:
188
 
                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)
 
157
                return (cmd_obj.run_argv(args) or 0)
189
158
        except BzrError, e:
190
159
            print e
191
160
        except KeyboardInterrupt, e:
196
165
 
197
166
 
198
167
    def completenames(self, text, line, begidx, endidx):
199
 
        return CompletionContext(text).get_completions()
 
168
        completions = []
 
169
        iter = (c for c in iter_command_names() if
 
170
                c not in COMPLETION_BLACKLIST)
 
171
        try:
 
172
            if len(line) > 0:
 
173
                arg = line.split()[-1]
 
174
            else:
 
175
                arg = ""
 
176
            iter = list(iter_munged_completions(iter, arg, text))
 
177
        except Exception, e:
 
178
            print e, type(e)
 
179
        return list(iter)
200
180
 
201
181
    def completedefault(self, text, line, begidx, endidx):
202
182
        """Perform completion for native commands.
212
192
        """
213
193
        (cmd, args, foo) = self.parseline(line)
214
194
        if cmd == "bzr":
215
 
            cmd = None
216
 
        return CompletionContext(text, command=cmd).get_completions()
217
 
 
 
195
            try:
 
196
                return self.completenames(text, line, begidx, endidx)
 
197
            except Exception, e:
 
198
                print e
 
199
        try:
 
200
            command_obj = get_cmd_object(cmd)
 
201
        except BzrError:
 
202
            command_obj = None
 
203
        try:
 
204
            if command_obj is not None:
 
205
                opts = []
 
206
                for option_name, option in command_obj.options().items():
 
207
                    opts.append("--" + option_name)
 
208
                    short_name = option.short_name()
 
209
                    if short_name:
 
210
                        opts.append("-" + short_name)
 
211
                q = list(iter_munged_completions(opts, args, text))
 
212
                return list(iter_munged_completions(opts, args, text))
 
213
            elif cmd == "cd":
 
214
                if len(args) > 0:
 
215
                    arg = args.split()[-1]
 
216
                else:
 
217
                    arg = ""
 
218
                iter = iter_dir_completions(arg)
 
219
                iter = iter_munged_completions(iter, arg, text)
 
220
                return list(iter)
 
221
            elif len(args)>0:
 
222
                arg = args.split()[-1]
 
223
                iter = iter_file_completions(arg)
 
224
                return list(iter_munged_completions(iter, arg, text))
 
225
            else:
 
226
                return self.completenames(text, line, begidx, endidx)
 
227
        except Exception, e:
 
228
            print e
218
229
 
219
230
def run_shell():
220
231
    try:
226
237
    except StopIteration:
227
238
        pass
228
239
 
229
 
 
230
 
def iter_opt_completions(command_obj):
231
 
    for option_name, option in command_obj.options().items():
232
 
        yield "--" + option_name
233
 
        short_name = option.short_name()
234
 
        if short_name:
235
 
            yield "-" + short_name
236
 
 
237
 
 
238
240
def iter_file_completions(arg, only_dirs = False):
239
241
    """Generate an iterator that iterates through filename completions.
240
242
 
263
265
                userfile+='/'
264
266
                yield userfile
265
267
            elif not only_dirs:
266
 
                yield userfile + ' '
 
268
                yield userfile
267
269
 
268
270
 
269
271
def iter_dir_completions(arg):
274
276
    """
275
277
    return iter_file_completions(arg, True)
276
278
 
277
 
 
278
279
def iter_command_names(hidden=False):
279
280
    for real_cmd_name, cmd_class in get_all_cmds():
280
281
        if not hidden and cmd_class.hidden:
284
285
            if name == real_cmd_name or not real_cmd_name.startswith(name):
285
286
                yield name
286
287
 
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
 
def filter_completions(iter, arg):
300
 
    return (c for c in iter if c.startswith(arg))
301
 
 
302
 
 
303
288
def iter_munged_completions(iter, arg, text):
304
289
    for completion in iter:
305
290
        completion = str(completion)
306
291
        if completion.startswith(arg):
307
292
            yield completion[len(arg)-len(text):]+" "
308
293
 
309
 
 
310
294
def too_complicated(line):
311
 
    for char in '|<>*?':
 
295
    for char in '|<>"\"*?':
312
296
        if char in line:
313
297
            return True
314
298
    return False