config: extract read_and_leak

crates/app/src/config.rs

@@ -1,8 +1,11 @@
 use crate::*;
+use std::path::PathBuf;
 
 /// Configuration
 #[derive(Default, Debug)]
 pub struct Configuration {
+    /// Path of configuration entrypoint
+    pub path: PathBuf,
     /// Name of configuration
     pub name: Option<Arc<str>>,
     /// Description of configuration
@@ -14,20 +17,19 @@ pub struct Configuration {
 }
 
 impl Configuration {
-    pub fn from_file (path: &impl AsRef<Path>, _watch: bool) -> Usually<Self> {
-        Self::from_source(String::from_utf8(std::fs::read(path.as_ref())?)?)
-    }
-    pub fn from_source (source: impl AsRef<str> + 'static) -> Usually<Self> {
-        let source: Box<str> = source.as_ref().into();
-        let source: &'static str = Box::leak(source);
-        let [name, info, view, keys] = Self::parse(TokenIter::from(source.as_ref()))?;
+
+    pub fn new (path: &impl AsRef<Path>, _watch: bool) -> Usually<Self> {
+        let text = read_and_leak(path.as_ref())?;
+        let [name, info, view, keys] = Self::parse(TokenIter::from(text))?;
         Ok(Self {
+            path: path.as_ref().into(),
             info: info.map(Self::parse_info).flatten(),
             name: name.map(Self::parse_name).flatten(),
             view: Self::parse_view(view)?,
-            keys: Self::parse_keys(keys)?,
+            keys: Self::parse_keys(&path, keys)?,
         })
     }
+
     fn parse (iter: TokenIter) -> Usually<[Option<TokenIter>;4]> {
         let mut name: Option<TokenIter> = None;
         let mut info: Option<TokenIter> = None;
@@ -59,6 +61,7 @@ impl Configuration {
         }
         Ok([name, info, view, keys])
     }
+
     fn parse_info (mut iter: TokenIter) -> Option<Arc<str>> {
         iter.next().and_then(|x|if let Value::Str(x) = x.value {
             Some(x.into())
@@ -66,6 +69,7 @@ impl Configuration {
             None
         })
     }
+
     fn parse_name (mut iter: TokenIter) -> Option<Arc<str>> {
         iter.next().and_then(|x|if let Value::Str(x) = x.value {
             Some(x.into())
@@ -73,6 +77,7 @@ impl Configuration {
             None
         })
     }
+
     fn parse_view (iter: Option<TokenIter>) -> Usually<TokenIter> {
         if let Some(view) = iter {
             Ok(view)
@@ -80,7 +85,8 @@ impl Configuration {
             Err(format!("missing view definition").into())
         }
     }
-    fn parse_keys (iter: Option<TokenIter>)
+
+    fn parse_keys (base: &impl AsRef<Path>, iter: Option<TokenIter>)
         -> Usually<InputMap<'static, Tek, TekCommand, TuiIn, TokenIter<'static>>>
     {
         if let Some(mut keys) = iter {
@@ -91,15 +97,46 @@ impl Configuration {
                         let next = exp.next();
                         match next {
                             Some(Token { value: Value::Key(sym), .. }) => match sym {
-                                "layer"    => { todo!() },
-                                "layer-if" => { todo!() },
+                                "layer" => {
+                                    let next = exp.next();
+                                    match next {
+                                        Some(Token { value: Value::Str(path), .. }) => {
+                                            map.add_layer(read_and_leak(path)?.into());
+                                        },
+                                        _ => return Err(
+                                            format!("(e4) unexpected non-string {next:?}").into()
+                                        )
+                                    }
+                                    todo!()
+                                },
+                                "layer-if" => {
+                                    let next = exp.next();
+                                    match next {
+                                        Some(Token { value: Value::Sym(sym), .. }) => {
+                                            todo!()
+                                        },
+                                        _ => return Err(
+                                            format!("(e4) unexpected non-symbol {next:?}").into()
+                                        )
+                                    }
+                                    let next = exp.next();
+                                    match next {
+                                        Some(Token { value: Value::Str(path), .. }) => {
+                                            todo!()
+                                        },
+                                        _ => return Err(
+                                            format!("(e4) unexpected non-symbol {next:?}").into()
+                                        )
+                                    }
+                                    todo!()
+                                },
                                 _ => return Err(
                                     format!("(e3) unexpected symbol {sym:?}").into()
                                 )
                             }
                             _ => return Err(
-                            format!("(e2) unexpected exp {:?}", next.map(|x|x.value)).into()
-                        )
+                                format!("(e2) unexpected exp {:?}", next.map(|x|x.value)).into()
+                            )
                         }
                     },
                     t => return Err(
@@ -112,4 +149,13 @@ impl Configuration {
             return Err(format!("missing keys definition").into())
         }
     }
+
+}
+
+fn read_and_leak (path: impl AsRef<Path>) -> Usually<&'static str> {
+    let path = path.as_ref();
+    let text = String::from_utf8(std::fs::read(path)?)?;
+    let text: Box<str> = text.into();
+    let text: &'static str = Box::leak(text);
+    Ok(text)
 }