pathlib-next 0.9.4__tar.gz → 0.9.6__tar.gz

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/CHANGELOG.md

@@ -7,6 +7,73 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.9.6] - 2026-09-16
+
+### Added
+- **`Path.glob(None)` / `rglob(None)`**: expand the pattern the path itself
+  carries (`LocalPath("/etc/*.conf").glob(None)`), splitting at the first
+  wildcard. `glob("")` still raises `ValueError` as pathlib does -- `None`
+  is the spelling that cannot collide with a real pattern -- so this restores
+  what 0.9.4 removed as an explicit, supported form rather than by accident.
+- **`Path.glob(native=)` / `rglob(native=)`**, default `True`: follow the
+  running interpreter on the two rules pathlib changed mid-series. A
+  trailing `/` is ignored before 3.11 and selects directories only from
+  3.11; a component that merely contains `**` (`a**`) raises `ValueError`
+  before 3.13 and is a plain wildcard from 3.13. `native=False` applies one
+  rule on every version instead, which is what a caller comparing results
+  across backends or interpreters wants.
+
+### Changed
+- **`glob()` now matches the running interpreter exactly**, including on
+  Python 3.9-3.12 where it previously applied its own rule for a trailing
+  `/` and for `a**`. Measured with a 46-comparison differential sweep
+  against `pathlib`: 3.14 was already identical, and 3.9 went from 4
+  disagreements to 0. Pass `native=False` for the previous, version-
+  independent behaviour; `pathlib_next.testing`'s contract suite does.
+
+### Documentation
+- **Named the replacement for `glob("")`**, which 0.9.4 removed for pathlib
+  parity: `pathlib_next.utils.glob.glob(path, recursive=...)` expands a
+  pattern the path itself carries, splitting at the first wildcard. The
+  0.9.4 entry withdrew the capability without naming it, and `Path.glob()`'s
+  docstring documented the `ValueError` but not the alternative. Reported by
+  yaconfiglib, whose `path.glob("", recursive=...)` calls stopped working.
+
+## [0.9.5] - 2026-09-16
+
+### Fixed
+- **Archive member names are normalized**, so the same member is reachable
+  however the archive was written and whichever format it is. A leading
+  `./` (what `tar -C dir .`, `TarFile.add(arcname=".")` and
+  `shutil.make_archive` put on every member), empty segments (`a//b`) and
+  interior `.`/`..` (`a/./b`, `a/b/../c`) now resolve to one name for
+  listing and lookup alike. Previously only `tar:` stripped a leading `./`:
+  a zip written that way listed as empty and none of its members could be
+  read under any spelling, while a name such as `d//e.txt` was readable but
+  absent from listings.
+
+### Changed
+- **A drive- or backslash-shaped member name is no longer dropped.**
+  `C:drive.txt` and `a\b` are ordinary filenames on POSIX, and an archive
+  written there may contain them; they were silently absent from every
+  listing and unreadable on every platform. The rule they were failing is a
+  *destination* rule, and now lives where the joining happens:
+  `Path.copy(recursive=True)` refuses a child name that would not stay
+  inside its target (`ValueError` through `ignore_error`), which is what
+  `PathSyncer` and `utils.unpack_archive()` already did per destination.
+  Copying such a member onto a Windows path is still refused; copying it to
+  a POSIX path, a `MemPath` or another archive now works.
+- **A member name that escapes the archive root** (`../x`, `/abs`, a
+  `..` with nothing left to consume) has no name inside the archive: it was
+  already never listed, and is now never readable either. Such a member
+  used to be hidden from listings while `read_bytes()` still returned it
+  under its raw name. (Writing to one already failed and created nothing;
+  that is unchanged.) A `..` that stays inside is resolved rather than
+  rejected (`pkg/../ok.txt` reads `ok.txt`), and when two spellings
+  normalize to one name the later member wins, as in `zipfile`/`tarfile`.
+- **`Uri`'s RFC 3986 dot-segment removal is documented** as a divergence
+  from `pathlib` (`docs/divergences.md`); the behaviour is unchanged.
+
 ## [0.9.4] - 2026-09-16
 
 ### Fixed
@@ -1269,7 +1336,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Sync error handling.
 - Generic Path Protocol based pathlib implementation for URI paths with file access support for sftp, http, file schemes.
 
-[Unreleased]: https://github.com/jose-pr/pathlib-next/compare/v0.9.4...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib-next/compare/v0.9.6...HEAD
+[0.9.6]: https://github.com/jose-pr/pathlib-next/compare/v0.9.5...v0.9.6
+[0.9.5]: https://github.com/jose-pr/pathlib-next/compare/v0.9.4...v0.9.5
 [0.9.4]: https://github.com/jose-pr/pathlib-next/compare/v0.9.3...v0.9.4
 [0.9.3]: https://github.com/jose-pr/pathlib-next/compare/v0.9.2...v0.9.3
 [0.9.2]: https://github.com/jose-pr/pathlib-next/compare/v0.9.1...v0.9.2

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pathlib-next
-Version: 0.9.4
+Version: 0.9.6
 Summary: Generic Path Protocol based pathlib
 Project-URL: Homepage, https://github.com/jose-pr/pathlib-next/
 Project-URL: Documentation, https://jose-pr.github.io/pathlib-next/

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/docs/divergences.md

@@ -55,7 +55,8 @@ these operations itself always keeps its own implementation.
 | Method | pathlib behavior | Our behavior | Why |
 | --- | --- | --- | --- |
 | `Uri("http://h/d/").name` (trailing `/`) | `PurePosixPath("d/").name == "d"` | A trailing `/` is kept: `name` is `""` and `parent` is `http://h/d`. | For HTTP/WebDAV a trailing slash is how a directory URL is spelled; normalizing it away changes which URL is requested. |
-| `Path.glob()` / `rglob()` edge cases | Version-dependent pathlib rules | Hidden entries are included by default (pathlib parity; `include_hidden=False` filters them). A trailing `/` selects directories only on every Python version (pathlib ignores it before 3.11). `recurse_symlinks=True` raises `NotImplementedError`: `**` never descends into directory symlinks. A trailing `**` follows the running interpreter (files too on 3.13+). `a**` is a plain wildcard (pathlib before 3.13 raises `ValueError`). | Loop-safe recursion without `st_dev`/`st_ino` (most backends' stats lack them) rules out following links; one trailing-slash rule keeps results identical across backends and versions. |
+| `Path.glob()` / `rglob()` edge cases | Version-dependent pathlib rules | Hidden entries are included by default (pathlib parity; `include_hidden=False` filters them). `recurse_symlinks=True` raises `NotImplementedError`: `**` never descends into directory symlinks. A trailing `**` follows the running interpreter (files too on 3.13+). The two rules pathlib changed mid-series follow the running interpreter by default (`native=True`): a trailing `/` is ignored before 3.11 and selects directories only from 3.11, and `a**` raises `ValueError` before 3.13 and is a plain wildcard from 3.13. `native=False` applies one rule on every version instead -- trailing `/` always selects directories only, `a**` is always a plain wildcard. | Loop-safe recursion without `st_dev`/`st_ino` (most backends' stats lack them) rules out following links. The `native` default keeps `LocalPath` answering exactly what the `pathlib` beside it answers; `native=False` is for a caller that wants one answer across backends and interpreters, which is what the contract suite asserts. |
+| `Path.glob(None)` / `rglob(None)` | `pathlib` has no such form (its pattern is always applied to a directory) | `None` expands the pattern THIS PATH CARRIES: `LocalPath("/etc/*.conf").glob(None)` splits at the first wildcard and globs from there (`utils.glob.glob()`). `glob("")` still raises `ValueError`, as pathlib does. | An extension: a path that is itself a pattern is a common shape for config and CLI inputs, and before 0.9.4 `glob("")` was the accidental spelling for it. `None` cannot collide with a real pattern, so parity is untouched. |
 | `Uri.query` | N/A (pathlib has no query) | The query is kept exactly as received (percent-encoded) and sent unchanged; `Query(...).decode()`/`to_dict()` decode. `Uri.parts` is `(source, path, query, fragment)`, not path segments (`segments` is). A `%2F` in a path decodes to `/` and is not distinguishable from a separator. | Decoding at parse time and re-encoding changed what reached the server (a signed URL's `%2B` became `+`, an escaped `&` split a value). The decoded-path model cannot keep `%2F` distinct. |
 | `Path.copy(follow_symlinks=False)` on a symlink | CPython 3.14: copies the link as a link | Same: the link is recreated (not its metadata). Where the source cannot `readlink()` or the target cannot create links, raises `NotImplementedError` instead of copying content. `copy(recursive=True)` into its own subtree raises `OSError(EINVAL)` before creating anything. | Copying the link target's content under the link's permissions produced a 0o777 regular file. |
 | `SftpPath.rename(target)` onto an existing file | POSIX `rename(2)`: replaces | Replaces through `posix-rename@openssh.com` where the server supports it; otherwise raises `FileExistsError`. | Plain SFTPv3 rename refuses an existing target with an uninformative failure. |
@@ -80,6 +81,10 @@ these operations itself always keeps its own implementation.
 | `str()`/`repr()` of `github:`/`gitlab:`/`git:` paths | N/A (no pathlib equivalent) | The **whole** userinfo is redacted, not just the part after `:` as for other schemes. `as_uri()` (unsanitized) still returns it. | The token is commonly the bare userinfo (`TOKEN@host`), the one part other schemes keep, so it reached logs and tracebacks. |
 | `Path.exists()` / `is_*()` on a stat error other than "not found" | pathlib 3.9-3.12 re-raise errors outside ENOENT/ENOTDIR/EBADF/ELOOP (e.g. `PermissionError`); 3.13+ return `False` | Every `OSError`/`ValueError` from `stat()` returns `False` on every Python version, including `LocalPath.exists()` on 3.9-3.12. | One rule across backends and versions, matching current pathlib. |
 | `PathSyncer` directory → file/symlink type change | N/A (closest: `rsync`, which will not delete a non-empty directory without `--delete`/`--force`) | With `remove_missing=False`, a non-empty target directory is not replaced when the source entry at that name became a file or symlink: `IsADirectoryError` goes through `ignore_error` (`SyncEvent.TypeMismatch`) and the directory is kept. Empty directories, or `remove_missing=True`, are replaced. | `remove_missing=False` means "never delete target-only data"; replacing the directory silently deleted its whole subtree. |
+| `Path.copy(recursive=True)` child names | `shutil.copytree` joins whatever the listing yields | A child name that would not stay inside `target` is refused with `ValueError` through `ignore_error`: `..`, and `\`/`:`/a trailing dot when the target reads names with Windows rules. | The names come from listings the destination does not control (an archive, an HTTP index, an object-store key); on a Windows target `"C:x"` joins to a drive-relative path outside the destination entirely. `PathSyncer` and `utils.unpack_archive()` already applied this per destination. |
+| Archive member names | N/A (`zipfile`/`tarfile` expose the raw name as written) | Normalized as POSIX relative paths for every format: a leading `./`, empty segments and interior `.`/`..` resolve, so one member has one name and listings and lookups agree; the raw spelling still addresses it, and the later of two members that normalize alike wins. A name that escapes the root (`../x`, `/abs`) has no name inside the archive at all, while a drive- or backslash-shaped name is a normal member (an ordinary POSIX filename) that only a Windows destination refuses to receive. | The same file was reachable or not depending on how the writer spelled it: a zip written by `shutil.make_archive`-style `./` prefixes listed as empty, and zip and tar disagreed about identical archives. |
+| The POSIX `//` root | `PurePosixPath("//")` keeps `//` as a root distinct from `/` (POSIX leaves exactly two leading slashes implementation-defined; three or more collapse) | The generic classes do not model it: `MemPath("//")` collapses to `/`, and `Uri("//")` reads `//` as the start of an authority (RFC 3986), giving an empty authority and an empty path -- so `Uri("//a/b")` has host `a` and path `/b`. `match()` therefore disagrees with `pathlib` on that one path. `LocalPath`/`WindowsPathname` are unaffected (they inherit pathlib's parsing, where `//server/share` is a UNC drive). | A distinct double-slash root has no meaning for an in-memory tree or a URI, and for a `Uri` it cannot: `//a/b` must read `a` as a host. Modelling it would change segment normalization everywhere (`parents`, `relative_to`, `is_absolute`, every scheme) to serve a spelling no backend can use. |
+| `Uri` path dot segments | `pathlib` keeps `..` lexically (`PurePosixPath("a/../b")` is `a/../b`) | `Uri` removes dot segments as RFC 3986 requires of a URI reference, in the constructor and in `/`-joins: `Uri("a/../b")` is `b`, `Uri("http://h/x") / "a/../b"` is `http://h/x/b`, and `Uri("a/b/..")` is `a/`. A leading `..` that would pass the root is kept, not resolved. `MemPath` follows `pathlib` instead. | A URI is resolved, not spelled: `..` in a URI reference has a defined meaning that servers, caches and proxies already apply, so keeping it lexically would address a different resource than the same string typed into a browser. |
 | Nested archive URIs | N/A | Each leading archive scheme in `<archive-uri>` consumes one `!/` (`zip:zip:file:///outer.zip!/inner.zip!/x.txt`); a member name containing `!/` is written `%21/`. Nested archives are read-only. | The first `!/` was always taken as the separator, so an archive inside an archive could not be addressed. |
 | Object-store key that is both an object and a prefix | N/A (a filesystem entry has one type) | `iterdir()`/`walk()`/`copy(recursive=True)` on `s3:`/`gs:`/`az:` show only the object (`x`), matching `stat()`'s exact-object precedence; the subtree under `x/` is not listed. | Listings used to keep the directory and drop the object, contradicting `stat()`. |
 | `HttpPath.iterdir()` on a file | pathlib raises `NotADirectoryError` | Raises `NotADirectoryError` for a non-HTML response, without downloading it. An HTML file cannot be told apart from an index page and lists as empty. | HTTP has no directory type; the response content type is the only signal. |

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/docs/guides/schemes.md

@@ -205,9 +205,17 @@ The `<archive-uri>` is any absolute URI with an explicit scheme, so
 - An archive inside an archive is addressed by nesting
   (`zip:zip:file:///outer.zip!/inner.zip!/x.txt`) and is read-only; a `!/`
   inside a member name is written `%21/`.
-- Members whose names would escape a destination (`..`, absolute or drive
-  paths) are never listed. Exception types are the POSIX ones on every
-  platform.
+- Member names are normalized as POSIX relative paths, the same way for
+  every format: `./x`, `a//b`, `a/./b` and `a/b/../c` all resolve, so a
+  member lists and reads under one name however the archive was written
+  (`tar -C dir .` and `shutil.make_archive` prefix every member with `./`).
+  The spelling as written still works.
+- Members whose names would escape the archive (`..` past the root, or an
+  absolute path) have no name inside it: never listed, never readable. A
+  name that merely a Windows destination would misread -- `C:drive.txt`, or
+  one containing `\` -- is a normal member, since both are ordinary
+  filenames on POSIX; copying or extracting it onto a Windows path is what
+  refuses it. Exception types are the POSIX ones on every platform.
 
 ## Git hosting
 

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "hatchling.build"
 # `import pathlib_next`) -- a hyphen is not legal in a Python identifier.
 # Distribution name and import name differing is ordinary and intended.
 name = "pathlib-next"
-version = "0.9.4"
+version = "0.9.6"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/src/pathlib_next/AGENTS.md

@@ -73,16 +73,28 @@ silently absent and `from pathlib_next.uri import UriPath` raises
     `PathSyncer`; override it when the listing call already returns metadata.
     `None` means "unknown", never "missing".
   - `glob(pattern, *, case_sensitive=None, include_hidden=True,
-    recursive=None, dironly=None, recurse_symlinks=False)` — pathlib
-    semantics: hidden entries included, a trailing `/` selects directories,
-    `**` never descends into directory symlinks (`recurse_symlinks=True` →
-    `NotImplementedError`), a trailing `**` selects files too on 3.13+, a
-    missing or non-directory base yields nothing, `""` → `ValueError`, an
-    absolute pattern → `glob.NonRelativePatternError`. `recursive=None`
-    enables recursion when a component is `**`; an explicit value wins.
-    Validates eagerly, selects lazily. On a remote scheme a recursive glob
-    lists every directory of the subtree.
+    recursive=None, dironly=None, recurse_symlinks=False, native=True)` —
+    pathlib semantics: hidden entries included, `**` never descends into
+    directory symlinks (`recurse_symlinks=True` → `NotImplementedError`), a
+    trailing `**` selects files too on 3.13+, a missing or non-directory base
+    yields nothing, `""` → `ValueError`, an absolute pattern →
+    `glob.NonRelativePatternError`. `recursive=None` enables recursion when a
+    component is `**`; an explicit value wins. Validates eagerly, selects
+    lazily. On a remote scheme a recursive glob lists every directory of the
+    subtree.
+    - **`pattern=None`** expands the pattern THIS PATH CARRIES
+      (`LocalPath("/etc/*.conf").glob(None)`), splitting at the first
+      wildcard — the supported form for a path that is itself a pattern.
+      `""` still raises.
+    - **`native=True`** (default) follows the running interpreter on the two
+      rules pathlib changed mid-series: a trailing `/` is ignored before 3.11
+      and selects directories only from 3.11; `a**` raises `ValueError`
+      before 3.13 and is a plain wildcard from 3.13. `native=False` applies
+      one rule on every version (trailing `/` → directories only, `a**` → a
+      plain wildcard), so a pattern answers the same on every interpreter and
+      backend; `pathlib_next.testing`'s contract suite uses it.
   - `rglob(pattern, **same_kwargs)` — `glob(f"**/{pattern}", recursive=True)`.
+    `pattern=None` is `glob(None)`.
   - `walk(top_down=True, on_error=None, follow_symlinks=False)` — drives
     `_scandir()`; its stats are trusted only with `follow_symlinks=False`. No
     symlink-cycle protection when following (only `LocalPath` has pathlib's).
@@ -114,6 +126,13 @@ silently absent and `from pathlib_next.uri import UriPath` raises
       the same file (or a case-insensitive alias) → `OSError(EINVAL)`.
     - The source is opened before the target is touched; a failed stream
       removes the partial target.
+    - A recursive copy refuses any child name that would not stay inside
+      `target` — `..`, and `\`/`:`/a trailing dot when the target reads
+      names with Windows rules (`utils.is_windows_flavoured()`). The names
+      come from a listing the destination does not control (an archive, a
+      remote index, an object-store key), and on a Windows target `"C:x"`
+      joins to a drive-relative path outside it. Raised as `ValueError`
+      through `ignore_error`, per child, like any other child failure.
     - `follow_symlinks=False` on a symlink recreates the link
       (`NotImplementedError` if either side cannot).
     - `preserve_metadata=True` copies permission bits only, and only a mode the
@@ -481,15 +500,30 @@ chained (their text can carry credentials).
   - One shared handle per archive (keyed by the real local path, or the outer
     URI), released when no path references it. A non-local outer is read into
     memory.
-  - Members named with `..`, an absolute path or a drive are never listed.
-    Exception types are POSIX on every platform.
+  - **Member names are normalized POSIX relative paths**, whatever the
+    writer emitted and whichever format: a leading `./` (`tar -C dir .`,
+    `shutil.make_archive`), empty segments (`a//b`) and interior `.`/`..`
+    (`a/./b`, `a/b/../c`) resolve, so one member has one name and a listing
+    and a lookup always agree. The spelling as written still addresses the
+    member. A name that would leave the root -- `../x`, `/abs`, or a `..`
+    with nothing to spend it on -- has no name inside the archive: it is
+    never listed, never readable, and cannot be written (the write fails and
+    creates nothing). A name only a *Windows destination* would misread
+    (`C:drive.txt`, `a\b`) IS a member, because it is an ordinary POSIX
+    filename; refusing to join it is the destination's rule, applied by
+    whatever writes there (see `copy()` below, `PathSyncer`,
+    `unpack_archive()`). `zipfile` itself rewrites `\` to `/`, so a
+    backslash name only survives in a tar. When two spellings normalize to one name the
+    later member wins, as in `zipfile`/`tarfile`. Exception types are POSIX on every
+    platform.
   - Writes: zip only, and only with a local `file:` outer (else
     `NotImplementedError`). `"w"`/`"x"`/`"r+"`, `mkdir()`, `unlink()`,
     `rmdir()`, `rename()` (same archive; replaces like POSIX `rename`);
     parents must exist; `"a"` unsupported. Every mutation replaces the archive
     atomically (temp file + `os.replace`) and keeps other members' metadata,
-    the comment and any prefix bytes. `tar:` (plain, gz, bz2, xz) is
-    read-only; `./` member prefixes are dropped.
+    the comment and any prefix bytes. A write uses the normalized name; a
+    name that escapes the root fails and creates nothing.
+    `tar:` (plain, gz, bz2, xz) is read-only.
 
 ## CLI (`uripath`, `pathlib_next.tools.uripath`)
 

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/src/pathlib_next/fspath.py

@@ -394,21 +394,35 @@ class LocalPath(
 
     def glob(
         self,
-        pattern: str | _proto.FsPathLike,
+        pattern: "str | _proto.FsPathLike | None",
         *,
         case_sensitive: bool = None,
         include_hidden: bool = True,
         recursive: bool = None,
         dironly: bool = None,
         recurse_symlinks: bool = False,
+        native: bool = True,
     ):
         """Iterate over this subtree and yield all existing files (of any
         kind, including directories) matching the given relative pattern.
 
-        Same semantics as Path.glob(); every separator of this flavour
-        splits the pattern, and a pattern with a drive or root raises
-        `glob.NonRelativePatternError` like pathlib.
+        Same semantics as Path.glob(), including `pattern=None` (expand the
+        pattern this path carries) and `native=` (follow the running
+        interpreter, or one rule on every version); every separator of this
+        flavour splits the pattern, and a pattern with a drive or root
+        raises `glob.NonRelativePatternError` like pathlib.
         """
+        if pattern is None:
+            return _proto.Path.glob(
+                self,
+                None,
+                case_sensitive=case_sensitive,
+                include_hidden=include_hidden,
+                recursive=recursive,
+                dironly=dironly,
+                recurse_symlinks=recurse_symlinks,
+                native=native,
+            )
         pattern = _os.fspath(pattern)
         if pattern:
             anchored = self.with_segments(pattern)
@@ -430,4 +444,5 @@ class LocalPath(
             recursive=recursive,
             dironly=dironly,
             recurse_symlinks=recurse_symlinks,
+            native=native,
         )

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/src/pathlib_next/path.py

@@ -704,13 +704,14 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
 
     def glob(
         self,
-        pattern: str | _ty.Self,
+        pattern: str | _ty.Self | None,
         *,
         case_sensitive: bool = None,
         include_hidden: bool = True,
         recursive: bool = None,
         dironly: bool = None,
         recurse_symlinks: bool = False,
+        native: bool = True,
     ):
         """Iterate over this subtree and yield all existing files (of any
         kind, including directories) matching the given relative pattern.
@@ -724,6 +725,20 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         `glob.NonRelativePatternError` (a `NotImplementedError` and a
         `ValueError`). `recurse_symlinks=True` is not supported.
 
+        `pattern=None` expands the pattern THIS PATH CARRIES
+        (`LocalPath("/etc/*.conf").glob(None)`) instead of applying one to a
+        directory: the path is split at its first wildcard and globbed from
+        there (`utils.glob.glob()`). `""` still raises, as pathlib does.
+
+        `native=True` (the default) follows the running interpreter on the
+        two rules pathlib changed mid-series: a trailing "/" is ignored
+        before 3.11, and a component that merely contains "**" ("a**")
+        raises `ValueError` before 3.13. `native=False` applies one rule on
+        every version -- trailing "/" always selects directories only, "a**"
+        is always a plain wildcard -- so a pattern answers the same
+        everywhere, which is what a cross-backend or cross-version caller
+        usually wants.
+
         A "**" component auto-enables recursion. Pass `recursive=False`
         explicitly to treat "**" as a plain "*" instead.
         Note for remote schemes (http/sftp): a recursive glob walks the
@@ -731,10 +746,21 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         """
         if recurse_symlinks:
             raise NotImplementedError("glob(recurse_symlinks=True)")
+        if pattern is None:
+            # The pattern is the path itself; `glob()` splits at the first
+            # wildcard, so an absolute one is fine here (unlike a pattern
+            # argument, which must stay relative to self).
+            return _glob.glob(
+                self,
+                recursive=bool(recursive),
+                include_hidden=include_hidden,
+                case_sensitive=case_sensitive,
+                dironly=bool(dironly),
+            )
         # Validates eagerly (like pathlib 3.13+); the returned selection is
         # lazy. The pattern is never joined onto self: `self / pattern` let an
         # absolute pattern escape self and re-parsed "?" as a URI query.
-        parts, trailing_sep = _glob.parse_pattern(pattern)
+        parts, trailing_sep = _glob.parse_pattern(pattern, native=native)
         if recursive is None:
             recursive = _glob.RECURSIVE in parts
         return _glob.select(
@@ -748,19 +774,33 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
 
     def rglob(
         self,
-        pattern: str,
+        pattern: str | None,
         *,
         case_sensitive: bool = None,
         include_hidden: bool = True,
         recursive: bool = True,
         dironly: bool = None,
         recurse_symlinks: bool = False,
+        native: bool = True,
     ):
-        """Equivalent to `glob(f"**/{pattern}", recursive=True)`."""
+        """Equivalent to `glob(f"**/{pattern}", recursive=True)`.
+
+        `pattern=None` and `native=` mean what they do on `glob()`; with
+        `None` this is `glob(None, recursive=True)`, since a carried pattern
+        brings its own anchor and nothing can be prefixed to it."""
+        if pattern is None:
+            return self.glob(
+                None,
+                case_sensitive=case_sensitive,
+                include_hidden=include_hidden,
+                recursive=recursive,
+                dironly=dironly,
+                recurse_symlinks=recurse_symlinks,
+            )
         if not (isinstance(pattern, str) and not pattern):
             # Reject an absolute pattern before "**/" hides its anchor;
             # glob() validates without listing anything.
-            self.glob(pattern, recursive=False)
+            self.glob(pattern, recursive=False, native=native)
         return self.glob(
             f"**/{pattern}",
             case_sensitive=case_sensitive,
@@ -768,6 +808,7 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
             recursive=recursive,
             dironly=dironly,
             recurse_symlinks=recurse_symlinks,
+            native=native,
         )
 
     def walk(
@@ -1180,8 +1221,27 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
                     raise FileExistsError(target)
             else:
                 target.mkdir()
+            windows_target = _utils.is_windows_flavoured(target)
             for child in children:
                 try:
+                    # The names come from a listing the destination does not
+                    # control (an archive, a remote index, an object-store
+                    # key), so one that is not a single component inside
+                    # `target` must never be joined onto it: on a Windows
+                    # target "C:x" joins to a drive-relative path outside it
+                    # entirely, and so does "a\\b". Reported through
+                    # `ignore_error` like any other per-child failure, not
+                    # silently skipped. `PathSyncer` and
+                    # `utils.unpack_archive()` apply the same rule per
+                    # destination; an archive listing keeps such names,
+                    # because they are ordinary filenames on POSIX.
+                    if not _utils.is_safe_child_name(
+                        child.name, windows=windows_target
+                    ):
+                        raise ValueError(
+                            f"refusing unsafe child name {child.name!r} "
+                            f"under {target}"
+                        )
                     child.copy(
                         target / child.name,
                         overwrite=overwrite,

{pathlib_next-0.9.4 → pathlib_next-0.9.6}/src/pathlib_next/testing.py

@@ -239,8 +239,13 @@ class ReadPathContract(PurePathContract):
             "empty_dir",
         }
         assert {_rel(root, p) for p in root.glob("sub/*.py")} == {"sub/c.py"}
-        # A trailing separator selects directories only.
-        assert {_rel(root, p) for p in root.glob("*/")} == {"sub", "empty_dir"}
+        # A trailing separator selects directories only -- with `native=False`,
+        # the one rule for every interpreter. The default follows the running
+        # one, and pathlib ignored a trailing separator before 3.11.
+        assert {_rel(root, p) for p in root.glob("*/", native=False)} == {
+            "sub",
+            "empty_dir",
+        }
 
     def test_glob_recursive(self, root):
         self._require("supports_listing")