consync 2.3.0__tar.gz → 2.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: consync
-Version: 2.3.0
+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.0 → consync-2.4.0}/consync/__init__.py

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

{consync-2.3.0 → 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.0 → 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.0 → consync-2.4.0}/consync/renderers/c_struct_table.py

@@ -41,7 +41,12 @@ def _sanitize_label(label: str) -> str:
 def _format_numeric(value: float | int, original_raw: str = "") -> str:
     """Format a numeric value back to C literal, preserving style of original.
 
-    Tries to maintain scientific notation, F suffix, etc. from the original.
+    Preserves:
+      1. Original exponent for scientific notation (E-3 stays E-3)
+      2. Lowercase/uppercase 'e'/'E'
+      3. Mantissa format (with/without decimal point)
+      4. Precision (number of decimal digits)
+      5. Exponent digit count (E-03 vs E-3)
     """
     if isinstance(value, int):
         if original_raw and original_raw.strip().startswith(("0x", "0X")):
@@ -55,42 +60,88 @@ def _format_numeric(value: float | int, original_raw: str = "") -> str:
         return f"{value}{suffix}"
 
     # Float value
-    suffix = "F"
+    suffix = "F"  # default
     if original_raw:
-        stripped = original_raw.strip().rstrip("fFlL")
-        if original_raw.strip().endswith("f") or original_raw.strip().endswith("F"):
-            suffix = original_raw.strip()[-1]
+        stripped = original_raw.strip()
+        if stripped.endswith("f"):
+            suffix = "f"
+        elif stripped.endswith("F"):
+            suffix = "F"
+        elif stripped.endswith("L") or stripped.endswith("l"):
+            suffix = stripped[-1]
         else:
             suffix = ""
 
     # Check if original used scientific notation
-    if original_raw and ("e" in original_raw.lower() or "E" in original_raw):
-        # Format in scientific notation
-        # Detect the exponent style from original
-        formatted = f"{value:E}"
-        # Simplify: use same number of significant digits as original
-        orig_stripped = original_raw.strip().rstrip("fFlL")
-        if "." in orig_stripped:
-            # Count digits after decimal before E
-            parts = orig_stripped.upper().split("E")
-            if "." in parts[0]:
-                decimal_digits = len(parts[0].split(".")[1])
+    if original_raw and ("e" in original_raw or "E" in original_raw):
+        # Determine case of exponent character
+        use_lowercase = "e" in original_raw and "E" not in original_raw
+        exp_char = "e" if use_lowercase else "E"
+
+        # Extract original exponent value
+        orig_no_suffix = original_raw.strip().rstrip("fFlLuU")
+        exp_match = re.search(r"[eE]([+-]?\d+)", orig_no_suffix)
+        if exp_match:
+            orig_exponent = int(exp_match.group(1))
+
+            # Handle negative values
+            sign = ""
+            abs_value = value
+            if value < 0:
+                sign = "-"
+                abs_value = abs(value)
+
+            # Calculate new mantissa preserving the original exponent
+            # value = mantissa * 10^exponent  =>  mantissa = value / 10^exponent
+            if abs_value == 0:
+                new_mantissa = 0.0
             else:
-                decimal_digits = 2
-        else:
-            decimal_digits = 2
+                new_mantissa = abs_value / (10 ** orig_exponent)
 
-        formatted = f"{value:.{decimal_digits}E}"
-        return f"{formatted}{suffix}"
+            # Determine mantissa format from original
+            mantissa_part = orig_no_suffix.split("e")[0].split("E")[0]
+            mantissa_part = mantissa_part.lstrip("+-")
+
+            if "." in mantissa_part:
+                decimal_digits = len(mantissa_part.split(".")[1])
+                mantissa_str = f"{new_mantissa:.{decimal_digits}f}"
+            else:
+                # No decimal in original (like "1E-2")
+                mantissa_str = f"{int(round(new_mantissa))}"
+
+            # Preserve exponent format (E-03 vs E-3, leading zeros)
+            exp_match_full = re.search(r"[eE]([+-]?)(\d+)", orig_no_suffix)
+            if exp_match_full:
+                exp_sign_char = exp_match_full.group(1)
+                exp_digit_count = len(exp_match_full.group(2))
+                if orig_exponent < 0:
+                    exp_sign_str = "-"
+                elif exp_sign_char == "+":
+                    exp_sign_str = "+"
+                else:
+                    exp_sign_str = ""
+                exp_abs = abs(orig_exponent)
+                exp_str = f"{exp_sign_str}{exp_abs:0{exp_digit_count}d}"
+            else:
+                exp_str = f"{orig_exponent:+d}"
+
+            formatted = f"{sign}{mantissa_str}{exp_char}{exp_str}"
+            return f"{formatted}{suffix}"
+        else:
+            # Fallback (shouldn't happen if we got here)
+            formatted = f"{value:E}"
+            return f"{formatted}{suffix}"
     else:
-        # Regular float notation
+        # Regular float notation (no scientific notation in original)
         if original_raw:
             orig_stripped = original_raw.strip().rstrip("fFlL")
             if "." in orig_stripped:
                 decimal_digits = len(orig_stripped.split(".")[1])
                 formatted = f"{value:.{decimal_digits}f}"
             else:
-                formatted = str(value)
+                formatted = (
+                    str(int(round(value))) if value == int(value) else str(value)
+                )
         else:
             formatted = str(value)
         return f"{formatted}{suffix}"

{consync-2.3.0 → 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.0 → consync-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "consync"
-version = "2.3.0"
+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.0 → 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.0 → 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.0 → consync-2.4.0}/tests/test_c_struct_table.py

@@ -1,10 +1,11 @@
-"""Tests for c_struct_table parser — generic C struct array initializer parsing."""
+"""Tests for c_struct_table parser and renderer — generic C struct array initializer."""
 
 import textwrap
 from pathlib import Path
 
 import pytest
 
+from consync.renderers.c_struct_table import _format_numeric
 from consync.parsers.c_struct_table import (
     parse_c_struct_table,
     _auto_detect_table_var,
@@ -472,3 +473,121 @@ class TestParseCStructTable:
         # Special chars in label → underscore, fields from header comment
         assert result[0].name == "Motor_A_B_v2__alpha"
         assert result[1].name == "Motor_A_B_v2__beta"
+
+
+# ============================================================
+# _format_numeric — renderer numeric formatting
+# ============================================================
+
+class TestFormatNumeric:
+    """Tests for _format_numeric() in the c_struct_table renderer.
+
+    Covers all C literal format variations found in automotive embedded code:
+    scientific notation exponent preservation, case preservation, mantissa
+    format, precision, hex, unsigned, and regular floats.
+    """
+
+    # --- Issue 1: Exponent preservation (CRITICAL) ---
+
+    def test_scientific_notation_preserves_exponent(self):
+        """Original E-3 exponent must be preserved, not renormalized."""
+        assert _format_numeric(0.205, "195.0E-3F") == "205.0E-3F"
+
+    def test_scientific_notation_same_value(self):
+        assert _format_numeric(0.195, "195.0E-3F") == "195.0E-3F"
+
+    def test_scientific_notation_higher_precision(self):
+        assert _format_numeric(0.0315, "30.13E-3F") == "31.50E-3F"
+
+    def test_scientific_notation_micro_scale(self):
+        assert _format_numeric(0.00002521, "24.21E-6F") == "25.21E-6F"
+
+    def test_scientific_notation_micro_scale_same(self):
+        assert _format_numeric(0.00002421, "24.21E-6F") == "24.21E-6F"
+
+    def test_scientific_notation_negative_value(self):
+        assert _format_numeric(-0.0001242, "-1.242E-4F") == "-1.242E-4F"
+
+    def test_scientific_notation_negative_different_exp(self):
+        assert _format_numeric(-0.0000101, "-1.01E-5F") == "-1.01E-5F"
+
+    def test_scientific_notation_positive_exponent(self):
+        assert _format_numeric(1000.0, "1.0E3F") == "1.0E3F"
+
+    def test_scientific_notation_positive_exponent_changed(self):
+        assert _format_numeric(2000.0, "1.0E3F") == "2.0E3F"
+
+    def test_scientific_notation_milli_scale(self):
+        assert _format_numeric(0.052, "42.0E-3F") == "52.0E-3F"
+
+    # --- Issue 2: Lowercase 'e' preservation ---
+
+    def test_lowercase_e_preserved_same_value(self):
+        assert _format_numeric(0.0726, "72.6e-3F") == "72.6e-3F"
+
+    def test_lowercase_e_preserved_new_value(self):
+        assert _format_numeric(0.0831, "72.6e-3F") == "83.1e-3F"
+
+    # --- Issue 3: No decimal point in mantissa ---
+
+    def test_no_decimal_mantissa_same(self):
+        assert _format_numeric(0.01, "1E-2F") == "1E-2F"
+
+    def test_no_decimal_mantissa_4e3(self):
+        assert _format_numeric(0.004, "4E-3F") == "4E-3F"
+
+    def test_no_decimal_mantissa_6e3(self):
+        assert _format_numeric(0.006, "6E-3F") == "6E-3F"
+
+    def test_no_decimal_mantissa_changed(self):
+        assert _format_numeric(0.02, "1E-2F") == "2E-2F"
+
+    # --- Issue 4: High precision + exponent digit preservation ---
+
+    def test_high_precision_same(self):
+        assert _format_numeric(0.002457019940, "2.457019940E-03F") == "2.457019940E-03F"
+
+    def test_high_precision_changed(self):
+        assert _format_numeric(0.002557019940, "2.457019940E-03F") == "2.557019940E-03F"
+
+    # --- Working cases: integers ---
+
+    def test_unsigned_int_same(self):
+        assert _format_numeric(5, "5u") == "5u"
+
+    def test_unsigned_int_changed(self):
+        assert _format_numeric(7, "5u") == "7u"
+
+    def test_hex_literal_same(self):
+        assert _format_numeric(255, "0xFF") == "0xFF"
+
+    def test_hex_literal_changed(self):
+        assert _format_numeric(16, "0xFF") == "0x10"
+
+    # --- Working cases: regular floats ---
+
+    def test_regular_float_same(self):
+        assert _format_numeric(121.0, "121.0F") == "121.0F"
+
+    def test_regular_float_changed(self):
+        assert _format_numeric(125.5, "121.0F") == "125.5F"
+
+    def test_small_float_no_sci(self):
+        assert _format_numeric(0.0055, "0.0055F") == "0.0055F"
+
+    def test_float_three_decimals(self):
+        assert _format_numeric(0.087, "0.087F") == "0.087F"
+
+    def test_zero_regular(self):
+        assert _format_numeric(0.0, "0.0F") == "0.0F"
+
+    def test_zero_scientific(self):
+        assert _format_numeric(0.0, "0.0E-3F") == "0.0E-3F"
+
+    def test_no_original_raw(self):
+        """When no original is provided, just format the value."""
+        result = _format_numeric(3.14)
+        assert result == "3.14F"
+
+    def test_int_no_original(self):
+        assert _format_numeric(42) == "42"

{consync-2.3.0 → 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.0 → 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.0 → 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.0 → 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)