def _editor(self):
        ed = os.getenv("EDITOR")
        if ed is None:
            from rez.util import which

            ed = which("vi", "vim", "xdg-open")
        return ed

    def _terminal_emulator_command(self):
        term = which("x-terminal-emulator", "xterm")
        if term is None:
            return None

        term = os.path.basename(term)
        if term == "x-terminal-emulator":
            return "%s --noclose -e" % term
        else:
            return "%s -hold -e" % term

    def rez_bin_path(self):
        """Get path containing rez binaries, or None if no binaries are
        available, or Rez is not a production install.
        """
        binpath = None
        if sys.argv and sys.argv[0]:
            executable = sys.argv[0]
            path = which("rezolve", env={"PATH": os.path.dirname(executable), "PATHEXT": os.environ.get("PATHEXT", "")})
            binpath = os.path.dirname(path) if path else None

        # TODO: improve this, could still pick up non-production 'rezolve'
        if not binpath:
            path = which("rezolve")
            if path:
                binpath = os.path.dirname(path)

        if binpath:
            validation_file = os.path.join(binpath, ".rez_production_install")
            if os.path.exists(validation_file):
                return os.path.realpath(binpath)

        return None

    def test_rez_env_output(self):
        # here we are making sure that running a command via rez-env prints
        # exactly what we expect.
        echo_cmd = which("echo")
        if not echo_cmd:
            print "\nskipping test, 'echo' command not found."
            return

        cmd = [os.path.join(system.rez_bin_path, "rez-env"), "--", "echo", "hey"]
        process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        sh_out, _ = process.communicate()
        out = str(sh_out).strip()
        self.assertEqual(out, "hey")

    def test_rez_env_output(self):
        # TODO: this test does not run on Windows using the CMD shell as it
        # does not accept commands from stdin.  Rather than explicitly skipping
        # the test (via the decorator) perhaps we should check for startup
        # capabilities as the other tests do.
        from rez.vendor.sh import sh

        # here we are making sure that running a command via rez-env prints
        # exactly what we expect. We use 'sh' because subprocess strips special
        # characters such as color codes - we want to ensure that the output
        # EXACTLY matches the output of the command being run.
        echo_cmd = which("echo")
        if not echo_cmd:
            print "\nskipping test, 'echo' command not found."
            return

        cmd = sh.Command(os.path.join(system.rez_bin_path, "rez-env"))
        sh_out = cmd(["--", "echo", "hey"])
        out = str(sh_out).strip()
        self.assertEqual(out, "hey")

def find_exe(name, filepath=None):
    """Find an executable.

    Args:
        name: Name of the program, eg 'python'.
        filepath: Path to executable, a search is performed if None.

    Returns:
        Path to the executable if found, otherwise an error is raised.
    """
    if filepath:
        if not os.path.exists(filepath):
            open(filepath)  # raise IOError
        elif not os.path.isfile(filepath):
            raise RezBindError("not a file: %s" % filepath)
    else:
        filepath = which(name)
        if not filepath:
            raise RezBindError("could not find executable: %s" % name)

    return filepath

    def execute_command(self, cmd_name, cmd_arguments, user, errors, env=None):
        def _err(msg):
            errors.append(msg)
            if self.settings.print_error:
                print >> sys.stderr, msg

        kwargs = {}
        if env:
            kwargs["env"] = env

        def _execute(commands):
            process = Popen(commands, stdout=PIPE, stderr=STDOUT, **kwargs)
            stdout, _ = process.communicate()

            if process.returncode != 0:
                msg = "command failed:\n%s" % stdout
                _err(msg)
                return False
            if self.settings.print_output:
                print stdout.strip()
            return True

        if not os.path.isfile(cmd_name):
            cmd_full_path = which(cmd_name)
        else:
            cmd_full_path = cmd_name
        if not cmd_full_path:
            msg = "%s: command not found" % cmd_name
            _err(msg)
            return False

        cmds = [cmd_full_path] + (cmd_arguments or [])
        if user == 'root':
            cmds = ['sudo'] + cmds
            return _execute(cmds)
        elif user and user != getpass.getuser():
            raise NotImplementedError  # TODO
        else:
            return _execute(cmds)

 def _difftool(self):
     # although meld would be preferred, fc ships with all Windows versions back to DOS
     from rez.util import which
     return which("meld", "fc")

 def _image_viewer(self):
     from rez.util import which
     return which("xdg-open", "eog", "kview")

 def find_executable(cls, name):
     exe = which(name)
     if not exe:
         raise RuntimeError("Couldn't find executable '%s'." % name)
     return exe

 def find_executable(cls, name):
     exe = which(name)
     if not exe:
         raise ReleaseVCSError("Couldn't find executable '%s' for VCS '%s'"
                               % (name, cls.name()))
     return exe

 def _difftool(self):
     return which("kdiff3", "meld", "diff")

 def _editor(self):
     ed = os.getenv("EDITOR")
     if ed is None:
         ed = which("xdg-open", "vim", "vi")
     return ed

 def _image_viewer(self):
     return which("xdg-open", "eog", "kview")