lambda-watcher 0.2.0__tar.gz → 0.3.0__tar.gz

{lambda_watcher-0.2.0 → lambda_watcher-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-watcher
-Version: 0.2.0
+Version: 0.3.0
 Summary: Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions.
 Author: Lambda Watcher contributors
 License: Apache-2.0

{lambda_watcher-0.2.0 → lambda_watcher-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lambda-watcher"
-version = "0.2.0"
+version = "0.3.0"
 description = "Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions."
 readme = "README.md"
 requires-python = ">=3.10"

{lambda_watcher-0.2.0 → lambda_watcher-0.3.0}/src/lambda_watcher/__init__.py

@@ -1,4 +1,4 @@
 """Watch a downloads folder for AWS Lambda deployment packages and version them."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __all__ = ["__version__"]

{lambda_watcher-0.2.0 → lambda_watcher-0.3.0}/src/lambda_watcher/cli.py

@@ -11,7 +11,7 @@ import sys
 import webbrowser
 import zipfile
 from datetime import datetime, timezone
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import NoReturn, Optional
 
 import typer
@@ -36,7 +36,7 @@ from .service import (
     install_service,
     stop_service,
 )
-from .store import Store
+from .store import Store, posix_stored_dir
 from .utils import format_ts, human_size, relative_ts, rmtree, setup_logging, slugify
 
 #: Index connections opened by the running command; see `_close_open_dbs`.
@@ -187,6 +187,19 @@ def _version_or_fail(db: Database, function_id: int, seq: int):
     return row
 
 
+def _stored_dirname(stored_dir: str) -> str:
+    """The last segment of a version's stored path: ``0007-a1b2c3d4``.
+
+    Goes through :func:`~lambda_watcher.store.posix_stored_dir` first, so it
+    reads the same answer out of a value an older release wrote on Windows —
+    where ``Path(...).name`` on Linux returns the whole backslash-joined string
+    instead of the directory name, and the caller then builds a path to nothing.
+    """
+    # back-compat: `posix_stored_dir` is the whole point of this helper existing
+    # rather than callers reaching for `Path(...).name` themselves.
+    return PurePosixPath(posix_stored_dir(stored_dir)).name
+
+
 def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: int, b_seq: int,
                 include_vendor: bool | None, compute_diffs: bool = True):
     """Resolve two versions and build the diff between them.
@@ -194,7 +207,10 @@ def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: in
     Warns, rather than fails, when a version's extracted code is missing from
     disk: the index still knows what changed at the file level, so the summary
     and dependency layers are worth printing even though the line diffs come out
-    empty. Deleting an archive directory by hand is the usual cause.
+    empty. Deleting an archive directory by hand is one cause; an index pointing
+    somewhere the directory no longer is, after the archive was moved or copied
+    from another machine, is the other — which is why the warning names
+    ``lw reindex``, the command that rebuilds the index from what is on disk.
     """
     a = _version_or_fail(db, function_row["id"], a_seq)
     b = _version_or_fail(db, function_row["id"], b_seq)
@@ -203,7 +219,8 @@ def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: in
         if not path.exists():
             err_console.print(
                 f"[yellow]warning:[/yellow] code for v{seq:04d} is missing at {path}; "
-                "line diffs for it will be empty"
+                "line diffs for it will be empty. If the archive was moved or copied "
+                "here, `lw reindex` re-points the index at what is on disk."
             )
     return diff_from_index(db, store, cfg.diff, function_row["name"], a, b,
                            include_vendor=include_vendor, compute_diffs=compute_diffs)
@@ -1128,8 +1145,15 @@ def rename(
         if new_dir.exists():
             _fail(f"{new_dir} already exists on disk; move it aside first")
         old_dir.rename(new_dir)
+        # back-compat: re-point the index by rebuilding each path from where the
+        # directory now is, rather than by patching the stored string. A
+        # `functions/<old slug>/` replacement silently matched nothing in an
+        # archive an older release wrote on Windows, where the separator is a
+        # backslash — and a version left pointing at the pre-rename path reads
+        # as missing from then on, which is a diff with no lines in it.
+        new_versions = store.versions_dir(new_slug)
         for version in db.list_versions(int(row["id"])):
-            updated = version["dir"].replace(f"functions/{old_slug}/", f"functions/{new_slug}/", 1)
+            updated = store.relative(new_versions / _stored_dirname(version["dir"]))
             db.conn.execute("UPDATE versions SET dir = ? WHERE id = ?", (updated, version["id"]))
     if old_slug != new_slug:
         # The mirror lives outside the function directory, so it does not move
@@ -1209,7 +1233,7 @@ def merge(
         stored = store.resolve_version_dir(version["dir"])
         if stored.exists():
             continue
-        candidate = dst_versions / Path(version["dir"]).name
+        candidate = dst_versions / _stored_dirname(version["dir"])
         if candidate.exists():
             db.conn.execute(
                 "UPDATE versions SET dir = ? WHERE id = ?",

{lambda_watcher-0.2.0 → lambda_watcher-0.3.0}/src/lambda_watcher/diffing/compare.py

@@ -38,7 +38,15 @@ class FileRecord:
 
     @classmethod
     def from_row(cls, row: Any) -> FileRecord:
-        """Build a record from an index row, filling in defaults for null columns."""
+        """Build a record from an index row, filling in defaults for null columns.
+
+        The defaults are not decoration: a row reindexed from a manifest written
+        before ``lang`` and ``mode`` were recorded has NULL in those columns, and
+        the diff would rather call the file ``text`` at 644 than fail on it.
+        """
+        # back-compat: `or "text"` / `or 0o644` cover columns an older manifest
+        # cannot fill. Drop them and reindexing an old archive builds rows that
+        # crash the diff instead of one that is merely vaguer than it could be.
         return cls(
             path=row["path"], size=int(row["size"]), sha256=row["sha256"],
             is_text=bool(row["is_text"]), is_vendor=bool(row["is_vendor"]),
@@ -56,8 +64,9 @@ class FileChange:
 
     ``diff_lines`` may be empty even for a real modification —
     ``skipped_reason`` then says why (binary, too large, ignored by config,
-    whitespace only), so the renderer can explain the absence rather than imply
-    nothing changed. Two of those absences are not refusals but better answers:
+    whitespace only, missing from the archive), so the renderer can explain the
+    absence rather than imply nothing changed. Two of those absences are not
+    refusals but better answers:
     a whitespace-only change is fully described by its label, and a file with no
     usable lines is described by ``word_edits`` instead. See :func:`_fill_diff`.
     """
@@ -87,6 +96,12 @@ class FileChange:
     #: The changed runs of a ``long_lines`` file, with enough text either side to
     #: place them. Empty for every ordinary file.
     word_edits: list[WordEdit] = field(default_factory=list)
+    #: True when the index lists the file but the archived version directory does
+    #: not hold it, so there was nothing to diff. Unlike every other reason a
+    #: hunk is absent, this one is not about the file at all — the archive is
+    #: incomplete, or the index is pointing at the wrong place — so the
+    #: renderers say what to do about it rather than only what happened.
+    missing: bool = False
 
     @property
     def is_vendor(self) -> bool:
@@ -146,6 +161,7 @@ class FileChange:
             "is_vendor": self.is_vendor,
             "whitespace_only": self.whitespace_only,
             "long_lines": self.long_lines,
+            "missing": self.missing,
             "word_edits": [e.as_dict() for e in self.word_edits],
         }
 
@@ -764,6 +780,21 @@ def _whitespace_key(text: str) -> tuple[str, ...]:
     return tuple(" ".join(line.split()) for line in text.splitlines() if line.strip())
 
 
+def _absent(root: Path, record: FileRecord | None) -> bool:
+    """True when the index lists this file but the archive no longer holds it.
+
+    :func:`~lambda_watcher.utils.read_text` answers None both for bytes that are
+    not text and for a file it could not open at all, and the second is by far
+    the likelier of the two here: the index is derived from disk, so a file it
+    lists was readable when it was written. A version directory that has been
+    deleted, moved, or restored under a path the index does not know about is
+    what actually produces it — see :meth:`lambda_watcher.store.Store.relative`.
+    Telling the reader "not decodable as text" for that sends them looking for an
+    encoding problem in a file that is simply not there.
+    """
+    return record is not None and not (root / record.path).is_file()
+
+
 def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConfig) -> None:
     """Work out what changed inside one file and write it onto the change.
 
@@ -792,7 +823,10 @@ def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConf
         Everything else, from :func:`difflib.unified_diff`.
 
     Before any of that, a file can be refused outright — binary, over
-    ``max_diff_file_kb``, or not decodable — and ``skipped_reason`` says which.
+    ``max_diff_file_kb``, not decodable, or missing from the archive — and
+    ``skipped_reason`` says which. The last of those is not a property of the
+    file's bytes but of the archive around it, so it is told apart by
+    :func:`_absent` rather than lumped in with the encodings.
     Line counts stay at zero on every route but the last: the counts describe a
     hunk, and where there is no hunk ``+3/-3`` is the noise the route exists to
     remove.
@@ -813,7 +847,10 @@ def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConf
     old_text = read_text(old_root / old.path) if old else ""
     new_text = read_text(new_root / new.path) if new else ""
     if old_text is None or new_text is None:
-        change.skipped_reason = "not decodable as text"
+        change.missing = _absent(old_root, old) or _absent(new_root, new)
+        change.skipped_reason = (
+            "missing from the archive" if change.missing else "not decodable as text"
+        )
         return
 
     if old_text and new_text and old_text != new_text: