~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to shell.py

• browse files at revision 258
• compare with another revision
• download diff
• download tarball
• view history from revision 258

• reverse the comparison (258 to 539)
• stop comparing with revision 539

Show diffs side-by-side

added

removed

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

 

class CompletionContext(object):

46

 

    def __init__(self, text, command=None, prev_opt=None, arg_pos=None):

47

 

        self.text = text

48

 

        self.command = command

49

 

        self.prev_opt = prev_opt

50

 

        self.arg_pos = None

51

 

 

52

 

    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

84

 

 

85

 

 

86

35

class PromptCmd(cmd.Cmd):

87

36

    def __init__(self):

88

37

        cmd.Cmd.__init__(self)

89

38

        self.prompt = "bzr> "

90

39

        try:

91

 

            self.tree = WorkingTree.open_containing('.')[0]

 

40

            self.tree = arch.tree_root(".")

92

41

        except:

93

42

            self.tree = None

94

43

        self.set_title()

122

71

    def set_prompt(self):

123

72

        if self.tree is not None:

124

73

            try:

125

 

                prompt_data = (self.tree.branch.nick, self.tree.branch.revno(),

126

 

                               self.tree.relpath('.'))

127

 

                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)

128

79

            except:

129

80

                prompt = ""

130

81

        else:

133

84

 

134

85

    def set_title(self, command=None):

135

86

        try:

136

 

            b = Branch.open_containing('.')[0]

137

 

            version = "%s:%d" % (b.nick, b.revno())

 

87

            version = pylon.alias_or_version(self.tree.tree_version, self.tree, 

 

88

                                             full=False)

138

89

        except:

139

90

            version = "[no version]"

140

91

        if command is None:

156

107

        except Exception, e:

157

108

            print e

158

109

        try:

159

 

            self.tree = WorkingTree.open_containing(".")[0]

 

110

            self.tree = arch.tree_root(".")

160

111

        except:

161

112

            self.tree = None

162

113

 

164

115

        self.default("help "+line)

165

116

 

166

117

    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

 

 

 

118

        args = line.split()

172

119

        commandname = args.pop(0)

173

120

        for char in ('|', '<', '>'):

174

121

            commandname = commandname.split(char)[0]

185

132

            if too_complicated(line):

186

133

                return os.system("bzr "+line)

187

134

            else:

188

 

                return (cmd_obj.run_argv_aliases(args, alias_args) or 0)

 

135

                return (cmd_obj.run_argv(args) or 0)

189

136

        except BzrError, e:

190

137

            print e

191

138

        except KeyboardInterrupt, e:

196

143

 

197

144

 

198

145

    def completenames(self, text, line, begidx, endidx):

199

 

        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)

200

158

 

201

159

    def completedefault(self, text, line, begidx, endidx):

202

160

        """Perform completion for native commands.

203

 

 

 

161

        

204

162

        :param text: The text to complete

205

163

        :type text: str

206

164

        :param line: The entire line to complete

212

170

        """

213

171

        (cmd, args, foo) = self.parseline(line)

214

172

        if cmd == "bzr":

215

 

            cmd = None

216

 

        return CompletionContext(text, command=cmd).get_completions()

217

 

 

 

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

218

207

 

219

208

def run_shell():

220

209

    try:

226

215

    except StopIteration:

227

216

        pass

228

217

 

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

218

def iter_file_completions(arg, only_dirs = False):

239

219

    """Generate an iterator that iterates through filename completions.

240

220

 

263

243

                userfile+='/'

264

244

                yield userfile

265

245

            elif not only_dirs:

266

 

                yield userfile + ' '

 

246

                yield userfile

267

247

 

268

248

 

269

249

def iter_dir_completions(arg):

274

254

    """

275

255

    return iter_file_completions(arg, True)

276

256

 

277

 

 

278

257

def iter_command_names(hidden=False):

279

258

    for real_cmd_name, cmd_class in get_all_cmds():

280

259

        if not hidden and cmd_class.hidden:

284

263

            if name == real_cmd_name or not real_cmd_name.startswith(name):

285

264

                yield name

286

265

 

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

266

def iter_munged_completions(iter, arg, text):

304

267

    for completion in iter:

305

268

        completion = str(completion)

306

269

        if completion.startswith(arg):

307

270

            yield completion[len(arg)-len(text):]+" "

308

271

 

309

 

 

310

272

def too_complicated(line):

311

 

    for char in '|<>*?':

 

273

    for char in '|<>"\"':

312

274

        if char in line:

313

275

            return True

314

276

    return False

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1