gitacross 2.0.0__tar.gz → 2.1.0__tar.gz

{gitacross-2.0.0/src/gitacross.egg-info → gitacross-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.0.0
+Version: 2.1.0
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -22,6 +22,7 @@ License-File: LICENSE
 Requires-Dist: PyYAML<7.0,>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Dynamic: license-file
@@ -77,6 +78,15 @@ For development, install the local checkout:
 pip install -e .
 ```
 
+### Tests
+
+```bash
+pip install -e .[dev]   # pytest + pytest-cov
+pytest                  # run the test suite
+pytest --cov=gitacross  # run with a coverage floor (90% line + branch)
+ruff check src tests    # lint
+```
+
 ### Config
 
 GitAcross reads a YAML file listing the mirrors you want. Each entry in the `projects` list is a **project**: it has a `source` (where releases come from) and a `target` (where they go).

{gitacross-2.0.0 → gitacross-2.1.0}/README.md

@@ -49,6 +49,15 @@ For development, install the local checkout:
 pip install -e .
 ```
 
+### Tests
+
+```bash
+pip install -e .[dev]   # pytest + pytest-cov
+pytest                  # run the test suite
+pytest --cov=gitacross  # run with a coverage floor (90% line + branch)
+ruff check src tests    # lint
+```
+
 ### Config
 
 GitAcross reads a YAML file listing the mirrors you want. Each entry in the `projects` list is a **project**: it has a `source` (where releases come from) and a `target` (where they go).

{gitacross-2.0.0 → gitacross-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacross"
-version = "2.0.0"
+version = "2.1.0"
 description = "Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -33,6 +33,7 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0",
+    "pytest-cov>=4.0",
     "build",
     "twine",
 ]
@@ -46,3 +47,15 @@ where = ["src"]
 [tool.pytest.ini_options]
 pythonpath = ["src"]
 testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["gitacross"]
+# Keep branch measurement on for the report, but don't gate on it —
+# a 100% branch gate incentivizes line-touching tests over behavior tests.
+branch = true
+
+[tool.coverage.report]
+# Enforcement floor with headroom: catches regressions without demanding
+# 100% (which encourages tests-for-the-sake-of-it on defensive branches).
+fail_under = 90
+show_missing = true

{gitacross-2.0.0 → gitacross-2.1.0}/src/gitacross/__init__.py

@@ -28,6 +28,7 @@ from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _installed_version
 from pathlib import Path
 
+from .cli import main  # the CLI lives in cli.py; main.py re-exports it too
 from .config import Config, ProjectConfig
 from .linter import (
     ConfigFixer,
@@ -40,7 +41,7 @@ from .linter import (
     fix_config,
     lint_config,
 )
-from .main import main, run, sync_project
+from .main import run, sync_project
 
 
 def _package_version() -> str:

{gitacross-2.0.0 → gitacross-2.1.0}/src/gitacross/__main__.py

@@ -1,7 +1,6 @@
 """Entry point when invoked with `python -m gitacross`."""
 from __future__ import annotations
 
-
 from .main import main
 
 if __name__ == "__main__":

gitacross-2.1.0/src/gitacross/cli.py

@@ -0,0 +1,105 @@
+"""Command-line interface for GitAcross.
+
+The sync logic lives in :mod:`gitacross.main`; this module only parses
+``argv`` and maps results to process exit codes.
+"""
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+from typing import cast
+
+
+def _setup_logging(verbose):
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+
+def main():
+    from .main import DEFAULT_WORK_DIR, run
+
+    parser = argparse.ArgumentParser(description="Sync releases from source to target")
+    _ = parser.add_argument("--config", required=True, help="Path to config.yml")
+    _ = parser.add_argument("--project", help="Sync only this project (by name)")
+    _ = parser.add_argument(
+        "--dry-run", action="store_true", help="Print changes without pushing"
+    )
+    _ = parser.add_argument(
+        "--reset",
+        action="store_true",
+        help="Clear state and cache before running (fresh start)",
+    )
+    _ = parser.add_argument(
+        "--lint",
+        action="store_true",
+        help="Lint config file for YAML errors, invalid settings, and redundant options",
+    )
+    _ = parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="Automatically fix misplaced keys and remove redundant options in config file",
+    )
+    _ = parser.add_argument(
+        "--workdir",
+        default=DEFAULT_WORK_DIR,
+        help="Directory for state.yml and cache/ (default: .gitsync)",
+    )
+    _ = parser.add_argument("-v", "--verbose", action="store_true", help="Debug logging")
+    args = parser.parse_args()
+
+    # Convert argparse's Any values into concrete types (cast is the escape hatch).
+    verbose = cast(bool, args.verbose)
+    config_path = Path(cast(str, args.config))
+    fix_flag = cast(bool, args.fix)
+    lint_flag = cast(bool, args.lint)
+    project_filter = None if args.project is None else cast(str, args.project)
+    dry_run_flag = cast(bool, args.dry_run)
+    reset_flag = cast(bool, args.reset)
+    workdir = cast(str, args.workdir)
+
+    _setup_logging(verbose)
+
+    if fix_flag:
+        if not config_path.exists():
+            sys.exit(f"Config file not found: {config_path}")
+        from .linter import fix_config, lint_config
+
+        fix_report = fix_config(
+            config_path, write_back=not dry_run_flag, dry_run=dry_run_flag
+        )
+        if not fix_report.is_valid:
+            sys.exit(1)
+        if lint_flag:
+            print()
+            lint_report = lint_config(config_path)
+            sys.exit(0 if lint_report.is_valid else 1)
+        sys.exit(0)
+
+    if lint_flag:
+        if not config_path.exists():
+            sys.exit(f"Config file not found: {config_path}")
+        from .linter import lint_config
+
+        report = lint_config(config_path)
+        sys.exit(0 if report.is_valid else 1)
+
+    try:
+        results = run(
+            config_path,
+            project=project_filter,
+            dry_run=dry_run_flag,
+            reset=reset_flag,
+            work_dir=workdir,
+        )
+    except (FileNotFoundError, ValueError) as exc:
+        sys.exit(str(exc))
+
+    if any(not r["synced"] for r in results):
+        sys.exit(1)
+

{gitacross-2.0.0 → gitacross-2.1.0}/src/gitacross/config.py

@@ -7,6 +7,8 @@ from typing import final
 
 import yaml
 
+from .providers import REMOTE_TYPES
+
 logger = logging.getLogger(__name__)
 
 VALID_PROJECT_KEYS = {
@@ -164,7 +166,12 @@ class _EndpointConfig:
 
     @property
     def is_remote(self):
-        return self.type in ("gitea", "github")
+        return self.type in REMOTE_TYPES
+
+    @property
+    def repo_slug(self):
+        """Filesystem-safe repo identifier (``owner/name`` → ``owner_name``)."""
+        return self.repo.replace("/", "_")
 
     @property
     def owner(self):

gitacross-2.1.0/src/gitacross/linter/__init__.py

@@ -0,0 +1,26 @@
+"""Config linter and fixer for GitAcross.
+
+``lint_config`` validates a config; ``fix_config`` rewrites it in place to
+remove redundant and misplaced options.
+
+Implementation lives in three modules:
+
+* :mod:`gitacross.linter.models` — report/issue data types and YAML dump helper
+* :mod:`gitacross.linter.validator` — :class:`ConfigLinter` (the checks)
+* :mod:`gitacross.linter.fixer` — :class:`ConfigFixer` (the rewrites)
+"""
+from .fixer import ConfigFixer, fix_config
+from .models import FixIssue, FixReport, LintIssue, LintReport, LintSeverity
+from .validator import ConfigLinter, lint_config
+
+__all__ = [
+    "ConfigFixer",
+    "ConfigLinter",
+    "FixIssue",
+    "FixReport",
+    "LintIssue",
+    "LintReport",
+    "LintSeverity",
+    "fix_config",
+    "lint_config",
+]

gitacross-2.1.0/src/gitacross/linter/fixer.py

@@ -0,0 +1,282 @@
+"""Config fixer — rewrites configs to remove redundant/misplaced options.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from ..config import KNOWN_SOURCE_KEYS, VALID_PROJECT_KEYS
+from .models import FixIssue, FixReport, _CleanDumper
+
+
+class ConfigFixer:
+    def __init__(self):
+        self.fixes: list[FixIssue] = []
+
+    def __repr__(self):
+        return f"ConfigFixer(fixes={len(self.fixes)})"
+
+    def _add(self, message: str, project: str | None = None):
+        self.fixes.append(FixIssue(message=message, project=project))
+
+    def fix_yaml_string(self, content: str) -> FixReport:
+        # Fresh accumulator — reusing an instance must not leak prior fixes
+        self.fixes = []
+        try:
+            data = yaml.safe_load(content)
+        except yaml.YAMLError as e:
+            return FixReport(fixes=[], content=content, is_valid=False, error=str(e))
+
+        if data is None:
+            return FixReport(fixes=[], content=content, is_valid=True)
+
+        is_dict_wrapper = isinstance(data, dict) and "projects" in data
+        projects_list = data["projects"] if is_dict_wrapper else data
+
+        if not isinstance(projects_list, list):
+            return FixReport(
+                fixes=[],
+                content=content,
+                is_valid=False,
+                error="Top-level YAML structure must be a list of projects or a map with a 'projects' list.",
+            )
+
+        for _idx, p in enumerate(projects_list):
+            if isinstance(p, dict):
+                self._fix_project(p)
+
+        fixed_yaml = yaml.dump(
+            data,
+            Dumper=_CleanDumper,
+            sort_keys=False,
+            default_flow_style=False,
+        )
+        return FixReport(fixes=self.fixes, content=fixed_yaml, is_valid=True)
+
+    def _fix_project(self, p: dict[str, Any]):
+        p_name = p.get("name") or "<unnamed>"
+
+        # 1. Misplaced endpoint keys at project level -> move to source
+        for k in list(p.keys()):
+            if k in KNOWN_SOURCE_KEYS:
+                val = p.pop(k)
+                if "source" not in p or not isinstance(p["source"], dict):
+                    p["source"] = {}
+                if k not in p["source"]:
+                    p["source"][k] = val
+                    self._add(
+                        f"Moved '{k}: {val}' from project level into 'source:'",
+                        project=p_name,
+                    )
+                else:
+                    self._add(
+                        f"Removed duplicate project-level '{k}' (already present under source)",
+                        project=p_name,
+                    )
+
+        # 2. Misplaced project-level keys inside source -> move to project level
+        if isinstance(p.get("source"), dict):
+            for k in list(p["source"].keys()):
+                if k in VALID_PROJECT_KEYS and k != "type":
+                    val = p["source"].pop(k)
+                    if k not in p:
+                        p[k] = val
+                        self._add(
+                            f"Moved '{k}' from 'source:' to project level",
+                            project=p_name,
+                        )
+                    else:
+                        self._add(
+                            f"Removed duplicate '{k}' from 'source:' (already present at project level)",
+                            project=p_name,
+                        )
+
+        # 3. Misplaced project keys in target -> move to project level
+        #    and misplaced source keys in target -> move to source
+        if isinstance(p.get("target"), dict):
+            for k in list(p["target"].keys()):
+                if k in VALID_PROJECT_KEYS and k != "type":
+                    val = p["target"].pop(k)
+                    if k not in p:
+                        p[k] = val
+                        self._add(
+                            f"Moved '{k}' from 'target:' to project level",
+                            project=p_name,
+                        )
+                    else:
+                        self._add(
+                            f"Removed duplicate '{k}' from 'target:' (already present at project level)",
+                            project=p_name,
+                        )
+                elif k in KNOWN_SOURCE_KEYS:
+                    val = p["target"].pop(k)
+                    if "source" not in p or not isinstance(p["source"], dict):
+                        p["source"] = {}
+                    if k not in p["source"]:
+                        p["source"][k] = val
+                        self._add(
+                            f"Moved '{k}: {val}' from 'target:' into 'source:'",
+                            project=p_name,
+                        )
+                    else:
+                        self._add(
+                            f"Removed duplicate '{k}' from 'target:' (already present under source)",
+                            project=p_name,
+                        )
+
+        # 4. Redundant project-level options
+        if p.get("enabled") is True:
+            del p["enabled"]
+            self._add("Removed redundant 'enabled: true'", project=p_name)
+
+        for key in ("preserve_description",):
+            if p.get(key) is True:
+                del p[key]
+                self._add(f"Removed redundant '{key}: true'", project=p_name)
+
+        for key in ("sync_assets",):
+            if p.get(key) is False:
+                del p[key]
+                self._add(f"Removed redundant '{key}: false'", project=p_name)
+
+        if p.get("stream_assets") is False:
+            del p["stream_assets"]
+            self._add("Removed redundant 'stream_assets: false'", project=p_name)
+
+        # 3. Source endpoint fixes
+        if isinstance(p.get("source"), dict):
+            src = p["source"]
+            if src.get("mode") == "release":
+                del src["mode"]
+                self._add(
+                    "Removed redundant 'source.mode: release'", project=p_name
+                )
+            if src.get("include_prereleases") is False:
+                del src["include_prereleases"]
+                self._add(
+                    "Removed redundant 'source.include_prereleases: false'",
+                    project=p_name,
+                )
+            if src.get("include_drafts") is False:
+                del src["include_drafts"]
+                self._add(
+                    "Removed redundant 'source.include_drafts: false'",
+                    project=p_name,
+                )
+            if src.get("sync_from") == "":
+                del src["sync_from"]
+                self._add(
+                    "Removed redundant 'source.sync_from: \"\"'",
+                    project=p_name,
+                )
+            if src.get("tag_pattern") == "*":
+                del src["tag_pattern"]
+                self._add(
+                    "Removed redundant 'source.tag_pattern: \"*\"'",
+                    project=p_name,
+                )
+
+        # 4. Target endpoint fixes
+        if isinstance(p.get("target"), dict):
+            tgt = p["target"]
+            if tgt.get("branch") == "main":
+                del tgt["branch"]
+                self._add(
+                    "Removed redundant 'target.branch: main'", project=p_name
+                )
+
+        # 5. Retry fixes
+        if isinstance(p.get("retry"), dict):
+            ret = p["retry"]
+            if ret.get("max_attempts") == 3:
+                del ret["max_attempts"]
+            if ret.get("backoff_seconds") == 2:
+                del ret["backoff_seconds"]
+            if len(ret) == 0:
+                del p["retry"]
+                self._add(
+                    "Removed default 'retry' configuration block",
+                    project=p_name,
+                )
+            else:
+                self._add(
+                    "Removed redundant retry defaults", project=p_name
+                )
+
+        # 6. Renderer fixes
+        if isinstance(p.get("renderer"), dict):
+            ren = p["renderer"]
+            if isinstance(ren.get("operations"), list):
+                for op in ren["operations"]:
+                    if not isinstance(op, dict):
+                        continue
+                    for op_type, items in op.items():
+                        if isinstance(items, list):
+                            for item in items:
+                                if not isinstance(item, dict):
+                                    continue
+                                if item.get("pattern") == "literal":
+                                    del item["pattern"]
+                                    self._add(
+                                        f"Removed redundant 'pattern: literal' in {op_type} operation",
+                                        project=p_name,
+                                    )
+                                if op_type == "replace":
+                                    if item.get("case_sensitive") is True:
+                                        del item["case_sensitive"]
+                                        self._add(
+                                            "Removed redundant 'case_sensitive: true' in replace operation",
+                                            project=p_name,
+                                        )
+                                    if item.get("match_case") is False:
+                                        del item["match_case"]
+                                        self._add(
+                                            "Removed redundant 'match_case: false' in replace operation",
+                                            project=p_name,
+                                        )
+                                if op_type == "validate" and item.get(
+                                    "case_sensitive"
+                                ) is True:
+                                    del item["case_sensitive"]
+                                    self._add(
+                                        "Removed redundant 'case_sensitive: true' in validate operation",
+                                        project=p_name,
+                                    )
+
+
+
+def fix_config(
+    config: str | Path,
+    write_back: bool = True,
+    print_output: bool = True,
+    dry_run: bool = False,
+) -> FixReport:
+    """Fix misplaced and redundant options in config file.
+
+    Path-only: unlike :func:`lint_config`, this writes the fixed YAML back to
+    the file (when *write_back* is true), so it requires a real file path.
+    Pass ``dry_run=True`` to preview the fixes without writing anything.
+    """
+    path = Path(config)
+    if not path.exists():
+        report = FixReport(
+            fixes=[], content="", is_valid=False, error=f"File not found: {path}"
+        )
+        if print_output:
+            print(report.format_text())
+        return report
+
+    content = path.read_text(encoding="utf-8")
+    fixer = ConfigFixer()
+    report = fixer.fix_yaml_string(content)
+    if report.is_valid and write_back and not dry_run and report.fixes:
+        _ = path.write_text(report.content, encoding="utf-8")
+    if print_output:
+        if dry_run and report.fixes:
+            print(f"[DRY-RUN] Would apply {len(report.fixes)} fix(es):")
+        print(report.format_text())
+    return report
+
+

gitacross-2.1.0/src/gitacross/linter/keys.py

@@ -0,0 +1,39 @@
+"""Valid key sets for source/target endpoints.
+
+Separate from the validator so the fixer never pulls in validation code.
+"""
+from __future__ import annotations
+
+_VALID_SOURCE_KEYS_REMOTE = {
+    "type",
+    "repo",
+    "api",
+    "token",
+    "mode",
+    "branch",
+    "include_prereleases",
+    "include_drafts",
+    "sync_from",
+}
+
+_VALID_SOURCE_KEYS_LOCAL = {
+    "type",
+    "path",
+    "tag_pattern",
+    "sync_from",
+}
+
+_VALID_TARGET_KEYS_REMOTE = {
+    "type",
+    "repo",
+    "api",
+    "token",
+    "branch",
+}
+
+_VALID_TARGET_KEYS_LOCAL = {
+    "type",
+    "path",
+    "branch",
+}
+