rem
stringlengths 0
322k
| add
stringlengths 0
2.05M
| context
stringlengths 8
228k
|
|---|---|---|
thefile = File(target) fm = FM() load_settings(fm, ranger.arg.clean) fm.execute_file(thefile, mode=arg.mode, flags=arg.flags)
|
def print_function(string): print(string) runner = Runner(logfunc=print_function) load_apps(runner, ranger.arg.clean) runner(files=[File(target)], mode=arg.mode, flags=arg.flags)
|
def main(): """initialize objects and run the filemanager""" try: import curses except ImportError as errormessage: print(errormessage) print('ranger requires the python curses module. Aborting.') sys.exit(1) # Ensure that a utf8 locale is set. if getdefaultlocale()[1] not in ('utf8', 'UTF-8'): for locale in ('en_US.utf8', 'en_US.UTF-8'): try: setlocale(LC_ALL, locale) except: pass else: break else: setlocale(LC_ALL, '') else: setlocale(LC_ALL, '') arg = parse_arguments() ranger.arg = arg if not ranger.arg.debug: curses_interrupt_handler.install_interrupt_handler() SettingsAware._setup() if arg.targets: target = arg.targets[0] if not os.access(target, os.F_OK): print("File or directory doesn't exist: %s" % target) sys.exit(1) elif os.path.isfile(target): thefile = File(target) fm = FM() load_settings(fm, ranger.arg.clean) fm.execute_file(thefile, mode=arg.mode, flags=arg.flags) sys.exit(0) else: path = target else: path = '.' try: # Initialize objects EnvironmentAware._assign(Environment(path)) fm = FM() load_settings(fm, ranger.arg.clean) FileManagerAware._assign(fm) fm.ui = UI() # Run the file manager fm.initialize() fm.ui.initialize() fm.loop() finally: # Finish, clean up try: fm.ui.destroy() except (AttributeError, NameError): pass
|
if os.path.isdir(f.path):
|
if os.path.isdir(f.path) and not os.path.islink(f.path):
|
def delete(self): self.notify("Deleting!", duration=1) selected = self.env.get_selection() self.env.copy -= selected if selected: for f in selected: if os.path.isdir(f.path): try: shutil.rmtree(f.path) except OSError as err: self.notify(str(err), bad=True) else: try: os.remove(f.path) except OSError as err: self.notify(str(err), bad=True)
|
position_of_last_space = self.line.rindex(" ")
|
i = self.line.index('!')+1
|
def _get_tab(self): try: position_of_last_space = self.line.rindex(" ") except ValueError: return (program + ' ' for program in self.fm.executables \ if program.startswith(self.line)) if position_of_last_space == len(self.line) - 1: return self.line + '%s ' else: before_word, start_of_word = self.line.rsplit(' ', 1) return (before_word + ' ' + file.basename \ for file in self.fm.env.pwd.files \ if file.basename.startswith(start_of_word))
|
return (program + ' ' for program in self.fm.executables \ if program.startswith(self.line)) if position_of_last_space == len(self.line) - 1:
|
line = self.line start = '' else: line = self.line[i:] start = self.line[:i] try: position_of_last_space = line.rindex(" ") except ValueError: return (start + program + ' ' for program in self.fm.executables \ if program.startswith(line)) if position_of_last_space == len(line) - 1:
|
def _get_tab(self): try: position_of_last_space = self.line.rindex(" ") except ValueError: return (program + ' ' for program in self.fm.executables \ if program.startswith(self.line)) if position_of_last_space == len(self.line) - 1: return self.line + '%s ' else: before_word, start_of_word = self.line.rsplit(' ', 1) return (before_word + ' ' + file.basename \ for file in self.fm.env.pwd.files \ if file.basename.startswith(start_of_word))
|
map('<delete>', wdg.delete(1))
|
map('<delete>', wdg.delete(0))
|
def ctrl_c(arg): try: item = arg.fm.loader.queue[0] except: arg.fm.notify("Type Q or :quit<Enter> to exit Ranger") else: arg.fm.notify("Aborting: " + item.get_description()) arg.fm.loader.remove(index=0)
|
self.assertEqual(10, d.move(direction=3, pagesize=5, maximum=10))
|
self.assertEqual(9, d.move(direction=3, pagesize=5, maximum=10))
|
def test_move(self): d = Direction(pages=True) self.assertEqual(3, d.move(direction=3)) self.assertEqual(5, d.move(direction=3, current=2)) self.assertEqual(15, d.move(direction=3, pagesize=5)) self.assertEqual(10, d.move(direction=3, pagesize=5, maximum=10)) self.assertEqual(18, d.move(direction=9, override=2)) d2 = Direction(absolute=True) self.assertEqual(5, d2.move(direction=9, override=5))
|
self.either(c, 'mimeopen')
|
return self.either(c, 'mimeopen')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
'type': lambda path: path.mimetype,
|
'type': lambda path: path.mimetype or '',
|
def accept_file(fname, hidden_filter, name_filter): if hidden_filter: try: if hidden_filter.search(fname): return False except: if hidden_filter in fname: return False if name_filter and name_filter not in fname: return False return True
|
if pos == 0:
|
elif pos == 0:
|
def _get_right_part(self, bar): right = bar.right if self.column is None: return
|
def addstr(self, *args):
|
def _addxyz_wrapper(self, function, args):
|
def addstr(self, *args): try: self.win.addstr(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addstr(*(obj.encode('utf8') for obj in args)) except UnicodeEncodeError: try: self.win.addstr(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
self.win.addstr(*args)
|
function(*args)
|
def addstr(self, *args): try: self.win.addstr(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addstr(*(obj.encode('utf8') for obj in args)) except UnicodeEncodeError: try: self.win.addstr(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
try: self.win.addstr(*(obj.encode('utf8') for obj in args)) except UnicodeEncodeError: try: self.win.addstr(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
function(*(obj.encode('utf8') if hasattr(obj, 'encode') \ else obj for obj in args)) def addstr(self, *args): self._addxyz_wrapper(self.win.addstr, args)
|
def addstr(self, *args): try: self.win.addstr(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addstr(*(obj.encode('utf8') for obj in args)) except UnicodeEncodeError: try: self.win.addstr(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
try: self.win.addnstr(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addnstr(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
self._addxyz_wrapper(self.win.addnstr, args)
|
def addnstr(self, *args): try: self.win.addnstr(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addnstr(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
try: self.win.addch(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addch(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
self._addxyz_wrapper(self.win.addch, args)
|
def addch(self, *args): try: self.win.addch(*args) except (_curses.error, TypeError): pass except UnicodeEncodeError: try: self.win.addch(*(ascii_only(obj) for obj in args)) except (_curses.error, TypeError): pass
|
import socket, os
|
import socket, os, pwd
|
def _get_left_part(self, bar): import socket, os
|
username = os.getenv('USER')
|
try: username = pwd.getpwuid(os.geteuid()).pw_name except: username = "???"
|
def _get_left_part(self, bar): import socket, os
|
for key, val in special_keys.items():
|
for key, val in tuple(special_keys.items()):
|
def parse_keybinding(obj): """ Translate a keybinding to a sequence of integers Example: lol<CR> => (108, 111, 108, 10) """ assert isinstance(obj, (tuple, int, str)) if isinstance(obj, tuple): for char in obj: yield char elif isinstance(obj, int): yield obj elif isinstance(obj, str): in_brackets = False bracket_content = None for char in obj: if in_brackets: if char == '>': in_brackets = False string = ''.join(bracket_content).lower() try: keys = special_keys[string] for key in keys: yield key except KeyError: yield ord('<') for c in bracket_content: yield ord(c) yield ord('>') except TypeError: yield keys # it was no tuple, just an int else: bracket_content.append(char) else: if char == '<': in_brackets = True bracket_content = [] else: yield ord(char) if in_brackets: yield ord('<') for c in bracket_content: yield ord(c)
|
itemsize = int(float(wid - rightsize - fixedsize) / nonfixed_items) + 1
|
itemsize = int(float(wid - rightsize - fixedsize) / \ (nonfixed_items + 1)) + 1
|
def shrink_by_cutting(self, wid): fixedsize = self.fixedsize() if wid < fixedsize: raise ValueError("Cannot shrink down to that size by cutting")
|
try: value = eval(line.rest(2)) except: return self.fm.settings[name] = value
|
name, value, _ = line.parse_setting_line() if name and value: try: value = eval(value) except: pass self.fm.settings[name] = value
|
def execute(self): line = parse(self.line) name = line.chunk(1) try: value = eval(line.rest(2)) except: return self.fm.settings[name] = value
|
return self.fm.open_console(self.mode, delete.WARNING)
|
return self.fm.open_console(self.mode, DELETE_WARNING)
|
def execute(self): line = parse(self.line) lastword = line.chunk(-1)
|
if self.env.cf.path == path: self.ui.browser.pager.need_redraw = True
|
if self.env.cf.realpath == path:
|
def on_after(signal): exit = signal.process.poll() content = signal.loader.stdout_buffer data['foundpreview'] = True if exit == 0: data[(width, height)] = content elif exit == 3: data[(-1, height)] = content elif exit == 4: data[(width, -1)] = content elif exit == 5: data[(-1, -1)] = content elif exit == 1: data[(-1, -1)] = None data['foundpreview'] = False else: data[(-1, -1)] = None if self.env.cf.path == path: self.ui.browser.pager.need_redraw = True self.ui.browser.need_redraw = True data['loading'] = False
|
self.enter_dir('..') self.move(down=n) self.move(right=0)
|
parent = self.env.at_level(-1) self.env.enter_dir(parent.files[parent.pointer+n])
|
def move_parent(self, n): self.enter_dir('..') self.move(down=n) self.move(right=0)
|
self.env.enter_dir(parent.files[parent.pointer+n])
|
try: self.env.enter_dir(parent.files[parent.pointer+n]) except IndexError: pass
|
def move_parent(self, n): parent = self.env.at_level(-1) self.env.enter_dir(parent.files[parent.pointer+n])
|
if mod == -1 and len(self.line) == 0: self.close() pos = self.pos + mod chars = uchars(self.line) self.line = ''.join(chars[0:pos] + chars[pos+1:]) self.move(right=mod)
|
if mod == -1 and self.pos == 0: if not self.line: self.close() return uc = uchars(self.line) upos = len(uchars(self.line[:self.pos])) + mod left_part = ''.join(uc[:upos]) self.pos = len(left_part) self.line = left_part + ''.join(uc[upos+1:])
|
def delete(self, mod): self.tab_deque = None if mod == -1 and len(self.line) == 0: self.close() pos = self.pos + mod
|
map('zh', '<C-h>', fm.toggle_boolean_option('show_hidden'))
|
map('zh', '<C-h>', '<backspace>', fm.toggle_boolean_option('show_hidden'))
|
def move(arg): arg.wdg.move(narg=arg.n, **arg.direction)
|
if not ranger.arg.clean:
|
if ranger.arg.clean: for i in range(4): self.histories.append( History(self.settings.max_console_history_size)) else:
|
def __init__(self, win): Widget.__init__(self, win) self.clear() self.histories = [] # load histories from files if not ranger.arg.clean: self.historypaths = [relpath_conf(x) for x in \ ('history', 'history_search', 'history_qopen', 'history_open')] for i, path in enumerate(self.historypaths): hist = History(self.settings.max_console_history_size) self.histories.append(hist) if ranger.arg.clean: continue try: f = open(path, 'r') except: continue for line in f: hist.add(line[:-1]) f.close()
|
raise text
|
raise
|
def notify(self, text, duration=4, bad=False): if isinstance(text, Exception): if ranger.debug: raise text text = str(text) bad = True self.log.appendleft(text) if hasattr(self.ui, 'notify'): self.ui.notify(text, duration=duration, bad=bad)
|
print(args, keywords)
|
def foo(xyz, narg): return hash((xyz, narg))
|
|
except: pass else: setlocale(LC_ALL, '')
|
except: pass else: break else: setlocale(LC_ALL, '') else: setlocale(LC_ALL, '')
|
def main(): """initialize objects and run the filemanager""" try: import curses except ImportError as errormessage: print(errormessage) print('ranger requires the python curses module. Aborting.') sys.exit(1) from signal import signal, SIGINT from locale import getdefaultlocale, setlocale, LC_ALL import ranger from ranger.ext import curses_interrupt_handler from ranger.core.fm import FM from ranger.core.environment import Environment from ranger.shared.settings import SettingsAware from ranger.gui.defaultui import DefaultUI as UI from ranger.fsobject.file import File # Ensure that a utf8 locale is set. if getdefaultlocale()[1] not in ('utf8', 'UTF-8'): for locale in ('en_US.utf8', 'en_US.UTF-8'): try: setlocale(LC_ALL, locale) except: pass #sometimes there is none available though... else: setlocale(LC_ALL, '') arg = parse_arguments() ranger.arg = arg if not ranger.arg.debug: curses_interrupt_handler.install_interrupt_handler() SettingsAware._setup() # Initialize objects if arg.targets: target = arg.targets[0] if not os.access(target, os.F_OK): print("File or directory doesn't exist: %s" % target) sys.exit(1) elif os.path.isfile(target): thefile = File(target) FM().execute_file(thefile, mode=arg.mode, flags=arg.flags) sys.exit(0) else: path = target else: path = '.' Environment(path) try: my_ui = UI() my_fm = FM(ui=my_ui) my_fm.stderr_to_out = arg.cd_after_exit # Run the file manager my_fm.initialize() my_ui.initialize() my_fm.loop() finally: # Finish, clean up if 'my_ui' in vars(): my_ui.destroy() if arg.cd_after_exit: try: sys.__stderr__.write(my_fm.env.cwd.path) except: pass
|
hint = notify
|
def hint(self, text): self.ui.status.hint = text
|
def notify(self, text, duration=4, bad=False): if isinstance(text, Exception): if ranger.arg.debug: raise bad = True text = str(text) self.log.appendleft(text) if hasattr(self.ui, 'notify'): self.ui.notify(text, duration=duration, bad=bad)
|
self.fm.search(order='search')
|
self.fm.search_method = 'search'
|
def execute(self): if self.mode != cmode.COMMAND_QUICK: self._search()
|
container.remove(obj)
|
self.container.remove(obj)
|
def remove_child(self, obj): """Remove the object from the container.""" try: container.remove(obj) except ValueError: pass else: obj.parent = None
|
fm = FM()
|
def print_function(string): print(string)
|
|
FileManagerAware.fm = fm
|
def print_function(string): print(string)
|
|
self.addnstr(line, 0, string.ljust(maxlen), self.wid)
|
self.addstr(line, 0, whitespace) self.addnstr(line, 0, string, self.wid)
|
def generator(): return zip(range(self.hei-1), sorted_bookmarks)
|
return line + expanduser(rel_dest) + '/'
|
rel_dest = expanduser(rel_dest)
|
def _tab_only_directories(self): from os.path import dirname, basename, expanduser, join, isdir
|
return line + expanduser(rel_dest) + '/'
|
rel_dest = expanduser(rel_dest)
|
def _tab_directory_content(self): from os.path import dirname, basename, expanduser, join, isdir
|
self._set_dict(new_dict)
|
self._set_dict(new_dict, original=new_dict)
|
def load(self): """Load the bookmarks from path/bookmarks""" try: new_dict = self._load_dict() except OSError: return
|
self._set_dict(real_dict)
|
self._set_dict(real_dict, original=real_dict_copy)
|
def update(self): """Update the bookmarks from the bookmark file. Useful if two instances are running which define different bookmarks. """ try: real_dict = self._load_dict() except OSError: return
|
def _set_dict(self, dct):
|
def _set_dict(self, dct, original): if original is None: original = {}
|
def _set_dict(self, dct): self.dct.clear() self.dct.update(dct) self.original_dict = self.dct.copy() self._update_mtime()
|
self.original_dict = self.dct.copy()
|
self.original_dict = original
|
def _set_dict(self, dct): self.dct.clear() self.dct.update(dct) self.original_dict = self.dct.copy() self._update_mtime()
|
if len(lst) == 1:
|
if len(lst) == 1 or by_name[name] in lst:
|
def get_command(name, abbrev=True): if abbrev: lst = [cls for cmd, cls in by_name.items() \ if cmd.startswith(name) \ and cls.allow_abbrev \ or cmd == name] if len(lst) == 0: raise KeyError if len(lst) == 1: return lst[0] raise ValueError("Ambiguous command") else: try: return by_name[name] except KeyError: return None
|
return self.app_make(c)
|
return self.either(c, 'make')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
return self.app_editor(c)
|
return self.either(c, 'editor')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
return self.app_fceux(c)
|
return self.either(c, 'fceux')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
return self.app_zsnes(c)
|
return self.either(c, 'zsnes')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
return self.app_edit_or_run(c)
|
return self.either(c, 'edit_or_run')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
return self.app_aunpack(c)
|
return self.either(c, 'aunpack')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
return self.either(c, 'feh', 'eye_of_gnome', 'mirage')
|
return self.either(c, 'feh', 'eog', 'mirage')
|
def app_default(self, c): """How to determine the default application?""" f = c.file
|
if c.mode is 4: return self.app_gimp(c)
|
if c.mode is 4: return self.either(c, 'gimp')
|
def app_feh(self, c): arg = {1: '--bg-scale', 2: '--bg-tile', 3: '--bg-center'}
|
if os.access(self.path, os.F_OK):
|
if self.accessible and os.access(self.path, os.F_OK):
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """ import os import stat from ranger.ext.human_readable import human_readable
|
real_dst = dst
|
real_dst = os.path.join(dst, _basename(src))
|
def move(src, dst, overwrite=False): """Recursively move a file or directory to another location. This is similar to the Unix "mv" command. If the destination is a directory or a symlink to a directory, the source is moved inside the directory. The destination path must not already exist. If the destination already exists but is not a directory, it may be overwritten depending on os.rename() semantics. If the destination is on our current filesystem, then rename() is used. Otherwise, src is copied to the destination and then removed. A lot more could be done here... A look at a mv.c shows a lot of the issues this implementation glosses over. """ real_dst = dst if not overwrite: real_dst = get_safe_path(os.path.join(dst, _basename(src))) try: os.rename(src, real_dst) except OSError: if os.path.isdir(src): if _destinsrc(src, dst): raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst)) for _ in copytree(src, real_dst, symlinks=True, overwrite=overwrite): yield rmtree(src) else: for _ in copy2(src, real_dst, symlinks=True, overwrite=overwrite): yield os.unlink(src)
|
real_dst = get_safe_path(os.path.join(dst, _basename(src)))
|
real_dst = get_safe_path(real_dst)
|
def move(src, dst, overwrite=False): """Recursively move a file or directory to another location. This is similar to the Unix "mv" command. If the destination is a directory or a symlink to a directory, the source is moved inside the directory. The destination path must not already exist. If the destination already exists but is not a directory, it may be overwritten depending on os.rename() semantics. If the destination is on our current filesystem, then rename() is used. Otherwise, src is copied to the destination and then removed. A lot more could be done here... A look at a mv.c shows a lot of the issues this implementation glosses over. """ real_dst = dst if not overwrite: real_dst = get_safe_path(os.path.join(dst, _basename(src))) try: os.rename(src, real_dst) except OSError: if os.path.isdir(src): if _destinsrc(src, dst): raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst)) for _ in copytree(src, real_dst, symlinks=True, overwrite=overwrite): yield rmtree(src) else: for _ in copy2(src, real_dst, symlinks=True, overwrite=overwrite): yield os.unlink(src)
|
map('b', hint="bind_//h//idden //p//review_files //d//irectories_first " \
|
map('b', hint="show_//h//idden //p//review_files //d//irectories_first " \
|
def initialize_commands(map): """Initialize the commands for the main user interface""" # -------------------------------------------------------- movement _vimlike_aliases(map) map.alias(KEY_LEFT, KEY_BACKSPACE, DEL) map(KEY_DOWN, fm.move_pointer(relative=1)) map(KEY_UP, fm.move_pointer(relative=-1)) map(KEY_RIGHT, KEY_ENTER, ctrl('j'), fm.move_right()) map(KEY_LEFT, KEY_BACKSPACE, DEL, fm.move_left(1)) map(KEY_HOME, fm.move_pointer(absolute=0)) map(KEY_END, fm.move_pointer(absolute=-1)) map(KEY_HOME, fm.move_pointer(absolute=0)) map(KEY_END, fm.move_pointer(absolute=-1)) map('%', fm.move_pointer_by_percentage(absolute=50)) map(KEY_NPAGE, fm.move_pointer_by_pages(1)) map(KEY_PPAGE, fm.move_pointer_by_pages(-1)) map(ctrl('d'), fm.move_pointer_by_pages(0.5)) map(ctrl('u'), fm.move_pointer_by_pages(-0.5)) map(']', fm.traverse()) map('[', fm.history_go(-1)) # --------------------------------------------------------- history map('H', fm.history_go(-1)) map('L', fm.history_go(1)) # ----------------------------------------------- tagging / marking map('t', fm.tag_toggle()) map('T', fm.tag_remove()) map(' ', fm.mark(toggle=True)) map('v', fm.mark(all=True, toggle=True)) map('V', fm.mark(all=True, val=False)) # ------------------------------------------ file system operations map('yy', fm.copy()) map('dd', fm.cut()) map('pp', fm.paste()) map('po', fm.paste(overwrite=True)) map('pl', fm.paste_symlink()) map('p', hint='press //p// once again to confirm pasting' \ ', or //l// to create symlinks') # ---------------------------------------------------- run programs map('s', fm.execute_command(os.environ['SHELL'])) map('E', fm.edit_file()) map(',term', fm.execute_command('x-terminal-emulator', flags='d')) map('du', fm.execute_command('du --max-depth=1 -h | less')) # -------------------------------------------------- toggle options map('b', hint="bind_//h//idden //p//review_files //d//irectories_first " \ "//c//ollapse_preview flush//i//nput") map('bh', fm.toggle_boolean_option('show_hidden')) map('bp', fm.toggle_boolean_option('preview_files')) map('bP', fm.toggle_boolean_option('preview_directories')) map('bi', fm.toggle_boolean_option('flushinput')) map('bd', fm.toggle_boolean_option('directories_first')) map('bc', fm.toggle_boolean_option('collapse_preview')) # ------------------------------------------------------------ sort map('o', 'O', hint="//s//ize //b//ase//n//ame //m//time //t//ype //r//everse") sort_dict = { 's': 'size', 'b': 'basename', 'n': 'basename', 'm': 'mtime', 't': 'type', } for key, val in sort_dict.items(): for key, is_capital in ((key, False), (key.upper(), True)): # reverse if any of the two letters is capital map('o' + key, fm.sort(func=val, reverse=is_capital)) map('O' + key, fm.sort(func=val, reverse=True)) map('or', 'Or', 'oR', 'OR', lambda arg: \ arg.fm.sort(reverse=not arg.fm.settings.reverse)) # ----------------------------------------------- console shortcuts @map("A") def append_to_filename(arg): command = 'rename ' + arg.fm.env.cf.basename arg.fm.open_console(cmode.COMMAND, command) map('cw', fm.open_console(cmode.COMMAND, 'rename ')) map('cd', fm.open_console(cmode.COMMAND, 'cd ')) map('f', fm.open_console(cmode.COMMAND_QUICK, 'find ')) map('tf', fm.open_console(cmode.COMMAND, 'filter ')) map('d', hint='d//u// (disk usage) d//d// (cut)') # --------------------------------------------- jump to directories map('gh', fm.cd('~')) map('ge', fm.cd('/etc')) map('gu', fm.cd('/usr')) map('gd', fm.cd('/dev')) map('gl', fm.cd('/lib')) map('go', fm.cd('/opt')) map('gv', fm.cd('/var')) map('gr', 'g/', fm.cd('/')) map('gm', fm.cd('/media')) map('gn', fm.cd('/mnt')) map('gt', fm.cd('/tmp')) map('gs', fm.cd('/srv')) map('gR', fm.cd(RANGERDIR)) # ------------------------------------------------------- searching map('/', fm.open_console(cmode.SEARCH)) map('n', fm.search()) map('N', fm.search(forward=False)) map(TAB, fm.search(order='tag')) map('cc', fm.search(order='ctime')) map('cm', fm.search(order='mimetype')) map('cs', fm.search(order='size')) map('c', hint='//c//time //m//imetype //s//ize') # ------------------------------------------------------- bookmarks for key in ALLOWED_BOOKMARK_KEYS: map("`" + key, "'" + key, fm.enter_bookmark(key)) map("m" + key, fm.set_bookmark(key)) map("um" + key, fm.unset_bookmark(key)) map("`", "'", "m", draw_bookmarks=True) # ---------------------------------------------------- change views map('i', fm.display_file()) map(ctrl('p'), fm.display_log()) map('?', KEY_F1, fm.display_help()) map('w', lambda arg: arg.fm.ui.open_taskview()) # ------------------------------------------------ system functions _system_functions(map) map('ZZ', fm.exit()) map(ctrl('R'), fm.reset()) map('R', fm.reload_cwd()) map(ctrl('C'), fm.exit()) map(':', ';', fm.open_console(cmode.COMMAND)) map('>', fm.open_console(cmode.COMMAND_QUICK)) map('!', fm.open_console(cmode.OPEN)) map('r', fm.open_console(cmode.OPEN_QUICK)) map.rebuild_paths()
|
if self.is_link: self.realpath = realpath(self.path) self.readlink = os.readlink(self.path)
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """
|
|
overflow = -self.wid + len(self.prompt) + len(self.line) + 1
|
overflow = -self.wid + len(self.prompt) + uwid(self.line) + 1
|
def draw(self): if self.mode is None: return
|
and self.settings.preview_directories:
|
and (self.level <= 0 or self.settings.preview_directories):
|
def draw(self): """Call either _draw_file() or _draw_directory()""" if self.target != self.old_dir: self.need_redraw = True self.old_dir = self.target
|
bind('ge', fm.enter_dir('etc'))
|
bind('ge', fm.enter_dir('/etc'))
|
def initialize_commands(command_list): """Initialize the commands for the main user interface""" bind, hint, alias = make_abbreviations(command_list) # -------------------------------------------------------- movement _vimlike_aliases(command_list) command_list.alias(KEY_LEFT, KEY_BACKSPACE, DEL) bind(KEY_DOWN, fm.move_pointer(relative=1)) bind(KEY_UP, fm.move_pointer(relative=-1)) bind(KEY_RIGHT, fm.move_right()) bind(KEY_LEFT, KEY_BACKSPACE, DEL, fm.move_left(1)) bind(KEY_HOME, fm.move_pointer(absolute=0)) bind(KEY_END, fm.move_pointer(absolute=-1)) bind(KEY_HOME, fm.move_pointer(absolute=0)) bind(KEY_END, fm.move_pointer(absolute=-1)) bind(KEY_ENTER, ctrl('j'), fm.move_right(mode=1)) bind('%', fm.move_pointer_by_percentage(absolute=50)) bind(KEY_NPAGE, fm.move_pointer_by_pages(1)) bind(KEY_PPAGE, fm.move_pointer_by_pages(-1)) bind(ctrl('d'), fm.move_pointer_by_pages(0.5)) bind(ctrl('u'), fm.move_pointer_by_pages(-0.5)) # --------------------------------------------------------- history bind('H', fm.history_go(-1)) bind('L', fm.history_go(1)) # ----------------------------------------------- tagging / marking bind('b', fm.tag_toggle()) bind('B', fm.tag_remove()) bind(' ', fm.mark(toggle=True)) bind('v', fm.mark(all=True, toggle=True)) bind('V', fm.mark(all=True, val=False)) # ------------------------------------------ file system operations bind('yy', fm.copy()) bind('dd', fm.cut()) bind('pp', fm.paste()) bind('pl', fm.paste_symlink()) hint('p', 'press //p// once again to confirm pasting' \ ', or //l// to create symlinks') # ---------------------------------------------------- run programs bind('s', fm.execute_command(os.environ['SHELL'])) bind('E', fm.edit_file()) bind('term', fm.execute_command('x-terminal-emulator', flags='d')) bind('du', fm.execute_command('du --max-depth=1 -h | less')) # -------------------------------------------------- toggle options hint('t', "show_//h//idden //p//review_files //d//irectories_first " \ "//c//ollapse_preview") bind('th', fm.toggle_boolean_option('show_hidden')) bind('tp', fm.toggle_boolean_option('preview_files')) bind('td', fm.toggle_boolean_option('directories_first')) bind('tc', fm.toggle_boolean_option('collapse_preview')) # ------------------------------------------------------------ sort hint('o', 'O', "//s//ize //b//ase//n//ame //m//time //t//ype //r//everse") sort_dict = { 's': 'size', 'b': 'basename', 'n': 'basename', 'm': 'mtime', 't': 'type', } for key, val in sort_dict.items(): for key, is_capital in ((key, False), (key.upper(), True)): # reverse if any of the two letters is capital bind('o' + key, fm.sort(func=val, reverse=is_capital)) bind('O' + key, fm.sort(func=val, reverse=True)) bind('or', 'Or', 'oR', 'OR', lambda arg: \ arg.fm.sort(reverse=not arg.fm.settings.reverse)) # ----------------------------------------------- console shortcuts bind('A', lambda arg: arg.fm.open_console(cmode.COMMAND, 'rename ' + arg.fm.env.cf.basename)) bind('cw', fm.open_console(cmode.COMMAND, 'rename ')) bind('cd', fm.open_console(cmode.COMMAND, 'cd ')) bind('f', fm.open_console(cmode.COMMAND_QUICK, 'find ')) bind('tf', fm.open_console(cmode.COMMAND, 'filter ')) hint('d', 'd//u// (disk usage) d//d// (cut)') # --------------------------------------------- jump to directories bind('gh', fm.enter_dir('~')) bind('ge', fm.enter_dir('etc')) bind('gu', fm.enter_dir('/usr')) bind('gd', fm.enter_dir('/dev')) bind('gl', fm.enter_dir('/lib')) bind('go', fm.enter_dir('/opt')) bind('gv', fm.enter_dir('/var')) bind('gr', 'g/', fm.enter_dir('/')) bind('gm', fm.enter_dir('/media')) bind('gn', fm.enter_dir('/mnt')) bind('gt', fm.enter_dir('/tmp')) bind('gs', fm.enter_dir('/srv')) bind('gR', fm.enter_dir(RANGERDIR)) # ------------------------------------------------------- searching bind('/', fm.open_console(cmode.SEARCH)) bind('n', fm.search()) bind('N', fm.search(forward=False)) bind(TAB, fm.search(order='tag')) bind('cc', fm.search(order='ctime')) bind('cm', fm.search(order='mimetype')) bind('cs', fm.search(order='size')) hint('c', '//c//time //m//imetype //s//ize') # ------------------------------------------------------- bookmarks for key in ALLOWED_BOOKMARK_KEYS: bind("`" + key, "'" + key, fm.enter_bookmark(key)) bind("m" + key, fm.set_bookmark(key)) bind("um" + key, fm.unset_bookmark(key)) # ---------------------------------------------------- change views bind('i', fm.display_file()) bind(ctrl('p'), fm.display_log()) bind('?', KEY_F1, fm.display_help()) bind('w', lambda arg: arg.fm.ui.open_taskview()) # ------------------------------------------------ system functions _system_functions(command_list) bind('ZZ', fm.exit()) bind(ctrl('R'), fm.reset()) bind('R', fm.reload_cwd()) bind(ctrl('C'), fm.exit()) bind(':', ';', fm.open_console(cmode.COMMAND)) bind('>', fm.open_console(cmode.COMMAND_QUICK)) bind('!', fm.open_console(cmode.OPEN)) bind('r', fm.open_console(cmode.OPEN_QUICK)) command_list.rebuild_paths()
|
self.shell = isinstance(self.action, str)
|
if isinstance(self.action, str): self.shell = True self.action = shell_escape(self.action) else: self.shell = False
|
def get_action(self, apps=None): """Get the action from app_xyz""" if apps is None and self.fm: apps = self.fm.apps
|
kmc = KeyManager(buffer, ['foo', 'bar']) map = kmc.get_context('foo')
|
keymanager = KeyManager(buffer, ['foo', 'bar']) map = keymanager.get_context('foo')
|
def getdown(arg): return arg.direction.down()
|
map = kmc.get_context('bar')
|
map = keymanager.get_context('bar')
|
def getdown(arg): return arg.direction.down()
|
kmc.map('directions', 'j', dir=Direction(down=1)) kmc.use_context('foo')
|
keymanager.map('directions', 'j', dir=Direction(down=1)) keymanager.use_context('foo')
|
def getdown(arg): return arg.direction.down()
|
kmc.use_context('bar')
|
keymanager.use_context('bar')
|
def getdown(arg): return arg.direction.down()
|
kmc.use_context('foo') kmc.use_context('foo') kmc.use_context('foo') kmc.use_context('bar') kmc.use_context('foo') kmc.use_context('bar') kmc.use_context('bar') self.assertEqual(1, press('j'))
|
keymanager.use_context('foo') keymanager.use_context('foo') keymanager.use_context('foo') keymanager.use_context('bar') keymanager.use_context('foo') keymanager.use_context('bar') keymanager.use_context('bar') self.assertEqual(1, press('j')) def test_alias_to_direction(self): def func(arg): return arg.direction.down() km = KeyMap() directions = KeyMap() kb = KeyBuffer(km, directions) press = self._mkpress(kb) km.map('<dir>', func) directions.map('j', dir=Direction(down=42)) self.assertEqual(42, press('j')) km.map('o', alias='j') self.assertEqual(42, press('o')) def test_both_directory_and_any_key(self): def func(arg): return arg.direction.down() def func2(arg): return "yay" km = KeyMap() directions = KeyMap() kb = KeyBuffer(km, directions) press = self._mkpress(kb) km.map('abc<dir>', func) directions.map('j', dir=Direction(down=42)) self.assertEqual(42, press('abcj')) km.unmap('abc<dir>') km.map('abc<any>', func2) self.assertEqual("yay", press('abcd')) km.map('abc<dir>', func) km.map('abc<any>', func2) self.assertEqual("yay", press('abcd'))
|
def getdown(arg): return arg.direction.down()
|
if not cwd or not cwd.accessible or not cwd.content_loaded: return
|
def move(self, narg=None, **kw): """ A universal movement method.
|
|
elif 'right' in direction: mode = 0 if narg is not None: mode = narg cf = self.env.cf selection = self.env.get_selection() if not self.env.enter_dir(cf) and selection: if self.execute_file(selection, mode=mode) is False: self.open_console(cmode.OPEN_QUICK) elif direction.vertical(): newpos = direction.move( direction=direction.down(), override=narg, maximum=len(cwd), current=cwd.pointer, pagesize=self.ui.browser.hei) cwd.move(to=newpos)
|
if cwd and cwd.accessible and cwd.content_loaded: if 'right' in direction: mode = 0 if narg is not None: mode = narg cf = self.env.cf selection = self.env.get_selection() if not self.env.enter_dir(cf) and selection: if self.execute_file(selection, mode=mode) is False: self.open_console(cmode.OPEN_QUICK) elif direction.vertical(): newpos = direction.move( direction=direction.down(), override=narg, maximum=len(cwd), current=cwd.pointer, pagesize=self.ui.browser.hei) cwd.move(to=newpos)
|
def move(self, narg=None, **kw): """ A universal movement method.
|
if self.is_link and self.exists:
|
if self.is_link:
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """
|
box = [int(randint(0, hei) * 0.2), 0, int(randint(0, wid) * 0.2), 0] box[1] = randint(box[0], hei) box[1] = randint(box[0], hei)
|
box = [int(randint(0, hei) * 0.2), int(randint(0, wid) * 0.2)] box.append(randint(0, hei - box[0])) box.append(randint(0, wid - box[1]))
|
def test_boundaries(self): disp = self.disp hei, wid = self.env.termsize
|
return (x >= box[1] and x < box[1] + box[3]) and \ (y >= box[0] and y < box[0] + box[2])
|
return (y >= box[1] and y < box[1] + box[3]) and \ (x >= box[0] and x < box[0] + box[2])
|
def in_box(y, x): return (x >= box[1] and x < box[1] + box[3]) and \ (y >= box[0] and y < box[0] + box[2])
|
from ranger import log
|
if key == curses.KEY_RESIZE: self.keybuffer.clear()
|
def key_append(self, key): """Append a key to the keybuffer""" from ranger import log self.keybuffer.append(key)
|
file_lstat = os.lstat(name)
|
def load_bit_by_bit(self): """ Returns a generator which load a part of the directory in each iteration. """
|
|
alias('q!', 'quit!') alias('qall', 'quit!')
|
alias('q!', 'quitall') alias('qall', 'quitall')
|
def execute(self): num = self.line.split()[1] self.fm.tab_open(int(num))
|
class quit_now(Command):
|
class quitall(Command): """ :quitall Quits the program immediately. """ def execute(self): self.fm.exit() class quit_bang(quitall):
|
def execute(self): if len(self.fm.tabs) <= 1: self.fm.exit() self.fm.tab_close()
|
def execute(self): self.fm.exit()
|
allow_abbrev = False
|
def execute(self): if len(self.fm.tabs) <= 1: self.fm.exit() self.fm.tab_close()
|
return int(max(min(pos, maximum + offset), minimum))
|
return int(max(min(pos, maximum + offset - 1), minimum))
|
def move(self, direction, override=None, minimum=0, maximum=9999, current=0, pagesize=1, offset=0): """ Calculates the new position in a given boundary.
|
self._chunks = line.split()
|
self._chunks = self.line.split()
|
def chunk(self, n, otherwise=''): """Chunks are pieces of the command seperated by spaces""" if self._chunks is None: self._chunks = line.split()
|
return [int(c) if c.isdigit() else c or 0 \ for c in _extract_number_re.split(self.basename)]
|
return [c if i % 3 == 1 else (int(c) if c else 0) for i, c in \ enumerate(_extract_number_re.split(self.basename))]
|
def basename_natural(self): return [int(c) if c.isdigit() else c or 0 \ for c in _extract_number_re.split(self.basename)]
|
return [int(c) if c.isdigit() else c or 0 \ for c in _extract_number_re.split(self.basename_lower)]
|
return [c if i % 3 == 1 else (int(c) if c else 0) for i, c in \ enumerate(_extract_number_re.split(self.basename_lower))]
|
def basename_natural_lower(self): return [int(c) if c.isdigit() else c or 0 \ for c in _extract_number_re.split(self.basename_lower)]
|
return False else: allow = lambda name: True for key, val in vars().copy().items(): if key.startswith('bm_'): bms.extend(v for k,v in vars(val).items() if type(v) == type) for bmclass in bms: for attrname in vars(bmclass): if not attrname.startswith('bm_'): continue bmobj = bmclass() t1 = time() method = getattr(bmobj, attrname) methodname = "{0}.{1}".format(bmobj.__class__.__name__, method.__name__) if allow(methodname): try: method(n) except: print("{0} failed!".format(methodname)) raise else: t2 = time() print("{0:60}: {1:10}s".format(methodname, t2 - t1))
|
t2 = time.time() print("{0:60}: {1:10}s".format(full_method_name, t2 - t1))
|
def allow(name): for re in args: if re.search(name): return True else: return False
|
return tup('less', *c)
|
return tup('less', '-R', *c)
|
def app_pager(self, c): return tup('less', *c)
|
if os.path.exists(ranger.relpath_conf('colorschemes')): initpy = ranger.relpath_conf('colorschemes', '__init__.py') if not os.path.exists(initpy): open(initpy, 'a').close()
|
if usecustom: if os.path.exists(ranger.relpath_conf('colorschemes')): initpy = ranger.relpath_conf('colorschemes', '__init__.py') if not os.path.exists(initpy): open(initpy, 'a').close()
|
def is_scheme(x): return isclass(x) and issubclass(x, ColorScheme)
|
if exists(ranger.relpath_conf('colorschemes', scheme_name)):
|
if usecustom and \ exists(ranger.relpath_conf('colorschemes', scheme_name)):
|
def is_scheme(x): return isclass(x) and issubclass(x, ColorScheme)
|
is_link = (new_stat.st_mode & 0o120000) == 0o120000
|
is_link = new_stat.st_mode & 0o170000 == 0o120000
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """
|
self.exists = new_stat and True or False
|
self.exists = True if new_stat else False
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """
|
if new_stat: mode = new_stat.st_mode self.accessible = True self.is_device = (mode & 0o060000) == 0o060000 self.is_fifo = (mode & 0o010000) == 0o010000 self.is_link = is_link self.is_socket = (mode & 0o140000) == 0o140000 else: self.accessible = False if self.is_file:
|
self.accessible = True if new_stat else False mode = new_stat.st_mode if new_stat else 0 format = mode & 0o170000 if format == 0o020000 or format == 0o060000: self.is_device = True self.size = 0 self.infostring = 'dev' elif format == 0o010000: self.is_fifo = True self.size = 0 self.infostring = 'fifo' elif format == 0o140000: self.is_socket = True self.size = 0 self.infostring = 'sock' elif self.is_file:
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """
|
elif self.is_device: self.size = 0 self.infostring = 'dev' elif self.is_fifo: self.size = 0 self.infostring = 'fifo' elif self.is_socket: self.size = 0 self.infostring = 'sock' if self.is_link:
|
if is_link:
|
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """
|
if hasattr(self, files):
|
try:
|
def filepaths(self): if hasattr(self, files): return [f.path for f in self.files] return []
|
return []
|
except: return []
|
def filepaths(self): if hasattr(self, files): return [f.path for f in self.files] return []
|
return iter(self.filepaths)
|
for item in self.filepaths: yield item
|
def __iter__(self): """Iterate over file paths""" return iter(self.filepaths)
|
flags=flags, wait=wait, popen_kws=popen_kws)
|
flags=flags, wait=wait, popen_kws=popen_kws, file=files and files[0] or None)
|
def __call__(self, action=None, try_app_first=False, app='default', files=None, mode=0, flags='', wait=True, **popen_kws): """ Run the application in the way specified by the options.
|
direction = event.mouse_wheel_direction()
|
direction = event.mouse_wheel_direction() * n
|
def click(self, event): n = event.ctrl() and 5 or 1 direction = event.mouse_wheel_direction() if direction: self.main_column.scroll(direction) else: DisplayableContainer.click(self, event)
|
target = arg.target[0]
|
target = arg.targets[0]
|
def main(): """initialize objects and run the filemanager""" try: import curses except ImportError as errormessage: print(errormessage) print('ranger requires the python curses module. Aborting.') sys.exit(1) from signal import signal, SIGINT from locale import setlocale, LC_ALL import ranger from ranger.ext import curses_interrupt_handler from ranger.core.fm import FM from ranger.core.environment import Environment from ranger.shared.settings import SettingsAware from ranger.gui.defaultui import DefaultUI as UI from ranger.fsobject.file import File try: setlocale(LC_ALL, 'en_US.utf8') except: pass curses_interrupt_handler.install_interrupt_handler() arg = parse_arguments() ranger.arg = arg SettingsAware._setup() # Initialize objects if arg.targets: target = arg.target[0] if not os.access(target, os.F_OK): print("File or directory doesn't exist: %s" % target) sys.exit(1) elif os.path.isfile(target): thefile = File(target) FM().execute_file(thefile, mode=arg.mode, flags=arg.flags) sys.exit(0) else: path = target else: path = '.' Environment(path) try: my_ui = UI() my_fm = FM(ui=my_ui) my_fm.stderr_to_out = arg.cd_after_exit # Run the file manager my_fm.initialize() my_ui.initialize() my_fm.loop() finally: # Finish, clean up if 'my_ui' in vars(): my_ui.destroy() if arg.cd_after_exit: try: sys.__stderr__.write(my_fm.env.cwd.path) except: pass
|
self.signal_bind('setopt.'+name, self._raw_set_with_signal, priority=0.2)
|
def __setattr__(self, name, value): if name[0] == '_': self.__dict__[name] = value else: assert name in self._settings, "No such setting: {0}!".format(name) assert self._check_type(name, value) kws = dict(setting=name, value=value, previous=self._settings[name]) self.signal_bind('setopt.'+name, self._raw_set_with_signal, priority=0.2) self.signal_emit('setopt', **kws) self.signal_emit('setopt.'+name, **kws)
|
|
length = len(self.lines) - self.hei - 1
|
length = len(self.lines) - self.hei
|
def move(self, relative=0, absolute=None, pages=False): i = self.scroll_begin if isinstance(absolute, int): i = absolute
|
cut_off_last = self.preview and not self.preview_available \ and self.stretch_ratios if cut_off_last:
|
self.is_collapsed = self._collapse() if self.is_collapsed:
|
def resize(self, y, x, hei, wid): """Resize all the columns according to the given ratio""" DisplayableContainer.resize(self, y, x, hei, wid) borders = self.settings.draw_borders pad = 1 if borders else 0 left = pad
|
if not self.pointer_is_synced(): self.sync_index()
|
if self.old_lst != lst: self.old_lst = lst self.need_redraw = True
|
def draw(self): base_clr = deque() base_clr.append('in_taskview') lst = self.get_list()
|
if self.hei <= 0: return
|
if self.need_redraw: self.win.erase() if not self.pointer_is_synced(): self.sync_index()
|
def draw(self): base_clr = deque() base_clr.append('in_taskview') lst = self.get_list()
|
self.addstr(0, 0, "Task View") self.color_at(0, 0, self.wid, base_clr, 'title')
|
if self.hei <= 0: return
|
def draw(self): base_clr = deque() base_clr.append('in_taskview') lst = self.get_list()
|
if lst: for i in range(self.hei - 1): i += self.scroll_begin try: obj = lst[i] except IndexError: break
|
self.addstr(0, 0, "Task View") self.color_at(0, 0, self.wid, base_clr, 'title')
|
def draw(self): base_clr = deque() base_clr.append('in_taskview') lst = self.get_list()
|
y = i + 1 clr = deque(base_clr)
|
if lst: for i in range(self.hei - 1): i += self.scroll_begin try: obj = lst[i] except IndexError: break
|
def draw(self): base_clr = deque() base_clr.append('in_taskview') lst = self.get_list()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.