Windows Gitbash Support Fixes #1302

src/rez/bind/python.py

@@ -10,7 +10,7 @@
     make_dirs, log, run_python_command
 from rez.package_maker import make_package
 from rez.system import system
-from rez.utils.lint_helper import env
+from rez.utils.lint_helper import env, this
 from rez.utils.platform_ import platform_
 import shutil
 import os.path
@@ -71,7 +71,12 @@ def bind(path, version_range=None, opts=None, parser=None):
     def make_root(variant, root):
         binpath = make_dirs(root, "bin")
         link = os.path.join(binpath, "python")
-        platform_.symlink(exepath, link)
+        # Symlinks to python2 on windows break python, so we copy the exe
+        if platform_.name == "windows" and str(version.major) == "2":
+            link += ".exe"
+            shutil.copy(exepath, link)
+        else:
+            platform_.symlink(exepath, link)
 
         if builtin_paths:
             pypath = make_dirs(root, "python")

src/rez/cli/selftest.py

@@ -36,7 +36,7 @@ def setup_parser(parser, completions=False):
     parser.add_argument(
         "-s", "--only-shell", metavar="SHELL",
         help="limit shell-dependent tests to the specified shell. Note: This "
-             "flag shadowed pytest '–capture=no' shorthand '-s', so the long "
+             "flag shadowed pytest '-capture=no' shorthand '-s', so the long "
              "name must be used for disabling stdout/err capturing in pytest."
     )
     parser.add_argument(

src/rez/config.py

@@ -384,6 +384,8 @@ def _parse_env_var(self, value):
     "release_hooks":                                StrList,
     "context_tracking_context_fields":              StrList,
     "pathed_env_vars":                              StrList,
+    "shell_pathed_env_vars":                        OptionalDict,
+    "enable_path_normalization":                    OptionalBool,
     "prompt_release_message":                       Bool,
     "critical_styles":                              OptionalStrList,
     "error_styles":                                 OptionalStrList,
@@ -481,6 +483,8 @@ def _parse_env_var(self, value):
     "debug_memcache":                               Bool,
     "debug_resolve_memcache":                       Bool,
     "debug_context_tracking":                       Bool,
+    "debug_shells":                                 Bool,
+    "debug_cygpath":                                Bool,
     "debug_all":                                    Bool,
     "debug_none":                                   Bool,
     "quiet":                                        Bool,
@@ -501,6 +505,7 @@ def _parse_env_var(self, value):
     "read_package_cache":                           Bool,
     "write_package_cache":                          Bool,
     "env_var_separators":                           Dict,
+    "shell_env_var_separators":                     OptionalDict,
     "variant_select_mode":                          VariantSelectMode_,
     "package_filter":                               OptionalDictOrDictList,
     "package_orderers":                             OptionalDictOrDictList,

src/rez/data/tests/builds/packages/foo/1.1.0/package.py

@@ -10,7 +10,9 @@
 
 @include("late_utils")
 def commands():
-    env.PYTHONPATH.append('{root}/python')
+    # Test prepends by throwing in an extra python path
+    env.PYTHONPATH.prepend('{root}/python')
+    env.PYTHONPATH.append('{root}/noexist')
     env.FOO_IN_DA_HOUSE = "1"
 
     late_utils.add_eek_var(env)

src/rez/data/tests/builds/packages/winning/9.6/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 2.8)
+
+# On Linux defining a project name is usually not necessary for rez packages which simply use cmake
+# as a Makefile recipe generator, however to be cross-compatible with Windows we can define it to
+# get the same functionality.
+#
+# Here we are telling cmake this is not a compiled project by providing NONE for the second argument.
+#
+# The project function is only being used in this in case because we are on Windows and want to use
+# the gnu make utility provided by a `make` rez package or configuring a path to `make.exe` in rez config.
+# This bypasses having to use the default `nmake` on Windows which requires the Windows compiler and
+# linker and attempts to build a simple c++ executable during a build.
+#
+project($ENV{REZ_BUILD_PROJECT_NAME}, NONE)
+
+include(RezBuild)
+
+file(GLOB_RECURSE py_files "python/*.py")
+
+# Not using rez_install_python b/c we don't want to require python for this test package
+rez_install_files(
+    ${py_files}
+    DESTINATION .
+)

src/rez/data/tests/builds/packages/winning/9.6/package.py

@@ -0,0 +1,15 @@
+name = "winning"
+version = "9.6"
+description = (
+    "Test cmake builds especially on Windows with Unix Makefiles generator. "
+    "This is a handy workflow to have on Windows b/c it supports rez + cmake with "
+    "minimal effort and w/o the overhead of Visual Studio. "
+    "Note: Using cmake on Windows requires path normalization to be enabled. "
+)
+
+build_requires = [
+    # make and cmake need to be installed locally for this test to build and succeed
+]
+
+def commands():
+    env.PYTHONPATH.append("{root}/python")

src/rez/data/tests/builds/packages/winning/9.6/python/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left blank

src/rez/data/tests/packages/shell/1.0.0/package.py

@@ -0,0 +1,14 @@
+# pyright: reportUndefinedVariable=false
+name = "shell"
+
+version = "1.0.0"
+
+
+def commands():
+    import os
+
+    env.PATH.append("{root}")
+    env.PYTHONPATH.append(os.path.join("{root}", "src"))
+    env.PYTHONPATH.append(os.path.join("{root}", "python"))
+    env.CMAKE_MODULE_PATH.append(os.path.join(this.root, "foo.cmake"))
+    env.CMAKE_MODULE_PATH.append(os.path.join(this.root, "bar.cmake"))

src/rez/data/tests/packages/shell/1.0.0/src/__init__.py

@@ -0,0 +1 @@
+

src/rez/rex.py

@@ -234,7 +234,13 @@ def get_public_methods(self):
             ('undefined', self.undefined)]
 
     def _env_sep(self, name):
-        return self._env_sep_map.get(name, self.interpreter.pathsep)
+        return self.interpreter.env_sep_map.get(
+            name,
+            self._env_sep_map.get(
+                name,
+                self.interpreter.pathsep
+            )
+        )
 
     def _is_verbose(self, command):
         if isinstance(self.verbose, (list, tuple)):
@@ -261,7 +267,23 @@ def _expand(self, value):
         def _fn(str_):
             str_ = expandvars(str_, self.environ)
             str_ = expandvars(str_, self.parent_environ)
-            return os.path.expanduser(str_)
+            if platform_.name != "windows":
+                return os.path.expanduser(str_)
+            else:
+                if os.path.exists(os.path.expanduser(str_)):
+                    return os.path.expanduser(str_)
+
+                # Expand user only if the str is path-like
+                # otherwise it could potentially be a weak reference `~`
+                # in a request string which python on windows will expand
+                # regardless if the user exists or not
+                matches = re.findall(r"[\\/]?", str_)
+                matches = list(set(matches))
+                matches.remove("")
+                if matches:
+                    return os.path.expanduser(str_)
+                else:
+                    return str_
 
         return EscapedString.promote(value).formatted(_fn)
 
@@ -479,6 +501,12 @@ class ActionInterpreter(object):
     #
     pathsep = os.pathsep
 
+    # Path separator mapping. There are cases (eg gitbash - git for windows) where
+    # the path separator changes based on the variable
+    # (eg "PATH": ":", and "PYTHONPATH": ";")
+    #
+    env_sep_map = {}
+
     # RegEx that captures environment variables (generic form).
     # Extend/override to regex formats that can capture environment formats
     # in other interpreters like shells if needed
@@ -544,7 +572,7 @@ def shebang(self):
 
     # --- other
 
-    def escape_string(self, value, is_path=False):
+    def escape_string(self, value, is_path=False, is_shell_path=False):
         """Escape a string.
 
         Escape the given string so that special characters (such as quotes and
@@ -562,6 +590,7 @@ def escape_string(self, value, is_path=False):
         Args:
             value (str or `EscapedString`): String to escape.
             is_path (bool): True if the value is path-like.
+            is_shell_path (bool): True if the value is a shell-path.
 
         Returns:
             str: The escaped string.
@@ -572,6 +601,16 @@ def escape_string(self, value, is_path=False):
     def _is_pathed_key(cls, key):
         return any(fnmatch(key, x) for x in config.pathed_env_vars)
 
+    @classmethod
+    def _is_shell_pathed_key(cls, key):
+        shell_name = cls.name()
+        if shell_name not in config.shell_pathed_env_vars:
+            return False
+
+        return any(
+            fnmatch(key, x) for x in config.shell_pathed_env_vars[shell_name]
+        )
+
     def normalize_path(self, path):
         """Normalize a path.
 
@@ -598,6 +637,9 @@ def normalize_paths(self, value):
 
         Note that `value` may be more than one pathsep-delimited paths.
         """
+        # Prevent path conversion if normalization is disabled in the config.
+        if not config.enable_path_normalization:
+            return value
         paths = value.split(self.pathsep)
         paths = [self.normalize_path(x) for x in paths]
         return self.pathsep.join(paths)
@@ -802,6 +844,45 @@ def _add_systemroot_to_env_win32(self, env):
 
         env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
 
+    def as_path(self, path):
+        """
+        Return the given path as a system path.
+        Used if the path needs to be reformatted to suit a specific case.
+        Args:
+            path (str): File path.
+
+        Returns:
+            (str): Transformed file path.
+        """
+        return path
+
+    def as_shell_path(self, path):
+        """
+        Return the given path as a shell path.
+        Used if the shell requires a different pathing structure.
+
+        Args:
+            path (str): File path.
+
+        Returns:
+            (str): Transformed file path.
+        """
+        return path
+
+    def normalize_path(self, path):
+        """
+        Normalize the path to fit the environment.
+        For example, POSIX paths, Windows path, etc. If no transformation is
+        necessary, just return the path.
+
+        Args:
+            path (str): File path.
+
+        Returns:
+            (str): Normalized file path.
+        """
+        return path
+
 
 #===============================================================================
 # String manipulation
@@ -1360,6 +1441,8 @@ def normalize_path(self, path):
         Returns:
             str: The normalized path.
         """
+        if not config.enable_path_normalization:
+            return path
         return self.interpreter.normalize_path(path)
 
     @classmethod

src/rez/rex_bindings.py

@@ -134,7 +134,7 @@ def root(self):
         root = self.__cached_root or self.__variant.root
 
         if self.__interpreter:
-            root = self.__interpreter.normalize_path(root)
+            root = self.__interpreter.as_path(root)
 
         return root
 

src/rez/rezconfig.py

@@ -567,14 +567,65 @@
 }
 
 # This setting identifies path-like environment variables. This is required
-# because some shells need to apply path normalization. For example, the command
-# ``env.PATH.append("{root}/bin")`` will be normalized to (eg) ``C:\...\bin`` in a
-# ``cmd`` shell on Windows. Note that wildcards are supported. If this setting is
-# not correctly configured, then your shell may not work correctly.
+# because some path vars need platform normalization. For example, a setting
+# such as ``["PATH"]`` with the command ``env.PATH.append("{root}/bin")`` will cause
+# ``{root}`` to be normalized to (eg) ``C:\...\bin`` in a ``cmd`` shell on Windows.
+#
+# Note that wildcards are supported, ``[*PATH]`` for example. Like the previous
+# example, a setting like this means ``env.PYTHONPATH.append("{root}/python")``
+# would similarly normalize to ``C:\...\python`` in a ``cmd`` shell on Windows.
+#
+# Conversely to path-like variables, it should be obvious that this setting is
+# not applied to variables that are not path-like. For example, if you set
+# ``env.FOO = "{root}/foo"``, then ``{root}`` will not be normalized and on the same
+# token ``this.root`` in ``foo = os.path.join(this.root, "foo")`` will also expand
+# to the platform native path.
+#
+# Use caution if experimenting with this setting, if it is not correctly
+# configured, then your shell may not work correctly. Also see
+# :data:`shell_pathed_env_vars` below for more more control over how shells handle
+# these path variables.
 pathed_env_vars = [
     "*PATH"
 ]
 
+# Much like :data:`env_var_separators` and companion to :data:`shell_pathed_env_vars`,
+# this setting provides control over separators for list-like env vars on a per-shell
+# basis. Each shell has it's own pathsep but this provides more explicit control
+# and flexibility.
+shell_env_var_separators = {
+    "gitbash": {
+        "PATH": ":",
+        "PYTHONPATH": ";",
+    }
+}
+
+# Some shells may require finer grained control over how path variables are
+# handled. Similar to :data:`pathed_env_vars`, this option provides a way to define
+# variables the shell should handle, but on a per-shell basis. This setting can
+# be used in addition to the platform pathing strategy provided by
+# :data:`pathed_env_vars` to override or disable it if that is desired.
+#
+# A path-like variable defined in this setting should correspond to a pathsep
+# setting in either :data:`env_var_separators` or :data:`shell_env_var_separators`.
+# It can be both, but only one is necessary. A corresponding pathsep setting informs
+# the shell plugin how to join paths of that type.
+#
+# Note that, similar to :data:`pathed_env_vars`, wildcards are supported.
+shell_pathed_env_vars = {
+    "gitbash": [
+        "PYTHONPATH",
+        "CMAKE_MODULE_PATH",
+    ]
+}
+
+# Global toggle to perform path normalization to path-like environment variables.
+# Applies the :data:`pathed_env_vars` and :data:`shell_pathed_env_vars` setting to all
+# shells. If :data:`shell_pathed_env_vars` setting is configured then it overrides
+# :data:`pathed_env_vars` if the keys are the same. Setting this to ``False`` disables
+# all normalization.
+enable_path_normalization = False
+
 # Defines what suites on ``$PATH`` stay visible when a new rez environment is resolved.
 # Possible values are:
 #
@@ -750,6 +801,12 @@
 # Turn off all warnings. This overrides :data:`warn_all`.
 warn_none = False
 
+# Print debugging info for shells
+debug_shells = False
+
+# Print debugging info for the cygpath module
+debug_cygpath = False
+
 # Print info whenever a file is loaded from disk, or saved to disk.
 debug_file_loads = False