Feat/env headers

src/action/env.rs

@@ -24,13 +24,26 @@
     env: String,
 }
 
+#[derive(clap::Args, Debug)]
+pub struct HeaderSetArgs {
+    key: String,
+    value: String,
+}
+
+#[derive(clap::Args, Debug)]
+pub struct HeaderLsArgs {}
+
 pub fn cmd(ctx: &mut Ctx, command: Cmd) -> QuartzResult {
     match command {
         Cmd::Create(args) => create(ctx, args),
         Cmd::Cp(args) => cp(ctx, args)?,
         Cmd::Use(args) => switch(ctx, args)?,
         Cmd::Ls => ls(ctx),
         Cmd::Rm(args) => rm(ctx, args),
+        Cmd::Header { command } => match command {
+            crate::cli::HeaderEnvCmd::Set(args) => header_set(ctx, args)?,
+            crate::cli::HeaderEnvCmd::Ls(args) => header_ls(ctx, args)?,
+        },
     };
 
     Ok(())
@@ -136,3 +149,14 @@
             .unwrap_or("default".into())
     );
 }
+pub fn header_set(ctx: &Ctx, args: HeaderSetArgs) -> QuartzResult {
+    let mut env = ctx.require_env();
+    env.headers.insert(args.key, args.value);
+    env.update(ctx)?;
+    Ok(())
+}
+pub fn header_ls(ctx: &Ctx, args: HeaderLsArgs) -> QuartzResult {
+    let env = ctx.require_env();
+    println!("{}", env.headers);
+    Ok(())
+}

src/action/ls.rs

@@ -156,6 +156,7 @@ pub fn cmd(ctx: &Ctx, args: Args) {
         }
 
         for child in node.children.iter() {
+            println!("This is a child: {}", child.value.handle());
             queue.push(&child);
         }
     }

src/cli.rs

@@ -231,6 +231,16 @@ pub enum EnvCmd {
     /// Delete a environment
     #[command(name = "rm", alias = "remove")]
     Rm(action::env::RmArgs),
+    Header {
+        #[command(subcommand)]
+        command: HeaderEnvCmd,
+    },
+}
+
+#[derive(Debug, Subcommand)]
+pub enum HeaderEnvCmd {
+    Set(action::env::HeaderSetArgs),
+    Ls(action::env::HeaderLsArgs),
 }
 
 #[derive(Debug, Subcommand)]

src/env.rs

@@ -57,17 +57,67 @@ impl Variables {
     }
 }
 
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct Headers(pub HashMap<String, String>);
+impl Deref for Headers {
+    type Target = HashMap<String, String>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Headers {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Display for Headers {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (key, value) in self.iter() {
+            writeln!(f, "{key}: {value}")?;
+        }
+
+        Ok(())
+    }
+}
+impl PairMap<'_> for Headers {
+    const NAME: &'static str = "variable";
+
+    fn map(&mut self) -> &mut HashMap<String, String> {
+        &mut self.0
+    }
+    fn pair(input: &'_ str) -> Option<(String, String)> {
+        let (key, val) = input.split_once(": ")?;
+        Some((key.to_owned(), val.to_owned()))
+    }
+}
+impl Headers {
+    pub fn parse(file_content: &str) -> Self {
+        let mut headers = Headers::default();
+
+        for var in file_content.split('\n').filter(|line| !line.is_empty()) {
+            headers.set(var);
+        }
+
+        headers
+    }
+}
+
 #[derive(Clone, Serialize, Deserialize)]
 pub struct Env {
     pub name: String,
     pub variables: Variables,
+    pub headers: Headers,
 }
 
 impl Default for Env {
     fn default() -> Self {
         Self {
             name: String::from("default"),
             variables: Variables::default(),
+            headers: Headers::default(),
         }
     }
 }
@@ -100,10 +150,18 @@ impl Env {
             .write(true)
             .truncate(true)
             .open(self.dir(ctx).join("variables"))?;
+        let mut headers_file = std::fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(self.dir(ctx).join("headers"))?;
 
         if !self.variables.is_empty() {
             var_file.write_all(format!("{}", self.variables).as_bytes())?;
         }
+        if !self.headers.0.is_empty() {
+            headers_file.write_all(format!("{}", self.headers).as_bytes())?;
+        }
 
         Ok(())
     }
@@ -119,6 +177,9 @@ impl Env {
         if let Ok(var_contents) = std::fs::read_to_string(env.dir(ctx).join("variables")) {
             env.variables = Variables::parse(&var_contents);
         }
+        if let Ok(header_contents) = std::fs::read_to_string(env.dir(ctx).join("headers")) {
+            env.headers = Headers::parse(&header_contents);
+        }
 
         Ok(env)
     }