def execute(self):
		command = os.environ.get('TERMCMD', os.environ.get('TERM'))
		if command not in get_executables():
			command = 'x-terminal-emulator'
		if command not in get_executables():
			command = 'xterm'
		self.fm.run(command, flags='d')

 def execute(self):
     command = os.environ.get("TERMCMD", os.environ.get("TERM"))
     if command not in get_executables():
         command = "x-terminal-emulator"
     if command not in get_executables():
         command = "xterm"
     self.fm.run(command, flags="f")

    def _eval_condition2(  # pylint: disable=too-many-return-statements,too-many-branches
            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':
            if os.path.isfile(files[0]):
                partitions = os.path.basename(files[0]).rpartition('.')
                if not partitions[0]:
                    return False
                return bool(re.search('^(' + argument + ')$', partitions[2].lower()))
        elif function == 'name':
            return bool(re.search(argument, os.path.basename(files[0])))
        elif function == 'match':
            return bool(re.search(argument, files[0]))
        elif function == 'file':
            return os.path.isfile(files[0])
        elif function == 'directory':
            return os.path.isdir(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':
            if argument.startswith("$"):
                if argument[1:] in os.environ:
                    return os.environ[argument[1:]] in get_executables()
                return False
            else:
                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 sys.platform == 'darwin' or 'DISPLAY' in os.environ
        elif function == 'env':
            return bool(os.environ.get(argument))
        elif function == 'else':
            return True
        return None

 def execute(self):
     import os
     from ranger.ext.get_executables import get_executables
     command = os.environ.get('TERMCMD', os.environ.get('TERM'))
     if command not in get_executables():
         command = 'sakura'
     if command not in get_executables():
         command = 'sakura'
     self.fm.run(command, flags='f')

    def execute(self):
        import os
        from ranger.ext.get_executables import get_executables

        command = os.environ.get("TERMCMD", os.environ.get("TERM"))
        if command not in get_executables():
            command = "x-terminal-emulator"
        if command not in get_executables():
            # command = 'xterm'
            command = "urxvt"
        self.fm.run(command, flags="f")

    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].lower()
            return bool(re.search('^(' + argument + ')$', extension))
        elif function == 'name':
            return bool(re.search(argument, os.path.basename(files[0])))
        elif function == 'match':
            return bool(re.search(argument, files[0]))
        elif function == 'file':
            return os.path.isfile(files[0])
        elif function == 'directory':
            return os.path.isdir(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':
            if argument.startswith("$"):
                if argument[1:] in os.environ:
                    return os.environ[argument[1:]] in get_executables()
                return False
            else:
                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 == 'env':
            return bool(os.environ.get(argument))
        elif function == 'else':
            return True

    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].lower()
            return bool(re.search("^(" + argument + ")$", extension))
        elif function == "name":
            return bool(re.search(argument, os.path.basename(files[0])))
        elif function == "match":
            return bool(re.search(argument, files[0]))
        elif function == "file":
            return os.path.isfile(files[0])
        elif function == "directory":
            return os.path.isdir(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":
            if argument.startswith("$"):
                if argument[1:] in os.environ:
                    return os.environ[argument[1:]] in get_executables()
                return False
            else:
                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 execute(self):
        import subprocess
        from ranger.ext.get_executables import get_executables
        if not 'fd' in get_executables():
            self.fm.notify("Couldn't find fd on the PATH.", bad=True)
            return
        if self.arg(1):
            if self.arg(1)[:2] == '-d':
                depth = self.arg(1)
                target = self.rest(2)
            else:
                depth = '-d1'
                target = self.rest(1)
        else:
            self.fm.notify(":fd_search needs a query.", bad=True)
            return

        # For convenience, change which dict is used as result_sep to change
        # fd's behavior from splitting results by \0, which allows for newlines
        # in your filenames to splitting results by \n, which allows for \0 in
        # filenames.
        null_sep = {'arg': '-0', 'split': '\0'}
        nl_sep = {'arg': '', 'split': '\n'}
        result_sep = null_sep

        process = subprocess.Popen(['fd', result_sep['arg'], depth, target],
                universal_newlines=True, stdout=subprocess.PIPE)
        (search_results, _err) = process.communicate()
        global fd_deq
        fd_deq = deque((self.fm.thisdir.path + os.sep + rel for rel in
            sorted(search_results.split(result_sep['split']), key=str.lower)
            if rel != ''))
        if len(fd_deq) > 0:
            self.fm.select_file(fd_deq[0])

 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 either(self, context, *args):
		for app in args:
			try:
				application_handler = getattr(self, 'app_' + app)
			except AttributeError:
				if app in get_executables():
					return _generic_app(app, context)
				continue
			if self._meets_dependencies(application_handler):
				return application_handler(context)

 def _tab_through_executables(self):
     from ranger.ext.get_executables import get_executables
     programs = [program for program in get_executables() if \
             program.startswith(self.rest(1))]
     if not programs:
         return
     if len(programs) == 1:
         return self.start(1) + programs[0]
     programs.sort()
     return (self.start(1) + program for program in programs)

	def apply(self, app, context):
		if not app:
			app = 'default'
		try:
			handler = getattr(self, 'app_' + app)
		except AttributeError:
			if app in get_executables():
				return _generic_app(app, context)
			handler = self.app_default
		return handler(context)

	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 app_editor(self, c):
        try:
            default_editor = os.environ['EDITOR']
        except KeyError:
            pass
        else:
            parts = default_editor.split()
            exe_name = os.path.basename(parts[0])
            if exe_name in get_executables():
                return tuple(parts) + tuple(c)

        return self.either(c, 'vim', 'emacs', 'nano')

	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 -- "[email protected]"' % 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 _meets_dependencies(self, fnc):
		try:
			deps = fnc.dependencies
		except AttributeError:
			return True

		for dep in deps:
			if hasattr(dep, 'dependencies') \
			and not self._meets_dependencies(dep):
				return False
			if dep not in get_executables():
				return False

		return True

	def _meets_dependencies(self, fnc):
		try:
			deps = fnc.dependencies
		except AttributeError:
			return True

		for dep in deps:
			if dep == 'X':
				if 'DISPLAY' not in os.environ or not os.environ['DISPLAY']:
					return False
				continue
			if hasattr(dep, 'dependencies') \
			and not self._meets_dependencies(dep):
				return False
			if dep not in get_executables():
				return False

		return True

	def tab(self):
		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:
			return self.line + '%s '
		else:
			before_word, start_of_word = self.line.rsplit(' ', 1)
			return (before_word + ' ' + file.shell_escaped_basename \
					for file in self.fm.env.cwd.files \
					if file.shell_escaped_basename.startswith(start_of_word))

	def apply(self, app, context):
		if not app:
			app = 'default'
		try:
			handler = getattr(self, 'app_' + app)
		except AttributeError:
			if app in get_executables():
				return [app] + list(context)
			handler = self.app_default
		arguments = handler(context)
		# flatten
		if isinstance(arguments, str):
			return (arguments, )
		if arguments is None:
			return None
		result = []
		for obj in arguments:
			if isinstance(obj, (tuple, list, Context)):
				result.extend(obj)
			else:
				result.append(obj)
		return result

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

		function = rule[0]
		argument = rule[1] if len(rule) > 1 else ''
		if not files:
			return False

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