实现简单的命令行解析器 (#49)

Author: MemoryShore

Cargo.toml

@@ -17,3 +17,5 @@ num_enum_derive = "0.7.1"
 path-clean = "1.0.1"
 crossterm = "0.27.0"
 colored = "2.1.0"
+which = "6.0.3"
+concat-idents = "1.1.5"

src/env.rs

@@ -1,109 +1,24 @@
 use std::{
-    collections::HashMap,
-    fmt,
     fs::File,
     io::{Read, Write},
-    ops::{Deref, DerefMut},
     path::Path,
 };
 
 pub const ROOT_PATH: &str = "/";
-pub const ENV_FILE_PATH: &str = "/etc/profile";
 
-#[derive(Clone, Debug)]
-pub struct EnvEntry {
-    /// 环境变量的名称
-    name: String,
-    /// 环境变量值的原始字符串，多个值之间使用':'分隔
-    origin: String,
-    /// 值分割后的集合
-    collection: Vec<String>,
-}
-
-impl EnvEntry {
-    pub fn new(env: String) -> Option<EnvEntry> {
-        let split_result = env.split('=').collect::<Vec<&str>>();
-        if split_result.len() != 2 || split_result.contains(&"") {
-            return None;
-        }
-
-        let name = split_result.get(0).unwrap().to_string();
-        let origin = split_result.get(1).unwrap().to_string();
-
-        let collection = origin
-            .split(':')
-            .filter_map(|str| {
-                let path = String::from(str);
-                if Path::new(&path).is_dir() {
-                    Some(path)
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<String>>();
-
-        Some(EnvEntry {
-            name,
-            origin,
-            collection,
-        })
-    }
-
-    #[allow(dead_code)]
-    pub fn name(&self) -> &String {
-        &self.name
-    }
-
-    pub fn origin(&self) -> &String {
-        &self.origin
-    }
-
-    #[allow(dead_code)]
-    pub fn collection(&self) -> &Vec<String> {
-        &self.collection
-    }
-}
-
-impl fmt::Display for EnvEntry {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}={}", self.name, self.origin)
-    }
-}
-
-pub struct Env(HashMap<String, EnvEntry>);
-
-static mut ENV: Option<Env> = None;
-
-impl Deref for Env {
-    type Target = HashMap<String, EnvEntry>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
+pub struct EnvManager;
 
-impl DerefMut for Env {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
+impl EnvManager {
+    pub const ENV_FILE_PATH: &str = "/etc/profile";
 
-impl Env {
-    /// 初始化环境变量结构体
+    /// 初始化环境变量相关信息
     pub fn init() {
-        // unsafe { ENV = Some(std::sync::Mutex::new(Env(HashMap::new()))) };
-        unsafe { ENV = Some(Env(HashMap::new())) };
         Self::read_env();
     }
 
-    /// 获取Env引用
-    pub fn env() -> &'static mut Env {
-        unsafe { ENV.as_mut().unwrap() }
-    }
-
     /// 初始化环境变量文件
     pub fn init_envfile() {
-        let mut file = File::create(ENV_FILE_PATH).unwrap();
+        let mut file = File::create(Self::ENV_FILE_PATH).unwrap();
         file.write_all("PATH=/bin:/usr/bin:/usr/local/bin\n".as_bytes())
             .unwrap();
         file.write_all("PWD=/\n".as_bytes()).unwrap();
@@ -112,89 +27,26 @@ impl Env {
     /// 读取环境变量文件
     /// 如果文件不存在则创建
     pub fn read_env() {
-        let env = unsafe { ENV.as_mut().unwrap() };
-
-        if !Path::new(ENV_FILE_PATH).exists() {
-            Env::init_envfile();
+        if !Path::new(Self::ENV_FILE_PATH).exists() {
+            Self::init_envfile();
         }
-        let mut file = File::open(ENV_FILE_PATH).unwrap();
+
+        let mut file = File::open(Self::ENV_FILE_PATH).unwrap();
         let mut buf: Vec<u8> = Vec::new();
         file.read_to_end(&mut buf).unwrap();
 
         for str in String::from_utf8(buf).unwrap().split('\n') {
-            if let Some(entry) = EnvEntry::new(str.to_string()) {
-                env.insert(entry.name.clone(), entry);
+            if let Some(index) = str.find('=') {
+                std::env::set_var(&str[..index], &str[index + 1..]);
             }
         }
     }
 
-    pub fn get(key: &String) -> Option<&EnvEntry> {
-        let env = unsafe { ENV.as_ref().unwrap() };
-        env.0.get(key)
-    }
-
-    pub fn insert(key: String, value: String) {
-        if let Some(entry) = EnvEntry::new(value) {
-            Self::env().insert(key, entry);
-        }
-    }
-
-    /// 获取PATH环境变量的值（已分割）
-    pub fn path() -> Vec<String> {
-        let env = Self::env();
-        env.get("PATH").unwrap().collection.clone()
-        // paths
-        //     .split(':')
-        //     .filter_map(|str| {
-        //         let path = String::from(str);
-        //         if Path::new(&path).is_dir() {
-        //             Some(path)
-        //         } else {
-        //             None
-        //         }
-        //     })
-        //     .collect::<Vec<String>>()
-    }
-
     pub fn current_dir() -> String {
         std::env::current_dir()
             .expect("Error getting current directory")
             .to_str()
             .unwrap()
             .to_string()
     }
-
-    /// 从环境变量搜索路径，返回第一个匹配的绝对路径
-    pub fn search_path_from_env(path: &String) -> Option<String> {
-        let mut absolute_path = String::new();
-        if !path.contains('/') {
-            let mut dir_collection = Env::path();
-            dir_collection.insert(0, Self::current_dir());
-            for dir in dir_collection {
-                let possible_path = format!("{}/{}", dir, path);
-                if Path::new(&possible_path).is_file() {
-                    absolute_path = possible_path;
-                    break;
-                }
-            }
-            if absolute_path.is_empty() {
-                return None;
-            } else {
-                return Some(absolute_path);
-            }
-        } else if Path::new(path).exists() {
-            return Some(path.clone());
-        } else {
-            return None;
-        }
-    }
-
-    /// 返回所有环境变量的集合
-    pub fn get_all() -> Vec<(String, String)> {
-        let mut vec = Vec::new();
-        for (name, entry) in Self::env().iter() {
-            vec.push((name.clone(), entry.origin.clone()));
-        }
-        vec
-    }
 }

src/main.rs

@@ -11,11 +11,13 @@ mod keycode;
 
 mod env;
 
-use env::Env;
+mod parser;
+
+use env::EnvManager;
 use shell::Shell;
 
 fn main() {
-    Env::init();
+    EnvManager::init();
     let mut shell = Shell::new();
     shell.exec();
     return;