Add aiscript-common crate

Author: Folyd

Cargo.lock

@@ -3,6 +3,7 @@ members = [
     "aiscript",
     "aiscript-lexer",
     "aiscript-arena",
+    "aiscript-common",
     "aiscript-derived",
     "aiscript-directive",
     "aiscript-runtime",

Cargo.toml

@@ -127,7 +127,7 @@ Configuration by `project.toml`:
 # use OpenAI
 [ai.openai]
 api_key = "YOUR_API_KEY"
-model = "gpt-3.5-turbo"
+model = "gpt-4"
 
 # or use DeepSeek
 [ai.deepseek]

README.md

@@ -0,0 +1,13 @@
+[package]
+name = "aiscript-common"
+version.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+authors.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[dependencies]
+serde.workspace = true

aiscript-common/Cargo.toml

@@ -0,0 +1,96 @@
+use std::{env, fmt::Display, ops::Deref};
+
+use serde::Deserialize;
+
+// Custom string type that handles environment variable substitution
+#[derive(Debug, Clone, Deserialize)]
+#[serde(from = "String")]
+pub struct EnvString(pub String);
+
+impl From<String> for EnvString {
+    fn from(s: String) -> Self {
+        if let Some(env_key) = s.strip_prefix('$') {
+            match env::var(env_key) {
+                Ok(val) => EnvString(val),
+                Err(_) => {
+                    // If env var is not found, use the original string
+                    // This allows for better error handling at runtime
+                    EnvString(s)
+                }
+            }
+        } else {
+            EnvString(s)
+        }
+    }
+}
+impl<'a> From<&'a str> for EnvString {
+    fn from(s: &'a str) -> Self {
+        if let Some(env_key) = s.strip_prefix('$') {
+            match env::var(env_key) {
+                Ok(val) => EnvString(val),
+                Err(_) => {
+                    // If env var is not found, use the original string
+                    // This allows for better error handling at runtime
+                    EnvString(s.to_owned())
+                }
+            }
+        } else {
+            EnvString(s.to_owned())
+        }
+    }
+}
+
+impl Display for EnvString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<EnvString> for String {
+    fn from(s: EnvString) -> Self {
+        s.0
+    }
+}
+
+impl Deref for EnvString {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<str> for EnvString {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+#[test]
+fn test_envstring_regular_value() {
+    let regular = EnvString::from("regular_value".to_string());
+    assert_eq!(regular.as_ref(), "regular_value");
+}
+
+#[test]
+fn test_envstring_env_var_exists() {
+    unsafe {
+        env::set_var("TEST_ENV_VAR", "value_from_env");
+        let env_string = EnvString::from("$TEST_ENV_VAR".to_string());
+        assert_eq!(env_string.as_ref(), "value_from_env");
+        env::remove_var("TEST_ENV_VAR");
+    };
+}
+
+#[test]
+fn test_envstring_env_var_not_exists() {
+    unsafe { env::remove_var("NONEXISTENT_VAR") };
+    let env_string = EnvString::from("$NONEXISTENT_VAR".to_string());
+    assert_eq!(env_string.as_ref(), "$NONEXISTENT_VAR");
+}
+
+#[test]
+fn test_envstring_dollar_in_middle() {
+    let regular = EnvString::from("some$value".to_string());
+    assert_eq!(regular.as_ref(), "some$value");
+}

aiscript-common/src/lib.rs

@@ -13,6 +13,7 @@ readme.workspace = true
 
 [dependencies]
 aiscript-lexer = { path = "../aiscript-lexer", version = "0.2.0" }
+aiscript-common = { path = "../aiscript-common", version = "0.2.0" }
 aiscript-directive = { path = "../aiscript-directive", version = "0.2.0" }
 aiscript-vm = { path = "../aiscript-vm", version = "0.2.0" }
 hyper = "1.6"

aiscript-runtime/Cargo.toml

@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-use super::EnvString;
+use aiscript_common::EnvString;
 
 #[derive(Debug, Deserialize, Default)]
 pub struct AuthConfig {

aiscript-runtime/src/config/auth.rs

@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-use super::EnvString;
+use aiscript_common::EnvString;
 
 #[derive(Debug, Deserialize, Default)]
 pub struct DatabaseConfig {

aiscript-runtime/src/config/db.rs

@@ -1,4 +1,4 @@
-use std::{env, fmt::Display, fs, ops::Deref, path::Path, sync::OnceLock};
+use std::{fs, path::Path, sync::OnceLock};
 
 use auth::AuthConfig;
 use serde::Deserialize;
@@ -15,54 +15,6 @@ mod tests;
 
 static CONFIG: OnceLock<Config> = OnceLock::new();
 
-// Custom string type that handles environment variable substitution
-#[derive(Debug, Clone, Deserialize)]
-#[serde(from = "String")]
-pub struct EnvString(String);
-
-impl From<String> for EnvString {
-    fn from(s: String) -> Self {
-        if let Some(env_key) = s.strip_prefix('$') {
-            match env::var(env_key) {
-                Ok(val) => EnvString(val),
-                Err(_) => {
-                    // If env var is not found, use the original string
-                    // This allows for better error handling at runtime
-                    EnvString(s)
-                }
-            }
-        } else {
-            EnvString(s)
-        }
-    }
-}
-
-impl Display for EnvString {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl From<EnvString> for String {
-    fn from(s: EnvString) -> Self {
-        s.0
-    }
-}
-
-impl Deref for EnvString {
-    type Target = String;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl AsRef<str> for EnvString {
-    fn as_ref(&self) -> &str {
-        &self.0
-    }
-}
-
 #[derive(Debug, Deserialize, Default)]
 pub struct Config {
     #[serde(default)]

aiscript-runtime/src/config/mod.rs

@@ -1,9 +1,10 @@
 use std::collections::HashMap;
 
+use aiscript_common::EnvString;
 use aiscript_directive::route::SsoProvider;
 use serde::Deserialize;
 
-use super::{Config, EnvString};
+use super::Config;
 
 #[derive(Debug, Deserialize, Default)]
 pub struct SsoConfig {