consync 2.3.0__tar.gz → 2.3.1__tar.gz

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

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

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "consync"
-version = "2.3.0"
+version = "2.3.1"
 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.3.1}/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"