dot-files/ranger/.config/ranger/commands_full.py
Bruno BELANYI b65bce1cb1 [ADD] Ranger configuration files
Those are mostlly the defaults from using `ranger --copy-config=all`.
2019-10-18 22:17:20 +02:00

1837 lines
56 KiB
Python

# -*- coding: utf-8 -*-
# This file is part of ranger, the console file manager.
# This configuration file is licensed under the same terms as ranger.
# ===================================================================
#
# NOTE: If you copied this file to /etc/ranger/commands_full.py or
# ~/.config/ranger/commands_full.py, then it will NOT be loaded by ranger,
# and only serve as a reference.
#
# ===================================================================
# This file contains ranger's commands.
# It's all in python; lines beginning with # are comments.
#
# Note that additional commands are automatically generated from the methods
# of the class ranger.core.actions.Actions.
#
# You can customize commands in the files /etc/ranger/commands.py (system-wide)
# and ~/.config/ranger/commands.py (per user).
# They have the same syntax as this file. In fact, you can just copy this
# file to ~/.config/ranger/commands_full.py with
# `ranger --copy-config=commands_full' and make your modifications, don't
# forget to rename it to commands.py. You can also use
# `ranger --copy-config=commands' to copy a short sample commands.py that
# has everything you need to get started.
# But make sure you update your configs when you update ranger.
#
# ===================================================================
# Every class defined here which is a subclass of `Command' will be used as a
# command in ranger. Several methods are defined to interface with ranger:
# execute(): called when the command is executed.
# cancel(): called when closing the console.
# tab(tabnum): called when <TAB> is pressed.
# quick(): called after each keypress.
#
# tab() argument tabnum is 1 for <TAB> and -1 for <S-TAB> by default
#
# 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() and cancel() doesn't matter.
#
# ===================================================================
# Commands have certain attributes and methods that facilitate parsing of
# the arguments:
#
# self.line: The whole line that was written in the console.
# self.args: A list of all (space-separated) arguments to the command.
# self.quantifier: If this command was mapped to the key "X" and
# the user pressed 6X, self.quantifier will be 6.
# self.arg(n): The n-th argument, or an empty string if it doesn't exist.
# self.rest(n): The n-th argument plus everything that followed. For example,
# if the command was "search foo bar a b c", rest(2) will be "bar a b c"
# self.start(n): Anything before the n-th argument. For example, if the
# command was "search foo bar a b c", start(2) will be "search foo"
#
# ===================================================================
# And this is a little reference for common ranger functions and objects:
#
# self.fm: A reference to the "fm" object which contains most information
# about ranger.
# self.fm.notify(string): Print the given string on the screen.
# self.fm.notify(string, bad=True): Print the given string in RED.
# self.fm.reload_cwd(): Reload the current working directory.
# self.fm.thisdir: The current working directory. (A File object.)
# self.fm.thisfile: The current file. (A File object too.)
# self.fm.thistab.get_selection(): A list of all selected files.
# self.fm.execute_console(string): Execute the string as a ranger command.
# self.fm.open_console(string): Open the console with the given string
# already typed in for you.
# self.fm.move(direction): Moves the cursor in the given direction, which
# can be something like down=3, up=5, right=1, left=1, to=6, ...
#
# File objects (for example self.fm.thisfile) have these useful attributes and
# methods:
#
# tfile.path: The path to the file.
# tfile.basename: The base name only.
# tfile.load_content(): Force a loading of the directories content (which
# obviously works with directories only)
# tfile.is_directory: True/False depending on whether it's a directory.
#
# For advanced commands it is unavoidable to dive a bit into the source code
# of ranger.
# ===================================================================
from __future__ import (absolute_import, division, print_function)
from collections import deque
import os
import re
from ranger.api.commands import Command
class alias(Command):
""":alias <newcommand> <oldcommand>
Copies the oldcommand as newcommand.
"""
context = 'browser'
resolve_macros = False
def execute(self):
if not self.arg(1) or not self.arg(2):
self.fm.notify('Syntax: alias <newcommand> <oldcommand>', bad=True)
return
self.fm.commands.alias(self.arg(1), self.rest(2))
class echo(Command):
""":echo <text>
Display the text in the statusbar.
"""
def execute(self):
self.fm.notify(self.rest(1))
class cd(Command):
""":cd [-r] <path>
The cd command changes the directory.
If the path is a file, selects that file.
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':
self.shift()
destination = os.path.realpath(self.rest(1))
if os.path.isfile(destination):
self.fm.select_file(destination)
return
else:
destination = self.rest(1)
if not destination:
destination = '~'
if destination == '-':
self.fm.enter_bookmark('`')
else:
self.fm.cd(destination)
def _tab_args(self):
# dest must be rest because path could contain spaces
if self.arg(1) == '-r':
start = self.start(2)
dest = self.rest(2)
else:
start = self.start(1)
dest = self.rest(1)
if dest:
head, tail = os.path.split(os.path.expanduser(dest))
if head:
dest_exp = os.path.join(os.path.normpath(head), tail)
else:
dest_exp = tail
else:
dest_exp = ''
return (start, dest_exp, os.path.join(self.fm.thisdir.path, dest_exp),
dest.endswith(os.path.sep))
@staticmethod
def _tab_paths(dest, dest_abs, ends_with_sep):
if not dest:
try:
return next(os.walk(dest_abs))[1], dest_abs
except (OSError, StopIteration):
return [], ''
if ends_with_sep:
try:
return [os.path.join(dest, path) for path in next(os.walk(dest_abs))[1]], ''
except (OSError, StopIteration):
return [], ''
return None, None
def _tab_match(self, path_user, path_file):
if self.fm.settings.cd_tab_case == 'insensitive':
path_user = path_user.lower()
path_file = path_file.lower()
elif self.fm.settings.cd_tab_case == 'smart' and path_user.islower():
path_file = path_file.lower()
return path_file.startswith(path_user)
def _tab_normal(self, dest, dest_abs):
dest_dir = os.path.dirname(dest)
dest_base = os.path.basename(dest)
try:
dirnames = next(os.walk(os.path.dirname(dest_abs)))[1]
except (OSError, StopIteration):
return [], ''
return [os.path.join(dest_dir, d) for d in dirnames if self._tab_match(dest_base, d)], ''
def _tab_fuzzy_match(self, basepath, tokens):
""" Find directories matching tokens recursively """
if not tokens:
tokens = ['']
paths = [basepath]
while True:
token = tokens.pop()
matches = []
for path in paths:
try:
directories = next(os.walk(path))[1]
except (OSError, StopIteration):
continue
matches += [os.path.join(path, d) for d in directories
if self._tab_match(token, d)]
if not tokens or not matches:
return matches
paths = matches
return None
def _tab_fuzzy(self, dest, dest_abs):
tokens = []
basepath = dest_abs
while True:
basepath_old = basepath
basepath, token = os.path.split(basepath)
if basepath == basepath_old:
break
if os.path.isdir(basepath_old) and not token.startswith('.'):
basepath = basepath_old
break
tokens.append(token)
paths = self._tab_fuzzy_match(basepath, tokens)
if not os.path.isabs(dest):
paths_rel = basepath
paths = [os.path.relpath(path, paths_rel) for path in paths]
else:
paths_rel = ''
return paths, paths_rel
def tab(self, tabnum):
from os.path import sep
start, dest, dest_abs, ends_with_sep = self._tab_args()
paths, paths_rel = self._tab_paths(dest, dest_abs, ends_with_sep)
if paths is None:
if self.fm.settings.cd_tab_fuzzy:
paths, paths_rel = self._tab_fuzzy(dest, dest_abs)
else:
paths, paths_rel = self._tab_normal(dest, dest_abs)
paths.sort()
if self.fm.settings.cd_bookmarks:
paths[0:0] = [
os.path.relpath(v.path, paths_rel) if paths_rel else v.path
for v in self.fm.bookmarks.dct.values() for path in paths
if v.path.startswith(os.path.join(paths_rel, path) + sep)
]
if not paths:
return None
if len(paths) == 1:
return start + paths[0] + sep
return [start + dirname for dirname in paths]
class chain(Command):
""":chain <command1>; <command2>; ...
Calls multiple commands at once, separated by semicolons.
"""
def execute(self):
if not self.rest(1).strip():
self.fm.notify('Syntax: chain <command1>; <command2>; ...', bad=True)
return
for command in [s.strip() for s in self.rest(1).split(";")]:
self.fm.execute_console(command)
class shell(Command):
escape_macros_for_shell = True
def execute(self):
if self.arg(1) and self.arg(1)[0] == '-':
flags = self.arg(1)[1:]
command = self.rest(2)
else:
flags = ''
command = self.rest(1)
if command:
self.fm.execute_command(command, flags=flags)
def tab(self, tabnum):
from ranger.ext.get_executables import get_executables
if self.arg(1) and self.arg(1)[0] == '-':
command = self.rest(2)
else:
command = self.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:
selection = self.fm.thistab.get_selection()
if len(selection) == 1:
return self.line + selection[0].shell_escaped_basename + ' '
return self.line + '%s '
before_word, start_of_word = self.line.rsplit(' ', 1)
return (before_word + ' ' + file.shell_escaped_basename
for file in self.fm.thisdir.files or []
if file.shell_escaped_basename.startswith(start_of_word))
class open_with(Command):
def execute(self):
app, flags, mode = self._get_app_flags_mode(self.rest(1))
self.fm.execute_file(
files=[f for f in self.fm.thistab.get_selection()],
app=app,
flags=flags,
mode=mode)
def tab(self, tabnum):
return self._tab_through_executables()
def _get_app_flags_mode(self, string): # pylint: disable=too-many-branches,too-many-statements
"""Extracts the application, flags and mode from a string.
examples:
"mplayer f 1" => ("mplayer", "f", 1)
"atool 4" => ("atool", "", 4)
"p" => ("", "p", 0)
"" => None
"""
app = ''
flags = ''
mode = 0
split = string.split()
if 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 _is_app(self, arg):
return not self._is_flags(arg) and not arg.isdigit()
@staticmethod
def _is_flags(arg):
from ranger.core.runner import ALLOWED_FLAGS
return all(x in ALLOWED_FLAGS for x in arg)
@staticmethod
def _is_mode(arg):
return all(x in '0123456789' for x in arg)
class set_(Command):
""":set <option name>=<python expression>
Gives an option a new value.
Use `:set <option>!` to toggle or cycle it, e.g. `:set flush_input!`
"""
name = 'set' # don't override the builtin set class
def execute(self):
name = self.arg(1)
name, value, _, toggle = self.parse_setting_line_v2()
if toggle:
self.fm.toggle_option(name)
else:
self.fm.set_option_from_string(name, value)
def tab(self, tabnum): # pylint: disable=too-many-return-statements
from ranger.gui.colorscheme import get_all_colorschemes
name, value, name_done = self.parse_setting_line()
settings = self.fm.settings
if not name:
return sorted(self.firstpart + setting for setting in settings)
if not value and not name_done:
return sorted(self.firstpart + setting for setting in settings
if setting.startswith(name))
if not value:
value_completers = {
"colorscheme":
# Cycle through colorschemes when name, but no value is specified
lambda: sorted(self.firstpart + colorscheme for colorscheme
in get_all_colorschemes(self.fm)),
"column_ratios":
lambda: self.firstpart + ",".join(map(str, settings[name])),
}
def default_value_completer():
return self.firstpart + str(settings[name])
return value_completers.get(name, default_value_completer)()
if bool in settings.types_of(name):
if 'true'.startswith(value.lower()):
return self.firstpart + 'True'
if 'false'.startswith(value.lower()):
return self.firstpart + 'False'
# Tab complete colorscheme values if incomplete value is present
if name == "colorscheme":
return sorted(self.firstpart + colorscheme for colorscheme
in get_all_colorschemes(self.fm) if colorscheme.startswith(value))
return None
class setlocal(set_):
""":setlocal path=<regular expression> <option name>=<python expression>
Gives an option a new value.
"""
PATH_RE_DQUOTED = re.compile(r'^setlocal\s+path="(.*?)"')
PATH_RE_SQUOTED = re.compile(r"^setlocal\s+path='(.*?)'")
PATH_RE_UNQUOTED = re.compile(r'^path=(.*?)$')
def _re_shift(self, match):
if not match:
return None
path = os.path.expanduser(match.group(1))
for _ in range(len(path.split())):
self.shift()
return path
def execute(self):
path = self._re_shift(self.PATH_RE_DQUOTED.match(self.line))
if path is None:
path = self._re_shift(self.PATH_RE_SQUOTED.match(self.line))
if path is None:
path = self._re_shift(self.PATH_RE_UNQUOTED.match(self.arg(1)))
if path is None and self.fm.thisdir:
path = self.fm.thisdir.path
if not path:
return
name, value, _ = self.parse_setting_line()
self.fm.set_option_from_string(name, value, localpath=path)
class setintag(set_):
""":setintag <tag or tags> <option name>=<option value>
Sets an option for directories that are tagged with a specific tag.
"""
def execute(self):
tags = self.arg(1)
self.shift()
name, value, _ = self.parse_setting_line()
self.fm.set_option_from_string(name, value, tags=tags)
class default_linemode(Command):
def execute(self):
from ranger.container.fsobject import FileSystemObject
if len(self.args) < 2:
self.fm.notify(
"Usage: default_linemode [path=<regexp> | tag=<tag(s)>] <linemode>", bad=True)
# Extract options like "path=..." or "tag=..." from the command line
arg1 = self.arg(1)
method = "always"
argument = None
if arg1.startswith("path="):
method = "path"
argument = re.compile(arg1[5:])
self.shift()
elif arg1.startswith("tag="):
method = "tag"
argument = arg1[4:]
self.shift()
# Extract and validate the line mode from the command line
lmode = self.rest(1)
if lmode not in FileSystemObject.linemode_dict:
self.fm.notify(
"Invalid linemode: %s; should be %s" % (
lmode, "/".join(FileSystemObject.linemode_dict)),
bad=True,
)
# Add the prepared entry to the fm.default_linemodes
entry = [method, argument, lmode]
self.fm.default_linemodes.appendleft(entry)
# Redraw the columns
if self.fm.ui.browser:
for col in self.fm.ui.browser.columns:
col.need_redraw = True
def tab(self, tabnum):
return (self.arg(0) + " " + lmode
for lmode in self.fm.thisfile.linemode_dict.keys()
if lmode.startswith(self.arg(1)))
class quit(Command): # pylint: disable=redefined-builtin
""":quit
Closes the current tab, if there's only one tab.
Otherwise quits if there are no tasks in progress.
"""
def _exit_no_work(self):
if self.fm.loader.has_work():
self.fm.notify('Not quitting: Tasks in progress: Use `quit!` to force quit')
else:
self.fm.exit()
def execute(self):
if len(self.fm.tabs) >= 2:
self.fm.tab_close()
else:
self._exit_no_work()
class quit_bang(Command):
""":quit!
Closes the current tab, if there's only one tab.
Otherwise force quits immediately.
"""
name = 'quit!'
allow_abbrev = False
def execute(self):
if len(self.fm.tabs) >= 2:
self.fm.tab_close()
else:
self.fm.exit()
class quitall(Command):
""":quitall
Quits if there are no tasks in progress.
"""
def _exit_no_work(self):
if self.fm.loader.has_work():
self.fm.notify('Not quitting: Tasks in progress: Use `quitall!` to force quit')
else:
self.fm.exit()
def execute(self):
self._exit_no_work()
class quitall_bang(Command):
""":quitall!
Force quits immediately.
"""
name = 'quitall!'
allow_abbrev = False
def execute(self):
self.fm.exit()
class terminal(Command):
""":terminal
Spawns an "x-terminal-emulator" starting in the current directory.
"""
def execute(self):
from ranger.ext.get_executables import get_term
self.fm.run(get_term(), flags='f')
class delete(Command):
""":delete
Tries to delete the selection or the files passed in arguments (if any).
The arguments use a shell-like escaping.
"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.
"""
allow_abbrev = False
escape_macros_for_shell = True
def execute(self):
import shlex
from functools import partial
def is_directory_with_files(path):
return os.path.isdir(path) and not os.path.islink(path) and len(os.listdir(path)) > 0
if self.rest(1):
files = shlex.split(self.rest(1))
many_files = (len(files) > 1 or is_directory_with_files(files[0]))
else:
cwd = self.fm.thisdir
tfile = self.fm.thisfile
if not cwd or not tfile:
self.fm.notify("Error: no file selected for deletion!", bad=True)
return
# relative_path used for a user-friendly output in the confirmation.
files = [f.relative_path for f in self.fm.thistab.get_selection()]
many_files = (cwd.marked_items or is_directory_with_files(tfile.path))
confirm = self.fm.settings.confirm_on_delete
if confirm != 'never' and (confirm != 'multiple' or many_files):
self.fm.ui.console.ask(
"Confirm deletion of: %s (y/N)" % ', '.join(files),
partial(self._question_callback, files),
('n', 'N', 'y', 'Y'),
)
else:
# no need for a confirmation, just delete
self.fm.delete(files)
def tab(self, tabnum):
return self._tab_directory_content()
def _question_callback(self, files, answer):
if answer == 'y' or answer == 'Y':
self.fm.delete(files)
class jump_non(Command):
""":jump_non [-FLAGS...]
Jumps to first non-directory if highlighted file is a directory and vice versa.
Flags:
-r Jump in reverse order
-w Wrap around if reaching end of filelist
"""
def __init__(self, *args, **kwargs):
super(jump_non, self).__init__(*args, **kwargs)
flags, _ = self.parse_flags()
self._flag_reverse = 'r' in flags
self._flag_wrap = 'w' in flags
@staticmethod
def _non(fobj, is_directory):
return fobj.is_directory if not is_directory else not fobj.is_directory
def execute(self):
tfile = self.fm.thisfile
passed = False
found_before = None
found_after = None
for fobj in self.fm.thisdir.files[::-1] if self._flag_reverse else self.fm.thisdir.files:
if fobj.path == tfile.path:
passed = True
continue
if passed:
if self._non(fobj, tfile.is_directory):
found_after = fobj.path
break
elif not found_before and self._non(fobj, tfile.is_directory):
found_before = fobj.path
if found_after:
self.fm.select_file(found_after)
elif self._flag_wrap and found_before:
self.fm.select_file(found_before)
class mark_tag(Command):
""":mark_tag [<tags>]
Mark all tags that are tagged with either of the given tags.
When leaving out the tag argument, all tagged files are marked.
"""
do_mark = True
def execute(self):
cwd = self.fm.thisdir
tags = self.rest(1).replace(" ", "")
if not self.fm.tags or not cwd.files:
return
for fileobj in cwd.files:
try:
tag = self.fm.tags.tags[fileobj.realpath]
except KeyError:
continue
if not tags or tag in tags:
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:])
except ValueError:
pass
else:
self.shift()
self.fm.open_console(self.rest(1), position=position)
class load_copy_buffer(Command):
""":load_copy_buffer
Load the copy buffer from datadir/copy_buffer
"""
copy_buffer_filename = 'copy_buffer'
def execute(self):
import sys
from ranger.container.file import File
from os.path import exists
fname = self.fm.datapath(self.copy_buffer_filename)
unreadable = IOError if sys.version_info[0] < 3 else OSError
try:
fobj = open(fname, 'r')
except unreadable:
return self.fm.notify(
"Cannot open %s" % (fname or self.copy_buffer_filename), bad=True)
self.fm.copy_buffer = set(File(g)
for g in fobj.read().split("\n") if exists(g))
fobj.close()
self.fm.ui.redraw_main_column()
return None
class save_copy_buffer(Command):
""":save_copy_buffer
Save the copy buffer to datadir/copy_buffer
"""
copy_buffer_filename = 'copy_buffer'
def execute(self):
import sys
fname = None
fname = self.fm.datapath(self.copy_buffer_filename)
unwritable = IOError if sys.version_info[0] < 3 else OSError
try:
fobj = open(fname, 'w')
except unwritable:
return self.fm.notify("Cannot open %s" %
(fname or self.copy_buffer_filename), bad=True)
fobj.write("\n".join(fobj.path for fobj in self.fm.copy_buffer))
fobj.close()
return None
class unmark_tag(mark_tag):
""":unmark_tag [<tags>]
Unmark all tags that are tagged with either of the given tags.
When leaving out the tag argument, all tagged files are unmarked.
"""
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 makedirs
dirname = join(self.fm.thisdir.path, expanduser(self.rest(1)))
if not lexists(dirname):
makedirs(dirname)
else:
self.fm.notify("file/directory exists!", bad=True)
def tab(self, tabnum):
return self._tab_directory_content()
class touch(Command):
""":touch <fname>
Creates a file with the name <fname>.
"""
def execute(self):
from os.path import join, expanduser, lexists
fname = join(self.fm.thisdir.path, expanduser(self.rest(1)))
if not lexists(fname):
open(fname, 'a').close()
else:
self.fm.notify("file/directory exists!", bad=True)
def tab(self, tabnum):
return self._tab_directory_content()
class edit(Command):
""":edit <filename>
Opens the specified file in vim
"""
def execute(self):
if not self.arg(1):
self.fm.edit_file(self.fm.thisfile.path)
else:
self.fm.edit_file(self.rest(1))
def tab(self, tabnum):
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.directories)
:eval p("Hello World!")
"""
name = 'eval'
resolve_macros = False
def execute(self):
# The import is needed so eval() can access the ranger module
import ranger # NOQA pylint: disable=unused-import,unused-variable
if self.arg(1) == '-q':
code = self.rest(2)
quiet = True
else:
code = self.rest(1)
quiet = False
global cmd, fm, p, quantifier # pylint: disable=invalid-name,global-variable-undefined
fm = self.fm
cmd = self.fm.execute_console
p = fm.notify
quantifier = self.quantifier
try:
try:
result = eval(code) # pylint: disable=eval-used
except SyntaxError:
exec(code) # pylint: disable=exec-used
else:
if result and not quiet:
p(result)
except Exception as err: # pylint: disable=broad-except
fm.notify("The error `%s` was caused by evaluating the "
"following code: `%s`" % (err, code), bad=True)
class rename(Command):
""":rename <newname>
Changes the name of the currently highlighted file to <newname>
"""
def execute(self):
from ranger.container.file import File
from os import access
new_name = self.rest(1)
if not new_name:
return self.fm.notify('Syntax: rename <newname>', bad=True)
if new_name == self.fm.thisfile.relative_path:
return None
if access(new_name, os.F_OK):
return self.fm.notify("Can't rename: file already exists!", bad=True)
if self.fm.rename(self.fm.thisfile, new_name):
file_new = File(new_name)
self.fm.bookmarks.update_path(self.fm.thisfile.path, file_new)
self.fm.tags.update_path(self.fm.thisfile.path, file_new.path)
self.fm.thisdir.pointed_obj = file_new
self.fm.thisfile = file_new
return None
def tab(self, tabnum):
return self._tab_directory_content()
class rename_append(Command):
""":rename_append [-FLAGS...]
Opens the console with ":rename <current file>" with the cursor positioned
before the file extension.
Flags:
-a Position before all extensions
-r Remove everything before extensions
"""
def __init__(self, *args, **kwargs):
super(rename_append, self).__init__(*args, **kwargs)
flags, _ = self.parse_flags()
self._flag_ext_all = 'a' in flags
self._flag_remove = 'r' in flags
def execute(self):
from ranger import MACRO_DELIMITER, MACRO_DELIMITER_ESC
tfile = self.fm.thisfile
relpath = tfile.relative_path.replace(MACRO_DELIMITER, MACRO_DELIMITER_ESC)
basename = tfile.basename.replace(MACRO_DELIMITER, MACRO_DELIMITER_ESC)
if basename.find('.') <= 0:
self.fm.open_console('rename ' + relpath)
return
if self._flag_ext_all:
pos_ext = re.search(r'[^.]+', basename).end(0)
else:
pos_ext = basename.rindex('.')
pos = len(relpath) - len(basename) + pos_ext
if self._flag_remove:
relpath = relpath[:-len(basename)] + basename[pos_ext:]
pos -= pos_ext
self.fm.open_console('rename ' + relpath, position=(7 + pos))
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_str = self.rest(1)
if not mode_str:
if not self.quantifier:
self.fm.notify("Syntax: chmod <octal number>", bad=True)
return
mode_str = str(self.quantifier)
try:
mode = int(mode_str, 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 fobj in self.fm.thistab.get_selection():
try:
os.chmod(fobj.path, mode)
except OSError as ex:
self.fm.notify(ex)
# reloading directory. maybe its better to reload the selected
# files only.
self.fm.thisdir.content_outdated = True
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): # pylint: disable=too-many-locals,too-many-statements
import sys
import tempfile
from ranger.container.file import File
from ranger.ext.shell_escape import shell_escape as esc
py3 = sys.version_info[0] >= 3
# Create and edit the file list
filenames = [f.relative_path for f in self.fm.thistab.get_selection()]
listfile = tempfile.NamedTemporaryFile(delete=False)
listpath = listfile.name
if py3:
listfile.write("\n".join(filenames).encode("utf-8"))
else:
listfile.write("\n".join(filenames))
listfile.close()
self.fm.execute_file([File(listpath)], app='editor')
listfile = open(listpath, 'r')
new_filenames = listfile.read().split("\n")
listfile.close()
os.unlink(listpath)
if all(a == b for a, b in zip(filenames, new_filenames)):
self.fm.notify("No renaming to be done!")
return
# Generate script
cmdfile = tempfile.NamedTemporaryFile()
script_lines = []
script_lines.append("# This file will be executed when you close the editor.\n")
script_lines.append("# Please double-check everything, clear the file to abort.\n")
script_lines.extend("mv -vi -- %s %s\n" % (esc(old), esc(new))
for old, new in zip(filenames, new_filenames) if old != new)
script_content = "".join(script_lines)
if py3:
cmdfile.write(script_content.encode("utf-8"))
else:
cmdfile.write(script_content)
cmdfile.flush()
# Open the script and let the user review it, then check if the script
# was modified by the user
self.fm.execute_file([File(cmdfile.name)], app='editor')
cmdfile.seek(0)
script_was_edited = (script_content != cmdfile.read())
# Do the renaming
self.fm.run(['/bin/sh', cmdfile.name], flags='w')
cmdfile.close()
# Retag the files, but only if the script wasn't changed during review,
# because only then we know which are the source and destination files.
if not script_was_edited:
tags_changed = False
for old, new in zip(filenames, new_filenames):
if old != new:
oldpath = self.fm.thisdir.path + '/' + old
newpath = self.fm.thisdir.path + '/' + new
if oldpath in self.fm.tags:
old_tag = self.fm.tags.tags[oldpath]
self.fm.tags.remove(oldpath)
self.fm.tags.tags[newpath] = old_tag
tags_changed = True
if tags_changed:
self.fm.tags.dump()
else:
fm.notify("files have not been retagged")
class relink(Command):
""":relink <newpath>
Changes the linked path of the currently highlighted symlink to <newpath>
"""
def execute(self):
new_path = self.rest(1)
tfile = self.fm.thisfile
if not new_path:
return self.fm.notify('Syntax: relink <newpath>', bad=True)
if not tfile.is_link:
return self.fm.notify('%s is not a symlink!' % tfile.relative_path, bad=True)
if new_path == os.readlink(tfile.path):
return None
try:
os.remove(tfile.path)
os.symlink(new_path, tfile.path)
except OSError as err:
self.fm.notify(err)
self.fm.reset()
self.fm.thisdir.pointed_obj = tfile
self.fm.thisfile = tfile
return None
def tab(self, tabnum):
if not self.rest(1):
return self.line + os.readlink(self.fm.thisfile.path)
return self._tab_directory_content()
class help_(Command):
""":help
Display ranger's manual page.
"""
name = 'help'
def execute(self):
def callback(answer):
if answer == "q":
return
elif answer == "m":
self.fm.display_help()
elif answer == "c":
self.fm.dump_commands()
elif answer == "k":
self.fm.dump_keybindings()
elif answer == "s":
self.fm.dump_settings()
self.fm.ui.console.ask(
"View [m]an page, [k]ey bindings, [c]ommands or [s]ettings? (press q to abort)",
callback,
list("mqkcs")
)
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.fm.notify("Not enough arguments", bad=True)
for arg in self.args[2:]:
self.fm.ui.keymaps.copy(self.context, self.arg(1), arg)
return None
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.ui.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):
if not self.arg(1) or not self.arg(2):
self.fm.notify("Syntax: {0} <keysequence> <command>".format(self.get_name()), bad=True)
return
self.fm.ui.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 scout(Command):
""":scout [-FLAGS...] <pattern>
Swiss army knife command for searching, traveling and filtering files.
Flags:
-a Automatically open a file on unambiguous match
-e Open the selected file when pressing enter
-f Filter files that match the current search pattern
-g Interpret pattern as a glob pattern
-i Ignore the letter case of the files
-k Keep the console open when changing a directory with the command
-l Letter skipping; e.g. allow "rdme" to match the file "readme"
-m Mark the matching files after pressing enter
-M Unmark the matching files after pressing enter
-p Permanent filter: hide non-matching files after pressing enter
-r Interpret pattern as a regular expression pattern
-s Smart case; like -i unless pattern contains upper case letters
-t Apply filter and search pattern as you type
-v Inverts the match
Multiple flags can be combined. For example, ":scout -gpt" would create
a :filter-like command using globbing.
"""
# pylint: disable=bad-whitespace
AUTO_OPEN = 'a'
OPEN_ON_ENTER = 'e'
FILTER = 'f'
SM_GLOB = 'g'
IGNORE_CASE = 'i'
KEEP_OPEN = 'k'
SM_LETTERSKIP = 'l'
MARK = 'm'
UNMARK = 'M'
PERM_FILTER = 'p'
SM_REGEX = 'r'
SMART_CASE = 's'
AS_YOU_TYPE = 't'
INVERT = 'v'
# pylint: enable=bad-whitespace
def __init__(self, *args, **kwargs):
super(scout, self).__init__(*args, **kwargs)
self._regex = None
self.flags, self.pattern = self.parse_flags()
def execute(self): # pylint: disable=too-many-branches
thisdir = self.fm.thisdir
flags = self.flags
pattern = self.pattern
regex = self._build_regex()
count = self._count(move=True)
self.fm.thistab.last_search = regex
self.fm.set_search_method(order="search")
if (self.MARK in flags or self.UNMARK in flags) and thisdir.files:
value = flags.find(self.MARK) > flags.find(self.UNMARK)
if self.FILTER in flags:
for fobj in thisdir.files:
thisdir.mark_item(fobj, value)
else:
for fobj in thisdir.files:
if regex.search(fobj.relative_path):
thisdir.mark_item(fobj, value)
if self.PERM_FILTER in flags:
thisdir.filter = regex if pattern else None
# clean up:
self.cancel()
if self.OPEN_ON_ENTER in flags or \
(self.AUTO_OPEN in flags and count == 1):
if pattern == '..':
self.fm.cd(pattern)
else:
self.fm.move(right=1)
if self.quickly_executed:
self.fm.block_input(0.5)
if self.KEEP_OPEN in flags and thisdir != self.fm.thisdir:
# reopen the console:
if not pattern:
self.fm.open_console(self.line)
else:
self.fm.open_console(self.line[0:-len(pattern)])
if self.quickly_executed and thisdir != self.fm.thisdir and pattern != "..":
self.fm.block_input(0.5)
def cancel(self):
self.fm.thisdir.temporary_filter = None
self.fm.thisdir.refilter()
def quick(self):
asyoutype = self.AS_YOU_TYPE in self.flags
if self.FILTER in self.flags:
self.fm.thisdir.temporary_filter = self._build_regex()
if self.PERM_FILTER in self.flags and asyoutype:
self.fm.thisdir.filter = self._build_regex()
if self.FILTER in self.flags or self.PERM_FILTER in self.flags:
self.fm.thisdir.refilter()
if self._count(move=asyoutype) == 1 and self.AUTO_OPEN in self.flags:
return True
return False
def tab(self, tabnum):
self._count(move=True, offset=tabnum)
def _build_regex(self):
if self._regex is not None:
return self._regex
frmat = "%s"
flags = self.flags
pattern = self.pattern
if pattern == ".":
return re.compile("")
# Handle carets at start and dollar signs at end separately
if pattern.startswith('^'):
pattern = pattern[1:]
frmat = "^" + frmat
if pattern.endswith('$'):
pattern = pattern[:-1]
frmat += "$"
# Apply one of the search methods
if self.SM_REGEX in flags:
regex = pattern
elif self.SM_GLOB in flags:
regex = re.escape(pattern).replace("\\*", ".*").replace("\\?", ".")
elif self.SM_LETTERSKIP in flags:
regex = ".*".join(re.escape(c) for c in pattern)
else:
regex = re.escape(pattern)
regex = frmat % regex
# Invert regular expression if necessary
if self.INVERT in flags:
regex = "^(?:(?!%s).)*$" % regex
# Compile Regular Expression
# pylint: disable=no-member
options = re.UNICODE
if self.IGNORE_CASE in flags or self.SMART_CASE in flags and \
pattern.islower():
options |= re.IGNORECASE
# pylint: enable=no-member
try:
self._regex = re.compile(regex, options)
except re.error:
self._regex = re.compile("")
return self._regex
def _count(self, move=False, offset=0):
count = 0
cwd = self.fm.thisdir
pattern = self.pattern
if not pattern or not cwd.files:
return 0
if pattern == '.':
return 0
if pattern == '..':
return 1
deq = deque(cwd.files)
deq.rotate(-cwd.pointer - offset)
i = offset
regex = self._build_regex()
for fsobj in deq:
if regex.search(fsobj.relative_path):
count += 1
if move and count == 1:
cwd.move(to=(cwd.pointer + i) % len(cwd.files))
self.fm.thisfile = cwd.pointed_obj
if count > 1:
return count
i += 1
return count == 1
class narrow(Command):
"""
:narrow
Show only the files selected right now. If no files are selected,
disable narrowing.
"""
def execute(self):
if self.fm.thisdir.marked_items:
selection = [f.basename for f in self.fm.thistab.get_selection()]
self.fm.thisdir.narrow_filter = selection
else:
self.fm.thisdir.narrow_filter = None
self.fm.thisdir.refilter()
class filter_inode_type(Command):
"""
:filter_inode_type [dfl]
Displays only the files of specified inode type. Parameters
can be combined.
d display directories
f display files
l display links
"""
def execute(self):
if not self.arg(1):
self.fm.thisdir.inode_type_filter = ""
else:
self.fm.thisdir.inode_type_filter = self.arg(1)
self.fm.thisdir.refilter()
class filter_stack(Command):
"""
:filter_stack ...
Manages the filter stack.
filter_stack add FILTER_TYPE ARGS...
filter_stack pop
filter_stack decompose
filter_stack rotate [N=1]
filter_stack clear
filter_stack show
"""
def execute(self):
from ranger.core.filter_stack import SIMPLE_FILTERS, FILTER_COMBINATORS
subcommand = self.arg(1)
if subcommand == "add":
try:
self.fm.thisdir.filter_stack.append(
SIMPLE_FILTERS[self.arg(2)](self.rest(3))
)
except KeyError:
FILTER_COMBINATORS[self.arg(2)](self.fm.thisdir.filter_stack)
elif subcommand == "pop":
self.fm.thisdir.filter_stack.pop()
elif subcommand == "decompose":
inner_filters = self.fm.thisdir.filter_stack.pop().decompose()
if inner_filters:
self.fm.thisdir.filter_stack.extend(inner_filters)
elif subcommand == "clear":
self.fm.thisdir.filter_stack = []
elif subcommand == "rotate":
rotate_by = int(self.arg(2) or 1)
self.fm.thisdir.filter_stack = (
self.fm.thisdir.filter_stack[-rotate_by:]
+ self.fm.thisdir.filter_stack[:-rotate_by]
)
elif subcommand == "show":
stack = list(map(str, self.fm.thisdir.filter_stack))
pager = self.fm.ui.open_pager()
pager.set_source(["Filter stack: "] + stack)
pager.move(to=100, percentage=True)
return
else:
self.fm.notify(
"Unknown subcommand: {}".format(subcommand),
bad=True
)
return
self.fm.thisdir.refilter()
class grep(Command):
""":grep <string>
Looks for a string in all marked files or directories
"""
def execute(self):
if self.rest(1):
action = ['grep', '--line-number']
action.extend(['-e', self.rest(1), '-r'])
action.extend(f.path for f in self.fm.thistab.get_selection())
self.fm.execute_command(action, flags='p')
class flat(Command):
"""
:flat <level>
Flattens the directory view up to the specified level.
-1 fully flattened
0 remove flattened view
"""
def execute(self):
try:
level_str = self.rest(1)
level = int(level_str)
except ValueError:
level = self.quantifier
if level is None:
self.fm.notify("Syntax: flat <level>", bad=True)
return
if level < -1:
self.fm.notify("Need an integer number (-1, 0, 1, ...)", bad=True)
self.fm.thisdir.unload()
self.fm.thisdir.flat = level
self.fm.thisdir.load_content()
# Version control commands
# --------------------------------
class stage(Command):
"""
:stage
Stage selected files for the corresponding version control system
"""
def execute(self):
from ranger.ext.vcs import VcsError
if self.fm.thisdir.vcs and self.fm.thisdir.vcs.track:
filelist = [f.path for f in self.fm.thistab.get_selection()]
try:
self.fm.thisdir.vcs.action_add(filelist)
except VcsError as ex:
self.fm.notify('Unable to stage files: {0}'.format(ex))
self.fm.ui.vcsthread.process(self.fm.thisdir)
else:
self.fm.notify('Unable to stage files: Not in repository')
class unstage(Command):
"""
:unstage
Unstage selected files for the corresponding version control system
"""
def execute(self):
from ranger.ext.vcs import VcsError
if self.fm.thisdir.vcs and self.fm.thisdir.vcs.track:
filelist = [f.path for f in self.fm.thistab.get_selection()]
try:
self.fm.thisdir.vcs.action_reset(filelist)
except VcsError as ex:
self.fm.notify('Unable to unstage files: {0}'.format(ex))
self.fm.ui.vcsthread.process(self.fm.thisdir)
else:
self.fm.notify('Unable to unstage files: Not in repository')
# Metadata commands
# --------------------------------
class prompt_metadata(Command):
"""
:prompt_metadata <key1> [<key2> [<key3> ...]]
Prompt the user to input metadata for multiple keys in a row.
"""
_command_name = "meta"
_console_chain = None
def execute(self):
prompt_metadata._console_chain = self.args[1:]
self._process_command_stack()
def _process_command_stack(self):
if prompt_metadata._console_chain:
key = prompt_metadata._console_chain.pop()
self._fill_console(key)
else:
for col in self.fm.ui.browser.columns:
col.need_redraw = True
def _fill_console(self, key):
metadata = self.fm.metadata.get_metadata(self.fm.thisfile.path)
if key in metadata and metadata[key]:
existing_value = metadata[key]
else:
existing_value = ""
text = "%s %s %s" % (self._command_name, key, existing_value)
self.fm.open_console(text, position=len(text))
class meta(prompt_metadata):
"""
:meta <key> [<value>]
Change metadata of a file. Deletes the key if value is empty.
"""
def execute(self):
key = self.arg(1)
update_dict = dict()
update_dict[key] = self.rest(2)
selection = self.fm.thistab.get_selection()
for fobj in selection:
self.fm.metadata.set_metadata(fobj.path, update_dict)
self._process_command_stack()
def tab(self, tabnum):
key = self.arg(1)
metadata = self.fm.metadata.get_metadata(self.fm.thisfile.path)
if key in metadata and metadata[key]:
return [" ".join([self.arg(0), self.arg(1), metadata[key]])]
return [self.arg(0) + " " + k for k in sorted(metadata)
if k.startswith(self.arg(1))]
class linemode(default_linemode):
"""
:linemode <mode>
Change what is displayed as a filename.
- "mode" may be any of the defined linemodes (see: ranger.core.linemode).
"normal" is mapped to "filename".
"""
def execute(self):
mode = self.arg(1)
if mode == "normal":
from ranger.core.linemode import DEFAULT_LINEMODE
mode = DEFAULT_LINEMODE
if mode not in self.fm.thisfile.linemode_dict:
self.fm.notify("Unhandled linemode: `%s'" % mode, bad=True)
return
self.fm.thisdir.set_linemode_of_children(mode)
# Ask the browsercolumns to redraw
for col in self.fm.ui.browser.columns:
col.need_redraw = True
class yank(Command):
""":yank [name|dir|path]
Copies the file's name (default), directory or path into both the primary X
selection and the clipboard.
"""
modes = {
'': 'basename',
'name_without_extension': 'basename_without_extension',
'name': 'basename',
'dir': 'dirname',
'path': 'path',
}
def execute(self):
import subprocess
def clipboards():
from ranger.ext.get_executables import get_executables
clipboard_managers = {
'xclip': [
['xclip'],
['xclip', '-selection', 'clipboard'],
],
'xsel': [
['xsel'],
['xsel', '-b'],
],
'pbcopy': [
['pbcopy'],
],
}
ordered_managers = ['pbcopy', 'xclip', 'xsel']
executables = get_executables()
for manager in ordered_managers:
if manager in executables:
return clipboard_managers[manager]
return []
clipboard_commands = clipboards()
mode = self.modes[self.arg(1)]
selection = self.get_selection_attr(mode)
new_clipboard_contents = "\n".join(selection)
for command in clipboard_commands:
process = subprocess.Popen(command, universal_newlines=True,
stdin=subprocess.PIPE)
process.communicate(input=new_clipboard_contents)
def get_selection_attr(self, attr):
return [getattr(item, attr) for item in
self.fm.thistab.get_selection()]
def tab(self, tabnum):
return (
self.start(1) + mode for mode
in sorted(self.modes.keys())
if mode
)