kvgit 0.3.8__tar.gz → 0.3.9__tar.gz

{kvgit-0.3.8 → kvgit-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kvgit
-Version: 0.3.8
+Version: 0.3.9
 Summary: Versioned key-value store with git-like commit, branch, and merge semantics.
 Author: ashenfad
 License: MIT

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/__init__.py

@@ -1,8 +1,16 @@
 """kvgit: Versioned key-value store."""
 
 from .content_types import MergeFn, counter, last_writer_wins, text_merge
-from .errors import ConcurrencyError, GcBusy, MergeConflict
-from .merges import CantMark, TextMergeFn, make_text_merge, ours, text, theirs
+from .errors import ConcurrencyError, GcBusy, MergeConflict, UnknownBranchError
+from .merges import (
+    CantMark,
+    TextMergeFn,
+    make_text_merge,
+    ours,
+    text,
+    text_merge_result,
+    theirs,
+)
 from .namespaced import Namespaced
 from .staged import Staged
 from .store import delete_branches, delete_tags, store
@@ -28,6 +36,7 @@ __all__ = [
     "Staged",
     "TagInfo",
     "TextMergeFn",
+    "UnknownBranchError",
     "Versioned",
     "VersionedKV",
     "counter",
@@ -39,5 +48,6 @@ __all__ = [
     "store",
     "text",
     "text_merge",
+    "text_merge_result",
     "theirs",
 ]

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/content_types.py

@@ -31,7 +31,12 @@ def last_writer_wins() -> MergeFn:
     return lambda old, ours, theirs: theirs
 
 
-def text_merge(*, ours_label: str = "ours", theirs_label: str = "theirs") -> MergeFn:
+def text_merge(
+    *,
+    ours_label: str = "ours",
+    theirs_label: str = "theirs",
+    strict: bool = False,
+) -> MergeFn:
     """Marker merge for ``str`` (or ``bytes``) values, for use with ``Staged``.
 
     The value-level counterpart to :func:`kvgit.merges.text`. ``Staged``
@@ -43,13 +48,17 @@ def text_merge(*, ours_label: str = "ours", theirs_label: str = "theirs") -> Mer
 
     Disjoint line changes merge cleanly and overlapping ones come back
     with git-style ``<<<<<<<`` markers (labelled by ``ours_label`` /
-    ``theirs_label``) rather than raising. A value that is neither
-    ``str`` nor ``bytes``, and anything the marker merge cannot handle —
-    undecodable bytes, NUL bytes, inputs over the size cap — raises
+    ``theirs_label``) rather than raising. With ``strict=True`` a
+    conflict raises instead of marking, so the merge aborts rather than
+    landing hunks. A value that is neither ``str`` nor ``bytes``, and
+    anything the marker merge cannot handle — undecodable bytes, NUL
+    bytes, inputs over the size cap — raises
     :class:`~kvgit.merges.CantMark`, which the merge machinery files as
     an ordinary conflict.
     """
-    merge_bytes = make_text_merge(ours_label=ours_label, theirs_label=theirs_label)
+    merge_bytes = make_text_merge(
+        ours_label=ours_label, theirs_label=theirs_label, strict=strict
+    )
 
     def encode(value: Any) -> bytes | None:
         if value is None or isinstance(value, bytes):

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/errors.py

@@ -28,6 +28,15 @@ class MergeConflict(Exception):
         super().__init__(f"Merge conflict on keys: {keys_str}")
 
 
+class UnknownBranchError(ValueError):
+    """Raised when opening or switching to a branch that does not exist.
+
+    A subclass of ``ValueError``, so existing ``except ValueError``
+    handlers keep working. Open with ``create=True`` (the default) to
+    mint the branch instead.
+    """
+
+
 class GcBusy(Exception):
     """Raised when a deep clean cannot take the store's GC lease.
 

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/merges.py

@@ -27,13 +27,24 @@ from .versioned.protocol import BytesMergeFn, MergeChoice
 #: is a whole-file conflict by inspection anyway.
 MAX_MARK_BYTES = 1024 * 1024
 
+#: Line boundaries recognized by ``str.splitlines`` beyond ``"\n"``. A
+#: line ending in any of these is already terminated — gluing the next
+#: line after it re-splits to the same lines — so :func:`_terminate`
+#: leaves it alone, and labels may not contain any of them.
+_LINE_BOUNDARIES = frozenset(
+    ["\n", "\r", "\v", "\f", "\x1c", "\x1d", "\x1e", "\x85", "\u2028", "\u2029"]
+)
+
 
 class CantMark(Exception):
-    """A value cannot be marker-merged: not text, or too big.
+    """A value cannot be marker-merged: not text, too big, or a conflict
+    under ``strict=True``.
 
     Raised instead of returning bytes when the inputs are undecodable as
-    UTF-8, contain NUL bytes, or exceed ``MAX_MARK_BYTES`` combined.
-    The merge machinery reports it as a conflict for that key.
+    UTF-8, contain NUL bytes, or exceed ``MAX_MARK_BYTES`` combined — or,
+    when built with ``strict=True``, when the merge would have written
+    conflict markers. The merge machinery reports it as a conflict for
+    that key.
     """
 
 
@@ -69,15 +80,17 @@ def _changes(base: list[str], side: list[str]) -> list[tuple[int, int, list[str]
 
 
 def _terminate(lines: list[str]) -> list[str]:
-    """Ensure every non-final line ends with a newline.
+    """Ensure every non-final line ends with a line break.
 
-    A line without a trailing newline glued onto following output would
+    A line without a trailing break glued onto following output would
     corrupt both; clean regions stay byte-exact (a final line keeps its
-    missing newline), markers pay the newline tax.
+    missing break, and lines ending in a non-LF ``splitlines`` boundary
+    such as lone ``\\r`` are already terminated, so no ``\\n`` is added),
+    markers pay the newline tax.
     """
     fixed: list[str] = []
     for i, ln in enumerate(lines):
-        if not ln.endswith("\n") and i + 1 < len(lines):
+        if i + 1 < len(lines) and ln[-1:] not in _LINE_BOUNDARIES:
             ln += "\n"
         fixed.append(ln)
     return fixed
@@ -210,33 +223,72 @@ def _merge_lines(
     return _terminate(out), conflicted
 
 
+def _check_labels(ours_label: str, theirs_label: str) -> None:
+    for name, label in (("ours_label", ours_label), ("theirs_label", theirs_label)):
+        if any(boundary in label for boundary in _LINE_BOUNDARIES):
+            raise ValueError(f"{name} may not contain a newline: {label!r}")
+
+
+def text_merge_result(
+    old: bytes | None,
+    ours: bytes | None,
+    theirs: bytes | None,
+    *,
+    ours_label: str = "ours",
+    theirs_label: str = "theirs",
+) -> tuple[bytes, bool]:
+    """Marker-merge returning ``(merged_bytes, conflicted)``.
+
+    Same merge as :func:`make_text_merge`, but the flag tells whether the
+    merge introduced conflict hunks — reliably, where counting
+    ``<<<<<<<`` lines cannot, because the inputs may legitimately contain
+    marker-like lines that merge through untouched. Anything unmarkable
+    still raises :class:`CantMark`.
+    """
+    _check_labels(ours_label, theirs_label)
+    total = sum(len(d) for d in (old, ours, theirs) if d is not None)
+    if total > MAX_MARK_BYTES:
+        raise CantMark(f"inputs total {total} bytes over cap {MAX_MARK_BYTES}")
+    merged, conflicted = _merge_lines(
+        _decode(old),
+        _decode(ours),
+        _decode(theirs),
+        ours_label,
+        theirs_label,
+        ours_deleted=ours is None and old is not None,
+        theirs_deleted=theirs is None and old is not None,
+    )
+    return "".join(merged).encode("utf-8"), conflicted
+
+
 def make_text_merge(
-    *, ours_label: str = "ours", theirs_label: str = "theirs"
+    *,
+    ours_label: str = "ours",
+    theirs_label: str = "theirs",
+    strict: bool = False,
 ) -> BytesMergeFn:
     """Build a marker-merge fn with custom conflict labels.
 
     Labels ride git's positions (``<<<<<<< <ours>`` /
     ``>>>>>>> <theirs>``); pass branch names so conflicts read
-    attributably. Labels may not contain newlines.
+    attributably. Labels may not contain newlines (any ``str.splitlines``
+    boundary: LF, lone CR, VT/FF, FS/GS/RS, NEL, U+2028/2029).
+
+    With ``strict=True`` the fn raises :class:`CantMark` instead of
+    writing markers when sides conflict — for branches where a true
+    conflict must abort the commit rather than land hunks. The merge
+    machinery files it as an ordinary conflict, same as unmarkable
+    input.
     """
-    for name, label in (("ours_label", ours_label), ("theirs_label", theirs_label)):
-        if "\n" in label:
-            raise ValueError(f"{name} may not contain a newline: {label!r}")
+    _check_labels(ours_label, theirs_label)
 
     def merge(old: bytes | None, ours: bytes | None, theirs: bytes | None) -> bytes:
-        total = sum(len(d) for d in (old, ours, theirs) if d is not None)
-        if total > MAX_MARK_BYTES:
-            raise CantMark(f"inputs total {total} bytes over cap {MAX_MARK_BYTES}")
-        merged, _ = _merge_lines(
-            _decode(old),
-            _decode(ours),
-            _decode(theirs),
-            ours_label,
-            theirs_label,
-            ours_deleted=ours is None and old is not None,
-            theirs_deleted=theirs is None and old is not None,
+        merged, conflicted = text_merge_result(
+            old, ours, theirs, ours_label=ours_label, theirs_label=theirs_label
         )
-        return "".join(merged).encode("utf-8")
+        if conflicted and strict:
+            raise CantMark("strict text merge: conflicting changes cannot be marked")
+        return merged
 
     return merge
 

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/staged.py

@@ -553,6 +553,10 @@ class Staged(MutableMapping[str, Any]):
         """List all branch names in the store."""
         return self._versioned.list_branches()
 
+    def branch_exists(self, name: str) -> bool:
+        """Whether a branch exists in the store."""
+        return self._versioned.branch_exists(name)
+
     def delete_branch(self, name: str) -> None:
         """Delete a branch by name. Cannot delete the current branch."""
         self._versioned.delete_branch(name)
@@ -625,6 +629,10 @@ class Staged(MutableMapping[str, Any]):
         """Yield the commit chain from newest to oldest."""
         return self._versioned.history(commit_hash, all_parents=all_parents)
 
+    def merge_base(self, commit_a: str, commit_b: str) -> str | None:
+        """Lowest common ancestor of two commits, or None if unrelated."""
+        return self._versioned.merge_base(commit_a, commit_b)
+
     def refresh(self) -> None:
         """Reload from HEAD and discard staged changes."""
         self._versioned.refresh()

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/store.py

@@ -52,6 +52,7 @@ def store(
     path: str | None = None,
     db_name: str = "kvgit",
     branch: str = "main",
+    create: bool = True,
     encoder: Callable[..., bytes] = pickle.dumps,
     decoder: Callable[..., Any] = pickle.loads,
     codecs: str | None = None,
@@ -66,6 +67,11 @@ def store(
         db_name: IndexedDB database name (default ``"kvgit"``).
             Only used when ``kind="indexeddb"``.
         branch: Branch name (default ``"main"``).
+        create: Mint the branch with an initial commit when it does not
+            exist (default ``True``). Pass ``False`` to raise
+            :class:`~kvgit.errors.UnknownBranchError` instead, so a
+            read after a delete cannot resurrect the branch and block
+            a later create.
         encoder: Value encoder (default ``pickle.dumps``).
         decoder: Value decoder (default ``pickle.loads``).
         codecs: Optional named codec preset. Currently supported:
@@ -106,6 +112,7 @@ def store(
         VersionedKV(
             backend,
             branch=branch,
+            create=create,
             recover_from_corrupt_head=recover_from_corrupt_head,
         ),
         encoder=encoder,

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/versioned/base.py

@@ -118,6 +118,15 @@ class VersionedBase(ABC):
         target = commit_hash or self._current_commit
         return self._load_parents(target)
 
+    def merge_base(self, commit_a: str, commit_b: str) -> str | None:
+        """Lowest common ancestor of two commits, or None if unrelated.
+
+        When several commits tie for lowest (criss-cross histories),
+        the smallest hash wins — deterministic, but arbitrary. This is
+        exactly the base a merge of the two commits would use.
+        """
+        return self._find_lca(commit_a, commit_b)
+
     # -- Commit orchestration --
 
     def commit(
@@ -137,6 +146,10 @@ class VersionedBase(ABC):
 
         Creates a new commit with the given changes and advances the
         branch HEAD.  If HEAD has diverged, performs a three-way merge.
+        A HEAD move that lands inside the fast-forward CAS window is
+        retried once against the new HEAD through that same merge path,
+        so a single well-behaved writer never sees ``ConcurrencyError``
+        for a race it can merge past.
 
         Args:
             updates: Key-value pairs to add or update (bytes values).
@@ -182,6 +195,7 @@ class VersionedBase(ABC):
             )
 
         current_head = self.latest_head
+        ours_built = False
 
         if current_head == self._base_commit:
             # Fast-forward path
@@ -205,31 +219,43 @@ class VersionedBase(ABC):
                 )
                 self.last_merge_result = result
                 return result
-            self._restore_state(saved)
-            if on_conflict == "abandon":
-                result = MergeResult(
-                    merged=False,
-                    commit=None,
-                    strategy="fast_forward",
-                    auto_merged_keys=(),
-                    carried_keys=(),
-                )
-                self.last_merge_result = result
-                return result
-            raise ConcurrencyError(
-                f"HEAD changed from {self._base_commit}. Refresh and retry."
-            )
+            # Lost the fast-forward race: another writer advanced HEAD
+            # between our read and our CAS. Re-read HEAD and merge, the
+            # way the base-behind-head case already does — in either
+            # mode, so a lost race is never mistaken for a conflict and
+            # the caller never has to refresh (and drop staged work)
+            # just to replay a mergeable commit.
+            try:
+                current_head = self.latest_head
+            except Exception:
+                # A failing re-read must not leave phantom state behind
+                # either.
+                self._restore_state(saved)
+                raise
+            # Keep the commit just built as our side of the merge rather
+            # than restoring and rebuilding it: a rebuild hashes
+            # identically (created_at is not in the commit hash) but
+            # writes different HAMT nodes, orphaning the first attempt's
+            # nodes where clean_orphans cannot find them.
+            ours_built = True
 
         # Three-way merge path
         if current_head is None:
+            # A retry that finds its branch gone restores the pre-commit
+            # snapshot, so the failed commit leaves the handle exactly as
+            # it found it. A null first read builds nothing, so only a
+            # retry can have anything to restore.
+            if ours_built:
+                self._restore_state(saved)
             raise ValueError(f"Branch '{self._branch}' has no HEAD")
-        saved = self._snapshot_state()
-        self._create_commit(
-            updates,
-            removals,
-            chunks=chunks,
-            chunk_refs=chunk_refs,
-        )
+        if not ours_built:
+            saved = self._snapshot_state()
+            self._create_commit(
+                updates,
+                removals,
+                chunks=chunks,
+                chunk_refs=chunk_refs,
+            )
         return self._three_way_merge(
             current_head,
             on_conflict=on_conflict,

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/versioned/kv.py

@@ -65,10 +65,11 @@ import logging
 import os
 import time
 import uuid
+from collections import deque
 from collections.abc import Callable
 
 from ..encoding import dumps, loads, safe_loads
-from ..errors import GcBusy
+from ..errors import GcBusy, UnknownBranchError
 from ..hamt import EMPTY_HASH
 from ..kv.base import KVStore
 from ..kv.memory import Memory
@@ -1184,6 +1185,7 @@ class VersionedKV(VersionedBase):
         *,
         commit_hash: str | None = None,
         branch: str = "main",
+        create: bool = True,
         recover_from_corrupt_head: CorruptHeadRecoverer | None = None,
     ) -> None:
         if store is None:
@@ -1205,6 +1207,11 @@ class VersionedKV(VersionedBase):
             if commit_hash is None and store.get(BRANCH_HEAD % branch) is not None:
                 raise ValueError(f"Branch '{branch}' HEAD is corrupt and unrecoverable")
             if commit_hash is None:
+                if not create:
+                    raise UnknownBranchError(
+                        f"Branch '{branch}' does not exist "
+                        "(open with create=True to create it)"
+                    )
                 # Create initial empty commit
                 commit_hash = content_hash((), {}, {})
                 initial = {
@@ -1578,41 +1585,71 @@ class VersionedKV(VersionedBase):
         return tuple(raw)
 
     def _find_lca(self, commit_a: str, commit_b: str) -> str | None:
-        """Find the lowest common ancestor of two commits."""
+        """Find the lowest common ancestor of two commits.
+
+        Ancestor-set intersection with non-minimal candidates dropped
+        (a candidate that is itself an ancestor of another candidate is
+        not lowest). When several commits tie for lowest — criss-cross
+        histories — the smallest hash wins: deterministic, but
+        arbitrary, so criss-cross merges resolve cleanly rather than
+        raising.
+        """
         if commit_a == commit_b:
             return commit_a
 
-        from collections import deque
-
-        seen_a: set[str] = {commit_a}
-        seen_b: set[str] = {commit_b}
-        queue_a: deque[str] = deque([commit_a])
-        queue_b: deque[str] = deque([commit_b])
-
-        while queue_a or queue_b:
-            if queue_a:
-                current = queue_a.popleft()
-                if current in seen_b:
-                    return current
-                for p in self._load_parents(current):
-                    if p not in seen_a:
-                        seen_a.add(p)
-                        queue_a.append(p)
-                        if p in seen_b:
-                            return p
-
-            if queue_b:
-                current = queue_b.popleft()
-                if current in seen_a:
-                    return current
-                for p in self._load_parents(current):
-                    if p not in seen_b:
-                        seen_b.add(p)
-                        queue_b.append(p)
-                        if p in seen_a:
-                            return p
+        parents: dict[str, tuple[str, ...]] = {}
+        ancestors_a = self._walk_ancestors(commit_a, parents)
+        # Fast path: b inside a's history (or vice versa) names the
+        # lowest directly — every other common ancestor sits above it.
+        if commit_b in ancestors_a:
+            return commit_b
+        ancestors_b = self._walk_ancestors(commit_b, parents)
+        if commit_a in ancestors_b:
+            return commit_a
 
-        return None
+        common = ancestors_a & ancestors_b
+        if not common:
+            return None
+        # Minimality in one bottom-up pass: a candidate is lowest when
+        # no other candidate sits below it. Propagate "a candidate is
+        # at-or-below here" from tips to roots over the in-memory
+        # parent map — no further store reads, linear in the history.
+        children: dict[str, list[str]] = {node: [] for node in parents}
+        for node, node_parents in parents.items():
+            for parent in node_parents:
+                children[parent].append(node)
+        below: dict[str, bool] = dict.fromkeys(parents, False)
+        remaining = {node: len(kids) for node, kids in children.items()}
+        queue = deque(node for node, kids in children.items() if not kids)
+        while queue:
+            node = queue.popleft()
+            for parent in parents[node]:
+                if node in common or below[node]:
+                    below[parent] = True
+                remaining[parent] -= 1
+                if remaining[parent] == 0:
+                    queue.append(parent)
+        best = {c for c in common if not below[c]}
+        return min(best) if best else None
+
+    def _walk_ancestors(
+        self, start: str, parents: dict[str, tuple[str, ...]]
+    ) -> set[str]:
+        """All ancestors of ``start`` (itself included), recording each
+        visited commit's parents in ``parents`` for later passes."""
+        ancestors = {start}
+        stack = [start]
+        while stack:
+            current = stack.pop()
+            if current in parents:
+                continue
+            node_parents = self._load_parents(current)
+            parents[current] = node_parents
+            for parent in node_parents:
+                if parent not in ancestors:
+                    ancestors.add(parent)
+                    stack.append(parent)
+        return ancestors
 
     def _read_blob(self, content_id: str) -> bytes | None:
         """Read a blob by its versioned key."""
@@ -1731,7 +1768,7 @@ class VersionedKV(VersionedBase):
         if commit_hash is None:
             if self.store.get(BRANCH_HEAD % name) is not None:
                 raise ValueError(f"Branch '{name}' HEAD is corrupt and unrecoverable")
-            raise ValueError(f"Branch '{name}' does not exist")
+            raise UnknownBranchError(f"Branch '{name}' does not exist")
         self._branch = name
         self._load_commit(commit_hash, update_base=True)
 
@@ -1816,6 +1853,25 @@ class VersionedKV(VersionedBase):
         """List all branch names in the store."""
         return VersionedKV.branches(self.store)
 
+    @staticmethod
+    def exists(store: KVStore, name: str) -> bool:
+        """Whether a branch exists — openable without creating.
+
+        The same predicate :meth:`branches` lists by: the branch has a
+        HEAD entry. Reserved ``refs/tags/`` names are never branches,
+        so they read as missing here as they are excluded there. A
+        damaged HEAD still counts as existing; opening it raises either
+        way. Never writes, so checking cannot resurrect a deleted
+        branch.
+        """
+        if not isinstance(name, str) or name.startswith(TAG_BRANCH_PREFIX):
+            return False
+        return store.get(BRANCH_HEAD % name) is not None
+
+    def branch_exists(self, name: str) -> bool:
+        """Whether a branch exists in this handle's store."""
+        return VersionedKV.exists(self.store, name)
+
     # -- Tags --
 
     def tag(self, name: str, *, at: str | None = None, info: dict | None = None) -> str:

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit/versioned/protocol.py

@@ -219,8 +219,14 @@ class Versioned(Protocol):
 
     def list_branches(self) -> list[str]: ...
 
+    def branch_exists(self, name: str) -> bool: ...
+
     def commit_info(self, commit_hash: str | None = None) -> dict | None: ...
 
     def diff(self, commit_a: str, commit_b: str) -> DiffResult: ...
 
+    def merge_base(self, commit_a: str, commit_b: str) -> str | None:
+        """Lowest common ancestor of two commits, or None if unrelated."""
+        ...
+
     def parents(self, commit_hash: str | None = None) -> tuple[str, ...]: ...

{kvgit-0.3.8 → kvgit-0.3.9}/kvgit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kvgit
-Version: 0.3.8
+Version: 0.3.9
 Summary: Versioned key-value store with git-like commit, branch, and merge semantics.
 Author: ashenfad
 License: MIT

{kvgit-0.3.8 → kvgit-0.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kvgit"
-version = "0.3.8"
+version = "0.3.9"
 description = "Versioned key-value store with git-like commit, branch, and merge semantics."
 authors = [{ name = "ashenfad" }]
 requires-python = ">=3.10"

{kvgit-0.3.8 → kvgit-0.3.9}/tests/test_content_types.py

@@ -189,3 +189,25 @@ class TestTextMerge:
         fn = text_merge()
         with pytest.raises(CantMark):
             fn(None, "text\n", b"\x00binary")
+
+    def test_strict_raises_on_conflict(self):
+        fn = text_merge(strict=True)
+        with pytest.raises(CantMark):
+            fn("a\nb\n", "a\nX\n", "a\nY\n")
+
+    def test_strict_passes_clean_merge_through(self):
+        fn = text_merge(strict=True)
+        assert fn("a\nb\n", "a\nB\n", "a\nb\n") == "a\nB\n"
+
+    def test_strict_conflict_aborts_staged_merge(self):
+        main = Staged(Versioned(Memory()))
+        main["doc"] = "a\nb\nc\nd\n"
+        main.commit()
+        dev = main.create_branch("dev")
+        dev["doc"] = "a\nY\nc\nd\n"
+        dev.commit()
+        main["doc"] = "a\nX\nc\nd\n"
+        main.commit()
+        with pytest.raises(MergeConflict) as exc_info:
+            main.merge(dev.current_commit, default_merge=text_merge(strict=True))
+        assert "doc" in exc_info.value.conflicting_keys

{kvgit-0.3.8 → kvgit-0.3.9}/tests/test_merges.py

@@ -10,7 +10,7 @@ import pytest
 
 from kvgit import MergeConflict, VersionedKV as Versioned
 from kvgit.kv.memory import Memory
-from kvgit.merges import CantMark, make_text_merge, text
+from kvgit.merges import CantMark, make_text_merge, text, text_merge_result
 
 GIT = shutil.which("git")
 needs_git = pytest.mark.skipif(GIT is None, reason="git binary not available")
@@ -45,6 +45,14 @@ class TestCleanMerges:
     def test_no_trailing_newline_preserved(self):
         assert text(b"a\nb", b"a\nB", b"a\nb") == b"a\nB"
 
+    def test_non_lf_endings_preserved_on_clean_merge(self):
+        """Lines ending in a non-LF splitlines boundary (lone CR here)
+        are already terminated: gluing the next line after one re-splits
+        to the same lines, so a clean merge must not rewrite them to
+        CRLF."""
+        base = b"a\rb\rc\r"
+        assert text(base, b"a\rB\rc\r", b"a\rb\rC\r") == b"a\rB\rC\r"
+
     def test_empty_inputs(self):
         assert text(b"", b"", b"") == b""
 
@@ -79,6 +87,34 @@ class TestConflicts:
         with pytest.raises(ValueError):
             make_text_merge(ours_label="a\nb")
 
+    @pytest.mark.parametrize(
+        "bad",
+        [
+            "a\rb",
+            "a\vb",
+            "a\fb",
+            "a\x1cb",
+            "a\x1db",
+            "a\x1eb",
+            "a\x85b",
+            "a\u2028b",
+            "a\u2029b",
+        ],
+    )
+    def test_label_other_line_breaks_rejected(self, bad):
+        """Every str.splitlines boundary can split a marker line for some
+        consumer, so labels may not contain any of them — not just LF."""
+        with pytest.raises(ValueError):
+            make_text_merge(ours_label=bad)
+        with pytest.raises(ValueError):
+            make_text_merge(theirs_label=bad)
+
+    def test_conflict_markers_over_cr_content(self):
+        """Conflict markers still arrive newline-terminated while CR
+        content lines pass through byte-exact."""
+        out = text(b"a\rb\rc\r", b"a\rB\rc\r", b"a\rX\rc\r")
+        assert out == b"a\r<<<<<<< ours\nB\r=======\nX\r>>>>>>> theirs\nc\r"
+
     def test_deterministic(self):
         args = (BASE, b"a\nX\nc\nd\n", b"a\nY\nc\nd\n")
         assert text(*args) == text(*args)
@@ -298,3 +334,87 @@ class TestVersionedIntegration:
             v2.commit({"doc": b"a\nb\nc\nD\n"}, default_merge=text_merge)
         assert "doc" in exc_info.value.conflicting_keys
         assert isinstance(exc_info.value.merge_errors["doc"], CantMark)
+
+
+class TestStrictAndFlag:
+    """Issue #38: strict mode aborts instead of marking; the flag reports
+    whether hunks were introduced (marker-like content merging cleanly
+    must not count)."""
+
+    def test_strict_raises_on_conflict(self):
+        fn = make_text_merge(strict=True)
+        with pytest.raises(CantMark):
+            fn(BASE, b"a\nX\nc\nd\n", b"a\nY\nc\nd\n")
+
+    def test_strict_passes_clean_merge_through(self):
+        fn = make_text_merge(strict=True)
+        assert fn(BASE, b"a\nB\nc\nd\n", b"a\nb\nc\nD\n") == b"a\nB\nc\nD\n"
+
+    def test_strict_ignores_carried_marker_like_content(self):
+        markerish = b"<<<<<<< not a real hunk\nsame\n"
+        fn = make_text_merge(strict=True)
+        assert fn(BASE, markerish, BASE) == markerish
+
+    def test_non_strict_default_still_marks(self):
+        out = make_text_merge()(BASE, b"a\nX\nc\nd\n", b"a\nY\nc\nd\n")
+        assert b"<<<<<<< ours\n" in out
+
+    def test_flag_false_on_clean_merge(self):
+        merged, conflicted = text_merge_result(BASE, b"a\nB\nc\nd\n", b"a\nb\nc\nD\n")
+        assert (merged, conflicted) == (b"a\nB\nc\nD\n", False)
+
+    def test_flag_false_for_carried_marker_like_content(self):
+        markerish = b"<<<<<<< not a real hunk\nsame\n"
+        merged, conflicted = text_merge_result(BASE, markerish, BASE)
+        assert (merged, conflicted) == (markerish, False)
+
+    def test_flag_true_on_conflict_and_bytes_match_marking_fn(self):
+        args = (BASE, b"a\nX\nc\nd\n", b"a\nY\nc\nd\n")
+        merged, conflicted = text_merge_result(*args)
+        assert conflicted is True
+        assert merged == make_text_merge()(*args) == text(*args)
+
+    def test_flag_custom_labels(self):
+        merged, conflicted = text_merge_result(
+            BASE,
+            b"a\nX\nc\nd\n",
+            b"a\nY\nc\nd\n",
+            ours_label="main",
+            theirs_label="dev",
+        )
+        assert conflicted is True
+        assert b"<<<<<<< main\n" in merged
+        assert b">>>>>>> dev\n" in merged
+
+    def test_unmarkable_still_raises(self):
+        with pytest.raises(CantMark):
+            text_merge_result(BASE, b"\xff binary", BASE)
+        with pytest.raises(CantMark):
+            make_text_merge(strict=True)(BASE, b"\xff binary", BASE)
+
+    def test_strict_conflict_aborts_versioned_merge(self):
+        store = Memory()
+        v1 = Versioned(store)
+        v1.commit({"doc": BASE})
+        v2 = Versioned(store)
+        v1.commit({"doc": b"a\nX\nc\nd\n"})
+        with pytest.raises(MergeConflict) as exc_info:
+            v2.commit(
+                {"doc": b"a\nY\nc\nd\n"},
+                default_merge=make_text_merge(strict=True),
+            )
+        assert "doc" in exc_info.value.conflicting_keys
+        assert isinstance(exc_info.value.merge_errors["doc"], CantMark)
+
+    def test_strict_clean_change_still_merges(self):
+        store = Memory()
+        v1 = Versioned(store)
+        v1.commit({"doc": BASE})
+        v2 = Versioned(store)
+        v1.commit({"doc": b"a\nB\nc\nd\n"})
+        result = v2.commit(
+            {"doc": b"a\nb\nc\nD\n"},
+            default_merge=make_text_merge(strict=True),
+        )
+        assert result
+        assert v2.get("doc") == b"a\nB\nc\nD\n"

{kvgit-0.3.8 → kvgit-0.3.9}/tests/test_staged.py

@@ -504,6 +504,40 @@ class TestStagedRefresh:
         assert not s.has_changes
 
 
+class TestStagedCommitRace:
+    """Issue #39 at the Staged level: dirty before, committed after —
+    no refresh (which would discard the buffer) required."""
+
+    def test_commit_survives_fast_forward_race(self):
+        store = Memory()
+        s1 = Staged(Versioned(store))
+        s1["seed"] = "0"
+        s1.commit()
+        s2 = Staged(Versioned(store))
+
+        s1["mine"] = "2"
+        assert s1.has_changes
+        real_cas = s1.versioned._cas_head
+        raced = False
+
+        def cas(expected, new_head):
+            nonlocal raced
+            if not raced:
+                raced = True
+                s2["other"] = "1"
+                s2.commit()
+            return real_cas(expected, new_head)
+
+        s1.versioned._cas_head = cas
+        result = s1.commit()
+
+        assert result.merged
+        assert result.strategy == "three_way"
+        assert not s1.has_changes
+        assert s1.get("mine") == "2"
+        assert s1.get("other") == "1"
+
+
 class TestStagedEncoder:
     def test_custom_encoder_decoder(self):
         import json

{kvgit-0.3.8 → kvgit-0.3.9}/tests/test_store_factory.py

@@ -26,6 +26,24 @@ class TestStoreFactory:
         assert isinstance(s, Staged)
         assert s.versioned._branch == "dev"
 
+    def test_branch_create_false_raises_on_fresh_store(self):
+        from kvgit import UnknownBranchError
+
+        with pytest.raises(UnknownBranchError):
+            store(branch="dev", create=False)
+
+    def test_branch_create_false_opens_shared_disk_branch(self):
+        from kvgit import UnknownBranchError
+
+        with tempfile.TemporaryDirectory() as path:
+            s = store(kind="disk", path=path)
+            s["k"] = "v"
+            s.commit()
+            s_main = store(kind="disk", path=path, branch="main", create=False)
+            assert s_main.get("k") == "v"
+            with pytest.raises(UnknownBranchError):
+                store(kind="disk", path=path, branch="dev", create=False)
+
 
 class TestStoreFactoryRoundTrip:
     def test_set_commit_get(self):