1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
|
# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# TODO: Add an optional "!" to all commands and set a flag if it's there
from __future__ import (absolute_import, division, print_function)
import os
import re
# COMPAT pylint: disable=unused-import
from collections import deque # NOQA
from ranger.api import LinemodeBase, hook_init, hook_ready, register_linemode # NOQA
# pylint: enable=unused-import
import ranger
from ranger.core.shared import FileManagerAware
from ranger.ext.lazy_property import lazy_property
_SETTINGS_RE = re.compile(r'^\s*([^\s]+?)=(.*)$')
_ALIAS_LINE_RE = re.compile(r'(\s+)')
class CommandContainer(FileManagerAware):
def __init__(self):
self.commands = {}
def __getitem__(self, key):
return self.commands[key]
def alias(self, name, full_command):
cmd_name = full_command.split()[0]
try:
cmd = self.get_command(cmd_name)
except KeyError:
self.fm.notify('alias failed: No such command: {0}'.format(cmd_name), bad=True)
return None
class CommandAlias(cmd): # pylint: disable=too-few-public-methods
def __init__(self, line, *args, **kwargs):
super(CommandAlias, self).__init__(
(self.full_command + ''.join(_ALIAS_LINE_RE.split(line)[1:])), *args, **kwargs)
self.commands[name] = type(name, (CommandAlias,), dict(full_command=full_command))
def load_commands_from_module(self, module):
for var in vars(module).values():
try:
if issubclass(var, Command) and var != Command \
and var != FunctionCommand:
self.commands[var.get_name()] = var
except TypeError:
pass
def load_commands_from_object(self, obj, filtr):
for attribute_name in dir(obj):
if attribute_name[0] == '_' or attribute_name not in filtr:
continue
attribute = getattr(obj, attribute_name)
if hasattr(attribute, '__call__'):
cmd = type(attribute_name, (FunctionCommand,), dict(__doc__=attribute.__doc__))
cmd.based_function = attribute
cmd.function_name = attribute.__name__
cmd.object_name = obj.__class__.__name__
self.commands[attribute_name] = cmd
def get_command(self, name, abbrev=True):
if abbrev:
lst = [cls for cmd, cls in self.commands.items()
if cls.allow_abbrev and cmd.startswith(name) or cmd == name]
if not lst:
raise KeyError
if len(lst) == 1:
return lst[0]
if self.commands[name] in lst:
return self.commands[name]
raise ValueError("Ambiguous command")
else:
try:
return self.commands[name]
except KeyError:
return None
def command_generator(self, start):
return sorted(cmd + ' ' for cmd in self.commands if cmd.startswith(start))
class Command(FileManagerAware):
"""Abstract command class"""
name = None
allow_abbrev = True
resolve_macros = True
escape_macros_for_shell = False
quantifier = None
_shifted = 0
_setting_line = None
def __init__(self, line, quantifier=None):
self.init_line(line)
self.quantifier = quantifier
self.quickly_executed = False
def init_line(self, line):
self.line = line
self.args = line.split()
try:
self.firstpart = line[:line.rindex(' ') + 1]
except ValueError:
self.firstpart = ''
@classmethod
def get_name(cls):
classdict = cls.__mro__[0].__dict__
if 'name' in classdict and classdict['name']:
return cls.name
return cls.__name__
def execute(self):
"""Override this"""
def tab(self, tabnum):
"""Override this"""
def quick(self):
"""Override this"""
def cancel(self):
"""Override this"""
# Easy ways to get information
def arg(self, n):
"""Returns the nth space separated word"""
try:
return self.args[n]
except IndexError:
return ""
def rest(self, n):
"""Returns everything from and after arg(n)"""
got_space = True
word_count = 0
for i, char in enumerate(self.line):
if char.isspace():
if not got_space:
got_space = True
word_count += 1
elif got_space:
got_space = False
if word_count == n + self._shifted:
return self.line[i:]
return ""
def start(self, n):
"""Returns everything until (inclusively) arg(n)"""
return ' '.join(self.args[:n]) + " " # XXX
def shift(self):
del self.args[0]
self._setting_line = None
self._shifted += 1
def parse_setting_line(self):
"""
Parses the command line argument that is passed to the `:set` command.
Returns [option, value, name_complete].
Can parse incomplete lines too, and `name_complete` is a boolean
indicating whether the option name looks like it's completed or
unfinished. This is useful for generating tab completions.
>>> Command("set foo=bar").parse_setting_line()
['foo', 'bar', True]
>>> Command("set foo").parse_setting_line()
['foo', '', False]
>>> Command("set foo=").parse_setting_line()
['foo', '', True]
>>> Command("set foo ").parse_setting_line()
['foo', '', True]
>>> Command("set myoption myvalue").parse_setting_line()
['myoption', 'myvalue', True]
>>> Command("set").parse_setting_line()
['', '', False]
"""
if self._setting_line is not None:
return self._setting_line
match = _SETTINGS_RE.match(self.rest(1))
if match:
self.firstpart += match.group(1) + '='
result = [match.group(1), match.group(2), True]
else:
result = [self.arg(1), self.rest(2), ' ' in self.rest(1)]
self._setting_line = result
return result
def parse_setting_line_v2(self):
"""
Parses the command line argument that is passed to the `:set` command.
Returns [option, value, name_complete, toggle].
>>> Command("set foo=bar").parse_setting_line_v2()
['foo', 'bar', True, False]
>>> Command("set foo!").parse_setting_line_v2()
['foo', '', True, True]
"""
option, value, name_complete = self.parse_setting_line()
if len(option) >= 2 and option[-1] == '!':
toggle = True
option = option[:-1]
name_complete = True
else:
toggle = False
return [option, value, name_complete, toggle]
def parse_flags(self):
"""Finds and returns flags in the command
>>> Command("").parse_flags()
('', '')
>>> Command("foo").parse_flags()
('', '')
>>> Command("shell test").parse_flags()
('', 'test')
>>> Command("shell -t ls -l").parse_flags()
('t', 'ls -l')
>>> Command("shell -f -- -q test").parse_flags()
('f', '-q test')
>>> Command("shell -foo -bar rest of the command").parse_flags()
('foobar', 'rest of the command')
"""
flags = ""
args = self.line.split()
rest = ""
if args:
rest = self.line[len(args[0]):].lstrip()
for arg in args[1:]:
if arg == "--":
rest = rest[2:].lstrip()
break
elif len(arg) > 1 and arg[0] == "-":
rest = rest[len(arg):].lstrip()
flags += arg[1:]
else:
break
return flags, rest
@lazy_property
def log(self):
import logging
return logging.getLogger('ranger.commands.' + self.__class__.__name__)
# COMPAT: this is still used in old commands.py configs
def _tab_only_directories(self):
from os.path import dirname, basename, expanduser, join
cwd = self.fm.thisdir.path
rel_dest = self.rest(1)
# expand the tilde into the user directory
if rel_dest.startswith('~'):
rel_dest = expanduser(rel_dest)
# define some shortcuts
abs_dest = join(cwd, rel_dest)
abs_dirname = dirname(abs_dest)
rel_basename = basename(rel_dest)
rel_dirname = dirname(rel_dest)
try:
# are we at the end of a directory?
if rel_dest.endswith('/') or rel_dest == '':
_, dirnames, _ = next(os.walk(abs_dest))
# are we in the middle of the filename?
else:
_, dirnames, _ = next(os.walk(abs_dirname))
dirnames = [dn for dn in dirnames
if dn.startswith(rel_basename)]
except (OSError, StopIteration):
# os.walk found nothing
pass
else:
dirnames.sort()
# no results, return None
if not dirnames:
return
# one result. since it must be a directory, append a slash.
if len(dirnames) == 1:
return self.start(1) + join(rel_dirname, dirnames[0]) + '/'
# more than one result. append no slash, so the user can
# manually type in the slash to advance into that directory
return (self.start(1) + join(rel_dirname, dirname)
for dirname in dirnames)
def _tab_directory_content(self): # pylint: disable=too-many-locals
from os.path import dirname, basename, expanduser, join
cwd = self.fm.thisdir.path
rel_dest = self.rest(1)
# expand the tilde into the user directory
if rel_dest.startswith('~'):
rel_dest = expanduser(rel_dest)
# define some shortcuts
abs_dest = join(cwd, rel_dest)
abs_dirname = dirname(abs_dest)
rel_basename = basename(rel_dest)
rel_dirname = dirname(rel_dest)
try:
directory = self.fm.get_directory(abs_dest)
# are we at the end of a directory?
if rel_dest.endswith('/') or rel_dest == '':
if directory.content_loaded:
# Take the order from the directory object
names = [f.basename for f in directory.files]
if self.fm.thisfile.basename in names:
i = names.index(self.fm.thisfile.basename)
names = names[i:] + names[:i]
else:
# Fall back to old method with "os.walk"
_, dirnames, filenames = next(os.walk(abs_dest))
names = sorted(dirnames + filenames)
# are we in the middle of the filename?
else:
if directory.content_loaded:
# Take the order from the directory object
names = [f.basename for f in directory.files
if f.basename.startswith(rel_basename)]
if self.fm.thisfile.basename in names:
i = names.index(self.fm.thisfile.basename)
names = names[i:] + names[:i]
else:
# Fall back to old method with "os.walk"
_, dirnames, filenames = next(os.walk(abs_dirname))
names = sorted([name for name in (dirnames + filenames)
if name.startswith(rel_basename)])
except (OSError, StopIteration):
# os.walk found nothing
pass
else:
# no results, return None
if not names:
return
# one result. append a slash if it's a directory
if len(names) == 1:
path = join(rel_dirname, names[0])
slash = '/' if os.path.isdir(path) else ''
return self.start(1) + path + slash
# more than one result. append no slash, so the user can
# manually type in the slash to advance into that directory
return (self.start(1) + join(rel_dirname, name) for name in names)
def _tab_through_executables(self):
from ranger.ext.get_executables import get_executables
programs = [program for program in get_executables() if
program.startswith(self.rest(1))]
if not programs:
return
if len(programs) == 1:
return self.start(1) + programs[0]
programs.sort()
return (self.start(1) + program for program in programs)
class FunctionCommand(Command):
based_function = None
object_name = ""
function_name = "unknown"
def execute(self): # pylint: disable=too-many-branches
if not self.based_function:
return
if len(self.args) == 1:
try:
return self.based_function( # pylint: disable=not-callable
**{'narg': self.quantifier})
except TypeError:
return self.based_function() # pylint: disable=not-callable
args, keywords = list(), dict()
for arg in self.args[1:]:
equal_sign = arg.find("=")
value = arg if equal_sign == -1 else arg[equal_sign + 1:]
try:
value = int(value)
except ValueError:
if value in ('True', 'False'):
value = (value == 'True')
else:
try:
value = float(value)
except ValueError:
pass
if equal_sign == -1:
args.append(value)
else:
keywords[arg[:equal_sign]] = value
if self.quantifier is not None:
keywords['narg'] = self.quantifier
try:
if self.quantifier is None:
return self.based_function(*args, **keywords) # pylint: disable=not-callable
else:
try:
return self.based_function(*args, **keywords) # pylint: disable=not-callable
except TypeError:
del keywords['narg']
return self.based_function(*args, **keywords) # pylint: disable=not-callable
except TypeError:
if ranger.args.debug:
raise
else:
self.fm.notify(
"Bad arguments for %s.%s: %s, %s" % (
self.object_name, self.function_name, repr(args), repr(keywords)),
bad=True,
)
if __name__ == '__main__':
import doctest
doctest.testmod()
|