Arch Linux

Last edited by loop (2012-04-02 06:01:38)

/bin/sh:  1: Syntax error: Bad fd number
/bin/sh:  1: Syntax error: Bad fd number
raise Exception(command)
raise Exception(command)
ranger version: 1.5.3, executed with python 2.7.2+
Locale: en_US.UTF-8
Current file: /tmp/tmp.7E7ABvYw4K/test.jpg
Traceback (most recent call last):
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/core/main.py", line 135, in main
    fm.loop()
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/core/fm.py", line 194, in loop
    ui.handle_input()
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/gui/ui.py", line 206, in handle_input
    self.handle_key(key)
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/gui/ui.py", line 142, in handle_key
    self.press(key)
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/gui/ui.py", line 157, in press
    quantifier=keybuffer.quantifier)
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/core/actions.py", line 148, in execute_console
    cmd_class(string, quantifier=quantifier).execute()
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/api/commands.py", line 306, in execute
    return self._based_function(*args, **keywords)
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/core/actions.py", line 349, in move
    if self.execute_file(selection, mode=mode) is False:
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/core/actions.py", line 305, in execute_file
    return self.rifle.execute(filenames, mode, label, flags, mimetype)
  File "/tmp/tmp.7E7ABvYw4K/ranger-master/ranger/ext/rifle.py", line 264, in execute
    raise Exception(command)
Exception: set -- '/tmp/tmp.7E7ABvYw4K/test.jpg'
setsid sxiv -- "$@" >& /dev/null &
chain shell mv Makefile ..; cd ..; shell make
chain shell mv Makefile ..; cd ..; shell make
readlink /bin/sh
dash

chsh
        Login Shell [/usr/bin/zsh]:
#!/bin/sh
target="$(realpath -s "$1")"
[ "$1" == '--' ] && shift
function listfiles {
  find "$(dirname "$target")" -maxdepth 1 -type f -regex '.*\(jpe?g\|png\|gif\)$' -print0 | sort -z
}
count="$(listfiles | grep -m 1 -Zznx "$target" | cut -d: -f1)"

if [ -n "$count" ]; then
  listfiles | xargs -0 sxiv -n "$count" --
else
  sxiv -- "$@" # fallback
fi
ext jpe?g|png|gif, flag f, X = <scriptname> "$@"
map <somekey> console shell command <MAGIC>
map <somekey> shell command
map('<DELETE>', fm.open_console('delete seriously? '))
ext py  = python -- %s
ext pl  = perl -- %s
0 | python -- %s
1 | "$PAGER" -- %s
ext py  = python -- "$@"
ext pl  = perl -- "$@"
context [ext py] r shell python -- %s
context [ext pl] r shell perl -- %s
context [ext rar] r markFiles %s
context [ext rar] R <secondary shortcut key options>
context [ext py] python -- %s
context [ext pl] perl -- %s
context [ext rar, noshell] markFiles %s
context [ext rar, key R, noshell] <secondary shortcut key options>
context ext py = python -- %s
context ext pl = perl -- %s
context ext rar, noshell = markFiles %s
context ext rar, key R, noshell= <secondary shortcut key options>
$ time python3 ranger/ext/rifle.py &> /dev/null

real	0m0.492s
user	0m0.393s
sys	0m0.010s
$ time python3 ranger/ext/rifle.py &> /dev/null

real	0m0.492s
user	0m0.393s
sys	0m0.010s
python    'rifle.py' -l 'rifle.py'  0.16s user 0.01s system 98% cpu 0.170 total
python -S 'rifle.py' -l 'rifle.py'  0.09s user 0.02s system 72% cpu 0.153 total
#!/usr/bin/python
# Copyright (C) 2012  Roman Zimbelmann <romanz@lavabit.com>
# This software is distributed under the terms of the GNU GPL version 3.

"""
rifle, the file executor/opener of ranger

This can be used as a standalone program or can be embedded in python code.
When used together with ranger, it doesn't have to be installed to $PATH.

You can use this program without installing ranger by inlining the imported
ranger functions. (shell_quote, spawn, ...)

Example usage:

	rifle = Rifle("rifle.conf")
	rifle.reload_config()
	rifle.execute(["file1", "file2"])
"""

import os, re, sys
from subprocess import Popen
from mimetypes import guess_type

_cached_executables = None

def get_executables():
	"""
	Return all executable files in each of the given directories.

	Looks in $PATH by default.
	"""
	global _cached_executables
	if _cached_executables is None:
		_cached_executables = get_executables_uncached()
	return _cached_executables

def get_executables_uncached(*paths):
	"""
	Return all executable files in each of the given directories.

	Looks in $PATH by default.
	"""
	if not paths:
		try:
			pathstring = os.environ['PATH']
		except KeyError:
			return ()
		paths = set(pathstring.split(':'))

	executables = set()
	for path in paths:
		try:
			content = os.listdir(path)
		except:
			continue
		for item in content:
			abspath = path + '/' + item
			try:
				filestat = os.stat(abspath)
			except:
				continue
			if filestat.st_mode & (os.stat.S_IXOTH | os.stat.S_IFREG):
				executables.add(item)
	return executables

DEFAULT_PAGER = 'less'
DEFAULT_EDITOR = 'nano'

def _is_terminal():
	# Check if stdin (file descriptor 0), stdout (fd 1) and
	# stderr (fd 2) are connected to a terminal
	try:
		os.ttyname(0)
		os.ttyname(1)
		os.ttyname(2)
	except:
		return False
	return True

def squash_flags(flags):
	"""
	Remove lowercase flags if the respective uppercase flag exists

	>>> squash_flags('abc')
	'abc'
	>>> squash_flags('abcC')
	'ab'
	>>> squash_flags('CabcAd')
	'bd'
	"""
	exclude = ''.join(f.upper() + f.lower() for f in flags if f == f.upper())
	return ''.join(f for f in flags if f not in exclude)

class Rifle(object):
	delimiter1 = '='
	delimiter2 = ','

	def hook_before_executing(self, command, mimetype, flags):
		pass

	def hook_after_executing(self, command, mimetype, flags):
		pass

	def hook_command_preprocessing(self, command):
		return command

	def hook_command_postprocessing(self, command):
		return command

	def hook_environment(self, env):
		return env

	def hook_logger(self, string):
		sys.stderr.write(string + "\n")

	def __init__(self, config_file):
		self.config_file = config_file
		self._app_flags = ''
		self._app_label = None

	def reload_config(self, config_file=None):
		"""Replace the current configuration with the one in config_file"""
		if config_file is None:
			config_file = self.config_file
		f = open(config_file, 'r')
		self.rules = []
		lineno = 1
		for line in f:
			if line.startswith('#') or line == '\n':
				continue
			line = line.strip()
			try:
				if self.delimiter1 not in line:
					raise Exception("Line without delimiter")
				tests, command = line.split(self.delimiter1, 1)
				tests = tests.split(self.delimiter2)
				tests = tuple(tuple(f.strip().split(None, 1)) for f in tests)
				tests = tuple(tests)
				command = command.strip()
				self.rules.append((command, tests))
			except Exception as e:
				self.hook_logger("Syntax error in %s line %d (%s)" % \
					(config_file, lineno, str(e)))
			lineno += 1
		f.close()

	def _eval_condition(self, condition, files, label):
		# Handle the negation of conditions starting with an exclamation mark,
		# then pass on the arguments to _eval_condition2().

		if not condition:
			return True
		if condition[0].startswith('!'):
			new_condition = tuple([condition[0][1:]]) + tuple(condition[1:])
			return not self._eval_condition2(new_condition, files, label)
		return self._eval_condition2(condition, files, label)

	def _eval_condition2(self, rule, files, label):
		# This function evaluates the condition, after _eval_condition() handled
		# negation of conditions starting with a "!".

		if not files: return False

		function = rule[0]
		argument = rule[1] if len(rule) > 1 else ''

		if   function == 'ext':
			extension = os.path.basename(files[0]).rsplit('.', 1)[-1]
			return bool(re.search('^' + argument + '$', extension))
		elif function == 'name':
			return bool(re.search(argument, os.path.basename(files[0])))
		elif function == 'path':
			return bool(re.search(argument, os.path.abspath(files[0])))
		elif function == 'mime':
			return bool(re.search(argument, self._get_mimetype(files[0])))
		elif function == 'has':
			return argument in get_executables()
		elif function == 'terminal':
			return _is_terminal()
		elif function == 'number':
			if argument.isdigit():
				self._skip = int(argument)
			return True
		elif function == 'label':
			self._app_label = argument
			if label:
				return argument == label
			return True
		elif function == 'flag':
			self._app_flags = argument
			return True
		elif function == 'X':
			return 'DISPLAY' in os.environ
		elif function == 'else':
			return True

	def _get_mimetype(self, fname):
		# Spawn "file" to determine the mime-type of the given file.
		if self._mimetype:
			return self._mimetype
		mimetype = guess_type(fname)[0]
		self._mimetype = mimetype
		return mimetype

	def _build_command(self, files, action, flags):
		# Get the flags
		if isinstance(flags, str):
			self._app_flags += flags
		self._app_flags = squash_flags(self._app_flags)
		flags = self._app_flags

		_filenames = "' '".join(f.replace("'", "'\\\''") for f in files
				if "\x00" not in f)
		command = "set -- '%s'" % _filenames + '\n'

		# Apply flags
		command += self._apply_flags(action, flags)
		return command

	def _apply_flags(self, action, flags):
		# FIXME: Flags do not work properly when pipes are in the command.
		if 'r' in flags:
			action = 'sudo ' + action
		if 't' in flags:
			if 'TERMCMD' not in os.environ:
				term = os.environ['TERM']
				if term.startswith('rxvt-unicode'):
					term = 'urxvt'
				if term not in get_executables():
					self.hook_logger("Can not determine terminal command.  "
						"Please set $TERMCMD manually.")
				os.environ['TERMCMD'] = term
			action = "$TERMCMD -e %s" % action
		if 'f' in flags:
			if 'setsid' in get_executables():
				action = "setsid %s > /dev/null 2> /dev/null &" % action
			else:
				action = "nohup %s > /dev/null 2> /dev/null &" % action
		return action

	def list_commands(self, files, mimetype=None):
		"""
		Returns one 4-tuple for all currently applicable commands
		The 4-tuple contains (count, command, label, flags).
		count is the index, counted from 0 upwards,
		command is the command that will be executed.
		label and flags are the label and flags specified in the rule.
		"""
		self._mimetype = mimetype
		count = -1
		for cmd, tests in self.rules:
			self._skip = None
			self._app_flags = ''
			self._app_label = None
			for test in tests:
				if not self._eval_condition(test, files, None):
					break
			else:
				if self._skip is None:
					count += 1
				else:
					count = self._skip
				yield (count, cmd, self._app_label, self._app_flags)

	def execute(self, files, number=0, label=None, flags=None, mimetype=None):
		"""
		Executes the given list of files.

		By default, this executes the first command where all conditions apply,
		but by specifying number=N you can run the 1+Nth command.

		If a label is specified, only rules with this label will be considered.

		If you specify the mimetype, rifle will not try to determine it itself.

		By specifying a flag, you extend the flag that is defined in the rule.
		Uppercase flags negate the respective lowercase flags.
		For example: if the flag in the rule is "pw" and you specify "Pf", then
		the "p" flag is negated and the "f" flag is added, resulting in "wf".
		"""
		command = None
		found_at_least_one = None

		# Determine command
		for count, cmd, lbl, flags in self.list_commands(files, mimetype):
			if label and label == lbl or not label and count == number:
				cmd = self.hook_command_preprocessing(cmd)
				command = self._build_command(files, cmd, flags)
				break
			else:
				found_at_least_one = True
		else:
			if label and label in get_executables():
				cmd = '%s -- "$@"' % label
				command = self._build_command(files, cmd, flags)

		# Execute command
		if command is None:
			if found_at_least_one:
				if label:
					self.hook_logger("Label '%s' is undefined" % label)
				else:
					self.hook_logger("Method number %d is undefined." % number)
			else:
				self.hook_logger("No action found.")
		else:
			if 'PAGER' not in os.environ:
				os.environ['PAGER'] = DEFAULT_PAGER
			if 'EDITOR' not in os.environ:
				os.environ['EDITOR'] = DEFAULT_EDITOR
			command = self.hook_command_postprocessing(command)
			self.hook_before_executing(command, self._mimetype, self._app_flags)
			try:
				p = Popen(command, env=self.hook_environment(os.environ), shell=True)
				p.wait()
			finally:
				self.hook_after_executing(command, self._mimetype, self._app_flags)

def main():
	"""The main function which is run when you start this program direectly."""
	import sys

	# Find configuration file path
	if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
		conf_path = os.environ['XDG_CONFIG_HOME'] + '/ranger/rifle.conf'
	else:
		conf_path = os.path.expanduser('~/.config/ranger/rifle.conf')
	if not os.path.isfile(conf_path):
		conf_path = os.path.normpath(os.path.join(os.path.dirname(__file__),
			'../defaults/rifle.conf'))

	# Evaluate arguments
	from optparse import OptionParser
	parser = OptionParser(usage="%prog [-fhlpw] [files]")
	parser.add_option('-f', type="string", default=None, metavar="FLAGS",
			help="use additional flags: f=fork, r=root, t=terminal. "
			"Uppercase flag negates respective lowercase flags.")
	parser.add_option('-l', action="store_true",
			help="list possible ways to open the files (id:label:flags:command)")
	parser.add_option('-p', type='string', default='0', metavar="KEYWORD",
			help="pick a method to open the files.  KEYWORD is either the "
			"number listed by 'rifle -l' or a string that matches a label in "
			"the configuration file")
	parser.add_option('-w', type='string', default=None, metavar="PROGRAM",
			help="open the files with PROGRAM")
	options, positional = parser.parse_args()
	if not positional:
		parser.print_help()
		raise SystemExit(1)

	if options.p.isdigit():
		number = int(options.p)
		label = None
	else:
		number = 0
		label = options.p

	if options.w is not None and not options.l:
		p = Popen([options.w] + list(positional))
		p.wait()
	else:
		# Start up rifle
		rifle = Rifle(conf_path)
		rifle.reload_config()
		#print(rifle.list_commands(sys.argv[1:]))
		if options.l:
			for count, cmd, label, flags in rifle.list_commands(positional):
				print("%d:%s:%s:%s" % (count, label or '', flags, cmd))
		else:
			rifle.execute(positional, number=number, label=label, flags=options.f)

if __name__ == '__main__':
	main()
tests = tuple(tuple(f.strip().split(None, 1)) for f in tests)
tests = tuple(tests)

Arch Linux

#1276 2012-04-01 20:38:02

Re: Ranger, a textbased filemanager

#1277 2012-04-02 06:00:44

Re: Ranger, a textbased filemanager

#1278 2012-04-02 11:28:03

Re: Ranger, a textbased filemanager

#1279 2012-04-02 12:48:58

Re: Ranger, a textbased filemanager

#1280 2012-04-02 12:52:58

Re: Ranger, a textbased filemanager

#1281 2012-04-02 15:06:34

Re: Ranger, a textbased filemanager

#1282 2012-04-02 15:12:57

Re: Ranger, a textbased filemanager

#1283 2012-04-02 15:32:43

Re: Ranger, a textbased filemanager

#1284 2012-04-02 15:48:03

Re: Ranger, a textbased filemanager

#1285 2012-04-02 15:55:31

Re: Ranger, a textbased filemanager

#1286 2012-04-02 18:08:23

Re: Ranger, a textbased filemanager

#1287 2012-04-02 20:01:16

Re: Ranger, a textbased filemanager

#1288 2012-04-03 05:34:48

Re: Ranger, a textbased filemanager

#1289 2012-04-03 18:48:25

Re: Ranger, a textbased filemanager

#1290 2012-04-03 22:05:31

Re: Ranger, a textbased filemanager

#1291 2012-04-05 15:33:59

Re: Ranger, a textbased filemanager

#1292 2012-04-06 11:49:07

Re: Ranger, a textbased filemanager

#1293 2012-04-06 18:30:04

Re: Ranger, a textbased filemanager

#1294 2012-04-06 19:39:12

Re: Ranger, a textbased filemanager

#1295 2012-04-10 21:04:15

Re: Ranger, a textbased filemanager

#1296 2012-04-10 21:46:23

Re: Ranger, a textbased filemanager

#1297 2012-04-11 10:51:42

Re: Ranger, a textbased filemanager

#1298 2012-04-11 11:58:42

Re: Ranger, a textbased filemanager

#1299 2012-04-11 15:44:33

Re: Ranger, a textbased filemanager

#1300 2012-04-12 17:21:58

Re: Ranger, a textbased filemanager

Board footer