feat: Add extra key mapping section

Using ASCII art to declare the layout is limited to the keys declared in
the geometries.

Added an extra section `mapping` to the TOML layout configuration file,
that enable mappings key explicitly with a dictionary.

Author: wismill

kalamine/layout.py

@@ -2,7 +2,7 @@
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Type, TypeVar
+from typing import Dict, List, Optional, Set, Type, TypeVar, Union
 
 import click
 import tomli
@@ -199,8 +199,47 @@ def __init__(
             self.layers[Layer.ALTGR]["spce"] = spc["altgr"]
             self.layers[Layer.ALTGR_SHIFT]["spce"] = spc["altgr_shift"]
 
+        # Extra mapping
+        if mapping := layout_data.get("mapping"):
+            self._parse_extra_mapping(mapping)
+
         self._parse_dead_keys(spc)
 
+    @staticmethod
+    def _parse_key_ref(raw: str) -> Optional[str]:
+        """Parse a key reference (e.g. to clone)"""
+        if raw.startswith("(") and raw.endswith(")"):
+            if (clone := raw[1:-1]) and clone in KEYS:
+                return clone
+        return None
+
+    def _parse_extra_mapping(self, mapping: Dict[str, Union[str, Dict[str, str]]]):
+        """Parse a layout dict"""
+        layer: Optional[Layer]
+        for raw_key, levels in mapping.items():
+            # TODO: parse key in various ways (XKB, Linux keycode)
+            if raw_key not in KEYS:
+                raise ValueError(f"Unknown key: “{raw_key}”")
+            key = raw_key
+            # Check for key clone
+            if isinstance(levels, str):
+                # Check for clone
+                if clone := self._parse_key_ref(levels):
+                    for layer, keys in self.layers.items():
+                        if value := keys.get(clone):
+                            self.layers[layer][key] = value
+                    continue
+                raise ValueError(f"Unsupported key mapping: {raw_key}: {levels}")
+            for raw_layer, raw_value in levels.items():
+                if (layer := Layer.parse(raw_layer)) is None:
+                    raise ValueError(f"Cannot parse layer: “{raw_layer}”")
+                if clone := self._parse_key_ref(raw_value):
+                    if (value := self.layers[layer].get(clone)) is None:
+                        continue
+                else:
+                    value = raw_value
+                self.layers[layer][key] = value
+
     def _parse_dead_keys(self, spc: Dict[str, str]) -> None:
         """Build a deadkey dict."""
 

kalamine/utils.py

@@ -47,6 +47,24 @@ class Layer(IntEnum):
     ALTGR = 4
     ALTGR_SHIFT = 5
 
+    @classmethod
+    def parse(cls, raw: str) -> Optional["Layer"]:
+        rawʹ = raw.casefold()
+        if rawʹ == "1dk":
+            return cls(cls.ODK)
+        elif rawʹ == "1dk_shift":
+            return cls(cls.ODK_SHIFT)
+        else:
+            for layer in cls:
+                if rawʹ == layer.name.casefold():
+                    return layer
+                try:
+                    if int(raw, base=10) == layer.value:
+                        return layer
+                except ValueError:
+                    pass
+            return None
+
     def next(self) -> "Layer":
         """The next layer in the layer ordering."""
         return Layer(int(self) + 1)