Always convert paths in 'comes_from' to posix

In order to guarantee more consistent outputs, especially in the case
of mixed paths with forward- and back-slashes, this changeset updates
the `comes_from` handling to *always* apply a level of normalization.

Paths passed back through the `parse_requirements()` wrapper will now
always be formatted as posix paths.

Author: sirosen

piptools/_compat/pip_compat.py

@@ -86,22 +86,20 @@ def parse_requirements(
     isolated: bool = False,
     comes_from_stdin: bool = False,
 ) -> Iterator[InstallRequirement]:
-    # the `comes_from` data will be rewritten based on a number of conditions
-    #
-    #   None        do not rewrite
-    #   callable    programmatic rewrite
-    #   str         fixed rewrite
-    rewrite_comes_from: str | Callable[[str], str] | None
+    # the `comes_from` data will be rewritten in different ways in different conditions
+    # each rewrite rule is expressible as a str->str function or as a static replacement
+    rewrite_comes_from: Callable[[str], str] | str
 
     if comes_from_stdin:
         # if data is coming from stdin, then `comes_from="-r -"`
         rewrite_comes_from = "-r -"
     elif pathlib.Path(filename).is_absolute():
-        rewrite_comes_from = None
+        # if the input path is absolute, just normalize paths to posix-style
+        rewrite_comes_from = _normalize_comes_from_location
     else:
         # if the input was a relative path, set the rewrite rule to rewrite
         # absolute paths to be relative
-        rewrite_comes_from = _rewrite_absolute_comes_from_location
+        rewrite_comes_from = _relativize_comes_from_location
 
     for parsed_req in _parse_requirements(
         filename, session, finder=finder, options=options, constraint=constraint
@@ -114,14 +112,16 @@ def parse_requirements(
             file_link._url = parsed_req.requirement
             install_req.link = file_link
         install_req = copy_install_requirement(install_req)
+
         if isinstance(rewrite_comes_from, str):
             install_req.comes_from = rewrite_comes_from
-        elif rewrite_comes_from is not None:
+        else:
             install_req.comes_from = rewrite_comes_from(install_req.comes_from)
+
         yield install_req
 
 
-def _rewrite_absolute_comes_from_location(original_comes_from: str, /) -> str:
+def _relativize_comes_from_location(original_comes_from: str, /) -> str:
     """
     This is the rewrite rule used when ``-r`` or ``-c`` appears in
     ``comes_from`` data with an absolute path.
@@ -138,15 +138,34 @@ def _rewrite_absolute_comes_from_location(original_comes_from: str, /) -> str:
 
     file_path = pathlib.Path(suffix)
 
-    # if the path was not absolute, bail out
+    # if the path was not absolute, normalize to posix-style and finish processing
     if not file_path.is_absolute():
-        return original_comes_from
+        return f"{prefix} {file_path.as_posix()}"
 
     # make it relative to the current working dir
     suffix = file_path.relative_to(pathlib.Path.cwd()).as_posix()
     return f"{prefix} {suffix}"
 
 
+def _normalize_comes_from_location(original_comes_from: str, /) -> str:
+    """
+    This is the rewrite rule when ``-r`` or ``-c`` appears in ``comes_from``
+    data and the input path was absolute, meaning we should not relativize the locations.
+
+    Instead, we apply minimal normalization, ensuring that posix-style paths are used.
+    """
+    # require `-r` or `-c` as the source
+    if not original_comes_from.startswith(("-r ", "-c ")):
+        return original_comes_from
+
+    # split on the space
+    prefix, _, suffix = original_comes_from.partition(" ")
+
+    # convert to a posix-style path
+    suffix = pathlib.Path(suffix).as_posix()
+    return f"{prefix} {suffix}"
+
+
 def create_wheel_cache(cache_dir: str, format_control: str | None = None) -> WheelCache:
     kwargs: dict[str, str | None] = {"cache_dir": cache_dir}
     if PIP_VERSION[:2] <= (23, 0):

tests/test_cli_compile.py

@@ -1967,7 +1967,7 @@ def test_many_inputs_includes_all_annotations(pip_conf, runner, tmp_path, num_in
                 "small-fake-a==0.1",
                 "    # via",
             ]
-            + [f"    #   -r {req_in}" for req_in in req_ins]
+            + [f"    #   -r {req_in.as_posix()}" for req_in in req_ins]
         )
         + "\n"
     )
@@ -3931,23 +3931,12 @@ def test_second_order_requirements_path_handling(
     # the input path is given on the CLI as absolute or relative
     # and this determines the expected output path as well
     if input_path_absolute:
-        input_path = str(tmp_path / "requirements.in")
-        output_path = str(tmp_path / "requirements2.in")
+        input_path = (tmp_path / "requirements.in").as_posix()
+        output_path = (tmp_path / "requirements2.in").as_posix()
     else:
         input_path = "requirements.in"
         output_path = "requirements2.in"
 
-    # on older pip versions, in which pip `comes_from` data is not normalized,
-    # override the expected output_path
-    #
-    # the second-order requirement will be preserved verbatim if the both paths
-    # are absolute on these pip versions
-    both_paths_are_absolute = (
-        input_path_absolute and test_files_collection.name == "absolute_include"
-    )
-    if not pip_produces_absolute_paths and both_paths_are_absolute:
-        output_path = (tmp_path / "requirements.in").read_text().partition(" ")[-1]
-
     with monkeypatch.context() as m:
         m.chdir(tmp_path)
 
@@ -4027,18 +4016,10 @@ def test_second_order_requirements_relative_path_in_separate_dir(
     if not pip_produces_absolute_paths:
         # traverse upwards to the root tmp dir, and append the output path to that
         # similar to pathlib.Path.relative_to(..., walk_up=True)
-        #
-        # the join must be done while preserving the original path (which may be posix-style)
-        # and the relative path part will be made in platform-specific path syntax
-        # but then the two parts will be joined with a forward-slash...
-        #
-        # on Windows, this can result in mixed slashes, e.g.
-        # `D:\tempstorage\abcdefg\sbudir/requirements2.in`
-        #
-        # this is the pip behavior, and we inherit it
         relative_segments = len(pathlib.Path(input_path).parents) - 1
-        relpath = str(pathlib.Path(input_path).parent / ("../" * relative_segments))
-        output_path = f"{relpath}/{output_path}"
+        output_path = (
+            pathlib.Path(input_path).parent / ("../" * relative_segments) / output_path
+        ).as_posix()
 
     with monkeypatch.context() as m:
         m.chdir(tmp_path)