Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: Remove settings dependency on migrator (#24642)

Browse source 
Closes #ISSUE

Release Notes:

- N/A
This commit is contained in:
Piotr Osiewicz 2025-02-11 13:34:33 +01:00 • committed by GitHub
parent 7f4957cf20
commit 64ae5093af
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 90 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -12035,7 +12035,6 @@ dependencies = [
"indoc",
"inventory",
"log",
"migrator",
"paths",
"pretty_assertions",
"release_channel",
@ -16647,6 +16646,7 @@ dependencies = [
"markdown",
"markdown_preview",
"menu",
"migrator",
"mimalloc",
"nix",
"node_runtime",

1
crates/settings/Cargo.toml
View file

@ -37,7 +37,6 @@ streaming-iterator.workspace = true
tree-sitter-json.workspace = true
tree-sitter.workspace = true
util.workspace = true
migrator.workspace = true
[dev-dependencies]
fs = { workspace = true, features = ["test-support"] }

40
crates/settings/src/keymap_file.rs
View file

@ -1,11 +1,10 @@
use anyhow::{anyhow, Context as _, Result};
use anyhow::{anyhow, Result};
use collections::{BTreeMap, HashMap, IndexMap};
use fs::Fs;
use gpui::{
Action, ActionBuildError, App, InvalidKeystrokeError, KeyBinding, KeyBindingContextPredicate,
NoAction, SharedString, KEYSTROKE_PARSE_EXPECTED_MESSAGE,
};
use migrator::migrate_keymap;
use schemars::{
gen::{SchemaGenerator, SchemaSettings},
schema::{ArrayValidation, InstanceType, Schema, SchemaObject, SubschemaValidation},
@ -598,7 +597,7 @@ impl KeymapFile {
self.0.iter()
}
async fn load_keymap_file(fs: &Arc<dyn Fs>) -> Result<String> {
pub async fn load_keymap_file(fs: &Arc<dyn Fs>) -> Result<String> {
match fs.load(paths::keymap_file()).await {
result @ Ok(_) => result,
Err(err) => {
@ -611,41 +610,6 @@ impl KeymapFile {
}
}
}
pub fn should_migrate_keymap(keymap_file: Self) -> bool {
let Ok(old_text) = serde_json::to_string(&keymap_file) else {
return false;
};
migrate_keymap(&old_text).is_some()
}
pub async fn migrate_keymap(fs: Arc<dyn Fs>) -> Result<()> {
let old_text = Self::load_keymap_file(&fs).await?;
let Some(new_text) = migrate_keymap(&old_text) else {
return Ok(());
};
let keymap_path = paths::keymap_file().as_path();
if fs.is_file(keymap_path).await {
fs.atomic_write(paths::keymap_backup_file().to_path_buf(), old_text)
.await
.with_context(|| {
"Failed to create settings backup in home directory".to_string()
})?;
let resolved_path = fs
.canonicalize(keymap_path)
.await
.with_context(|| format!("Failed to canonicalize keymap path {:?}", keymap_path))?;
fs.atomic_write(resolved_path.clone(), new_text)
.await
.with_context(|| format!("Failed to write keymap to file {:?}", resolved_path))?;
} else {
fs.atomic_write(keymap_path.to_path_buf(), new_text)
.await
.with_context(|| format!("Failed to write keymap to file {:?}", keymap_path))?;
}
Ok(())
}
}
// Double quotes a string and wraps it in backticks for markdown inline code..

49
crates/settings/src/settings_store.rs
View file

@ -4,7 +4,7 @@ use ec4rs::{ConfigParser, PropertiesSource, Section};
use fs::Fs;
use futures::{channel::mpsc, future::LocalBoxFuture, FutureExt, StreamExt};
use gpui::{App, AsyncApp, BorrowAppContext, Global, Task, UpdateGlobal};
use migrator::migrate_settings;
use paths::{local_settings_file_relative_path, EDITORCONFIG_NAME};
use schemars::{gen::SchemaGenerator, schema::RootSchema, JsonSchema};
use serde::{de::DeserializeOwned, Deserialize, Serialize};
@ -390,7 +390,7 @@ impl SettingsStore {
self.set_user_settings(&new_text, cx).unwrap();
}
async fn load_settings(fs: &Arc<dyn Fs>) -> Result<String> {
pub async fn load_settings(fs: &Arc<dyn Fs>) -> Result<String> {
match fs.load(paths::settings_file()).await {
result @ Ok(_) => result,
Err(err) => {
@ -996,51 +996,6 @@ impl SettingsStore {
properties.use_fallbacks();
Some(properties)
}
pub fn should_migrate_settings(settings: &serde_json::Value) -> bool {
let Ok(old_text) = serde_json::to_string(settings) else {
return false;
};
migrate_settings(&old_text).is_some()
}
pub fn migrate_settings(&self, fs: Arc<dyn Fs>) {
self.setting_file_updates_tx
.unbounded_send(Box::new(move |_: AsyncApp| {
async move {
let old_text = Self::load_settings(&fs).await?;
let Some(new_text) = migrate_settings(&old_text) else {
return anyhow::Ok(());
};
let settings_path = paths::settings_file().as_path();
if fs.is_file(settings_path).await {
fs.atomic_write(paths::settings_backup_file().to_path_buf(), old_text)
.await
.with_context(|| {
"Failed to create settings backup in home directory".to_string()
})?;
let resolved_path =
fs.canonicalize(settings_path).await.with_context(|| {
format!("Failed to canonicalize settings path {:?}", settings_path)
})?;
fs.atomic_write(resolved_path.clone(), new_text)
.await
.with_context(|| {
format!("Failed to write settings to file {:?}", resolved_path)
})?;
} else {
fs.atomic_write(settings_path.to_path_buf(), new_text)
.await
.with_context(|| {
format!("Failed to write settings to file {:?}", settings_path)
})?;
}
anyhow::Ok(())
}
.boxed_local()
}))
.ok();
}
}
#[derive(Debug, Clone, PartialEq)]

1
crates/zed/Cargo.toml
View file

@ -77,6 +77,7 @@ log.workspace = true
markdown.workspace = true
markdown_preview.workspace = true
menu.workspace = true
migrator.workspace = true
mimalloc = { version = "0.1", optional = true }
nix = { workspace = true, features = ["pthread", "signal"] }
node_runtime.workspace = true

9
crates/zed/src/zed.rs
View file

@ -4,6 +4,7 @@ pub mod inline_completion_registry;
pub(crate) mod linux_prompts;
#[cfg(target_os = "macos")]
pub(crate) mod mac_only_instance;
mod migrate;
mod open_listener;
mod quick_action_bar;
#[cfg(target_os = "windows")]
@ -1213,7 +1214,7 @@ fn show_keymap_migration_notification_if_needed(
notification_id: NotificationId,
cx: &mut App,
) -> bool {
if !KeymapFile::should_migrate_keymap(keymap_file) {
if !migrate::should_migrate_keymap(keymap_file) {
return false;
}
let message = MarkdownString(format!(
@ -1228,7 +1229,7 @@ fn show_keymap_migration_notification_if_needed(
move |_, cx| {
let fs = <dyn Fs>::global(cx);
cx.spawn(move |weak_notification, mut cx| async move {
KeymapFile::migrate_keymap(fs).await.ok();
migrate::migrate_keymap(fs).await.ok();
weak_notification
.update(&mut cx, |_, cx| {
cx.emit(DismissEvent);
@ -1247,7 +1248,7 @@ fn show_settings_migration_notification_if_needed(
settings: serde_json::Value,
cx: &mut App,
) {
if !SettingsStore::should_migrate_settings(&settings) {
if !migrate::should_migrate_settings(&settings) {
return;
}
let message = MarkdownString(format!(
@ -1261,7 +1262,7 @@ fn show_settings_migration_notification_if_needed(
"Backup and Migrate Settings".into(),
move |_, cx| {
let fs = <dyn Fs>::global(cx);
cx.update_global(|store: &mut SettingsStore, _| store.migrate_settings(fs));
migrate::migrate_settings(fs, cx);
cx.emit(DismissEvent);
},
cx,

79
crates/zed/src/zed/migrate.rs Normal file
View file

@ -0,0 +1,79 @@
use std::sync::Arc;
use anyhow::Context;
use fs::Fs;
use settings::{KeymapFile, SettingsStore};
pub fn should_migrate_settings(settings: &serde_json::Value) -> bool {
let Ok(old_text) = serde_json::to_string(settings) else {
return false;
};
migrator::migrate_settings(&old_text).is_some()
}
pub fn migrate_settings(fs: Arc<dyn Fs>, cx: &mut gpui::App) {
cx.background_executor()
.spawn(async move {
let old_text = SettingsStore::load_settings(&fs).await?;
let Some(new_text) = migrator::migrate_settings(&old_text) else {
return anyhow::Ok(());
};
let settings_path = paths::settings_file().as_path();
if fs.is_file(settings_path).await {
fs.atomic_write(paths::settings_backup_file().to_path_buf(), old_text)
.await
.with_context(|| {
"Failed to create settings backup in home directory".to_string()
})?;
let resolved_path = fs.canonicalize(settings_path).await.with_context(|| {
format!("Failed to canonicalize settings path {:?}", settings_path)
})?;
fs.atomic_write(resolved_path.clone(), new_text)
.await
.with_context(|| {
format!("Failed to write settings to file {:?}", resolved_path)
})?;
} else {
fs.atomic_write(settings_path.to_path_buf(), new_text)
.await
.with_context(|| {
format!("Failed to write settings to file {:?}", settings_path)
})?;
}
Ok(())
})
.detach_and_log_err(cx);
}
pub fn should_migrate_keymap(keymap_file: KeymapFile) -> bool {
let Ok(old_text) = serde_json::to_string(&keymap_file) else {
return false;
};
migrator::migrate_keymap(&old_text).is_some()
}
pub async fn migrate_keymap(fs: Arc<dyn Fs>) -> anyhow::Result<()> {
let old_text = KeymapFile::load_keymap_file(&fs).await?;
let Some(new_text) = migrator::migrate_keymap(&old_text) else {
return Ok(());
};
let keymap_path = paths::keymap_file().as_path();
if fs.is_file(keymap_path).await {
fs.atomic_write(paths::keymap_backup_file().to_path_buf(), old_text)
.await
.with_context(|| "Failed to create settings backup in home directory".to_string())?;
let resolved_path = fs
.canonicalize(keymap_path)
.await
.with_context(|| format!("Failed to canonicalize keymap path {:?}", keymap_path))?;
fs.atomic_write(resolved_path.clone(), new_text)
.await
.with_context(|| format!("Failed to write keymap to file {:?}", resolved_path))?;
} else {
fs.atomic_write(keymap_path.to_path_buf(), new_text)
.await
.with_context(|| format!("Failed to write keymap to file {:?}", keymap_path))?;
}
Ok(())
}