Add --print-layout / -p flag to both commands

Parses the keymap and prints each layer as a formatted table, then exits
without performing any conversion. Respects --cols and --keyboard for
column width; defaults to 10 columns.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Patrick Carroll

src/bin/qmk2zmk.rs

@@ -64,6 +64,10 @@ struct Cli {
     /// Suppress warnings for unmapped keycodes
     #[arg(long)]
     no_warn: bool,
+
+    /// Parse the keymap and print a layout table, then exit without converting
+    #[arg(short = 'p', long)]
+    print_layout: bool,
 }
 
 /// Process exit boundary for the binary.
@@ -108,6 +112,12 @@ fn run() -> Result<(), Error> {
     let cols = cli
         .cols
         .or_else(|| cli.keyboard.as_deref().and_then(codes::keyboard_cols));
+
+    if cli.print_layout {
+        qmk2zmk::print_layout(&keyboard, cols);
+        return Ok(());
+    }
+
     let output = zmk::render(&keyboard, cols);
     io::write_output(&output, cli.output.as_deref())
 }

src/bin/zmk2qmk.rs

@@ -52,6 +52,10 @@ struct Cli {
     /// Suppress warnings for unmapped keycodes
     #[arg(long)]
     no_warn: bool,
+
+    /// Parse the keymap and print a layout table, then exit without converting
+    #[arg(short = 'p', long)]
+    print_layout: bool,
 }
 
 /// Process exit boundary for the binary.
@@ -89,6 +93,12 @@ fn run() -> Result<(), Error> {
     let cols = cli
         .cols
         .or_else(|| cli.keyboard.as_deref().and_then(codes::keyboard_cols));
+
+    if cli.print_layout {
+        qmk2zmk::print_layout(&keyboard, cols);
+        return Ok(());
+    }
+
     let output = match cli.format {
         OutputFormat::Json => qmk::render_json(&keyboard),
         OutputFormat::C => qmk::render_c(&keyboard, cols),

src/lib.rs

@@ -11,6 +11,60 @@ pub mod ir;
 pub mod qmk;
 pub mod zmk;
 
+/// Write all layers of `keyboard` as a formatted table, `cols` keys per row.
+///
+/// If `cols` is `None`, defaults to 10 (a common 40% keyboard row width).
+/// Output is written to `out`; I/O errors are silently ignored (same as
+/// `println!`).
+pub fn print_layout_to(keyboard: &ir::Keyboard, cols: Option<usize>, out: &mut impl std::io::Write) {
+    for layer in &keyboard.layers {
+        let _ = writeln!(out, "Layer {}: {}", layer.index, layer.name);
+        let labels: Vec<String> = layer.keys.iter().map(key_label).collect();
+        if labels.is_empty() {
+            let _ = writeln!(out);
+            continue;
+        }
+        let col_count = cols.unwrap_or(10).min(labels.len());
+        let width = labels.iter().map(String::len).max().unwrap_or(1);
+        for row in labels.chunks(col_count) {
+            let parts: Vec<String> = row.iter().map(|l| format!("{l:<width$}")).collect();
+            let _ = writeln!(out, "  {}", parts.join("  "));
+        }
+        let _ = writeln!(out);
+    }
+}
+
+/// Print all layers of `keyboard` as a formatted table to stdout.
+pub fn print_layout(keyboard: &ir::Keyboard, cols: Option<usize>) {
+    print_layout_to(keyboard, cols, &mut std::io::stdout());
+}
+
+fn key_label(key: &ir::Key) -> String {
+    match key {
+        ir::Key::Kp(e) => e.to_string(),
+        ir::Key::Mo(n) => format!("MO({n})"),
+        ir::Key::Lt(n, e) => format!("LT({n},{e})"),
+        ir::Key::Mt(m, e) => format!("MT({m},{e})"),
+        ir::Key::Tog(n) => format!("TG({n})"),
+        ir::Key::Sk(m) => format!("SK({m})"),
+        ir::Key::Sl(n) => format!("SL({n})"),
+        ir::Key::To(n) => format!("TO({n})"),
+        ir::Key::Df(n) => format!("DF({n})"),
+        ir::Key::Mmv(m) => m.to_string(),
+        ir::Key::Mkp(b) => b.to_string(),
+        ir::Key::Msc(s) => s.to_string(),
+        ir::Key::Trans => "_____".to_string(),
+        ir::Key::None => "XXXXX".to_string(),
+        ir::Key::CapsWord => "CAPS_WORD".to_string(),
+        ir::Key::Bootloader => "BOOT".to_string(),
+        ir::Key::SysReset => "RESET".to_string(),
+        ir::Key::RgbUg(a) => a.to_string(),
+        ir::Key::Macro(name) => format!("M({name})"),
+        ir::Key::TapDance(n) => format!("TD({n})"),
+        ir::Key::Unknown(s) => format!("?({s})"),
+    }
+}
+
 /// Print a stderr warning for every `Key::Unknown` in the parsed keyboard.
 pub fn warn_unknowns(keyboard: &ir::Keyboard) {
     for layer in &keyboard.layers {

tests/integration.rs

@@ -306,6 +306,45 @@ fn zmk_rgb_survives_to_qmk() {
     assert!(out.contains("RGB_TOG"));
 }
 
+// ── print_layout ─────────────────────────────────────────────────────────────
+
+#[test]
+fn print_layout_contains_layer_headers_and_keys() {
+    let km = qmk_c::parse(KEYMAP_C).unwrap();
+    let mut buf = Vec::new();
+    qmk2zmk::print_layout_to(&km, Some(12), &mut buf);
+    let out = String::from_utf8(buf).unwrap();
+
+    assert!(out.contains("Layer 0: _BASE"));
+    assert!(out.contains("Layer 1: _LOWER"));
+    assert!(out.contains("Layer 2: _RAISE"));
+    assert!(out.contains("Layer 3: _ADJUST"));
+
+    assert!(out.contains("TAB"));
+    assert!(out.contains("MO(1)"));
+    assert!(out.contains("MO(2)"));
+    assert!(out.contains("_____"));
+    assert!(out.contains("XXXXX"));
+}
+
+#[test]
+fn print_layout_respects_col_count() {
+    let km = qmk_c::parse(KEYMAP_C).unwrap();
+    let mut buf = Vec::new();
+    qmk2zmk::print_layout_to(&km, Some(6), &mut buf);
+    let out = String::from_utf8(buf).unwrap();
+
+    // 48 keys at 6 cols = 8 rows per layer; each row ends with a newline before
+    // the next row starts, so we can verify there are more rows than at 12-wide.
+    let mut buf12 = Vec::new();
+    qmk2zmk::print_layout_to(&km, Some(12), &mut buf12);
+    let out12 = String::from_utf8(buf12).unwrap();
+    assert!(
+        out.lines().count() > out12.lines().count(),
+        "6-col layout should have more lines than 12-col"
+    );
+}
+
 // ── Round-trip tests ──────────────────────────────────────────────────────────
 
 /// ZMK → render ZMK → parse → render ZMK again: the two renders must be equal.