add: config rw

Author: invra

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["xtask", "asteride", "pages", "elements"]
+members = ["xtask", "asteride", "pages", "elements", "config"]
 
 default-members = ["asteride"]
 resolver = "3"
@@ -14,19 +14,32 @@ authors = [
 ]
 
 [workspace.dependencies]
+pico-args = "0.5.0"
+tracing = "0.1.44"
 image = "0.25.10"
+toml = "1.1.2"
 rfd = "0.17.2"
 
-[workspace.dependencies.lucide-icons]
-version = "1.24.0"
-features = ["iced"]
-
 [workspace.dependencies.elements]
 path = "./elements"
 
+[workspace.dependencies.config]
+path = "./config"
+
 [workspace.dependencies.pages]
 path = "./pages"
 
+[workspace.dependencies.serde]
+version = "1.0.228"
+features = ["derive"]
+
+[workspace.dependencies.lucide-icons]
+version = "1.24.0"
+features = ["iced"]
+
+[workspace.dependencies.logging_subscriber]
+git = "https://gitlab.com/invra/logging_subscriber"
+
 [workspace.dependencies.tokio]
 version = "1.52.3"
 features = ["rt", "macros", "rt-multi-thread", "sync"]

Cargo.toml

@@ -11,5 +11,9 @@ iced.workspace = true
 tokio.workspace = true
 image.workspace = true
 pages.workspace = true
+config.workspace = true
+tracing.workspace = true
 elements.workspace = true
+pico-args.workspace = true
 lucide-icons.workspace = true
+logging_subscriber.workspace = true

asteride/Cargo.toml

@@ -1,17 +1,15 @@
 mod app_icon;
 mod sidebar;
+use std::path::PathBuf;
+
 use elements::bottom_area;
 use iced::{
-    Element,
-    Subscription,
-    Task,
+    Element, Subscription, Task,
     theme::Theme,
-    widget::{
-        column,
-        row,
-    },
+    widget::{column, row},
     window,
 };
+
 use lucide_icons::LUCIDE_FONT_BYTES;
 
 struct AsterIDE {
@@ -83,7 +81,36 @@ impl AsterIDE {
     }
 }
 
+struct Args {
+    config_path: Option<PathBuf>,
+    version: bool,
+    silent: bool,
+}
+
+fn parse_args() -> Args {
+    let mut args = pico_args::Arguments::from_env();
+
+    Args {
+        config_path: args.opt_value_from_str(["-c", "--config"]).unwrap(),
+        version: args.contains(["-v", "--version"]),
+        silent: args.contains(["-s", "--silent"]),
+    }
+}
+
 pub fn main() -> iced::Result {
+    let args = parse_args();
+
+    if args.version {
+        print!("AsterIDE v{}", env!("CARGO_PKG_VERSION"));
+        return iced::Result::Ok(());
+    }
+
+    if !args.silent {
+        tracing::subscriber::set_global_default(logging_subscriber::SimpleSubscriber).unwrap();
+    }
+
+    let _config = config::init_ring(args.config_path);
+
     let window_settings = window::Settings {
         // TODO: Create own titlebar later
         decorations: true,
@@ -97,6 +124,8 @@ pub fn main() -> iced::Result {
         ..Default::default()
     };
 
+    tracing::info!("Init iced app");
+
     iced::application(AsterIDE::new, AsterIDE::update, AsterIDE::view)
         .subscription(AsterIDE::subscription)
         .title("AsterIDE")

asteride/src/main.rs

@@ -0,0 +1,12 @@
+[package]
+name = "config"
+description = "Configuration management"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+version.workspace = true
+
+[dependencies]
+toml.workspace = true
+iced.workspace = true
+serde.workspace = true

config/Cargo.toml

@@ -0,0 +1,62 @@
+pub mod spec;
+mod theme;
+use std::{env, path::PathBuf, sync::OnceLock};
+
+/// Configuration ring, holds all configuration that is in a config file.
+static INSTANCE: OnceLock<spec::Config> = OnceLock::new();
+
+fn config_home() -> PathBuf {
+    if cfg!(target_family = "unix") {
+        std::env::var_os("XDG_CONFIG_HOME")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                let home_var: PathBuf = env::var("HOME").unwrap().into();
+                home_var.join(".config")
+            })
+            .join("asteride")
+    } else {
+        let home_var: PathBuf = env::var("LOCALAPPDATA").unwrap().into();
+        home_var.join("asteride")
+    }
+}
+
+/// Goes around and initializes vital stuff for config to
+/// be read and written
+pub fn init_ring(
+    // used to override a path, e.g -c / --config
+    override_default_path: Option<PathBuf>,
+) {
+    let maybe_file = override_default_path.unwrap_or_else(config_home);
+    let config_path = if maybe_file.is_dir() {
+        maybe_file.join("config.toml")
+    } else {
+        maybe_file.to_path_buf()
+    };
+
+    let inner_config = if config_path.is_file() {
+        let raw = std::fs::read_to_string(&config_path)
+            .unwrap_or_else(|e| panic!("failed to read config at {config_path:?}: {e}"));
+        toml::from_str(&raw)
+            .unwrap_or_else(|e| panic!("failed to parse config at {config_path:?}: {e}"))
+    } else {
+        if let Some(parent) = config_path.parent() {
+            std::fs::create_dir_all(parent).expect("failed to create config directory");
+        }
+
+        let default = spec::InnerConfig::default();
+        let toml_str =
+            toml::to_string_pretty(&default).expect("failed to serialize default config");
+        std::fs::write(&config_path, toml_str).expect("failed to write default config");
+        default
+    };
+
+    let config: spec::Config = inner_config.into();
+
+    INSTANCE.set(config).unwrap();
+}
+
+pub fn get() -> &'static spec::Config {
+    INSTANCE
+        .get()
+        .expect("init_ring wasn't called before access")
+}

config/src/lib.rs

@@ -0,0 +1,75 @@
+use serde::{Deserialize, Serialize};
+
+/// Public surface for the config.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Config {
+    pub appearance: Appearance,
+}
+
+impl Config {
+    pub fn new() -> Self {
+        Self {
+            appearance: Appearance {
+                theme: iced::Theme::GruvboxLight,
+                scale: 1.0,
+            },
+        }
+    }
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Fills in any missing fields from `inner` using `Config::default()`.
+impl From<InnerConfig> for Config {
+    fn from(inner: InnerConfig) -> Self {
+        let defaults = Config::default();
+        Self {
+            appearance: inner
+                .appearance
+                .map(|a| Appearance {
+                    theme: a
+                        .theme
+                        .map(iced::Theme::from)
+                        .unwrap_or(defaults.appearance.theme.clone()),
+                    scale: a.scale.unwrap_or(defaults.appearance.scale.clone()),
+                })
+                .unwrap_or(defaults.appearance.clone()),
+        }
+    }
+}
+
+/// For writing config back out to disk — only include what differs
+/// from defaults if you want a "sparse" file, or just mirror everything.
+impl From<&Config> for InnerConfig {
+    fn from(config: &Config) -> Self {
+        Self {
+            appearance: Some(InnerAppearance {
+                theme: crate::theme::ThemeSetting::try_from(&config.appearance.theme).ok(),
+                scale: Some(config.appearance.scale),
+            }),
+        }
+    }
+}
+
+/// Reader to config file
+#[derive(Deserialize, Serialize, Default)]
+pub(crate) struct InnerConfig {
+    appearance: Option<InnerAppearance>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Appearance {
+    /// Inner to `iced::Theme` until I feel like adding custom themes
+    pub theme: iced::Theme,
+    pub scale: f32,
+}
+
+#[derive(Deserialize, Serialize)]
+pub(crate) struct InnerAppearance {
+    theme: Option<crate::theme::ThemeSetting>,
+    scale: Option<f32>,
+}