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
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
|
# Copyright (C) 2009, 2010 Roman Zimbelmann <romanz@lavabit.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
This is the default file for command definitions.
Each command is a subclass of `Command'. Several methods are defined
to interface with the console:
execute: call this method when the command is executed.
cancel: call this method when closing the console without executing.
tab: call this method when tab is pressed.
quick: call this method after each keypress.
The return values for tab() can be either:
None: There is no tab completion
A string: Change the console to this string
A list/tuple/generator: cycle through every item in it
The return value for quick() can be:
False: Nothing happens
True: Execute the command afterwards
The return value for execute() doesn't matter.
If you want to add custom commands, you can create a file
~/.config/ranger/commands.py, add the line:
from ranger.api.commands import *
and write some command definitions, for example:
class tabnew(Command):
def execute(self):
self.fm.tab_new()
class tabgo(Command):
"""
:tabgo <n>
Go to the nth tab.
"""
def execute(self):
num = self.line.split()[1]
self.fm.tab_open(int(num))
For a list of all actions, check /ranger/core/actions.py.
'''
from ranger.api.commands import *
from ranger.ext.get_executables import get_executables
from ranger.core.runner import ALLOWED_FLAGS
class alias(Command):
"""
:alias <newcommand> <oldcommand>
Copies the oldcommand as newcommand.
"""
def execute(self):
if not self.arg(1) or not self.arg(2):
self.fm.notify('Syntax: alias <newcommand> <oldcommand>', bad=True)
else:
self.fm.commands.alias(self.arg(1), self.arg(2))
class cd(Command):
"""
:cd [-r] <dirname>
The cd command changes the directory.
The command 'cd -' is equivalent to typing ``.
Using the option "-r" will get you to the real path.
"""
def execute(self):
if self.arg(1) == '-r':
import os.path
self.shift()
destination = os.path.realpath(self.rest(1))
else:
destination = self.rest(1)
if not destination:
destination = '~'
if destination == '-':
self.fm.enter_bookmark('`')
else:
self.fm.cd(destination)
def tab(self):
from os.path import dirname, basename, expanduser, join, isdir
line = parse(self.line)
cwd = self.fm.env.cwd.path
try:
rel_dest = line.rest(1)
except IndexError:
rel_dest = ''
bookmarks = [v.path for v in self.fm.bookmarks.dct.values()
if rel_dest in v.path ]
# 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()
dirnames = bookmarks + dirnames
# no results, return None
if len(dirnames) == 0:
return
# one result. since it must be a directory, append a slash.
if len(dirnames) == 1:
return line.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 (line.start(1) + join(rel_dirname, dirname) for dirname in dirnames)
class chain(Command):
"""
:chain <command1>; <command2>; ...
Calls multiple commands at once, separated by semicolons.
"""
def execute(self):
for command in self.rest(1).split(";"):
self.fm.execute_console(command)
class search(Command):
def execute(self):
self.fm.search_file(parse(self.line).rest(1), regexp=True)
class search_inc(Command):
def quick(self):
self.fm.search_file(parse(self.line).rest(1), regexp=True, offset=0)
class shell(Command):
def execute(self):
line = parse(self.line)
if line.chunk(1) and line.chunk(1)[0] == '-':
flags = line.chunk(1)[1:]
command = line.rest(2)
else:
flags = ''
command = line.rest(1)
if not command and 'p' in flags: command = 'cat %f'
if command:
if '%' in command:
command = self.fm.substitute_macros(command)
self.fm.execute_command(command, flags=flags)
def tab(self):
line = parse(self.line)
if line.chunk(1) and line.chunk(1)[0] == '-':
flags = line.chunk(1)[1:]
command = line.rest(2)
else:
flags = ''
command = line.rest(1)
start = self.line[0:len(self.line) - len(command)]
try:
position_of_last_space = command.rindex(" ")
except ValueError:
return (start + program + ' ' for program \
in get_executables() if program.startswith(command))
if position_of_last_space == len(command) - 1:
return self.line + '%s '
else:
before_word, start_of_word = self.line.rsplit(' ', 1)
return (before_word + ' ' + file.shell_escaped_basename \
for file in self.fm.env.cwd.files \
if file.shell_escaped_basename.startswith(start_of_word))
class open_with(Command):
def execute(self):
line = parse(self.line)
app, flags, mode = self._get_app_flags_mode(line.rest(1))
self.fm.execute_file(
files = [f for f in self.fm.env.cwd.get_selection()],
app = app,
flags = flags,
mode = mode)
def _get_app_flags_mode(self, string):
"""
Extracts the application, flags and mode from a string.
examples:
"mplayer d 1" => ("mplayer", "d", 1)
"aunpack 4" => ("aunpack", "", 4)
"p" => ("", "p", 0)
"" => None
"""
app = ''
flags = ''
mode = 0
split = string.split()
if len(split) == 0:
pass
elif len(split) == 1:
part = split[0]
if self._is_app(part):
app = part
elif self._is_flags(part):
flags = part
elif self._is_mode(part):
mode = part
elif len(split) == 2:
part0 = split[0]
part1 = split[1]
if self._is_app(part0):
app = part0
if self._is_flags(part1):
flags = part1
elif self._is_mode(part1):
mode = part1
elif self._is_flags(part0):
flags = part0
if self._is_mode(part1):
mode = part1
elif self._is_mode(part0):
mode = part0
if self._is_flags(part1):
flags = part1
elif len(split) >= 3:
part0 = split[0]
part1 = split[1]
part2 = split[2]
if self._is_app(part0):
app = part0
if self._is_flags(part1):
flags = part1
if self._is_mode(part2):
mode = part2
elif self._is_mode(part1):
mode = part1
if self._is_flags(part2):
flags = part2
elif self._is_flags(part0):
flags = part0
if self._is_mode(part1):
mode = part1
elif self._is_mode(part0):
mode = part0
if self._is_flags(part1):
flags = part1
return app, flags, int(mode)
def _get_tab(self):
line = parse(self.line)
data = line.rest(1)
if ' ' not in data:
all_apps = self.fm.apps.all()
if all_apps:
return (app for app in all_apps if app.startswith(data))
return None
def _is_app(self, arg):
return self.fm.apps.has(arg) or \
(not self._is_flags(arg) and arg in get_executables())
def _is_flags(self, arg):
return all(x in ALLOWED_FLAGS for x in arg)
def _is_mode(self, arg):
return all(x in '0123456789' for x in arg)
class find(Command):
"""
:find <string>
The find command will attempt to find a partial, case insensitive
match in the filenames of the current directory and execute the
file automatically.
"""
count = 0
tab = Command._tab_directory_content
def execute(self):
if self.count == 1:
self.fm.move(right=1)
self.fm.block_input(0.5)
else:
self.fm.cd(parse(self.line).rest(1))
def quick(self):
self.count = 0
line = parse(self.line)
cwd = self.fm.env.cwd
try:
arg = line.rest(1)
except IndexError:
return False
if arg == '.':
return False
if arg == '..':
return True
deq = deque(cwd.files)
deq.rotate(-cwd.pointer)
i = 0
case_insensitive = arg.lower() == arg
for fsobj in deq:
if case_insensitive:
filename = fsobj.basename_lower
else:
filename = fsobj.basename
if arg in filename:
self.count += 1
if self.count == 1:
cwd.move(to=(cwd.pointer + i) % len(cwd.files))
self.fm.env.cf = cwd.pointed_obj
if self.count > 1:
return False
i += 1
return self.count == 1
class set_(Command):
"""
:set <option name>=<python expression>
Gives an option a new value.
"""
name = 'set' # don't override the builtin set class
def execute(self):
line = parse(self.line)
name = line.chunk(1)
name, value, _ = line.parse_setting_line()
if name and value:
from re import compile as regexp
try:
value = eval(value)
except:
pass
self.fm.settings[name] = value
def tab(self):
line = parse(self.line)
name, value, name_done = line.parse_setting_line()
settings = self.fm.settings
if not name:
return (line + setting for setting in settings)
if not value and not name_done:
return (line + setting for setting in settings \
if setting.startswith(name))
if not value:
return line + repr(settings[name])
if bool in settings.types_of(name):
if 'true'.startswith(value.lower()):
return line + 'True'
if 'false'.startswith(value.lower()):
return line + 'False'
class quit(Command):
"""
:quit
Closes the current tab. If there is only one tab, quit the program.
"""
def execute(self):
if len(self.fm.tabs) <= 1:
self.fm.exit()
self.fm.tab_close()
class quitall(Command):
"""
:quitall
Quits the program immediately.
"""
def execute(self):
self.fm.exit()
class quit_bang(quitall):
"""
:quit!
Quits the program immediately.
"""
name = 'quit!'
allow_abbrev = False
class terminal(Command):
"""
:terminal
Spawns an "x-terminal-emulator" starting in the current directory.
"""
def execute(self):
self.fm.run('x-terminal-emulator', flags='d')
class delete(Command):
"""
:delete
Tries to delete the selection.
"Selection" is defined as all the "marked files" (by default, you
can mark files with space or v). If there are no marked files,
use the "current file" (where the cursor is)
When attempting to delete non-empty directories or multiple
marked files, it will require a confirmation: The last word in
the line has to start with a 'y'. This may look like:
:delete yes
:delete seriously? yeah!
"""
allow_abbrev = False
def execute(self):
line = parse(self.line)
lastword = line.chunk(-1)
if lastword.startswith('y'):
# user confirmed deletion!
return self.fm.delete()
elif self.line.startswith(DELETE_WARNING):
# user did not confirm deletion
return
cwd = self.fm.env.cwd
cf = self.fm.env.cf
if cwd.marked_items or (cf.is_directory and not cf.is_link \
and len(os.listdir(cf.path)) > 0):
# better ask for a confirmation, when attempting to
# delete multiple files or a non-empty directory.
return self.fm.open_console(DELETE_WARNING)
# no need for a confirmation, just delete
self.fm.delete()
class mark(Command):
"""
:mark <regexp>
Mark all files matching a regular expression.
"""
do_mark = True
def execute(self):
import re
cwd = self.fm.env.cwd
line = parse(self.line)
input = line.rest(1)
searchflags = re.UNICODE
if input.lower() == input: # "smartcase"
searchflags |= re.IGNORECASE
pattern = re.compile(input, searchflags)
for fileobj in cwd.files:
if pattern.search(fileobj.basename):
cwd.mark_item(fileobj, val=self.do_mark)
self.fm.ui.status.need_redraw = True
self.fm.ui.need_redraw = True
class console(Command):
"""
:console <command>
Open the console with the given command.
"""
def execute(self):
position = None
if self.arg(1)[0:2] == '-p':
try:
position = int(self.arg(1)[2:])
self.shift()
except:
pass
self.fm.open_console(self.rest(1), position=position)
class load_copy_buffer(Command):
"""
:load_copy_buffer
Load the copy buffer from confdir/copy_buffer
"""
copy_buffer_filename = 'copy_buffer'
def execute(self):
from ranger.fsobject import File
from os.path import exists
try:
fname = self.fm.confpath(self.copy_buffer_filename)
f = open(fname, 'r')
except:
return self.fm.notify("Cannot open %s" % \
(fname or self.copy_buffer_filename), bad=True)
self.fm.env.copy = set(File(g) \
for g in f.read().split("\n") if exists(g))
f.close()
self.fm.ui.redraw_main_column()
class save_copy_buffer(Command):
"""
:save_copy_buffer
Save the copy buffer to confdir/copy_buffer
"""
copy_buffer_filename = 'copy_buffer'
def execute(self):
fname = None
try:
fname = self.fm.confpath(self.copy_buffer_filename)
f = open(fname, 'w')
except:
return self.fm.notify("Cannot open %s" % \
(fname or self.copy_buffer_filename), bad=True)
f.write("\n".join(f.path for f in self.fm.env.copy))
f.close()
class unmark(mark):
"""
:unmark <regexp>
Unmark all files matching a regular expression.
"""
do_mark = False
class mkdir(Command):
"""
:mkdir <dirname>
Creates a directory with the name <dirname>.
"""
def execute(self):
from os.path import join, expanduser, lexists
from os import mkdir
line = parse(self.line)
dirname = join(self.fm.env.cwd.path, expanduser(line.rest(1)))
if not lexists(dirname):
mkdir(dirname)
else:
self.fm.notify("file/directory exists!", bad=True)
class touch(Command):
"""
:touch <fname>
Creates a file with the name <fname>.
"""
def execute(self):
from os.path import join, expanduser, lexists
from os import mkdir
line = parse(self.line)
fname = join(self.fm.env.cwd.path, expanduser(line.rest(1)))
if not lexists(fname):
open(fname, 'a').close()
else:
self.fm.notify("file/directory exists!", bad=True)
class edit(Command):
"""
:edit <filename>
Opens the specified file in vim
"""
def execute(self):
line = parse(self.line)
if not line.chunk(1):
self.fm.edit_file(self.fm.env.cf.path)
else:
self.fm.edit_file(line.rest(1))
def tab(self):
return self._tab_directory_content()
class eval_(Command):
"""
:eval [-q] <python code>
Evaluates the python code.
`fm' is a reference to the FM instance.
To display text, use the function `p'.
Examples:
:eval fm
:eval len(fm.env.directories)
:eval p("Hello World!")
"""
name = 'eval'
resolve_macros = False
def execute(self):
if self.arg(1) == '-q':
code = self.rest(2)
quiet = True
else:
code = self.rest(1)
quiet = False
import ranger
global cmd, fm, p, quantifier
fm = self.fm
cmd = self.fm.execute_console
p = fm.notify
quantifier = self.quantifier
try:
try:
result = eval(code)
except SyntaxError:
exec(code)
else:
if result and not quiet:
p(result)
except Exception as err:
p(err)
class rename(Command):
"""
:rename <newname>
Changes the name of the currently highlighted file to <newname>
"""
def execute(self):
from ranger.fsobject import File
from os import access
from os.path import join
line = parse(self.line)
new_name = line.rest(1)
if not new_name:
return self.fm.notify('Syntax: rename <newname>', bad=True)
if new_name == self.fm.env.cf.basename:
return
if access(new_name, os.F_OK):
return self.fm.notify("Can't rename: file already exists!", bad=True)
self.fm.rename(self.fm.env.cf, new_name)
f = File(new_name)
self.fm.env.cwd.pointed_obj = f
self.fm.env.cf = f
def tab(self):
return self._tab_directory_content()
class chmod(Command):
"""
:chmod <octal number>
Sets the permissions of the selection to the octal number.
The octal number is between 0 and 777. The digits specify the
permissions for the user, the group and others.
A 1 permits execution, a 2 permits writing, a 4 permits reading.
Add those numbers to combine them. So a 7 permits everything.
"""
def execute(self):
mode = self.rest(1)
if not mode:
mode = str(self.quantifier)
try:
mode = int(mode, 8)
if mode < 0 or mode > 0o777:
raise ValueError
except ValueError:
self.fm.notify("Need an octal number between 0 and 777!", bad=True)
return
for file in self.fm.env.get_selection():
try:
os.chmod(file.path, mode)
except Exception as ex:
self.fm.notify(ex)
try:
# reloading directory. maybe its better to reload the selected
# files only.
self.fm.env.cwd.load_content()
except:
pass
class bulkrename(Command):
"""
:bulkrename
This command opens a list of selected files in an external editor.
After you edit and save the file, it will generate a shell script
which does bulk renaming according to the changes you did in the file.
This shell script is opened in an editor for you to review.
After you close it, it will be executed.
"""
def execute(self):
import sys
import tempfile
from ranger.fsobject.file import File
from ranger.ext.shell_escape import shell_escape as esc
py3 = sys.version > "3"
# Create and edit the file list
filenames = [f.basename for f in self.fm.env.get_selection()]
listfile = tempfile.NamedTemporaryFile()
if py3:
listfile.write("\n".join(filenames).encode("utf-8"))
else:
listfile.write("\n".join(filenames))
listfile.flush()
self.fm.execute_file([File(listfile.name)], app='editor')
listfile.seek(0)
if py3:
new_filenames = listfile.read().decode("utf-8").split("\n")
else:
new_filenames = listfile.read().split("\n")
listfile.close()
if all(a == b for a, b in zip(filenames, new_filenames)):
self.fm.notify("No renaming to be done!")
return
# Generate and execute script
cmdfile = tempfile.NamedTemporaryFile()
cmdfile.write(b"# This file will be executed when you close the editor.\n")
cmdfile.write(b"# Please double-check everything, clear the file to abort.\n")
if py3:
cmdfile.write("\n".join("mv -vi " + esc(old) + " " + esc(new) \
for old, new in zip(filenames, new_filenames) \
if old != new).encode("utf-8"))
else:
cmdfile.write("\n".join("mv -vi " + esc(old) + " " + esc(new) \
for old, new in zip(filenames, new_filenames) if old != new))
cmdfile.flush()
self.fm.execute_file([File(cmdfile.name)], app='editor')
self.fm.run(['/bin/sh', cmdfile.name], flags='w')
cmdfile.close()
class help_(Command):
"""
:help
Display ranger's manual page.
"""
name = 'help'
def execute(self):
if self.quantifier == 1:
self.fm.dump_keybindings()
elif self.quantifier == 2:
self.fm.dump_commands()
elif self.quantifier == 3:
self.fm.dump_settings()
else:
self.fm.display_help()
class copymap(Command):
"""
:copymap <keys> <newkeys1> [<newkeys2>...]
Copies a "browser" keybinding from <keys> to <newkeys>
"""
context = 'browser'
def execute(self):
if not self.arg(1) or not self.arg(2):
return self.notify("Not enough arguments", bad=True)
for arg in self.args[2:]:
self.fm.env.keymaps.copy(self.context, self.arg(1), arg)
class copypmap(copymap):
"""
:copypmap <keys> <newkeys1> [<newkeys2>...]
Copies a "pager" keybinding from <keys> to <newkeys>
"""
context = 'pager'
class copycmap(copymap):
"""
:copycmap <keys> <newkeys1> [<newkeys2>...]
Copies a "console" keybinding from <keys> to <newkeys>
"""
context = 'console'
class copytmap(copymap):
"""
:copycmap <keys> <newkeys1> [<newkeys2>...]
Copies a "taskview" keybinding from <keys> to <newkeys>
"""
context = 'taskview'
class unmap(Command):
"""
:unmap <keys> [<keys2>, ...]
Remove the given "browser" mappings
"""
context = 'browser'
def execute(self):
for arg in self.args[1:]:
self.fm.env.keymaps.unbind(self.context, arg)
class cunmap(unmap):
"""
:cunmap <keys> [<keys2>, ...]
Remove the given "console" mappings
"""
context = 'browser'
class punmap(unmap):
"""
:punmap <keys> [<keys2>, ...]
Remove the given "pager" mappings
"""
context = 'pager'
class tunmap(unmap):
"""
:tunmap <keys> [<keys2>, ...]
Remove the given "taskview" mappings
"""
context = 'taskview'
class map_(Command):
"""
:map <keysequence> <command>
Maps a command to a keysequence in the "browser" context.
Example:
map j move down
map J move down 10
"""
name = 'map'
context = 'browser'
resolve_macros = False
def execute(self):
self.fm.env.keymaps.bind(self.context, self.arg(1), self.rest(2))
class cmap(map_):
""":cmap <keysequence> <command>
Maps a command to a keysequence in the "console" context.
Example:
cmap <ESC> console_close
cmap <C-x> console_type test
"""
context = 'console'
class tmap(map_):
""":tmap <keysequence> <command>
Maps a command to a keysequence in the "taskview" context.
"""
context = 'taskview'
class pmap(map_):
""":pmap <keysequence> <command>
Maps a command to a keysequence in the "pager" context.
"""
context = 'pager'
class filter(Command):
"""
:filter <string>
Displays only the files which contain <string> in their basename.
"""
def execute(self):
line = parse(self.line)
self.fm.set_filter(line.rest(1))
self.fm.reload_cwd()
class grep(Command):
"""
:grep <string>
Looks for a string in all marked files or directories
"""
def execute(self):
line = parse(self.line)
if line.rest(1):
action = ['grep', '--color=always', '--line-number']
action.extend(['-e', line.rest(1), '-r'])
action.extend(f.path for f in self.fm.env.get_selection())
self.fm.execute_command(action, flags='p')
|