some flake things among other stuff

flake.nix

@@ -19,6 +19,7 @@
       in
       {
         devShells.default = pkgs.mkShell {
+          name = "flake-rustshell";
           buildInputs = with pkgs; [
             # Rust toolchain
             rustc
@@ -34,13 +35,13 @@
 
           # Environment variables
           shellHook = ''
-            export RUST_BACKTRACE=1
-            echo "🦀 Rust Dev Environment Loaded"
+                        export RUST_BACKTRACE=full
+            						export DEVSHELL_NAME="󱄅 flake/#89dceb|🦀 rustproject/red"
 
-            # Trigger zsh if not already in it
-            if [[ -z "$ZSH_VERSION" ]]; then
-              exec zsh
-            fi
+                        # Trigger zsh if not already in it
+                        if [[ -z "$ZSH_VERSION" ]]; then
+                          exec zsh
+                        fi
           '';
         };
       }

src/main.rs

@@ -1,34 +1,90 @@
 use reqwest::Error;
 use reqwest::blocking::get;
+use serde_json::Value;
 use std::env;
 
 fn request_url(url: &str) -> Result<String, Error> {
-    dbg!(url);
     let response = get(url)?;
     let body = response.text()?;
     Ok(body)
 }
 
+fn aur(args: &Vec<String>) {
+    struct Package {
+        name: String,
+        dependancies: Vec<String>,
+        parent: String,
+    }
+    // Check length of arguments
+    let args_length = args.len();
+
+    if args_length < 3 {
+        // If there is no third param, return
+        println!("no package specified")
+    } else {
+        // get package and package api url
+        let package: &str = args[2].as_str();
+        let url: String = make_url(package);
+
+        // Get json returned from api
+        let package_info: String = match request_url(&url) {
+            Ok(s) => s,
+            Err(e) => panic!("shit... {e:?}"),
+        };
+
+        // Decode into ""usable"" data
+        let package_info_decoded: Value = serde_json::from_str(&package_info).unwrap();
+
+        // check if the package exists
+        let resultcount: i64 = package_info_decoded["resultcount"].as_i64().unwrap();
+        if resultcount > 0 {
+            // Nice user facing nonsense
+            println!("package {} found", &package);
+
+            // Get dependancies as a weird value type
+            let results_vector: &Vec<Value> = package_info_decoded["results"].as_array().unwrap();
+            let deps: &Vec<Value> = results_vector[0]["Depends"].as_array().unwrap();
+
+            // Get dependancies as an actual data type
+            let mut dependancies: Vec<String> = get_deps(deps);
+
+            let deps_tree_traversed: bool = false;
+
+            while deps_tree_traversed == false {
+                for dependancy in &dependancies {
+                    make_url(&dependancy);
+                }
+            }
+        } else {
+            // If there are no results
+            println!("No such package")
+        }
+
+        fn get_pkg_info(package: &str) -> Value {}
+
+        fn make_url(package: &str) -> String {
+            let url: String = format!("https://aur.archlinux.org/rpc/v5/info/{}", package);
+            return url;
+        }
+
+        fn get_deps(deps: &Vec<Value>) -> Vec<String> {
+            let mut output: Vec<String> = vec![];
+            for dependancy in deps {
+                let dependancy_name: &str = dependancy.as_str().unwrap();
+                output.push(String::from(dependancy_name))
+            }
+            return output;
+        }
+    }
+}
+
 fn main() {
     // Get arguments from commandline
     let args: Vec<String> = env::args().collect();
 
-    // Check length of arguments
-    let args_length = args.len();
+    let manager: &String = &args[1].to_string();
 
-    if &args[1] == "aur" {
-        if args_length < 3 {
-            println!("no package specified")
-        } else {
-            let package: &String = &args[2];
-            let url: String = format!("https://aur.archlinux.org/rpc/v5/info/{}", package);
-
-            let package_info = match request_url(&url) {
-                Ok(s) => s,
-                Err(e) => panic!("shit... {e:?}"),
-            };
-
-            println!("something {}", &package_info)
-        }
-    };
+    if manager == "aur" {
+        aur(&args);
+    }
 }