Merge pull request #524 from nerdvegas/windows_fixes

Windows fixes

Author: nerdvegas

src/rez/shells.py

@@ -2,14 +2,16 @@
 Pluggable API for creating subshells using different programs, such as bash.
 """
 from rez.rex import RexExecutor, ActionInterpreter, OutputStyle
-from rez.util import which, shlex_join
+from rez.util import shlex_join
+from rez.backport.shutilwhich import which
 from rez.utils.logging_ import print_warning
 from rez.utils.system import popen
 from rez.system import system
 from rez.exceptions import RezSystemError
 from rez.rex import EscapedString
 from rez.config import config
 import subprocess
+import os
 import os.path
 import pipes
 
@@ -58,14 +60,6 @@ def startup_capabilities(cls, rcfile=False, norc=False, stdin=False,
         """
         raise NotImplementedError
 
-    #@cached_class_property
-    #def executable(cls):
-    #    name = cls.name()
-    #    exe = which(name)
-    #    if not exe:
-    #        raise RuntimeError("Couldn't find executable '%s'." % name)
-    #    return exe
-
     @classmethod
     def get_syspaths(cls):
         raise NotImplementedError
@@ -107,8 +101,25 @@ def _overruled_option(cls, option, overruling_option, val):
                           % (option, cls.name(), overruling_option))
 
     @classmethod
-    def find_executable(cls, name):
+    def find_executable(cls, name, check_syspaths=False):
+        """Find an executable.
+
+        Args:
+            name (str): Program name.
+            check_syspaths (bool): If True, check the standard system paths as
+                well, if program was not found on current $PATH.
+
+        Returns:
+            str: Full filepath of executable.
+        """
         exe = which(name)
+
+        if not exe and check_syspaths:
+            paths = cls.get_syspaths()
+            env = os.environ.copy()
+            env["PATH"] = os.pathsep.join(paths)
+            exe = which(name, env=env)
+
         if not exe:
             raise RuntimeError("Couldn't find executable '%s'." % name)
         return exe

src/rez/tests/test_shells.py

@@ -197,7 +197,11 @@ def _rex_assigning():
 
             def _print(value):
                 env.FOO = value
-                info("%FOO%" if windows else "${FOO}")
+                # Wrap the output in quotes to prevent the shell from
+                # interpreting parts of our output as commands. This can happen
+                # when we include special characters (&, <, >, ^) in a
+                # variable.
+                info('"%FOO%"' if windows else '"${FOO}"')
 
             env.GREET = "hi"
             env.WHO = "Gary"
@@ -226,6 +230,12 @@ def _print(value):
             _print(literal("${WHO}"))
             _print(literal("${WHO}").e(" %WHO%" if windows else " $WHO"))
 
+            # Make sure we are escaping &, <, >, ^ properly.
+            _print('hey & world')
+            _print('hey > world')
+            _print('hey < world')
+            _print('hey ^ world')
+
         expected_output = [
             "ello",
             "ello",
@@ -249,9 +259,18 @@ def _print(value):
             "hi Gary",
             "hi $WHO",
             "${WHO}",
-            "${WHO} Gary"
+            "${WHO} Gary",
+            "hey & world",
+            "hey > world",
+            "hey < world",
+            "hey ^ world"
         ]
 
+        # We are wrapping all variable outputs in quotes in order to make sure
+        # our shell isn't interpreting our output as instructions when echoing
+        # it but this means we need to wrap our expected output as well.
+        expected_output = ['"{}"'.format(o) for o in expected_output]
+
         _execute_code(_rex_assigning, expected_output)
 
         def _rex_appending():
@@ -273,6 +292,40 @@ def _rex_appending():
 
         _execute_code(_rex_appending, expected_output)
 
+    @shell_dependent()
+    def test_rex_code_alias(self):
+        """Ensure PATH changes do not influence the alias command.
+
+        This is important for Windows because the doskey.exe might not be on
+        the PATH anymore at the time it's executed. That's why we figure out
+        the absolute path to doskey.exe before we modify PATH and continue to
+        use the absolute path after the modifications.
+
+        """
+        def _execute_code(func):
+            loc = inspect.getsourcelines(func)[0][1:]
+            code = textwrap.dedent('\n'.join(loc))
+            r = self._create_context([])
+            p = r.execute_rex_code(code, stdout=subprocess.PIPE)
+
+            out, _ = p.communicate()
+            self.assertEqual(p.returncode, 0)
+
+        def _alias_after_path_manipulation():
+            # Appending something to the PATH and creating an alias afterwards
+            # did fail before we implemented a doskey specific fix.
+            env.PATH.append("hey")
+            alias('alias_test', '"echo test_echo"')
+
+            # We can not run the command from a batch file because the Windows
+            # doskey doesn't support it. From the docs:
+            # "You cannot run a doskey macro from a batch program."
+            # command('alias_test')
+
+        # We don't expect any output, the shell should just return with exit
+        # code 0.
+        _execute_code(_alias_after_path_manipulation)
+
 
 if __name__ == '__main__':
     unittest.main()

src/rez/utils/_version.py

@@ -1,7 +1,7 @@
 
 
 # Update this value to version up Rez. Do not place anything else in this file.
-_rez_version = "2.20.0"
+_rez_version = "2.20.1"
 
 try:
     from rez.vendor.version.version import Version

src/rezplugins/shell/cmd.py

@@ -2,12 +2,13 @@
 Windows Command Prompt (DOS) shell.
 """
 from rez.config import config
-from rez.rex import RexExecutor, literal, OutputStyle
+from rez.rex import RexExecutor, literal, OutputStyle, EscapedString
 from rez.shells import Shell
 from rez.system import system
 from rez.utils.system import popen
 from rez.utils.platform_ import platform_
 from rez.util import shlex_join
+from functools import partial
 import os
 import re
 import subprocess
@@ -19,6 +20,12 @@ class CMD(Shell):
     # http://ss64.com/nt/cmd.html
     syspaths = None
     _executable = None
+    _doskey = None
+
+    # Regex to aid with escaping of Windows-specific special chars:
+    # http://ss64.com/nt/syntax-esc.html
+    _escape_re = re.compile(r'(?<!\^)[&<>]|(?<!\^)\^(?![&<>\^])')
+    _escaper = partial(_escape_re.sub, lambda m: '^' + m.group(0))
 
     @property
     def executable(cls):
@@ -182,8 +189,20 @@ def _create_ex():
             _record_shell(executor, files=startup_sequence["files"], print_msg=(not quiet))
 
         if shell_command:
+            # Launch the provided command in the configured shell and wait
+            # until it exits.
             executor.command(shell_command)
-            executor.command('exit %errorlevel%')
+
+        # Test for None specifically because resolved_context.execute_rex_code
+        # passes '' and we do NOT want to keep a shell open during a rex code
+        # exec operation.
+        elif shell_command is None: 
+            # Launch the configured shell itself and wait for user interaction
+            # to exit.
+            executor.command('cmd /Q /K')
+            
+        # Exit the configured shell.
+        executor.command('exit %errorlevel%')
 
         code = executor.get_output()
         target_file = os.path.join(tmpdir, "rez-shell.%s"
@@ -226,7 +245,18 @@ def get_output(self, style=OutputStyle.file):
         return script
 
     def escape_string(self, value):
-        return value
+        """Escape the <, >, ^, and & special characters reserved by Windows.
+
+        Args:
+            value (str/EscapedString): String or already escaped string.
+
+        Returns:
+            str: The value escaped for Windows.
+
+        """
+        if isinstance(value, EscapedString):
+            return value.formatted(self._escaper)
+        return self._escaper(value)
 
     def _saferefenv(self, key):
         pass
@@ -245,7 +275,16 @@ def resetenv(self, key, value, friends=None):
         self._addline(self.setenv(key, value))
 
     def alias(self, key, value):
-        self._addline("doskey %s=%s" % (key, value))
+        # find doskey, falling back to system paths if not in $PATH. Fall back
+        # to unqualified 'doskey' if all else fails
+        if self._doskey is None:
+            try:
+                self.__class__._doskey = \
+                    self.find_executable("doskey", check_syspaths=True)
+            except:
+                self._doskey = "doskey"
+
+        self._addline("%s %s=%s" % (self._doskey, key, value))
 
     def comment(self, value):
         for line in value.split('\n'):