You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1878 lines
57 KiB

What the fuck did you just fucking say about me, you little bitch? I'll have you know I graduated top of my class in the Navy Seals, and I've been involved in numerous secret raids on Al-Quaeda, and I have over 300 confirmed kills. I am trained in gorilla warfare and I'm the top sniper in the entire US armed forces. You are nothing to me but just another target. I will wipe you the fuck out with precision the likes of which has never been seen before on this Earth, mark my fucking words. You think you can get away with saying that shit to me over the Internet? Think again, fucker. As we speak I am contacting my secret network of spies across the USA and your IP is being traced right now so you better prepare for the storm, maggot. The storm that wipes out the pathetic little thing you call your life. You're fucking dead, kid. I can be anywhere, anytime, and I can kill you in over seven hundred ways, and that's just with my bare hands. Not only am I extensively trained in unarmed combat, but I have access to the entire arsenal of the United States Marine Corps and I will use it to its full extent to wipe your miserable ass off the face of the continent, you little shit. If only you could have known what unholy retribution your little "clever" comment was about to bring down upon you, maybe you would have held your fucking tongue. But you couldn't, you didn't, and now you're paying the price, you goddamn idiot. I will shit fury all over you and you will drown in it. You're fucking dead, kiddo.
5 years ago
# Note that additional commands are automatically generated from the methods
# of the class ranger.core.actions.Actions.
# ===================================================================
# 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()