Update opm-common submodule and rebuild keyword index

Advance the opm-common submodule pointer and regenerate the keyword
index from it.

Also tolerate the non-strict JSON a few opm-common keyword files use:
multi-line comment strings with raw newlines (ROCK, MAPAXES), number
literals like 1.e-01 (NETBALAN), and an empty placeholder (REACACT).
A sanitizing fallback loads these instead of dropping them with a
warning, recovering 3 keywords in the index.

Author: magnesj

opm-common

@@ -157,6 +157,66 @@ def _classify_size(opm_data: dict) -> tuple[str, Optional[int]]:
     return "none", 0
 
 
+def _sanitize_lax_json(text: str) -> str:
+    """Rewrite the non-strict JSON a handful of opm-common keyword files use
+    into something Python's strict ``json`` accepts. opm-common ships these
+    through its own lenient C++ parser, so two constructs slip in:
+
+    * multi-line ``"comment"`` strings containing raw newlines/tabs (e.g.
+      ROCK, MAPAXES) — control chars are illegal inside JSON strings;
+    * number literals with no digit after the decimal point, like
+      ``1.e-01`` in NETBALAN — JSON requires ``1.0e-01``.
+
+    A single left-to-right scan tracks whether we're inside a string so the
+    two fixes never interfere: control chars are escaped only inside strings,
+    and the ``.`` -> ``.0`` fix is applied only outside them (in JSON a bare
+    ``.`` can only occur within a number).
+    """
+    out: list[str] = []
+    in_string = False
+    escaped = False
+    ctrl_map = {"\n": "\\n", "\r": "\\r", "\t": "\\t"}
+    n = len(text)
+    for i, ch in enumerate(text):
+        if in_string:
+            if escaped:
+                out.append(ch)
+                escaped = False
+            elif ch == "\\":
+                out.append(ch)
+                escaped = True
+            elif ch == '"':
+                out.append(ch)
+                in_string = False
+            elif ord(ch) < 0x20:
+                out.append(ctrl_map.get(ch, "\\u%04x" % ord(ch)))
+            else:
+                out.append(ch)
+        elif ch == '"':
+            in_string = True
+            out.append(ch)
+        elif ch == "." and i + 1 < n and text[i + 1] in "eE":
+            # 1.e-01 -> 1.0e-01
+            out.append(".0")
+        else:
+            out.append(ch)
+    return "".join(out)
+
+
+def _load_keyword_json(kw_file: Path) -> Optional[dict]:
+    """Read one opm-common keyword file, tolerating the lenient JSON a few
+    upstream files use. Returns the parsed dict, ``None`` for an empty file
+    (e.g. REACACT, a placeholder), and re-raises only if even the sanitized
+    text fails to parse."""
+    text = kw_file.read_text(encoding="utf-8")
+    if not text.strip():
+        return None
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return json.loads(_sanitize_lax_json(text))
+
+
 def load_opm_common_index(keywords_dir: Path) -> dict:
     """
     Walk the opm-common keywords tree and return a dict keyed by keyword name.
@@ -179,11 +239,12 @@ def load_opm_common_index(keywords_dir: Path) -> dict:
                 if not kw_file.is_file():
                     continue
                 try:
-                    with open(kw_file, "r", encoding="utf-8") as f:
-                        data = json.load(f)
+                    data = _load_keyword_json(kw_file)
                 except (OSError, json.JSONDecodeError) as e:
                     print(f"  WARNING: failed to read {kw_file}: {e}", file=sys.stderr)
                     continue
+                if data is None:  # empty placeholder file
+                    continue
                 name = data.get("name") or kw_file.name
                 if name in out:
                     continue

scripts/build_keyword_index.py

@@ -41,6 +41,8 @@
     attach_string_options,
     _opm_item_for_param,
     _classify_size,
+    _sanitize_lax_json,
+    _load_keyword_json,
     _summary_size_shape,
     _summary_optional_body,
     NS,
@@ -685,6 +687,75 @@ def test_title_size_kind_overridden_to_none(self, tmp_path):
         assert idx["TITLE"]["size_kind"] == "none"
         assert idx["TITLE"]["size_count"] is None
 
+    def test_multiline_comment_is_loaded(self, tmp_path):
+        # ROCK / MAPAXES ship a "comment" with raw newlines, which strict
+        # JSON rejects. The lenient loader should still pick the keyword up.
+        d = tmp_path / "000_Eclipse100" / "R"
+        d.mkdir(parents=True)
+        (d / "ROCK").write_text(
+            '{\n  "name": "ROCK",\n  "sections": ["PROPS"],\n'
+            '  "comment" : "\nline one\nline two\n",\n  "items": []\n}\n',
+            encoding="utf-8",
+        )
+        idx = load_opm_common_index(tmp_path)
+        assert "ROCK" in idx
+        assert idx["ROCK"]["sections"] == ["PROPS"]
+
+    def test_lax_number_literal_is_loaded(self, tmp_path):
+        # NETBALAN uses 1.e-01, which JSON requires written as 1.0e-01.
+        d = tmp_path / "000_Eclipse100" / "N"
+        d.mkdir(parents=True)
+        (d / "NETBALAN").write_text(
+            '{ "name": "NETBALAN", "sections": ["SCHEDULE"],'
+            ' "items": [{ "name": "LIMIT", "value_type": "DOUBLE",'
+            ' "default": 1.e-01 }] }',
+            encoding="utf-8",
+        )
+        idx = load_opm_common_index(tmp_path)
+        assert "NETBALAN" in idx
+        assert idx["NETBALAN"]["items"][0]["default"] == 0.1
+
+    def test_empty_file_is_skipped_without_error(self, tmp_path):
+        # REACACT is an empty placeholder file; it should drop out quietly.
+        d = tmp_path / "000_Eclipse100" / "R"
+        d.mkdir(parents=True)
+        (d / "REACACT").write_text("", encoding="utf-8")
+        idx = load_opm_common_index(tmp_path)
+        assert idx == {}
+
+
+class TestSanitizeLaxJson:
+    def test_escapes_control_chars_inside_strings(self):
+        out = _sanitize_lax_json('{ "c": "a\nb\tc" }')
+        assert json.loads(out)["c"] == "a\nb\tc"
+
+    def test_fixes_decimal_without_trailing_digit(self):
+        assert json.loads(_sanitize_lax_json('{ "v": 1.e-01 }'))["v"] == 0.1
+
+    def test_leaves_dot_inside_strings_alone(self):
+        # A literal ".e" sequence inside a string must not be rewritten.
+        out = _sanitize_lax_json('{ "c": "see 1.e-01 here", "v": 2.e0 }')
+        data = json.loads(out)
+        assert data["c"] == "see 1.e-01 here"
+        assert data["v"] == 2.0
+
+    def test_well_formed_json_is_unchanged(self):
+        src = '{ "a": 1, "b": [1.5, 2.0], "c": "x" }'
+        assert json.loads(_sanitize_lax_json(src)) == json.loads(src)
+
+
+class TestLoadKeywordJson:
+    def test_empty_file_returns_none(self, tmp_path):
+        p = tmp_path / "EMPTY"
+        p.write_text("   \n", encoding="utf-8")
+        assert _load_keyword_json(p) is None
+
+    def test_truly_broken_json_still_raises(self, tmp_path):
+        p = tmp_path / "BAD"
+        p.write_text("{ not valid", encoding="utf-8")
+        with pytest.raises(json.JSONDecodeError):
+            _load_keyword_json(p)
+
 
 class TestClassifySize:
     def test_explicit_size_zero_means_none(self):