consync 2.3.1__tar.gz → 2.4.0__tar.gz

{consync-2.3.1 → consync-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: consync
-Version: 2.3.1
+Version: 2.4.0
 Summary: Bidirectional sync between spreadsheets and source code constants — with full decimal precision.
 Project-URL: Homepage, https://github.com/naveenkumarbaskaran/consync
 Project-URL: Repository, https://github.com/naveenkumarbaskaran/consync

{consync-2.3.1 → consync-2.4.0}/consync/__init__.py

@@ -1,6 +1,6 @@
 """consync — Bidirectional sync between spreadsheets and source code constants."""
 
-__version__ = "2.3.1"
+__version__ = "2.4.0"
 
 from consync.models import Constant, SyncDirection
 from consync.config import load_config

{consync-2.3.1 → consync-2.4.0}/consync/config.py

@@ -140,6 +140,18 @@ def _parse_mapping(raw: dict[str, Any], config_dir: Path) -> MappingConfig:
         if key not in parser_options and key in raw:
             parser_options[key] = raw[key]
 
+    # protect_target is mandatory when direction is not 'both'
+    protect_target_raw = raw.get("protect_target")
+    if direction != SyncDirection.BOTH:
+        if protect_target_raw is None:
+            raise ValueError(
+                f"Mapping '{source}' → '{target}': 'protect_target' is required "
+                f"when direction is '{raw.get('direction', 'source_to_target')}' (not 'both'). "
+                f"Set protect_target: true to make the destination file read-only after sync, "
+                f"or protect_target: false to allow manual edits."
+            )
+    protect_target = bool(protect_target_raw) if protect_target_raw is not None else False
+
     return MappingConfig(
         source=source,
         target=target,
@@ -155,6 +167,7 @@ def _parse_mapping(raw: dict[str, Any], config_dir: Path) -> MappingConfig:
         output_style=raw.get("output_style", "const"),
         static_const=raw.get("static_const", False),
         typed_ints=raw.get("typed_ints", True),
+        protect_target=protect_target,
         parser_options=parser_options,
         renderer_options=raw.get("renderer_options") or {},
         validators=raw.get("validators") or {},
@@ -241,10 +254,13 @@ mappings:
   # - source: params.csv              # Will be created from your existing code
   #   target: legacy/params.h         # Already exists
   #   direction: target_to_source     # First sync creates the CSV from the .h
+  #   protect_target: true            # REQUIRED when direction is not 'both'
 
     # Optional:
     # prefix: ""                    # Prefix all constant names (e.g., "HW_")
     # uppercase_names: true         # Force UPPER_CASE names in output
+    # protect_target: true          # Make destination file read-only after sync
+    #                               # (mandatory when direction is not 'both')
 
 # Global settings:
 # state_file: .consync.state.json   # Track sync state (gitignore this)

{consync-2.3.1 → consync-2.4.0}/consync/models.py

@@ -90,6 +90,9 @@ class MappingConfig:
     output_style: str = "const"  # "const" | "define" — #define vs const declaration
     static_const: bool = False  # emit "static const" to avoid linker duplicates
     typed_ints: bool = True  # use uint32_t/int32_t instead of plain int/double for integers
+    # File protection — prevents manual edits to the destination file
+    # Mandatory when direction is not 'both'.
+    protect_target: bool = False  # make target read-only after sync (source_to_target)
     # Parser/renderer options (format-specific kwargs)
     parser_options: dict = field(default_factory=dict)  # passed to parser as **kwargs
     renderer_options: dict = field(default_factory=dict)  # passed to renderer as **kwargs

{consync-2.3.1 → consync-2.4.0}/consync/sync.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import logging
+import os
+import stat
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -169,7 +171,9 @@ def _sync_one(
                     + (f" (+{len(validation.errors)-1} more)" if len(validation.errors) > 1 else ""),
                 )
             backup_file(target_path, backup_dir=config_dir / ".consync" / "backups")
+            _unprotect_before_write(target_path, mapping)
             _render_file(constants, target_path, mapping.target_format, mapping)
+            _protect_after_write(target_path, mapping)
             result = SyncResult.SYNCED_SOURCE_TO_TARGET
             logger.info(
                 "Synced %s → %s (%d constants)",
@@ -187,7 +191,9 @@ def _sync_one(
                     + (f" (+{len(validation.errors)-1} more)" if len(validation.errors) > 1 else ""),
                 )
             backup_file(source_path, backup_dir=config_dir / ".consync" / "backups")
+            _unprotect_before_write(source_path, mapping)
             _render_file(constants, source_path, mapping.source_format, mapping)
+            _protect_after_write(source_path, mapping)
             result = SyncResult.SYNCED_TARGET_TO_SOURCE
             logger.info(
                 "Synced %s → %s (%d constants)",
@@ -389,6 +395,37 @@ def _render_file(constants: list, filepath: Path, format_name: str, mapping: Map
     renderer(constants, filepath, config=mapping)
 
 
+def _unprotect_before_write(filepath: Path, mapping: MappingConfig) -> None:
+    """Temporarily make a protected file writable before consync writes to it.
+
+    Only acts if protect_target is enabled and the file exists and is read-only.
+    """
+    if not mapping.protect_target:
+        return
+    if not filepath.exists():
+        return
+    current = filepath.stat().st_mode
+    if not (current & stat.S_IWUSR):
+        filepath.chmod(current | stat.S_IWUSR)
+        logger.debug("Temporarily made %s writable for sync.", filepath.name)
+
+
+def _protect_after_write(filepath: Path, mapping: MappingConfig) -> None:
+    """Make the destination file read-only after sync writes it.
+
+    Removes the owner write bit so the user cannot accidentally edit the
+    file that is managed by consync.  Only acts when protect_target is True.
+    """
+    if not mapping.protect_target:
+        return
+    if not filepath.exists():
+        return
+    current = filepath.stat().st_mode
+    readonly = current & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)
+    filepath.chmod(readonly)
+    logger.info("Protected %s (read-only). Use 'consync sync' to update.", filepath.name)
+
+
 def _validate_if_needed(constants: list, mapping: MappingConfig):
     """Run validation hooks if configured. Returns ValidationResult or None."""
     if not mapping.validators:

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "consync"
-version = "2.3.1"
+version = "2.4.0"
 description = "Bidirectional sync between spreadsheets and source code constants — with full decimal precision."
 readme = "README.md"
 license = {text = "MIT"}

{consync-2.3.1 → consync-2.4.0}/tests/test_arrays.py

@@ -446,6 +446,7 @@ class TestEndToEndArraySync:
             "  - source: params.csv\n"
             "    target: out.h\n"
             "    direction: source_to_target\n"
+            "    protect_target: false\n"
             "    header_guard: PARAMS_H\n"
             "    static_const: true\n"
             "    typed_ints: true\n"

{consync-2.3.1 → consync-2.4.0}/tests/test_audit_sync.py

@@ -495,6 +495,7 @@ static const MotorParam_t params[3] = {
                 target: motor_params.xlsx
                 format: c_struct_table
                 direction: target_to_source
+                protect_target: false
                 parser_options:
                   variant: all
         """))
@@ -508,6 +509,7 @@ static const MotorParam_t params[3] = {
                 target: motor_params.xlsx
                 format: c_struct_table
                 direction: source_to_target
+                protect_target: false
                 parser_options:
                   variant: all
         """))
@@ -526,6 +528,7 @@ static const MotorParam_t params[3] = {
                 target: motor_params.xlsx
                 format: c_struct_table
                 direction: target_to_source
+                protect_target: false
                 parser_options:
                   variant: all
         """))
@@ -567,6 +570,7 @@ static const Param_t tbl[2] = {
                 target: p.xlsx
                 format: c_struct_table
                 direction: source_to_target
+                protect_target: false
         """))
         # First sync to create xlsx
         sync(config_path=config)

{consync-2.3.1 → consync-2.4.0}/tests/test_cli.py

@@ -22,6 +22,7 @@ def project_dir(tmp_path):
           - source: data.csv
             target: out.h
             direction: source_to_target
+            protect_target: false
             precision: 17
             header_guard: TEST_H
     """))
@@ -90,4 +91,4 @@ class TestVersionCommand:
     def test_version(self, runner):
         result = runner.invoke(main, ["--version"])
         assert result.exit_code == 0
-        assert "2.1.0" in result.output
+        assert "2.4.0" in result.output

{consync-2.3.1 → consync-2.4.0}/tests/test_comprehensive_sync.py

@@ -129,7 +129,8 @@ C_STRUCT_TABLE_VARIANTS = textwrap.dedent("""\
 
 
 def create_config(tmp_path, source_name, target_name, direction="source_to_target",
-                  source_format="", target_format="", parser_options=None):
+                  source_format="", target_format="", parser_options=None,
+                  protect_target=False):
     """Create a .consync.yaml config file."""
     cfg = f"""\
 mappings:
@@ -137,6 +138,9 @@ mappings:
     target: {target_name}
     direction: {direction}
 """
+    # protect_target is mandatory when direction is not 'both'
+    if direction != "both":
+        cfg += f"    protect_target: {'true' if protect_target else 'false'}\n"
     if source_format:
         cfg += f"    source_format: {source_format}\n"
     if target_format:
@@ -403,12 +407,15 @@ class TestOneWaySourceToTarget:
               - source: params.csv
                 target: params.h
                 direction: source_to_target
+                protect_target: false
               - source: params.csv
                 target: params.json
                 direction: source_to_target
+                protect_target: false
               - source: params.csv
                 target: params.py
                 direction: source_to_target
+                protect_target: false
         """)
         config = tmp_path / ".consync.yaml"
         config.write_text(cfg_text)
@@ -1059,6 +1066,7 @@ class TestFormatRendering:
               - source: params.csv
                 target: params.h
                 direction: source_to_target
+                protect_target: false
                 output_style: define
         """)
         config = tmp_path / ".consync.yaml"
@@ -1076,6 +1084,7 @@ class TestFormatRendering:
               - source: params.csv
                 target: params.h
                 direction: source_to_target
+                protect_target: false
                 output_style: const
         """)
         config = tmp_path / ".consync.yaml"
@@ -1093,6 +1102,7 @@ class TestFormatRendering:
               - source: params.csv
                 target: params.v
                 direction: source_to_target
+                protect_target: false
                 module_name: motor_params
         """)
         config = tmp_path / ".consync.yaml"
@@ -1111,6 +1121,7 @@ class TestFormatRendering:
               - source: params.csv
                 target: params.cs
                 direction: source_to_target
+                protect_target: false
                 namespace: Motor.Config
         """)
         config = tmp_path / ".consync.yaml"

{consync-2.3.1 → consync-2.4.0}/tests/test_embedded.py

@@ -239,6 +239,7 @@ class TestECUEndToEnd:
               - source: ecu_params.csv
                 target: ecu_params.h
                 direction: source_to_target
+                protect_target: false
                 precision: 17
                 header_guard: ECU_PARAMS_H
                 output_style: const

{consync-2.3.1 → consync-2.4.0}/tests/test_safety.py

@@ -414,6 +414,7 @@ mappings:
   - source: data.csv
     target: out.h
     direction: source_to_target
+    protect_target: false
 """)
         source = tmp_path / "data.csv"
         source.write_text(source_content)
@@ -470,6 +471,7 @@ mappings:
   - source: data.csv
     target: out.h
     direction: source_to_target
+    protect_target: false
     validators:
       X:
         min: 0
@@ -494,6 +496,7 @@ mappings:
   - source: data.csv
     target: out.h
     direction: source_to_target
+    protect_target: false
     validators:
       X:
         min: 0
@@ -506,3 +509,144 @@ mappings:
         reports = sync(config_path=str(config))
 
         assert reports[0].result == SyncResult.SYNCED_SOURCE_TO_TARGET
+
+
+# ============================================================
+# protect_target Tests
+# ============================================================
+
+class TestProtectTarget:
+    """Tests for the protect_target option that makes destination files read-only."""
+
+    def test_config_requires_protect_target_for_s2t(self, tmp_path):
+        """Config loader rejects source_to_target without protect_target."""
+        from consync.config import load_config
+
+        config = tmp_path / ".consync.yaml"
+        config.write_text("""\
+mappings:
+  - source: data.csv
+    target: out.h
+    direction: source_to_target
+""")
+        (tmp_path / "data.csv").write_text("Name,Value\nX,1\n")
+
+        with pytest.raises(ValueError, match="protect_target.*required"):
+            load_config(config)
+
+    def test_config_requires_protect_target_for_t2s(self, tmp_path):
+        """Config loader rejects target_to_source without protect_target."""
+        from consync.config import load_config
+
+        config = tmp_path / ".consync.yaml"
+        config.write_text("""\
+mappings:
+  - source: data.csv
+    target: out.h
+    direction: target_to_source
+    protect_target: false
+""")
+        # This should load fine (protect_target is set)
+        cfg = load_config(config)
+        assert cfg.mappings[0].protect_target is False
+
+    def test_config_optional_for_both_direction(self, tmp_path):
+        """Config loader does NOT require protect_target when direction is 'both'."""
+        from consync.config import load_config
+
+        config = tmp_path / ".consync.yaml"
+        config.write_text("""\
+mappings:
+  - source: data.csv
+    target: out.h
+    direction: both
+""")
+        # Should load without error
+        cfg = load_config(config)
+        assert cfg.mappings[0].protect_target is False
+
+    def test_protect_target_true_makes_file_readonly(self, tmp_path):
+        """When protect_target is True, target file is set read-only after sync."""
+        import stat
+        from consync.sync import sync, SyncResult
+
+        config = tmp_path / ".consync.yaml"
+        config.write_text("""\
+mappings:
+  - source: data.csv
+    target: out.h
+    direction: source_to_target
+    protect_target: true
+""")
+        source = tmp_path / "data.csv"
+        source.write_text("Name,Value\nX,42\n")
+
+        os.chdir(tmp_path)
+        reports = sync(config_path=str(config))
+        assert reports[0].result == SyncResult.SYNCED_SOURCE_TO_TARGET
+
+        target = tmp_path / "out.h"
+        assert target.exists()
+        mode = target.stat().st_mode
+        assert not (mode & stat.S_IWUSR), "Target should be read-only (no owner write bit)"
+        assert not (mode & stat.S_IWGRP), "Target should be read-only (no group write bit)"
+        assert not (mode & stat.S_IWOTH), "Target should be read-only (no other write bit)"
+
+    def test_protect_target_false_leaves_file_writable(self, tmp_path):
+        """When protect_target is False, target file stays writable."""
+        import stat
+        from consync.sync import sync, SyncResult
+
+        config = tmp_path / ".consync.yaml"
+        config.write_text("""\
+mappings:
+  - source: data.csv
+    target: out.h
+    direction: source_to_target
+    protect_target: false
+""")
+        source = tmp_path / "data.csv"
+        source.write_text("Name,Value\nX,42\n")
+
+        os.chdir(tmp_path)
+        reports = sync(config_path=str(config))
+        assert reports[0].result == SyncResult.SYNCED_SOURCE_TO_TARGET
+
+        target = tmp_path / "out.h"
+        mode = target.stat().st_mode
+        assert mode & stat.S_IWUSR, "Target should remain writable"
+
+    def test_protect_target_resync_works(self, tmp_path):
+        """Protected (read-only) file can still be updated by subsequent sync."""
+        import stat
+        from consync.sync import sync, SyncResult
+
+        config = tmp_path / ".consync.yaml"
+        config.write_text("""\
+mappings:
+  - source: data.csv
+    target: out.h
+    direction: source_to_target
+    protect_target: true
+""")
+        source = tmp_path / "data.csv"
+        source.write_text("Name,Value\nX,42\n")
+
+        os.chdir(tmp_path)
+        sync(config_path=str(config))
+        target = tmp_path / "out.h"
+        assert not (target.stat().st_mode & stat.S_IWUSR)
+
+        content_v1 = target.read_text()
+
+        # Update source and sync again — should work despite file being read-only
+        source.write_text("Name,Value\nX,99\n")
+        reports = sync(config_path=str(config))
+        assert reports[0].result == SyncResult.SYNCED_SOURCE_TO_TARGET
+
+        content_v2 = target.read_text()
+        assert content_v2 != content_v1
+        assert "99" in content_v2
+
+        # File should be read-only again
+        assert not (target.stat().st_mode & stat.S_IWUSR)