pathlib-next 0.9.2__tar.gz → 0.9.3__tar.gz

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/CHANGELOG.md

@@ -7,6 +7,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.9.3] - 2026-08-16
+
+### Fixed
+- **A `str` destination to `rename()`/`symlink_to()` was re-parsed as a URI,
+  so part of it was silently discarded.** Every scheme resolved the
+  destination by feeding it back through the URI parser
+  (`Uri(self.parent, target)` for `rename()`, `type(self)(target)` inside
+  `Path.symlink_to()`). That reads a **decoded filesystem path** as URI
+  syntax: everything from a `?` or `#` onward became a query/fragment and was
+  dropped, `%xx` was percent-decoded, and a relative destination whose first
+  segment ended in `:` was read as a *scheme*. Measured against a real SFTP
+  server (TrueNAS 26.0.0-BETA.1):
+
+  | call | file/link actually produced |
+  | --- | --- |
+  | `rename(".../rn?b.txt")` | `.../rn` |
+  | `rename(".../rn%20b.txt")` | `.../rn b.txt` |
+  | `symlink_to(".../cache?v=2")` | link points at `.../cache` |
+  | `rename("C:/Temp/x.txt")` | `/Temp/x.txt` (`C:` taken as a scheme) |
+
+  Nothing raised. When something already occupied the truncated name the call
+  instead failed with a bare `OSError: Failure`, so the symptom was either
+  silent misplacement or an unexplained error depending on what happened to
+  be there. Downstream, `pytruenas`'s documented
+  `client.path(x).symlink_to(y)` route created a wrong link, and
+  `PathSyncer`'s `symlink_mode="preserve"` (which hands `symlink_to()` the
+  raw target string `readlink()` returned) mirrored such a link to the wrong
+  place.
+
+  A `str` destination is now taken as an already-decoded path — `?`, `#`,
+  `%` and `:` are ordinary filename characters — via the new
+  `Uri._from_decoded_path()`, one implementation shared by
+  `Uri._rename_target()` (used by `SftpPath`, `FtpPath`, `DavPath`,
+  `S3Path`, `GsPath`, `AzPath` and `ArchiveUri`) and by
+  `UriPath._symlink_target()`, an override of a new `Path._symlink_target()`
+  hook. Relative destinations keep their existing meaning: a `rename()`
+  destination is a sibling, a `symlink_to()` target is stored verbatim and
+  stays relative. The string is **not** percent-encoded on the way in, so a
+  destination that legitimately contains a literal `%20` — or a path object
+  built by a consumer that already encoded it — is not encoded twice.
+  `readlink()`, `unlink()`, `rmdir()` and `hardlink_to()` never had this
+  defect. `copy()`/`move()` are deliberately unchanged: their `str`
+  destination is still parsed as a URI, which is what makes a cross-scheme
+  `copy("s3://bucket/key")` work. See `docs/divergences.md`.
+
 ## [0.9.2] - 2026-08-16
 
 ### Fixed
@@ -778,7 +823,8 @@ 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.2...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib-next/compare/v0.9.3...HEAD
+[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
 [0.9.1]: https://github.com/jose-pr/pathlib-next/compare/v0.9.0...v0.9.1
 [0.8.6]: https://github.com/jose-pr/pathlib-next/compare/v0.8.5...v0.8.6

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pathlib-next
-Version: 0.9.2
+Version: 0.9.3
 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.2 → pathlib_next-0.9.3}/docs/divergences.md

@@ -63,6 +63,7 @@ these operations itself always keeps its own implementation.
 | `Path.symlink_to(target, target_is_directory=False, *, force=False)` | `pathlib.Path.symlink_to(target, target_is_directory=False)` -- raises `FileExistsError` if anything already exists at the link path | Adds a keyword-only `force=`. `force=False` (the default) is stdlib-exact. `force=True` unlinks an existing **non-directory** entry at the link path first, then creates the symlink; an existing *directory* is never removed and the underlying error propagates. Not atomic: no filesystem or transport offers "replace a symlink" as one operation, so the path briefly does not exist between the unlink and the symlink. | Additive extension (an extra optional kwarg, per the parity contract). No backend can offer this atomically, so every consumer was re-implementing the same unlink-then-symlink dance -- it is path semantics, not transport semantics, so it belongs at the `Path` layer where one implementation serves every backend. Backends implement only the `_symlink_to()` primitive (same `_mkdir`/`_open` shape) and get `force=` for free. Because no stdlib version accepts the keyword, `symlink_to` is in `_OPERATION_NAMES` so `LocalPath` honors it too. |
 | `Path.chown(uid=None, gid=None, *, follow_symlinks=True)` | Not in `pathlib` at all -- it has `owner()`/`group()` **readers** but no writer (the stdlib writers are `os.chown`/`shutil.chown`, which are functions over a path, not path methods) | Our own extension. `None` (default) leaves a field unchanged; `-1` is accepted as an alias for `None` (`os.chown`'s own sentinel); an `int` is a uid/gid and a `str` is a user/group name. A call where both fields are unchanged short-circuits without touching the backend. Implemented for `LocalPath`/`FileUri` (via `shutil.chown`, or `os.lchown` for `follow_symlinks=False`) and `SftpPath` (`setstat`); `NotImplementedError` elsewhere -- including `LocalPath` on a platform without `os.chown` (Windows), where `shutil.chown` exists but cannot work. | Ownership was the one permission attribute `stat()` could report (`st_uid`/`st_gid`) that nothing could write back. The valuable part is centralizing the **"unchanged" sentinel** on `Path` (`utils.as_owner()`): `os.chown` spells it `-1`, SFTP omits the field, other middlewares use `None` -- normalizing per-scheme would be three chances to disagree. Backends implement `_chown()` and receive an already-canonical pair. SFTPv3 sends uid/gid as one paired attribute, so `SftpPath` reads the current owner for whichever field is unchanged rather than guessing a value. |
 | `Path.chmod(mode, ...)` accepting a `str` | `mode` must be an `int`; a `str` raises `TypeError` | Additionally accepts a `str`, parsed as **octal**: `"0755"`, `"755"` and `0o755` all mean the same thing. An optional `0o` prefix is allowed; any character outside `[0-7]` raises `ValueError` rather than being coerced. | The string form is how modes are written in `chmod(1)`, Ansible, Dockerfiles and shell scripts, so config-driven callers arrive holding one. Accepted only with an **explicit base 8** (`utils.as_mode()`), never a plain `int()`: `int("0755")` in decimal is 755 == `0o1363`, a different *and valid* mode, so a fallback to decimal would set plausible-but-wrong permissions with nothing raising -- which is exactly why stdlib refuses strings. Parsing in one shared helper is what makes the base non-negotiable across the five backends that implement `chmod` directly. |
+| A `str` destination to `rename()`/`symlink_to()` on a `UriPath` | `pathlib.Path.rename(str)`/`symlink_to(str)` take the string as a path, verbatim; a relative one is resolved against the **cwd** | The string is taken as an already-**decoded path**, never re-parsed as URI syntax: `?`, `#`, `%` and `:` are ordinary filename characters, so `rename("rn?b.txt")` renames to `rn?b.txt`. A relative `rename()` destination resolves against `self.parent` (sibling rename), since a URI has no cwd; a relative `symlink_to()` target is stored verbatim and stays relative, exactly as pathlib does. `copy()`/`move()` are unchanged -- their `str` destination is still parsed as a URI, which is what makes a cross-scheme `copy("s3://bucket/key")` work. | Restores pathlib parity on the two methods whose destination is unambiguously a path on the same host. Re-parsing it as a URI discarded everything from a `?`/`#` onward and percent-decoded the rest -- silently, so a rename landed on a different file and a symlink pointed somewhere else (measured against a real SFTP server, 0.9.3). Percent-encoding the string before parsing was rejected: it double-encodes a name that legitimately contains a literal `%20`, and it puts a copy of the safe set in every consumer. The parse is bypassed instead -- `Uri._from_decoded_path()`, one implementation for every scheme. |
 | `PathSyncer` / `Query` / `Source` | N/A | Our own extensions | N/A -- pure extensions, no pathlib equivalent. |
 | `PathSyncer(follow_symlinks=False).sync()` on a symlink source | N/A (no pathlib equivalent) | Previously always raised `NotImplementedError`. Now controlled by the new `symlink_mode` constructor kwarg (`"preserve"` default, `"reject"` opt-out): `"preserve"` creates a matching symlink on `target` with the same raw, unresolved target string `readlink()` returned (dangling links and relative targets included, never validated/resolved); `"reject"` restores the exact old unconditional-raise behavior. If `target` can't create symlinks at all (every backend except `LocalPath` and `SftpPath`), `"preserve"` also raises `NotImplementedError`, through the same `ignore_error`/`hook()` machinery as every other sync branch, not a silent skip. **This is a default-behavior change, not a pure extension** -- flagged here because existing callers relying on the old unconditional raise (e.g. to detect and skip symlinks) must now pass `symlink_mode="reject"` explicitly. | Faithful one-way tree mirroring needs symlinks preserved as symlinks by default, not silently dropped/erroring -- discovered via a real cross-host sync use case (hostctl). `follow_symlinks=True` (unchanged default) still resolves through symlinks during traversal, so this only affects callers who already opted into `follow_symlinks=False`. **User decision, 2026-07-28.** |
 | `S3Path` directories | N/A (pathlib directories are real filesystem entries) | `is_dir()` is prefix emulation (any object key under `"<path>/"`); `mkdir()` creates a zero-byte `"<path>/"` marker object; `rmdir()` requires no other keys under that prefix (pathlib-parity "must be empty"). If an exact object key and a `"<path>/"` prefix both exist, exact object operations such as `stat()` and `rm(recursive=True)` treat the path as the object first. | S3 has no native directory concept -- this is the same prefix convention the AWS console itself uses for an empty "folder". Exact-object precedence avoids deleting a prefix tree when the addressed path is a real object. |

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/pyproject.toml

@@ -12,7 +12,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.2"
+version = "0.9.3"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/AGENTS.md

@@ -73,15 +73,21 @@ pathlib_next`.
     equivalent. Removes a file or (with `recursive=True`) a directory tree;
     `ignore_error` (bool or predicate) controls whether an error during the
     walk is swallowed (predicate return `True`) or re-raised.
-  - `rename(target)` — not implemented by default.
+  - `rename(target)` — not implemented by default. On a `UriPath` a `str`
+    `target` is an already-**decoded path**, not URI syntax, and a relative
+    one is a sibling rename — see `Uri._rename_target()` under "URIs".
   - `_symlink_to(target, target_is_directory=False)` (not implemented by
     default) / `symlink_to(target, target_is_directory=False, *,
     force=False)` — same primitive/wrapper split as `_mkdir`/`mkdir`: a
     backend implements only `_symlink_to()` and receives an already
-    normalized path object (a `str` target is turned into one by the
-    wrapper, as `copy()`/`move()` do), then reads the raw target string the
+    normalized path object, then reads the raw target string the
     way its transport needs (`Uri.path` on the wire, `os.fspath()`
-    locally). `force=` is this library's extension: `False` is
+    locally). The `str`→path step is `_symlink_target(target)`, an
+    overridable hook: the default is `type(self)(target)`, and `UriPath`
+    overrides it so a link target is taken literally instead of being
+    re-parsed as a URI (a `?`/`#` in it is a filename character, not a
+    delimiter). A relative target is never anchored — it stays relative,
+    as in pathlib. `force=` is this library's extension: `False` is
     stdlib-exact, `True` unlinks an existing **non-directory** entry at the
     link path first (never a directory) and is **not** atomic. Listed in
     `_OPERATION_NAMES`, since no stdlib version accepts `force=`.
@@ -232,6 +238,18 @@ extra that depends on it).
   is the unambiguous accessor for "path on the URI's own host" — same
   `_host_filesystem_path` gate, but never falls back to local-path
   semantics. See `docs/divergences.md`.
+  Destination/target normalization (used by every scheme's `rename()` and
+  by `symlink_to()`): `_from_decoded_path(path)` builds a same-type URI
+  whose `.path` is `path` **verbatim** — an already-decoded path string,
+  not URI syntax, so `?`, `#`, `%` and `:` in it are ordinary filename
+  characters and only dot segments are normalized.
+  `_rename_target(target)` is what `rename()` calls: a `Uri` passes
+  through untouched, a `str` goes through `_from_decoded_path()` and, if
+  relative, is joined onto `self.parent` (sibling rename — a URI has no
+  cwd). `_symlink_target(target)` (overriding `Path`'s) is the same minus
+  the parent anchoring, so a relative link target stays relative.
+  `copy()`/`move()` deliberately still parse a `str` destination as a URI
+  — that is what makes a cross-scheme `copy("s3://bucket/key")` work.
 - **`UriPath(Uri, Path)`** — `Uri` + `Path` (I/O) + scheme dispatch.
   `UriPath(*uris, **options)` (the bare class) parses the URI and returns an
   instance of the concrete subclass registered for its scheme via

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/path.py

@@ -732,6 +732,17 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         """
         ...
 
+    def _symlink_target(self, target: "_ty.Self | str") -> "_ty.Self":
+        """Normalize a `symlink_to()` target argument to a path object.
+
+        A `str` target is the **literal link target** -- whatever it says
+        is what gets stored, verbatim and unresolved, exactly as
+        `pathlib.Path.symlink_to()` does. Override this wherever
+        `type(self)(str)` would reinterpret the string instead of taking
+        it literally (`UriPath` does; see `UriPath._symlink_target`).
+        """
+        return type(self)(target) if isinstance(target, str) else target
+
     def symlink_to(
         self,
         target: "_ty.Self | str",
@@ -758,10 +769,12 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         for.
         """
         # Normalize a str target to a path object, so the primitive only
-        # ever handles one type -- same `type(self)(target)` form as
-        # copy()/move() use for their destination, for consistency.
-        if isinstance(target, str):
-            target = type(self)(target)
+        # ever handles one type. Routed through `_symlink_target()` rather
+        # than inlining `type(self)(target)`: for a URI-backed path that
+        # constructor re-parses the string as URI syntax, which silently
+        # truncated a link target at a "?"/"#" and percent-decoded it (see
+        # `UriPath._symlink_target`).
+        target = self._symlink_target(target)
         if force:
             try:
                 self.unlink(missing_ok=True)

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/__init__.py

@@ -232,6 +232,50 @@ class Uri(Pathname):
         uri._init(source, path, query, fragment, **kwargs)
         return uri
 
+    def _from_decoded_path(self, path: str, /, **kwargs) -> "_ty.Self":
+        """Build a same-type URI whose `.path` is `path` verbatim.
+
+        `path` is an **already-decoded path string**, not URI syntax: `?`,
+        `#`, `%` and `:` are ordinary filename characters here. Only
+        path-level normalization (dot segments, exactly what `_parse_uri`
+        applies *after* decoding) is performed -- nothing is split off and
+        nothing is percent-decoded.
+
+        This is what a destination/target argument must go through.
+        Feeding such a string back into the URI parser (`Uri(path)`,
+        `type(self)(path)`) reads it as syntax: "a?b.txt" silently became
+        "a" plus a query, "a#b.txt" became "a" plus a fragment,
+        "a%20b.txt" became "a b.txt", and a relative "C:/Temp/x" became
+        scheme "c" plus "/Temp/x" -- so the wire call went to a different
+        file than the caller named, with no error. Percent-encoding the
+        string before parsing would fix the truncation but re-encode an
+        already-encoded name (a literal "%20" would come back as a space),
+        so the parse is bypassed instead of being fed encoded input.
+        """
+        return self._from_parsed_parts(
+            _NOSOURCE, _remove_dot_segments(path), None, None, **kwargs
+        )
+
+    def _rename_target(self, target: UriLike) -> "Uri":
+        """Normalize a `rename()`/`replace()` destination to a `Uri`.
+
+        A `str` is an already-decoded path (see `_from_decoded_path`), and
+        a relative one is resolved against `self.parent` -- the documented
+        sibling-rename semantics ("rename this to a new name in the same
+        directory"), not against `self` itself. A `Uri` (of any scheme
+        class) is taken as given; anything else keeps the pre-existing
+        `Uri(...)` conversion, which is already lossless for
+        `PurePath`/`os.PathLike` (they are percent-encoded on the way in
+        and decoded back out).
+        """
+        if isinstance(target, Uri):
+            return target
+        if isinstance(target, str):
+            target = self._from_decoded_path(target)
+        # target is a Uri by now, so this join re-uses `_load_parts`'
+        # existing right-to-left semantics without re-parsing anything.
+        return Uri(self.parent, target)
+
     @classmethod
     def _format_parsed_parts(
         cls,
@@ -691,6 +735,21 @@ class UriPath(Uri, Path):
         inst._init(source, self.path, self.query, self.fragment)
         return inst
 
+    def _symlink_target(self, target: "UriLike") -> "_ty.Self":
+        """`Path._symlink_target()` for URI-backed paths: a `str` target is
+        an already-decoded path, never URI syntax (see
+        `Uri._from_decoded_path`).
+
+        The default `type(self)(target)` ran the link target back through
+        the URI parser, so `symlink_to("/mnt/cache?v=2")` created a link
+        pointing at `/mnt/cache`. Unlike `_rename_target()` this never
+        anchors at `self.parent`: a symlink target is stored as given, so
+        a relative one stays relative.
+        """
+        if isinstance(target, str):
+            return self._from_decoded_path(target)
+        return target
+
     @_utils.notimplemented
     def _listdir(self) -> "_ty.Iterator[str]": ...
 

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/archive/_base.py

@@ -283,8 +283,7 @@ class ArchiveUri(UriPath):
         # A plain str target is a sibling rename (relative to self's
         # parent), matching sftp.py's/ftp.py's rename() semantics.
         self._require_writable()
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         old_path = self.path
         new_path = target.path.lstrip("/")
         names = self._names()

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/az.py

@@ -282,8 +282,7 @@ class AzPath(UriPath):
                     raise
 
     def rename(self, target: "AzPath | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest_key = (
             self.with_segments(target).key
             if not isinstance(target, AzPath)

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/dav.py

@@ -212,8 +212,7 @@ class DavPath(HttpPath):
                 raise
 
     def rename(self, target: "DavPath | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest = self.with_path(target.path)._wire_uri()
         resp = self.backend.request(
             "MOVE", self._wire_uri(), headers={"Destination": dest, "Overwrite": "F"}

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/ftp.py

@@ -228,8 +228,7 @@ class FtpPath(UriPath):
     def rename(self, target: "FtpPath | Uri | str"):
         # A plain str target is a sibling rename (relative to self's
         # parent), matching sftp.py's rename() semantics.
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         self._ftpclient.rename(self.path, target.path)
 
     def chmod(self, mode: int | str, *, follow_symlinks: bool = True):

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/gs.py

@@ -247,8 +247,7 @@ class GsPath(UriPath):
                     raise
 
     def rename(self, target: "GsPath | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest_key = target.path.lstrip("/")
         source_blob = self._bucket.blob(self.key)
         self._bucket.copy_blob(source_blob, self._bucket, dest_key)

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/s3.py

@@ -254,8 +254,7 @@ class S3Path(UriPath):
                     raise
 
     def rename(self, target: "S3Path | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest_key = target.path.lstrip("/")
         self._client.copy_object(
             Bucket=self.bucket,

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/sftp/__init__.py

@@ -357,9 +357,11 @@ class SftpPath(UriPath):
         # "host:" for the sftp wire protocol, which only wants the raw path.
         # A plain str target is resolved relative to self's *parent*
         # (sibling rename -- "rename this file to a new name in the same
-        # directory"), not to self itself (which would join it as a child).
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        # directory"), not to self itself (which would join it as a child)
+        # -- and is taken as a literal path rather than re-parsed as a URI,
+        # which used to truncate "rn?b.txt" to "rn" on the wire (see
+        # `Uri._rename_target`).
+        target = self._rename_target(target)
         return self._sftpclient.rename(self.path, target.path)
 
     def _symlink_to(

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/tests/test_archive_uri.py

@@ -402,3 +402,18 @@ def test_archive_scheme_tar_detected_write_raises_not_implemented(tar_archive):
     p = UriPath(_archive_uri(tar_archive)) / "new.txt"
     with pytest.raises(NotImplementedError):
         p.write_text("nope")
+
+
+# --- destination member names are decoded paths, not URI syntax (0.9.3) ---
+
+
+@pytest.mark.parametrize("name", ["re?named.txt", "re#named.txt", "re%20named.txt"])
+def test_zip_rename_str_destination_is_a_literal_member_name(zip_archive, name):
+    # Asserted against the archive's own namelist, not via `root / name`:
+    # `__truediv__` is a URI join and would re-interpret the "?" itself.
+    root = UriPath(_zip_uri(zip_archive))
+    (root / "top.txt").rename(name)
+    with zipfile.ZipFile(zip_archive) as zf:
+        assert name in zf.namelist()
+        assert zf.read(name) == b"top level"
+        assert "top.txt" not in zf.namelist()

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/tests/test_ftp.py

@@ -365,3 +365,17 @@ def test_chmod_follow_symlinks_false_raises_notimplemented():
     p = _ftp("ftp://host/a.txt", backend=backend)
     with pytest.raises(NotImplementedError):
         p.chmod(0o644, follow_symlinks=False)
+
+
+# --- destination arguments are decoded paths, not URI syntax (0.9.3) ------
+# Same defect as SftpPath's (`Uri(self.parent, target)` re-parsed the
+# destination as a URI); FtpPath's `.path` is likewise a filesystem path on
+# the server, so "?" / "#" / "%xx" in it are ordinary filename characters.
+
+
+@pytest.mark.parametrize("name", ["rn?b.txt", "rn#b.txt", "rn%20b.txt", "rn:b.txt"])
+def test_rename_str_destination_is_a_literal_path(name):
+    backend = _FakeBackend()
+    p = _ftp("ftp://host/mnt/a.txt", backend=backend)
+    p.rename(name)
+    assert backend._client.rename_calls == [("/mnt/a.txt", f"/mnt/{name}")]

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/tests/test_s3.py

@@ -294,3 +294,17 @@ def test_rename_uses_copy_then_delete():
 def test_chmod_not_implemented():
     with pytest.raises(NotImplementedError):
         _s3("s3://bucket/a.txt").chmod(0o644)
+
+
+# --- destination keys are decoded paths, not URI syntax (0.9.3) ----------
+# "?" and "#" are legal S3 key characters; the old
+# `Uri(self.parent, target)` truncated the destination key at either one.
+
+
+@pytest.mark.parametrize("name", ["b?x.txt", "b#x.txt", "b%20x.txt"])
+def test_rename_str_destination_key_is_literal(name):
+    backend = _FakeBackend()
+    backend._client.objects["a.txt"] = b"content"
+    _s3("s3://bucket/a.txt", backend).rename(name)
+    assert backend._client.objects.get(name) == b"content"
+    assert "a.txt" not in backend._client.objects

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/tests/test_sftp.py

@@ -34,6 +34,8 @@ class _FakeSftpClient:
         self.rename_calls = []
         self.chmod_calls = []
         self.chown_calls = []
+        self.symlink_calls = []
+        self.link_calls = []
         # Owner reported by stat(), so a partial chown() (one field left
         # "unchanged") has something to read back for the other field.
         self.stat_uid = 501
@@ -72,6 +74,12 @@ class _FakeSftpClient:
     def mkdir(self, path, mode):
         pass
 
+    def symlink(self, target, path):
+        self.symlink_calls.append((target, path))
+
+    def link(self, target, path):
+        self.link_calls.append((target, path))
+
 
 class _FakeBackend(BaseSftpBackend):
     def __init__(self):
@@ -1048,3 +1056,124 @@ def test_chmod_rejects_non_octal_digits():
     p = _sftp("sftp://host/a.txt")
     with pytest.raises(ValueError):
         p.chmod("0899")
+
+
+# --- destination arguments are decoded paths, not URI syntax (0.9.3) ------
+#
+# `rename()`/`symlink_to()` used to run a `str` destination back through the
+# URI parser (`Uri(self.parent, target)` / `type(self)(target)`), so anything
+# from a "?" or "#" onward was discarded and "%xx" was decoded -- silently,
+# and against a real server (measured on TrueNAS 26.0.0-BETA.1):
+#     rename(".../rn?b.txt")      -> the file became ".../rn"
+#     symlink_to(".../cache?v=2") -> the link pointed at ".../cache"
+# Every assertion below is on the argument the BACKEND received, not on the
+# absence of an exception: the buggy code raised nothing at all.
+
+# ("filename", "the path the wire call must carry for /mnt/<filename>")
+_DEST_NAMES = [
+    "rn?b.txt",  # query delimiter
+    "rn#b.txt",  # fragment delimiter
+    "rn b.txt",  # space (already survived, guards the fix)
+    "rn%20b.txt",  # LITERAL percent-escape: must NOT become "rn b.txt"
+    "rn%b.txt",  # bare, un-decodable percent
+    "rn:b.txt",  # colon must stay readable (a "/C:/Temp" path depends on it)
+    "a+b&c=d.txt",  # other sub-delims
+]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_rename_str_destination_is_a_literal_path(name):
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/a.txt", backend=backend)
+    p.rename(name)
+    # Relative str == sibling rename, so it lands beside self.
+    assert backend._client.rename_calls == [("/mnt/a.txt", f"/mnt/{name}")]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_rename_absolute_str_destination_is_a_literal_path(name):
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/a.txt", backend=backend)
+    p.rename(f"/other/{name}")
+    assert backend._client.rename_calls == [("/mnt/a.txt", f"/other/{name}")]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_symlink_to_str_target_is_a_literal_path(name):
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/link", backend=backend)
+    p.symlink_to(f"/mnt/{name}")
+    assert backend._client.symlink_calls == [(f"/mnt/{name}", "/mnt/link")]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_symlink_to_relative_str_target_stays_relative_and_literal(name):
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/link", backend=backend)
+    p.symlink_to(name)
+    # Unlike rename()'s destination, a symlink target is stored verbatim --
+    # never anchored at self.parent (pathlib.Path.symlink_to() parity).
+    assert backend._client.symlink_calls == [(name, "/mnt/link")]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_hardlink_to_str_target_is_a_literal_path(name):
+    class _HardlinkBackend(_FakeBackend):
+        supports_hardlink = True
+
+    backend = _HardlinkBackend()
+    p = _sftp("sftp://host/mnt/link", backend=backend)
+    p.hardlink_to(f"/mnt/{name}")
+    assert backend._client.link_calls == [(f"/mnt/{name}", "/mnt/link")]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_rename_path_object_destination_is_not_double_decoded(name):
+    """A destination that is already a path OBJECT must reach the wire
+    exactly once-decoded.
+
+    This is the double-encoding guard: consumers (pytruenas 0.4.4/0.4.5)
+    percent-encode a decoded filesystem path and construct the path from
+    the resulting URI. The fix must not add a second encode/decode round
+    on top -- a literal "%20" in the name is the case that catches it.
+    """
+    import uritools
+
+    # RFC 3986 pchar + "/" -- ":" deliberately left unencoded so that a
+    # "/C:/Temp/..." path stays readable in the URI.
+    encoded = uritools.uriencode(f"/mnt/{name}", safe="/:@-._~!$&'()*+,;=").decode()
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/a.txt", backend=backend)
+    target = SftpPath(f"sftp://host{encoded}", backend=backend)
+    assert target.path == f"/mnt/{name}"
+    p.rename(target)
+    assert backend._client.rename_calls == [("/mnt/a.txt", f"/mnt/{name}")]
+
+
+@pytest.mark.parametrize("name", _DEST_NAMES)
+def test_symlink_to_path_object_target_is_not_double_decoded(name):
+    import uritools
+
+    encoded = uritools.uriencode(f"/mnt/{name}", safe="/:@-._~!$&'()*+,;=").decode()
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/link", backend=backend)
+    target = SftpPath(f"sftp://host{encoded}", backend=backend)
+    p.symlink_to(target)
+    assert backend._client.symlink_calls == [(f"/mnt/{name}", "/mnt/link")]
+
+
+def test_rename_str_destination_keeps_a_windows_style_drive_path():
+    # A relative destination whose first segment ends in ":" used to be
+    # read as a URI SCHEME: "C:/Temp/x.txt" parsed as scheme "c" with path
+    # "/Temp/x.txt", so the rename left the directory entirely.
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/a.txt", backend=backend)
+    p.rename("C:/Temp/x.txt")
+    assert backend._client.rename_calls == [("/mnt/a.txt", "/mnt/C:/Temp/x.txt")]
+
+
+def test_symlink_to_str_target_keeps_dot_dot_relative():
+    backend = _FakeBackend()
+    p = _sftp("sftp://host/mnt/sub/link", backend=backend)
+    p.symlink_to("../real.txt")
+    assert backend._client.symlink_calls == [("../real.txt", "/mnt/sub/link")]

{pathlib_next-0.9.2 → pathlib_next-0.9.3}/tests/test_uri_path.py

@@ -140,3 +140,61 @@ def test_uripath_unimplemented_unlink():
     p = UriPath("custom://host/a")
     with pytest.raises(NotImplementedError):
         p.unlink()
+
+
+# --- destination/target normalization (0.9.3) ----------------------------
+#
+# The single place every scheme's `rename()` and `symlink_to()` now converts
+# a `str` destination. Tested here, once, rather than per-scheme: a `str`
+# destination is an already-decoded PATH, so feeding it back through the URI
+# parser truncated it at "?"/"#", percent-decoded it, and read a leading
+# "C:" as a scheme -- silently, on the wire.
+
+_DECODED = ["rn?b.txt", "rn#b.txt", "rn b.txt", "rn%20b.txt", "rn%b.txt", "rn:b.txt"]
+
+
+@pytest.mark.parametrize("name", _DECODED)
+def test_rename_target_str_is_a_sibling_literal_path(name):
+    p = UriPath("customscheme://host/mnt/a.txt")
+    assert p._rename_target(name).path == f"/mnt/{name}"
+
+
+@pytest.mark.parametrize("name", _DECODED)
+def test_rename_target_absolute_str_is_a_literal_path(name):
+    p = UriPath("customscheme://host/mnt/a.txt")
+    assert p._rename_target(f"/other/{name}").path == f"/other/{name}"
+
+
+@pytest.mark.parametrize("name", _DECODED)
+def test_rename_target_uri_is_taken_as_given(name):
+    p = UriPath("customscheme://host/mnt/a.txt")
+    target = Uri("customscheme://host/mnt/x")._from_decoded_path(f"/mnt/{name}")
+    # An already-built path object must pass straight through: no second
+    # encode/decode round on top of whatever built it (consumers that
+    # percent-encode a decoded path and construct from the resulting URI
+    # would otherwise see a literal "%20" come back as a space).
+    assert p._rename_target(target).path == f"/mnt/{name}"
+
+
+@pytest.mark.parametrize("name", _DECODED)
+def test_symlink_target_str_is_literal_and_never_anchored(name):
+    p = UriPath("customscheme://host/mnt/link")
+    # Relative stays relative -- unlike rename(), a symlink target is
+    # stored verbatim (pathlib.Path.symlink_to() parity).
+    assert p._symlink_target(name).path == name
+    assert p._symlink_target(f"/mnt/{name}").path == f"/mnt/{name}"
+
+
+def test_symlink_target_keeps_dot_dot_relative():
+    p = UriPath("customscheme://host/mnt/sub/link")
+    assert p._symlink_target("../real.txt").path == "../real.txt"
+
+
+def test_from_decoded_path_keeps_backend_and_drops_query_fragment():
+    p = UriPath("customscheme://host/mnt/a.txt?q=1#f")
+    target = p._from_decoded_path("/mnt/b?c#d.txt")
+    assert target.path == "/mnt/b?c#d.txt"
+    # self's own query/fragment must not leak onto a destination.
+    assert not target.query
+    assert not target.fragment
+    assert target.backend is p.backend