gitacross 2.3.1__tar.gz → 2.4.0__tar.gz

{gitacross-2.3.1/src/gitacross.egg-info → gitacross-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.3.1
+Version: 2.4.0
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -223,7 +223,7 @@ Stream each asset upload directly from the temporary download directory on disk
 
 ### Source mode: release, tag, or commit
 
-Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced.
+Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced. If the exact tag no longer exists (renamed or deleted upstream), releases with a **higher version** are synced instead, so an absent anchor never blocks newer releases. Both SemVer tags (`v1.2.3`) and calendar tags (`2024.05.01`, `2024-05-01`) are compared version-wise; the two schemes are never confused with each other.
 
 Synced state is keyed by **tag name**, so switching a repo between `release` and `tag` modes is safe: already-synced tags are skipped regardless of the current mode (older state files keyed by API release id are migrated automatically).
 
@@ -390,17 +390,22 @@ In `regex` mode, backreferences (e.g. `\1`) are expanded before the casing adapt
 | Field | Required | Description |
 |---|---|---|
 | `path` | yes | File path to create (parent dirs auto-created) |
-| `content` | yes | File contents |
+| `content` | one of | Inline file contents. Takes precedence over `src` when both are given |
+| `src` | one of | Path of an existing **regular file** to copy in — binary-safe, mode & timestamps preserved (relative to where you run gitacross) |
+
+Provide inline `content` or point `src` at an existing file (`content` wins if both are set — use `content: ""` for an empty file). Inline `content` is written as UTF-8 text with `\n` line endings on every OS. `src` copies the file in with `shutil.copy2` — no decode/encode round-trip and no newline translation — so binary assets work and the result is byte-identical on any platform. `src` must point to a single file, not a directory.
 
 ```yaml
 - add:
     - path: .github/FUNDING.yml
       content: |
         github: myuser
-    - path: RELEASE_NOTES.md
-      content: |
-        # Release Notes
-        ...
+    - path: LICENSE
+      src: ../templates/LICENSE   # copy an existing file instead of inlining it
+    - path: assets/favicon.ico
+      src: ../../branding/favicon.ico   # binary files work too
+    - path: tools/deploy.sh
+      src: ./scripts/deploy.sh    # executable bit is preserved (copy2)
 ```
 
 #### `validate`

{gitacross-2.3.1 → gitacross-2.4.0}/README.md

@@ -194,7 +194,7 @@ Stream each asset upload directly from the temporary download directory on disk
 
 ### Source mode: release, tag, or commit
 
-Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced.
+Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced. If the exact tag no longer exists (renamed or deleted upstream), releases with a **higher version** are synced instead, so an absent anchor never blocks newer releases. Both SemVer tags (`v1.2.3`) and calendar tags (`2024.05.01`, `2024-05-01`) are compared version-wise; the two schemes are never confused with each other.
 
 Synced state is keyed by **tag name**, so switching a repo between `release` and `tag` modes is safe: already-synced tags are skipped regardless of the current mode (older state files keyed by API release id are migrated automatically).
 
@@ -361,17 +361,22 @@ In `regex` mode, backreferences (e.g. `\1`) are expanded before the casing adapt
 | Field | Required | Description |
 |---|---|---|
 | `path` | yes | File path to create (parent dirs auto-created) |
-| `content` | yes | File contents |
+| `content` | one of | Inline file contents. Takes precedence over `src` when both are given |
+| `src` | one of | Path of an existing **regular file** to copy in — binary-safe, mode & timestamps preserved (relative to where you run gitacross) |
+
+Provide inline `content` or point `src` at an existing file (`content` wins if both are set — use `content: ""` for an empty file). Inline `content` is written as UTF-8 text with `\n` line endings on every OS. `src` copies the file in with `shutil.copy2` — no decode/encode round-trip and no newline translation — so binary assets work and the result is byte-identical on any platform. `src` must point to a single file, not a directory.
 
 ```yaml
 - add:
     - path: .github/FUNDING.yml
       content: |
         github: myuser
-    - path: RELEASE_NOTES.md
-      content: |
-        # Release Notes
-        ...
+    - path: LICENSE
+      src: ../templates/LICENSE   # copy an existing file instead of inlining it
+    - path: assets/favicon.ico
+      src: ../../branding/favicon.ico   # binary files work too
+    - path: tools/deploy.sh
+      src: ./scripts/deploy.sh    # executable bit is preserved (copy2)
 ```
 
 #### `validate`

{gitacross-2.3.1 → gitacross-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacross"
-version = "2.3.1"
+version = "2.4.0"
 description = "Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines."
 readme = "README.md"
 requires-python = ">=3.8"

{gitacross-2.3.1 → gitacross-2.4.0}/src/gitacross/linter/fixer.py

@@ -244,6 +244,16 @@ class ConfigFixer:
                                         "Removed redundant 'case_sensitive: true' in validate operation",
                                         project_name=p_name,
                                     )
+                                if (
+                                    op_type == "add"
+                                    and item.get("content") is not None
+                                    and item.get("src")
+                                ):
+                                    del item["src"]
+                                    self._add(
+                                        "Removed redundant 'src' in add operation ('content' takes precedence)",
+                                        project_name=p_name,
+                                    )
 
 
 

{gitacross-2.3.1 → gitacross-2.4.0}/src/gitacross/linter/validator.py

@@ -693,14 +693,41 @@ class ConfigLinter:
 
                 elif op_type == "add":
                     for item in items:
-                        if (
-                            not isinstance(item, dict)
-                            or not item.get("path")
-                            or "content" not in item
+                        if not isinstance(item, dict):
+                            self._add(
+                                LintSeverity.ERROR,
+                                "Add operation item requires 'path' and either 'content' or 'src'.",
+                                project_name=p_name,
+                            )
+                            continue
+                        if not item.get("path") or (
+                            item.get("content") is None and not item.get("src")
+                        ):
+                            self._add(
+                                LintSeverity.ERROR,
+                                "Add operation item requires 'path' and either 'content' or 'src'.",
+                                project_name=p_name,
+                            )
+                        if item.get("content") is not None and not isinstance(
+                            item["content"], str
                         ):
                             self._add(
                                 LintSeverity.ERROR,
-                                "Add operation item requires 'path' and 'content'.",
+                                "Add option 'content' must be a string.",
+                                project_name=p_name,
+                            )
+                        if item.get("src") is not None and not isinstance(
+                            item["src"], str
+                        ):
+                            self._add(
+                                LintSeverity.ERROR,
+                                "Add option 'src' must be a string path to an existing file.",
+                                project_name=p_name,
+                            )
+                        if item.get("content") is not None and item.get("src"):
+                            self._add(
+                                LintSeverity.REDUNDANT,
+                                "'src' is ignored when 'content' is present in add operation.",
                                 project_name=p_name,
                             )
 

{gitacross-2.3.1 → gitacross-2.4.0}/src/gitacross/renderer.py

@@ -196,9 +196,17 @@ def _match_case(matched, replacement):
 def _op_add(work, ops):
     """Create files in the work tree before commit.
 
-    Each op: {path: str, content: str}
-    Raises if the path already exists (avoids silently overwriting).
-    Creates parent directories automatically.
+    Each op: {path: str, content?: str, src?: str}
+    - content: inline file contents — takes precedence over ``src`` when both
+      are given (even an empty string). Written as UTF-8 text with ``\n`` line
+      endings on every OS.
+    - src: path of an existing regular file to copy in — binary-safe (no
+      decode/encode round-trip) via :func:`shutil.copy2`, so the bytes as well
+      as the mode/timestamps are preserved. Directories are rejected; relative
+      paths resolve against the current working directory.
+    If neither is given the file is created empty. Raises if the path already
+    exists (avoids silently overwriting). Creates parent directories
+    automatically.
     """
     for op in ops:
         path = op["path"]
@@ -206,10 +214,37 @@ def _op_add(work, ops):
         if target.exists():
             raise RuntimeError(f"Add conflict: '{path}' already exists")
         target.parent.mkdir(parents=True, exist_ok=True)
-        target.write_text(op.get("content", ""), encoding="utf-8")
+        content = op.get("content")
+        if content is not None:
+            _write_text_lf(target, content)
+        else:
+            src = op.get("src")
+            if not src:
+                _write_text_lf(target, "")
+            else:
+                source = Path(src)
+                if not source.is_file():
+                    if source.exists():
+                        raise RuntimeError(
+                            f"Add failed: 'src' '{src}' is not a file (path: '{path}') — only regular files can be added"
+                        )
+                    raise RuntimeError(
+                        f"Add failed: source file '{src}' not found for '{path}'"
+                    )
+                _ = shutil.copy2(source, target)
         logger.debug("Added file: %s", path)
 
 
+def _write_text_lf(path, text):
+    """Write *text* as UTF-8 with ``\n`` endings regardless of the host OS.
+
+    Text mode on Windows would otherwise translate ``\n`` to ``\r\n``
+    (``os.linesep``), making inline content depend on where gitacross runs.
+    """
+    with open(path, "w", encoding="utf-8", newline="\n") as f:
+        _ = f.write(text)
+
+
 def _op_validate(work, ops):
     """Assert conditions on the final tree. Aborts on failure.
 

{gitacross-2.3.1 → gitacross-2.4.0}/src/gitacross/source.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import fnmatch
 import logging
+import re
 from pathlib import Path
 from typing import final
 
@@ -31,20 +32,122 @@ def create_source(config, cache_dir, dry_run=False):
     )
 
 
-def _filter_from_sync_point(releases, sync_from):
-    """Filter to releases at or after the sync_from tag (inclusive).
+# Calendar versions start with a 4-digit year (YYYY[.MM[.DD[...]]], e.g.
+# 2024.05.01 or 2024-05-01). Every dot/dash/underscore-separated numeric
+# field is part of the date sequence.
+_CALENDAR_RE = re.compile(r"[^0-9]*(\d{4}(?:[._-]\d{1,4})*)")
+# SemVer-style cores are dot-separated numbers; a hyphen introduces a
+# prerelease, never another core field.
+_SEMVER_CORE_RE = re.compile(r"(\d+(?:\.\d+)*)")
+
+
+def _version_key(tag):
+    """Parse a version-like tag into a comparable ``(fields, prerelease)`` key.
+
+    Two schemes are supported, parsed separately because they are semantically
+    different:
 
-    Releases must already be sorted oldest-first. If sync_from is empty
-    return all releases. If the tag isn't found, return nothing —
-    better to skip than silently backfill history.
+    * **SemVer** — ``v1.2.3``, ``v1.2.3-rc.1``. Dot-separated core; a hyphen
+      starts a prerelease that sorts before the final release.
+    * **Calendar (CalVer)** — ``2024.05.01``, ``2024-05-01``, ``2024.05``.
+      Date-based: a leading 4-digit year marks it, and every numeric field
+      (dot *or* dash separated) belongs to the (year, month, day, ...)
+      sequence, compared as plain numbers. No major/minor/patch or SemVer
+      prerelease semantics apply to the date fields themselves.
+
+    Returns ``None`` when the tag carries no parseable version.
+    """
+    if not isinstance(tag, str):
+        return None
+    calendar = _CALENDAR_RE.match(tag)
+    if calendar:
+        fields = tuple(int(part) for part in re.split(r"[._-]", calendar.group(1)))
+        rest = tag[calendar.end():].split("+", 1)[0]
+    else:
+        match = _SEMVER_CORE_RE.search(tag)
+        if not match:
+            return None
+        fields = tuple(int(part) for part in match.group(1).split("."))
+        rest = tag[match.end():].split("+", 1)[0]
+    # Anything remaining after the version fields is a prerelease; build
+    # metadata ("+...") is ignored for ordering, per SemVer.
+    ids = tuple(re.findall(r"[0-9A-Za-z]+", rest))
+    return fields, (ids or None)
+
+
+def _cmp_version_key(a, b):
+    """Compare two ``_version_key`` results: -1/0/1 (SemVer-ish ordering)."""
+    (ca, pa), (cb, pb) = a, b
+    width = max(len(ca), len(cb))
+    ca += (0,) * (width - len(ca))
+    cb += (0,) * (width - len(cb))
+    if ca != cb:
+        return 1 if ca > cb else -1
+    # Same core: a final release outranks any prerelease of it
+    if pa is None and pb is None:
+        return 0
+    if pa is None:
+        return 1
+    if pb is None:
+        return -1
+    # Compare prerelease identifiers: numeric < alphanumeric, identifiers
+    # compare numerically when both numeric, lexically when both alphanumeric
+    for x, y in zip(pa, pb):
+        xn, yn = x.isdigit(), y.isdigit()
+        if xn and yn:
+            xi, yi = int(x), int(y)
+            if xi != yi:
+                return 1 if xi > yi else -1
+        elif xn != yn:
+            return -1 if xn else 1
+        elif x != y:
+            return 1 if x > y else -1
+    return 1 if len(pa) > len(pb) else (-1 if len(pa) < len(pb) else 0)
+
+
+def _newer_than_version(tag, cutoff):
+    """True when *tag* parses as a version strictly newer than *cutoff*."""
+    key = _version_key(tag)
+    return key is not None and _cmp_version_key(key, cutoff) > 0
+
+
+def _filter_from_sync_point(releases, sync_from):
+    """Filter to releases at or after the sync_from tag.
+
+    Releases must already be sorted oldest-first. If sync_from is empty return
+    all releases. When the exact tag is present, everything from it onwards is
+    included; when it is missing (renamed, deleted, or never released), releases
+    whose version is strictly newer than sync_from are synced instead. Tags that
+    cannot be compared (no version digits) are skipped rather than silently
+    backfilling history.
     """
     if not sync_from:
         return releases
     for i, rel in enumerate(releases):
         if rel["tag_name"] == sync_from:
             return releases[i:]
-    logger.warning("sync_from tag '%s' not found — syncing nothing", sync_from)
-    return []
+
+    # Exact tag not found — fall back to releases with a newer version.
+    cutoff = _version_key(sync_from)
+    if cutoff is None:
+        logger.warning(
+            "sync_from '%s' not found and is not version-like — syncing nothing",
+            sync_from,
+        )
+        return []
+    newer = [r for r in releases if _newer_than_version(r.get("tag_name"), cutoff)]
+    if not newer:
+        logger.warning(
+            "sync_from tag '%s' not found and no releases are newer — syncing nothing",
+            sync_from,
+        )
+    else:
+        logger.info(
+            "sync_from tag '%s' not found — syncing %d release(s) newer than it",
+            sync_from,
+            len(newer),
+        )
+    return newer
 
 
 # ---------------------------------------------------------------------------

{gitacross-2.3.1 → gitacross-2.4.0/src/gitacross.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.3.1
+Version: 2.4.0
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -223,7 +223,7 @@ Stream each asset upload directly from the temporary download directory on disk
 
 ### Source mode: release, tag, or commit
 
-Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced.
+Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced. If the exact tag no longer exists (renamed or deleted upstream), releases with a **higher version** are synced instead, so an absent anchor never blocks newer releases. Both SemVer tags (`v1.2.3`) and calendar tags (`2024.05.01`, `2024-05-01`) are compared version-wise; the two schemes are never confused with each other.
 
 Synced state is keyed by **tag name**, so switching a repo between `release` and `tag` modes is safe: already-synced tags are skipped regardless of the current mode (older state files keyed by API release id are migrated automatically).
 
@@ -390,17 +390,22 @@ In `regex` mode, backreferences (e.g. `\1`) are expanded before the casing adapt
 | Field | Required | Description |
 |---|---|---|
 | `path` | yes | File path to create (parent dirs auto-created) |
-| `content` | yes | File contents |
+| `content` | one of | Inline file contents. Takes precedence over `src` when both are given |
+| `src` | one of | Path of an existing **regular file** to copy in — binary-safe, mode & timestamps preserved (relative to where you run gitacross) |
+
+Provide inline `content` or point `src` at an existing file (`content` wins if both are set — use `content: ""` for an empty file). Inline `content` is written as UTF-8 text with `\n` line endings on every OS. `src` copies the file in with `shutil.copy2` — no decode/encode round-trip and no newline translation — so binary assets work and the result is byte-identical on any platform. `src` must point to a single file, not a directory.
 
 ```yaml
 - add:
     - path: .github/FUNDING.yml
       content: |
         github: myuser
-    - path: RELEASE_NOTES.md
-      content: |
-        # Release Notes
-        ...
+    - path: LICENSE
+      src: ../templates/LICENSE   # copy an existing file instead of inlining it
+    - path: assets/favicon.ico
+      src: ../../branding/favicon.ico   # binary files work too
+    - path: tools/deploy.sh
+      src: ./scripts/deploy.sh    # executable bit is preserved (copy2)
 ```
 
 #### `validate`

{gitacross-2.3.1 → gitacross-2.4.0}/tests/test_linter.py

@@ -859,6 +859,9 @@ def test_linter_operations_kitchen_sink():
       - replace: [search, replace]
       - replace: [{search: a, replace: b, pattern: banana}]
       - add: [{}]
+      - add: [{path: no-body}]
+      - add: [{path: n, content: 123}]
+      - add: [{path: n, src: 123}]
       - validate: [not-a-dict]
 """)
     assert not report.is_valid
@@ -871,10 +874,35 @@ def test_linter_operations_kitchen_sink():
     assert "Rename pattern mode 'glob' is not supported" in msgs
     assert "Replace operation item requires 'search' and 'replace'" in msgs
     assert "Invalid replace pattern mode 'banana'" in msgs
-    assert "Add operation item requires 'path' and 'content'" in msgs
+    assert "Add operation item requires 'path' and either 'content' or 'src'" in msgs
+    assert "Add option 'content' must be a string" in msgs
+    assert "Add option 'src' must be a string path" in msgs
     assert "Validate operation item requires 'path'" in msgs
     print("  ✓ linter: operation kitchen-sink validation")
 
+
+def test_linter_add_src_and_precedence():
+    """add accepts 'content' or 'src'; both together is redundant, not an error."""
+    from gitacross.linter import ConfigLinter
+
+    linter = ConfigLinter()
+    report = linter.lint_yaml_string("""
+- name: p
+  source: {type: local, path: /a}
+  target: {type: local, path: /b}
+  renderer:
+    operations:
+      - add: [{path: a.txt, content: hi}]
+      - add: [{path: b.txt, src: tmpl.txt}]
+      - add: [{path: c.txt, content: hi, src: tmpl.txt}]
+      - add: [{path: d.txt, content: ""}]
+""")
+    assert report.is_valid  # redundant 'src' + no type errors
+    red = " | ".join(r.message for r in report.redundant)
+    assert "'src' is ignored when 'content' is present" in red
+    assert len(report.errors) == 0
+    print("  ✓ linter: add accepts content or src (content wins when both given)")
+
 def test_fix_report_and_issue_formatting():
     """FixIssue strings and FixReport.format_text variants."""
     from gitacross.linter import FixIssue, FixReport
@@ -1029,3 +1057,43 @@ def test_fixer_missing_endpoint_sections():
     ).is_valid
     print("  ✓ fixer: missing endpoint sections and junk operations handled")
 
+
+def test_fixer_add_drops_src_shadowed_by_content():
+    """'src' is dead weight next to 'content' — --fix removes it, keeps src alone."""
+    import yaml
+
+    from gitacross.linter import ConfigFixer
+
+    fixer = ConfigFixer()
+    r = fixer.fix_yaml_string(
+        "- name: p\n"
+        + "  source: {type: local, path: /a}\n"
+        + "  target: {type: local, path: /b}\n"
+        + "  renderer:\n"
+        + "    operations:\n"
+        + "      - add:\n"
+        + "          - path: a.txt\n"
+        + "            content: hi\n"
+        + "            src: tmpl.txt\n"
+        + "          - path: b.txt\n"
+        + "            src: tmpl.txt\n"
+    )
+    assert r.is_valid
+    assert any("'src' in add operation" in f.message for f in r.fixes)
+    adds = yaml.safe_load(r.content)[0]["renderer"]["operations"][0]["add"]
+    assert "src" not in adds[0]
+    assert adds[0]["content"] == "hi"
+    assert adds[1]["src"] == "tmpl.txt"  # src alone is untouched
+
+    # content: null does NOT shadow src → src kept
+    r = fixer.fix_yaml_string(
+        "- name: p\n"
+        + "  source: {type: local, path: /a}\n"
+        + "  target: {type: local, path: /b}\n"
+        + "  renderer:\n"
+        + "    operations:\n"
+        + "      - add: [{path: a.txt, content: null, src: tmpl.txt}]\n"
+    )
+    assert r.is_valid and not r.fixes
+    print("  ✓ fixer: add op drops 'src' shadowed by 'content'")
+

{gitacross-2.3.1 → gitacross-2.4.0}/tests/test_renderer.py

@@ -431,6 +431,95 @@ def test_renderer_add():
     print("  ✓ renderer add")
 
 
+def test_renderer_add_from_src():
+    """add can copy an existing file via 'src'; inline 'content' wins over it."""
+    from gitacross.config import ProjectConfig
+    from gitacross.renderer import apply_operations
+
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        # Source template lives *outside* the exported work tree (as in real
+        # runs — the work tree is an ephemeral export, so 'src' resolves
+        # against the process working directory).
+        template = Path(tmp) / "FUNDING.tmpl"
+        _ = template.write_text("github: myuser\n", encoding="utf-8")
+        _ = _make_file(root, "README.md")
+
+        ops = [
+            {
+                "add": [
+                    {"path": ".github/FUNDING.yml", "src": str(template)},
+                    # content wins, even an empty string
+                    {"path": "inline.txt", "content": "inline", "src": str(template)},
+                    {"path": "empty.txt", "content": "", "src": str(template)},
+                ]
+            }
+        ]
+        project = ProjectConfig(_make_project_raw(ops))
+        apply_operations(root, project)
+
+        assert (root / ".github/FUNDING.yml").read_text() == "github: myuser\n"
+        assert (root / "inline.txt").read_text() == "inline"
+        assert (root / "empty.txt").read_text() == ""
+
+        # Missing source file -> loud error naming both paths
+        ops = [{"add": [{"path": "x.txt", "src": str(root / "nope.txt")}]}]
+        project = ProjectConfig(_make_project_raw(ops))
+        try:
+            apply_operations(root, project)
+            assert False, "should raise"
+        except RuntimeError as e:
+            assert "source file" in str(e) and "x.txt" in str(e)
+
+        # Directory as src -> explicit rejection, not a confusing copy
+        (root / "adir").mkdir()
+        ops = [{"add": [{"path": "y.txt", "src": str(root / "adir")}]}]
+        project = ProjectConfig(_make_project_raw(ops))
+        try:
+            apply_operations(root, project)
+            assert False, "should raise"
+        except RuntimeError as e:
+            assert "is not a file" in str(e) and "y.txt" in str(e)
+
+    print("  ✓ renderer add from src file")
+
+
+def test_renderer_add_src_binary():
+    """src copies non-UTF-8/binary files byte-for-byte; copy2 keeps the mode."""
+    from gitacross.config import ProjectConfig
+    from gitacross.renderer import apply_operations
+
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        # Every byte value 0..255 (invalid UTF-8) + NULs + no trailing newline
+        payload = bytes(range(256)) * 3 + b"\x00\xfftail"
+        asset = root / "logo.bin"
+        _ = asset.write_bytes(payload)
+        _ = _make_file(root, "README.md")
+        if os.name != "nt":  # exec bit is a POSIX concept
+            os.chmod(asset, 0o755)
+
+        ops = [{"add": [{"path": "assets/deep/logo.bin", "src": str(asset)}]}]
+        project = ProjectConfig(_make_project_raw(ops))
+        apply_operations(root, project)
+
+        copied = root / "assets/deep/logo.bin"
+        assert copied.exists()
+        assert copied.read_bytes() == payload  # exact byte identity
+        assert asset.read_bytes() == payload  # source untouched
+        assert (root / "README.md").exists()
+        if os.name != "nt":
+            assert os.stat(copied).st_mode & 0o777 == 0o755  # mode preserved
+
+        # empty add item (no content/src) still creates an empty file
+        ops = [{"add": [{"path": "bare.txt"}]}]
+        project = ProjectConfig(_make_project_raw(ops))
+        apply_operations(root, project)
+        assert (root / "bare.txt").read_bytes() == b""
+
+    print("  ✓ renderer add copies binary src byte-for-byte (mode preserved)")
+
+
 def test_renderer_validate_fail():
     from gitacross.config import ProjectConfig
     from gitacross.renderer import apply_operations

{gitacross-2.3.1 → gitacross-2.4.0}/tests/test_source.py

@@ -103,9 +103,172 @@ def test_source_local_sync_from():
         releases2 = src2.fetch_releases()
         assert releases2 == []
 
+        # sync_from = missing tag but with newer releases present — the newer
+        # releases are synced instead of syncing nothing
+        cfg3 = _EndpointConfig(
+            {
+                "type": "local",
+                "path": str(repo),
+                "tag_pattern": "v*",
+                "sync_from": "v1.5",
+            },
+            is_source=True,
+        )
+        src3 = create_source(cfg3, tmp)
+        tags3 = [r["tag_name"] for r in src3.fetch_releases()]
+        assert tags3 == ["v2.0", "v3.0"]
+
         print("  ✓ source: local sync_from")
 
 
+def test_filter_from_sync_point_fallback_newer_versions():
+    """A missing sync_from tag falls back to releases with a newer version."""
+    from gitacross.source import _filter_from_sync_point
+
+    def rel(tag):
+        return {"tag_name": tag}
+
+    all_rel = [rel("v0.8.0"), rel("v0.9.0"), rel("v1.0.0"), rel("v1.2.0"), rel("v2.0.0")]
+
+    # Exact match: everything from the tag onwards (unchanged behaviour)
+    assert [r["tag_name"] for r in _filter_from_sync_point(all_rel, "v0.9.0")] == [
+        "v0.9.0", "v1.0.0", "v1.2.0", "v2.0.0",
+    ]
+
+    # Missing tag: only strictly-newer versions are kept (v0.8.0 < v0.9.0)
+    assert [r["tag_name"] for r in _filter_from_sync_point(all_rel, "v0.9.1")] == [
+        "v1.0.0", "v1.2.0", "v2.0.0",
+    ]
+
+    # Numeric (not lexicographic) comparison: v0.10.0 > v0.9.9
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v0.10.0"), rel("v0.9.0")], "v0.9.9")
+    ] == ["v0.10.0"]
+
+    # Zero-padding: v1.2 == v1.2.0, so it is NOT counted as newer
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v1.2"), rel("v1.3")], "v1.2.0")
+    ] == ["v1.3"]
+
+    # No newer release and nothing comparable -> nothing synced
+    assert _filter_from_sync_point([rel("v0.5.0")], "v0.9.0") == []
+    assert _filter_from_sync_point([rel("v0.9.0"), rel("latest")], "v0.9.1") == []
+
+    # A non-version sync_from cannot be compared -> nothing synced
+    assert _filter_from_sync_point(all_rel, "alpha") == []
+
+    # Unversioned / non-string release tags are never counted as newer
+    assert _filter_from_sync_point(
+        [rel("latest"), {"tag_name": None}, rel("v1.0.0")], "v0.9.0"
+    ) == [rel("v1.0.0")]
+
+    # SemVer: a prerelease of a version is OLDER than its final release, so a
+    # missing v1.2.3 never pulls in v1.2.3-rc.1 — only truly newer versions do
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v1.2.3-rc.1"), rel("v1.2.4")], "v1.2.3")
+    ] == ["v1.2.4"]
+
+    # Prerelease identifier ordering: numeric pre identifiers compare
+    # numerically, and a final release outranks any prerelease of its version
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("v1.2.3-rc.2"), rel("v1.2.3")], "v1.2.3-rc.1"
+        )
+    ] == ["v1.2.3-rc.2", "v1.2.3"]
+
+    # SemVer: numeric prerelease identifiers sort BEFORE alphanumeric ones, and
+    # a final release outranks every prerelease of its version
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("v1.0.0-1"), rel("v1.0.0-10"), rel("v1.0.0-beta"), rel("v1.0.0")],
+            "v1.0.0-2",
+        )
+    ] == ["v1.0.0-10", "v1.0.0-beta", "v1.0.0"]
+
+    # Build metadata is ignored for ordering
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v1.2.3+meta"), rel("v1.2.4")], "v1.2.3")
+    ] == ["v1.2.4"]
+
+    # Alphanumeric prerelease identifiers compare lexically (beta > alpha), and
+    # longer identifier lists after an equal prefix sort later
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("v1.0.0-alpha.1"), rel("v1.0.0-beta"), rel("v1.0.0")],
+            "v1.0.0-alpha",
+        )
+    ] == ["v1.0.0-alpha.1", "v1.0.0-beta", "v1.0.0"]
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [
+                rel("v1.0.0-alpha"),
+                rel("v1.0.0-beta"),
+                rel("v1.0.0-alpha.2"),
+                rel("v1.0.0-alpha.1.beta"),
+            ],
+            "v1.0.0-alpha.1",
+        )
+    ] == ["v1.0.0-beta", "v1.0.0-alpha.2", "v1.0.0-alpha.1.beta"]
+
+    # ── Calendar versions (CalVer) are date-based, not SemVer ──
+    # Dot-shaped dates compare as plain (year, month, day) numbers
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024.01.15"), rel("2024.04.30"), rel("2024.05.01")], "2024.04.01"
+        )
+    ] == ["2024.04.30", "2024.05.01"]
+
+    # Dash-separated dates: '-' joins date fields; it is NOT a prerelease
+    # marker, so 2024-06-01 is newer than 2024-05-01
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024-04-15"), rel("2024-06-01")], "2024-05-01"
+        )
+    ] == ["2024-06-01"]
+
+    # Month-only anchor (2024.05 = May) vs day releases
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("2024.04"), rel("2024.05.10")], "2024.05")
+    ] == ["2024.05.10"]
+
+    # A prerelease of the same calendar date is not newer than the date itself
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024.05.01-rc.1"), rel("2024.05.02")], "2024.05.01"
+        )
+    ] == ["2024.05.02"]
+
+    # Scheme switch on one repo: a 2024.x calendar tag clears a v2-era SemVer
+    # anchor, while a v9.x tag never clears a 2024 calendar anchor
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v2.9.0"), rel("2024.01.15")], "v2.9.9")
+    ] == ["2024.01.15"]
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024.02.01"), rel("v9.9.9")], "2024.01.15"
+        )
+    ] == ["2024.02.01"]
+
+    # No sync_from -> everything
+    assert len(_filter_from_sync_point(all_rel, "")) == 5
+
+    print("  ✓ source: missing sync_from falls back to newer versions")
+
+
 def test_source_remote_mode_tag_sync_from():
     """mode: tag reads releases straight from git tags, no API involved."""
     from unittest import mock