1use crate::{settings_store::SettingsStore, KeymapFile, Settings};
  2use anyhow::Result;
  3use fs::Fs;
  4use futures::{channel::mpsc, StreamExt};
  5use gpui::{AppContext, BackgroundExecutor};
  6use std::{io::ErrorKind, path::PathBuf, str, sync::Arc, time::Duration};
  7use util::{paths, ResultExt};
  8
  9pub const EMPTY_THEME_NAME: &'static str = "empty-theme";
 10
 11#[cfg(any(test, feature = "test-support"))]
 12pub fn test_settings() -> String {
 13    let mut value = crate::settings_store::parse_json_with_comments::<serde_json::Value>(
 14        crate::default_settings().as_ref(),
 15    )
 16    .unwrap();
 17    util::merge_non_null_json_value_into(
 18        serde_json::json!({
 19            "ui_font_family": "Courier",
 20            "ui_font_features": {},
 21            "ui_font_size": 14,
 22            "buffer_font_family": "Courier",
 23            "buffer_font_features": {},
 24            "buffer_font_size": 14,
 25            "theme": EMPTY_THEME_NAME,
 26        }),
 27        &mut value,
 28    );
 29    value.as_object_mut().unwrap().remove("languages");
 30    serde_json::to_string(&value).unwrap()
 31}
 32
 33pub fn watch_config_file(
 34    executor: &BackgroundExecutor,
 35    fs: Arc<dyn Fs>,
 36    path: PathBuf,
 37) -> mpsc::UnboundedReceiver<String> {
 38    let (tx, rx) = mpsc::unbounded();
 39    executor
 40        .spawn(async move {
 41            let events = fs.watch(&path, Duration::from_millis(100)).await;
 42            futures::pin_mut!(events);
 43
 44            let contents = fs.load(&path).await.unwrap_or_default();
 45            if tx.unbounded_send(contents).is_err() {
 46                return;
 47            }
 48
 49            loop {
 50                if events.next().await.is_none() {
 51                    break;
 52                }
 53
 54                if let Ok(contents) = fs.load(&path).await {
 55                    if !tx.unbounded_send(contents).is_ok() {
 56                        break;
 57                    }
 58                }
 59            }
 60        })
 61        .detach();
 62    rx
 63}
 64
 65pub fn handle_settings_file_changes(
 66    mut user_settings_file_rx: mpsc::UnboundedReceiver<String>,
 67    cx: &mut AppContext,
 68) {
 69    let user_settings_content = cx
 70        .background_executor()
 71        .block(user_settings_file_rx.next())
 72        .unwrap();
 73    cx.update_global(|store: &mut SettingsStore, cx| {
 74        store
 75            .set_user_settings(&user_settings_content, cx)
 76            .log_err();
 77    });
 78    cx.spawn(move |mut cx| async move {
 79        while let Some(user_settings_content) = user_settings_file_rx.next().await {
 80            eprintln!("settings file changed");
 81            let result = cx.update_global(|store: &mut SettingsStore, cx| {
 82                store
 83                    .set_user_settings(&user_settings_content, cx)
 84                    .log_err();
 85                cx.refresh();
 86            });
 87            if result.is_err() {
 88                break; // App dropped
 89            }
 90        }
 91    })
 92    .detach();
 93}
 94
 95async fn load_settings(fs: &Arc<dyn Fs>) -> Result<String> {
 96    match fs.load(&paths::SETTINGS).await {
 97        result @ Ok(_) => result,
 98        Err(err) => {
 99            if let Some(e) = err.downcast_ref::<std::io::Error>() {
100                if e.kind() == ErrorKind::NotFound {
101                    return Ok(crate::initial_user_settings_content().to_string());
102                }
103            }
104            return Err(err);
105        }
106    }
107}
108
109pub fn update_settings_file<T: Settings>(
110    fs: Arc<dyn Fs>,
111    cx: &mut AppContext,
112    update: impl 'static + Send + FnOnce(&mut T::FileContent),
113) {
114    cx.spawn(|cx| async move {
115        let old_text = load_settings(&fs).await?;
116        let new_text = cx.read_global(|store: &SettingsStore, _cx| {
117            store.new_text_for_update::<T>(old_text, update)
118        })?;
119        fs.atomic_write(paths::SETTINGS.clone(), new_text).await?;
120        anyhow::Ok(())
121    })
122    .detach_and_log_err(cx);
123}
124
125pub fn load_default_keymap(cx: &mut AppContext) {
126    for path in ["keymaps/default.json", "keymaps/vim.json"] {
127        // TODO: Remove this conditional when we're ready to add Vim support.
128        // Right now we're avoiding loading the Vim keymap to silence the warnings
129        // about invalid action bindings.
130        if path.contains("vim") {
131            let _: Option<()> = Err(format!(
132                "TODO: Skipping {path} until we're ready to add Vim support"
133            ))
134            .log_err();
135            continue;
136        }
137
138        KeymapFile::load_asset(path, cx).unwrap();
139    }
140
141    // todo!()
142    // if let Some(asset_path) = settings::get::<BaseKeymap>(cx).asset_path() {
143    //     KeymapFile::load_asset(asset_path, cx).unwrap();
144    // }
145}