improv: Avoid duplicating layout data between laptops

This matches the changes in EC, and avoids duplicating `physical.json`.
`keymap.json` remains duplicated since it contains a `board` key that is
checked when loading.

Author: ids1024

backend/Cargo.toml

@@ -28,6 +28,9 @@ features = ["hidapi", "std"]
 [target.'cfg(target_os = "linux")'.dependencies]
 zbus = "1.9.1"
 
+[build-dependencies]
+serde_json = "1.0"
+
 [dev-dependencies]
 libc = "0.2"
 

backend/build.rs

@@ -0,0 +1,41 @@
+use std::{
+    env,
+    fs::{self, File},
+    io::Write,
+    path::Path,
+};
+
+fn main() {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+    let mut outfile = File::create(Path::new(&out_dir).join("keyboards.rs")).unwrap();
+
+    writeln!(outfile, "keyboards![").unwrap();
+
+    println!("cargo:rerun-if-changed=../layouts/system76");
+    for i in fs::read_dir("../layouts/system76").unwrap() {
+        let i = i.unwrap();
+
+        let path = i.path().join("meta.json");
+        let meta = serde_json::from_reader::<_, serde_json::Map<_, _>>(File::open(&path).unwrap())
+            .unwrap();
+        let file_name = i.file_name().into_string().unwrap();
+        let keyboard = meta
+            .get("keyboard")
+            .and_then(|x| x.as_str())
+            .unwrap_or_else(|| {
+                panic!("'keyboard:' not found in {}", path.display());
+            });
+
+        writeln!(
+            outfile,
+            "    (\"system76/{}\", \"{}\"),",
+            file_name, keyboard
+        )
+        .unwrap();
+
+        println!("cargo:rerun-if-changed=../layouts/system76/{}", file_name);
+        println!("cargo:rerun-if-changed=../layouts/keyboards/{}", keyboard);
+    }
+
+    writeln!(outfile, "];").unwrap();
+}

backend/src/layout/mod.rs

@@ -20,23 +20,23 @@ pub struct Layout {
 }
 
 macro_rules! keyboards {
-    ($( $board:expr ),* $(,)?) => {
+    ($( ($board:expr, $keyboard:expr) ),* $(,)?) => {
         fn layout_data(board: &str) -> Option<(&'static str, &'static str, &'static str, &'static str, &'static str, &'static str)> {
             match board {
                 $(
                 $board => {
                     let meta_json =
-                        include_str!(concat!("../../../layouts/", $board, "/meta.json"));
+                        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../layouts/", $board, "/meta.json"));
                     let default_json =
-                        include_str!(concat!("../../../layouts/", $board, "/default.json"));
+                        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../layouts/", $board, "/default.json"));
                     let keymap_json =
-                        include_str!(concat!("../../../layouts/", $board, "/keymap.json"));
+                        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../layouts/keyboards/", $keyboard, "/keymap.json"));
                     let layout_json =
-                        include_str!(concat!("../../../layouts/", $board, "/layout.json"));
+                        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../layouts/keyboards/", $keyboard, "/layout.json"));
                     let leds_json =
-                        include_str!(concat!("../../../layouts/", $board, "/leds.json"));
+                        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../layouts/keyboards/", $keyboard, "/leds.json"));
                     let physical_json =
-                        include_str!(concat!("../../../layouts/", $board, "/physical.json"));
+                        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../layouts/keyboards/", $keyboard, "/physical.json"));
                     Some((meta_json, default_json, keymap_json, layout_json, leds_json, physical_json))
                 }
                 )*
@@ -51,26 +51,8 @@ macro_rules! keyboards {
     };
 }
 
-keyboards![
-    "system76/addw1",
-    "system76/addw2",
-    "system76/bonw14",
-    "system76/darp5",
-    "system76/darp6",
-    "system76/darp7",
-    "system76/galp3-c",
-    "system76/galp4",
-    "system76/galp5",
-    "system76/gaze15",
-    "system76/launch_alpha_1",
-    "system76/launch_alpha_2",
-    "system76/launch_1",
-    "system76/lemp9",
-    "system76/lemp10",
-    "system76/oryp5",
-    "system76/oryp6",
-    "system76/oryp7",
-];
+// Calls the `keyboards!` macro
+include!(concat!(env!("OUT_DIR"), "/keyboards.rs"));
 
 impl Layout {
     pub fn from_data(

layouts.py

@@ -281,22 +281,22 @@ def gen_default_json(path: str, board: str, keymap: Dict[str, List[str]], is_qmk
         json.dump({"model": board, "version": 1, "map": keymap, "key_leds": key_leds, "layers": layers}, f, indent=2)
 
 
-def update_meta_json(meta_json: str, has_brightness: bool, has_color: bool):
+def update_meta_json(meta_json: str, has_brightness: bool, has_color: bool, keyboard: str):
     meta = {}
     if os.path.exists(meta_json):
         with open(meta_json, 'r') as f:
             meta = json.load(f, object_pairs_hook=OrderedDict)
 
     meta['has_brightness'] = has_brightness
     meta['has_color'] = has_color
+    meta['keyboard'] = keyboard
 
     with open(meta_json, 'w') as f:
         json.dump(meta, f, indent=2)
 
 
 def generate_layout_dir(ecdir: str, board: str, is_qmk: bool) -> None:
-    layoutdir = f'layouts/{board}'
-    print(f'Generating {layoutdir}...')
+    print(f'Generating layouts/{board}...')
 
     has_brightness = True
     has_color = True
@@ -308,6 +308,7 @@ def generate_layout_dir(ecdir: str, board: str, is_qmk: bool) -> None:
             f"{ecdir}/keyboards/{board}/keymaps/default/keymap.c").read()
         led_c = open(
             f"{ecdir}/keyboards/{board}/{board.split('/')[-1]}.c").read()
+        keyboard = board
     else:
         with open(f"{ecdir}/src/board/{board}/board.mk") as f:
             board_mk = f.read()
@@ -333,17 +334,18 @@ def generate_layout_dir(ecdir: str, board: str, is_qmk: bool) -> None:
         default_c = open(f"{ecdir}/src/keyboard/{keyboard}/keymap/default.c").read()
         led_c = ""
 
-    os.makedirs(f'{layoutdir}', exist_ok=True)
+    os.makedirs(f'layouts/{board}', exist_ok=True)
+    os.makedirs(f'layouts/keyboards/{keyboard}', exist_ok=True)
 
     physical, physical2 = parse_layout_define(keymap_h, is_qmk)
     leds = parse_led_config(led_c, physical)
     scancodes, mapping = extract_scancodes(ecdir, board, is_qmk, has_brightness, has_color)
     default_keymap = parse_keymap(default_c, mapping, physical, is_qmk)
-    gen_layout_json(f'{layoutdir}/layout.json', physical, physical2)
-    gen_leds_json(f'{layoutdir}/leds.json', leds)
-    gen_keymap_json(f'{layoutdir}/keymap.json', scancodes)
-    gen_default_json(f'{layoutdir}/default.json', board, default_keymap, is_qmk)
-    update_meta_json(f'{layoutdir}/meta.json', has_brightness, has_color)
+    gen_layout_json(f'layouts/keyboards/{keyboard}/layout.json', physical, physical2)
+    gen_leds_json(f'layouts/keyboards/{keyboard}/leds.json', leds)
+    gen_keymap_json(f'layouts/keyboards/{keyboard}/keymap.json', scancodes)
+    gen_default_json(f'layouts/{board}/default.json', board, default_keymap, is_qmk)
+    update_meta_json(f'layouts/{board}/meta.json', has_brightness, has_color, keyboard)
 
 parser = argparse.ArgumentParser()
 parser.add_argument("ecdir")

layouts/README.md

@@ -2,10 +2,14 @@
 
 Within each layout:
 * `default.json` - The default keymap and LED settings, in the same format the Configurator can import/export through its UI.
+* `meta.json` - Micellanous values associated with the keyboard.
+
+`meta.json` includes a `keyboard` key that refers to a subdirectory of `keyboards/`, since multiple laptop models have the same keyboard, so they share this data.
+
+In `keyboards/`:
 * `keymap.json` - Maps keycode names to their numerical values.
 * `layout.json` - Maps key position to electrical matrix indices.
 * `leds.json` - For a keyboard with per-key LEDs, maps key position to LED index.
-* `meta.json` - Micellanous values associated with the keyboard.
 * `physical.json` - Defines the physical layout of keys, the colors to display as their backgrounds, and labels (only shown in a tab when `--debug-layers` is passed to the Configurator).
 
 Other than `meta.json` and `physical.json`, these files are generated from the EC/QMK source using `layouts.py` from the root of this repository. `meta.json` is written manually, with other keys added by `layouts.py`. `physical.json` is created with <http://www.keyboard-layout-editor.com>.