pep610: handle mixed case dist-info names

In certain cases, eg: PyYAML, the package metadata is installed at
`PyYAML-<version>.dist-info`. This change ensures that we detect
the `direct_url.json` files correctly in these cases.

Author: abn

Diff for: poetry/installation/executor.py

@@ -743,7 +743,9 @@ def _save_url_reference(self, operation: "OperationTypes") -> None:
             # That's not what we want so we remove the direct_url.json file,
             # if it exists.
             for direct_url in self._env.site_packages.find(
-                self._direct_url_json_path(package), True
+                self._direct_url_json_path(package),
+                writable_only=True,
+                case_insensitive=True,
             ):
                 direct_url.unlink()
 
@@ -762,7 +764,9 @@ def _save_url_reference(self, operation: "OperationTypes") -> None:
 
         if url_reference:
             for path in self._env.site_packages.find(
-                self._package_dist_info_path(package), writable_only=True
+                self._package_dist_info_path(package),
+                writable_only=True,
+                case_insensitive=True,
             ):
                 self._env.site_packages.write_text(
                     path / "direct_url.json",

Diff for: poetry/utils/env.py

@@ -198,7 +198,9 @@ def writable_candidates(self) -> List[Path]:
 
         return self._writable_candidates
 
-    def make_candidates(self, path: Path, writable_only: bool = False) -> List[Path]:
+    def make_candidates(
+        self, path: Path, writable_only: bool = False, strict: bool = False
+    ) -> List[Path]:
         candidates = self._candidates if not writable_only else self.writable_candidates
         if path.is_absolute():
             for candidate in candidates:
@@ -214,7 +216,71 @@ def make_candidates(self, path: Path, writable_only: bool = False) -> List[Path]
                     )
                 )
 
-        return [candidate / path for candidate in candidates if candidate]
+        results = [candidate / path for candidate in candidates if candidate]
+
+        if not results and strict:
+            raise RuntimeError(
+                'Unable to find a suitable destination for "{}" in {}'.format(
+                    str(path), paths_csv(self._candidates)
+                )
+            )
+
+        return results
+
+    def _exists_case_insensitive(
+        self,
+        path: Union[str, Path],
+        return_first: bool = True,
+        writable_only: bool = False,
+    ) -> Union[Tuple[Path, Any], List[Tuple[Path, Any]]]:
+        if isinstance(path, str):
+            path = Path(path)
+
+        candidates = self._candidates if not writable_only else self.writable_candidates
+
+        if path.is_absolute():
+            for candidate in candidates:
+                try:
+                    # we set the path to be relative here
+                    path = path.relative_to(candidate)
+                    # we consider only one candidate as the path is relative to it
+                    candidates = [candidate]
+                    break
+                except ValueError:
+                    pass
+            else:
+                raise ValueError(
+                    "{} is not relative to any discovered {}sites".format(
+                        path, "writable " if writable_only else ""
+                    )
+                )
+
+        results = []
+
+        for candidate in candidates:
+            try:
+                # because this is a case insensitive search, we use posix lower form
+                path_posix_lower = candidate.joinpath(path).as_posix().lower()
+
+                for match in candidate.glob("**/*"):
+                    if path_posix_lower == match.as_posix().lower():
+                        # a case insensitive match was found, we return the matched path
+                        # (case sensitive) as this is used by the caller
+                        result = match, True
+                        if return_first:
+                            return result
+                        results.append(result)
+                        break
+                else:
+                    results.append((candidate.joinpath(path), False))
+            except OSError:
+                # TODO: Replace with PermissionError
+                pass
+
+        if results:
+            return results
+
+        raise OSError("Unable to access any of {}".format(paths_csv(candidates)))
 
     def _path_method_wrapper(
         self,
@@ -228,14 +294,9 @@ def _path_method_wrapper(
         if isinstance(path, str):
             path = Path(path)
 
-        candidates = self.make_candidates(path, writable_only=writable_only)
-
-        if not candidates:
-            raise RuntimeError(
-                'Unable to find a suitable destination for "{}" in {}'.format(
-                    str(path), paths_csv(self._candidates)
-                )
-            )
+        candidates = self.make_candidates(
+            path, writable_only=writable_only, strict=True
+        )
 
         results = []
 
@@ -244,8 +305,7 @@ def _path_method_wrapper(
                 result = candidate, getattr(candidate, method)(*args, **kwargs)
                 if return_first:
                     return result
-                else:
-                    results.append(result)
+                results.append(result)
             except OSError:
                 # TODO: Replace with PermissionError
                 pass
@@ -261,20 +321,28 @@ def write_text(self, path: Union[str, Path], *args: Any, **kwargs: Any) -> Path:
     def mkdir(self, path: Union[str, Path], *args: Any, **kwargs: Any) -> Path:
         return self._path_method_wrapper(path, "mkdir", *args, **kwargs)[0]
 
-    def exists(self, path: Union[str, Path]) -> bool:
-        return any(
-            value[-1]
-            for value in self._path_method_wrapper(path, "exists", return_first=False)
-        )
+    def exists(self, path: Union[str, Path], case_insensitive: bool = False) -> bool:
+        if case_insensitive:
+            results = self._exists_case_insensitive(path, return_first=False)
+        else:
+            results = self._path_method_wrapper(path, "exists", return_first=False)
+        return any(value[-1] for value in results)
 
-    def find(self, path: Union[str, Path], writable_only: bool = False) -> List[Path]:
-        return [
-            value[0]
-            for value in self._path_method_wrapper(
+    def find(
+        self,
+        path: Union[str, Path],
+        writable_only: bool = False,
+        case_insensitive: bool = False,
+    ) -> List[Path]:
+        if case_insensitive:
+            results = self._exists_case_insensitive(
+                path, return_first=False, writable_only=writable_only
+            )
+        else:
+            results = self._path_method_wrapper(
                 path, "exists", return_first=False, writable_only=writable_only
             )
-            if value[-1] is True
-        ]
+        return [value[0] for value in results if value[-1] is True]
 
     def __getattr__(self, item: str) -> Any:
         try: