feat(src): Make usable

4 files changed, 292 insertions, 0 deletions

diff --git a/rust/format/src/format_layer/mod.rs b/rust/format/src/format_layer/mod.rs
new file mode 100644
index 0000000..1b93c97
--- /dev/null
+++ b/rust/format/src/format_layer/mod.rs
@@ -0,0 +1,209 @@
+use std::fmt::{Display, Write};
+
+include!("output_def.fs");
+
+macro_rules! check {
+    ($c1:expr, $cf:expr, $ind:expr, $ma:expr) => {
+        if ($cf[$ind] >= $ma) {
+            $c1[$ind] = $cf[$ind];
+        } else {
+            // eprintln!("Changed {} from {} -> {}", stringify!($cf), $cf[$ind], $ma);
+            $c1[$ind] = $ma;
+            $cf[$ind] = $ma;
+        }
+    };
+}
+
+macro_rules! get {
+    ($val:expr, $column:tt, $key:tt) => {
+        [
+            $val.row1.$key.$column.to_string(),
+            $val.row2.$key.$column.to_string(),
+            $val.row3.$key.$column.to_string(),
+            $val.row4.$key.$column.to_string(),
+            $val.row5.$key.$column.to_string(),
+            $val.row6.$key.$column.to_string(),
+        ]
+        .iter()
+        .map(|val| val.chars().count())
+        .max()
+        .expect("Works")
+    };
+}
+
+impl Output {
+    fn format(&self, c_column_max: &mut [usize; 14]) -> String {
+        let mut columns_max = [0; 14];
+
+        check!(columns_max, c_column_max, 0, get! {self, 0, 0});
+        check!(columns_max, c_column_max, 1, get! {self, 1, 0});
+        check!(columns_max, c_column_max, 2, get! {self, 2, 0});
+        check!(columns_max, c_column_max, 3, get! {self, 3, 0});
+        check!(columns_max, c_column_max, 4, get! {self, 4, 0});
+        check!(columns_max, c_column_max, 5, get! {self, 5, 0});
+        check!(columns_max, c_column_max, 6, get! {self, 6, 0});
+        check!(columns_max, c_column_max, 7, get! {self, 0, 0});
+        check!(columns_max, c_column_max, 8, get! {self, 1, 1});
+        check!(columns_max, c_column_max, 9, get! {self, 2, 1});
+        check!(columns_max, c_column_max, 10, get! {self, 3, 1});
+        check!(columns_max, c_column_max, 11, get! {self, 4, 1});
+        check!(columns_max, c_column_max, 12, get! {self, 5, 1});
+        check!(columns_max, c_column_max, 13, get! {self, 6, 1});
+
+        let mut f = String::new();
+        write!(
+            f,
+            include_str!("prints.txt"),
+            // row 1
+            self.row1.0 .0,
+            self.row1.0 .1,
+            self.row1.0 .2,
+            self.row1.0 .3,
+            self.row1.0 .4,
+            self.row1.0 .5,
+            self.row1.0 .6,
+            self.row1.1 .0,
+            self.row1.1 .1,
+            self.row1.1 .2,
+            self.row1.1 .3,
+            self.row1.1 .4,
+            self.row1.1 .5,
+            self.row1.1 .6,
+            // row 2
+            self.row2.0 .0,
+            self.row2.0 .1,
+            self.row2.0 .2,
+            self.row2.0 .3,
+            self.row2.0 .4,
+            self.row2.0 .5,
+            self.row2.0 .6,
+            self.row2.1 .0,
+            self.row2.1 .1,
+            self.row2.1 .2,
+            self.row2.1 .3,
+            self.row2.1 .4,
+            self.row2.1 .5,
+            self.row2.1 .6,
+            // row 3
+            self.row3.0 .0,
+            self.row3.0 .1,
+            self.row3.0 .2,
+            self.row3.0 .3,
+            self.row3.0 .4,
+            self.row3.0 .5,
+            self.row3.0 .6,
+            self.row3.1 .0,
+            self.row3.1 .1,
+            self.row3.1 .2,
+            self.row3.1 .3,
+            self.row3.1 .4,
+            self.row3.1 .5,
+            self.row3.1 .6,
+            // row 4
+            self.row4.0 .0.to_string(),
+            self.row4.0 .1.to_string(),
+            self.row4.0 .2.to_string(),
+            self.row4.0 .3.to_string(),
+            self.row4.0 .4.to_string(),
+            self.row4.0 .5.to_string(),
+            self.row4.0 .6.to_string(),
+            self.row4.1 .0.to_string(),
+            self.row4.1 .1.to_string(),
+            self.row4.1 .2.to_string(),
+            self.row4.1 .3.to_string(),
+            self.row4.1 .4.to_string(),
+            self.row4.1 .5.to_string(),
+            self.row4.1 .6.to_string(),
+            // row 5
+            self.row5.0 .0.to_string(),
+            self.row5.0 .1.to_string(),
+            self.row5.0 .2.to_string(),
+            self.row5.0 .3.to_string(),
+            self.row5.0 .4.to_string(),
+            self.row5.0 .5.to_string(),
+            self.row5.0 .6.to_string(),
+            self.row5.1 .0.to_string(),
+            self.row5.1 .1.to_string(),
+            self.row5.1 .2.to_string(),
+            self.row5.1 .3.to_string(),
+            self.row5.1 .4.to_string(),
+            self.row5.1 .5.to_string(),
+            self.row4.1 .6.to_string(),
+            // thumbs
+            self.row6.0 .0.to_string(),
+            self.row6.0 .1.to_string(),
+            self.row6.0 .2.to_string(),
+            self.row6.0 .3.to_string(),
+            self.row6.0 .4.to_string(),
+            self.row6.0 .5.to_string(),
+            self.row6.0 .6.to_string(),
+            self.row6.1 .0.to_string(),
+            self.row6.1 .1.to_string(),
+            self.row6.1 .2.to_string(),
+            self.row6.1 .3.to_string(),
+            self.row6.1 .4.to_string(),
+            self.row6.1 .5.to_string(),
+            self.row6.1 .6.to_string(),
+            col0 = columns_max[0],
+            col1 = columns_max[1],
+            col2 = columns_max[2],
+            col3 = columns_max[3],
+            col4 = columns_max[4],
+            col5 = columns_max[5],
+            col6 = columns_max[6],
+            col7 = columns_max[7],
+            col8 = columns_max[8],
+            col9 = columns_max[9],
+            col10 = columns_max[10],
+            col11 = columns_max[11],
+            col12 = columns_max[12],
+            col13 = columns_max[13],
+        )
+        .expect("Works");
+        f
+    }
+}
+
+#[must_use]
+pub fn format_layer(input: String, c_column_max: &mut [usize; 14]) -> String {
+    let mut a = input
+        .lines()
+        .map(|val| val.to_owned())
+        .collect::<Vec<String>>()
+        .join(" ")
+        .split_whitespace()
+        .map(|val| val.to_owned())
+        .rev()
+        .collect::<Vec<String>>();
+    let mut n = || a.pop().expect("This should exist");
+    let e = || Emt();
+
+    let out = Output {
+        row1: (
+            (n(), n(), n(), n(), n(), n(), n()),
+            (n(), n(), n(), n(), n(), n(), n()),
+        ),
+        row2: (
+            (n(), n(), n(), n(), n(), n(), n()),
+            (n(), n(), n(), n(), n(), n(), n()),
+        ),
+        row3: (
+            (n(), n(), n(), n(), n(), n(), n()),
+            (n(), n(), n(), n(), n(), n(), n()),
+        ),
+        row4: (
+            (n(), n(), n(), n(), n(), n(), e()),
+            (e(), n(), n(), n(), n(), n(), n()),
+        ),
+        row5: (
+            (n(), n(), n(), n(), n(), n(), e()),
+            (e(), n(), n(), n(), n(), n(), n()),
+        ),
+        row6: (
+            (e(), e(), e(), n(), n(), n(), e()),
+            (e(), n(), n(), n(), e(), e(), e()),
+        ),
+    };
+
+    out.format(c_column_max)
+}
diff --git a/rust/format/src/format_layer/output_def.fs b/rust/format/src/format_layer/output_def.fs
new file mode 100644
index 0000000..c7d46b1
--- /dev/null
+++ b/rust/format/src/format_layer/output_def.fs
@@ -0,0 +1,22 @@
+// This file is not a `rs` file, to avoid formatting it.
+type Key = String;
+type Thb = Key;
+
+#[derive(Default, Debug)]
+struct Output {
+    row1: ((Key, Key, Key, Key, Key, Key, Key), (Key, Key, Key, Key, Key, Key, Key)),
+    row2: ((Key, Key, Key, Key, Key, Key, Key), (Key, Key, Key, Key, Key, Key, Key)),
+    row3: ((Key, Key, Key, Key, Key, Key, Key), (Key, Key, Key, Key, Key, Key, Key)),
+    row4: ((Key, Key, Key, Key, Key, Key, Emt), (Emt, Key, Key, Key, Key, Key, Key)),
+    row5: ((Key, Key, Key, Key, Key, Thb, Emt), (Emt, Thb, Key, Key, Key, Key, Key)),
+    row6: ((Emt, Emt, Emt, Thb, Thb, Thb, Emt), (Emt, Thb, Thb, Thb, Emt, Emt, Emt)),
+}
+
+#[derive(Debug, Default)]
+struct Emt ();
+
+impl Display for Emt {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("")
+    }
+}
diff --git a/rust/format/src/format_layer/prints.txt b/rust/format/src/format_layer/prints.txt
new file mode 100644
index 0000000..f67b774
--- /dev/null
+++ b/rust/format/src/format_layer/prints.txt
@@ -0,0 +1,6 @@
+    {:<col0$} {:<col1$} {:<col2$} {:<col3$} {:<col4$} {:<col5$} {:<col6$}           {:<col7$} {:<col8$} {:<col9$} {:<col10$} {:<col11$} {:<col12$} {:<col13$}
+    {:<col0$} {:<col1$} {:<col2$} {:<col3$} {:<col4$} {:<col5$} {:<col6$}           {:<col7$} {:<col8$} {:<col9$} {:<col10$} {:<col11$} {:<col12$} {:<col13$}
+    {:<col0$} {:<col1$} {:<col2$} {:<col3$} {:<col4$} {:<col5$} {:<col6$}           {:<col7$} {:<col8$} {:<col9$} {:<col10$} {:<col11$} {:<col12$} {:<col13$}
+    {:<col0$} {:<col1$} {:<col2$} {:<col3$} {:<col4$} {:<col5$} {:<col6$}           {:<col7$} {:<col8$} {:<col9$} {:<col10$} {:<col11$} {:<col12$} {:<col13$}
+    {:<col0$} {:<col1$} {:<col2$} {:<col3$} {:<col4$} {:<col5$} {:<col6$}           {:<col7$} {:<col8$} {:<col9$} {:<col10$} {:<col11$} {:<col12$} {:<col13$}
+    {:<col0$} {:<col1$} {:<col2$} {:<col3$} {:<col4$} {:<col5$} {:<col6$}           {:<col7$} {:<col8$} {:<col9$} {:<col10$} {:<col11$} {:<col12$} {:<col13$}
diff --git a/rust/format/src/main.rs b/rust/format/src/main.rs
new file mode 100644
index 0000000..3554087
--- /dev/null
+++ b/rust/format/src/main.rs
@@ -0,0 +1,55 @@
+use std::{env::args, fs::File, io::Read};
+
+mod format_layer;
+
+fn main() {
+    let mut keymap_h = String::new();
+
+    File::open(args().skip(1).last().expect("Exists"))
+        .expect("Should work")
+        .read_to_string(&mut keymap_h)
+        .expect("Failed to read keymap_h");
+
+    let mut c_column_max = [0; 14];
+
+    let out = calculate(&mut c_column_max, keymap_h);
+    let output = calculate(&mut c_column_max, out.join("\n"));
+
+    print!("{}", output.join("\n"));
+}
+
+fn calculate(c_column_max: &mut [usize; 14], keymap_h: String) -> Vec<String> {
+    let mut output: Vec<String> = vec![];
+    let mut c_layer: Vec<String> = vec![];
+    keymap_h
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .for_each(|line| {
+            let first_char = line.trim().chars().take(1).last().unwrap();
+            let line = line.trim();
+
+            match first_char {
+                'c' | '}' => {
+                    // Start or end of the kemap def, leave it alone
+                    output.push(line.to_owned());
+                }
+                '[' => {
+                    // Start of a new layer
+                    assert!(c_layer.is_empty(), "No new layer, without empty");
+                    output.push(format!("  {}", line));
+                }
+                ')' => {
+                    // End of a layer
+                    output.push(format_layer::format_layer(c_layer.join("\n"), c_column_max));
+                    c_layer.clear();
+
+                    output.push(format!("  {}", line));
+                }
+                _ => {
+                    // We are in a layer
+                    c_layer.push(line.to_owned());
+                }
+            }
+        });
+    output
+}