From 8c7096f7a62b73393898014c8694599768aaa921 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Tue, 4 Feb 2025 13:24:35 -0500 Subject: [PATCH] Rename `model` based variable names to `entity` (#24198) ## Context While looking through the client crate, I noticed that some of the old functions and variables were still using gpui::model name that was deprecated during the gpui3 transition. This PR renames those instances of model to entity to be more inline with gpui3. In addition, I also renamed `model` to `entity` in cases found by the below search terms given by @someone13574 - model = cx. - model: Entity - model: &Entity - OpenedModelHandle - model.update - model.upgrade - model = .*\.root (regex) - parent_model - model = cx.new - cx.spawn(move |model Release Notes: - N/A --- crates/assistant2/src/assistant_panel.rs | 2 +- crates/assistant2/src/context_store.rs | 30 +++--- crates/assistant2/src/context_strip.rs | 10 +- .../src/context_store.rs | 12 +-- crates/channel/src/channel_buffer.rs | 6 +- crates/channel/src/channel_chat.rs | 8 +- crates/channel/src/channel_store.rs | 36 +++---- crates/client/src/client.rs | 54 +++++----- .../collab/src/tests/channel_buffer_tests.rs | 4 +- crates/collab/src/tests/test_server.rs | 8 +- crates/collab_ui/src/chat_panel.rs | 6 +- crates/collab_ui/src/collab_panel.rs | 6 +- crates/collab_ui/src/notification_panel.rs | 16 +-- crates/editor/src/editor_tests.rs | 20 ++-- crates/git_ui/src/git_panel.rs | 2 +- crates/markdown/src/markdown.rs | 4 +- crates/outline_panel/src/outline_panel.rs | 4 +- crates/picker/src/picker.rs | 8 +- crates/project/src/buffer_store.rs | 18 ++-- crates/project/src/debounced_delay.rs | 4 +- crates/project/src/image_store.rs | 8 +- crates/project/src/lsp_store.rs | 62 ++++++------ crates/project/src/project.rs | 70 ++++++------- crates/project/src/project_settings.rs | 2 +- crates/project/src/task_store.rs | 2 +- crates/project/src/toolchain_store.rs | 12 +-- crates/project/src/worktree_store.rs | 14 +-- crates/project_panel/src/project_panel.rs | 4 +- crates/recent_projects/src/remote_servers.rs | 2 +- crates/remote_server/src/headless_project.rs | 22 ++--- crates/repl/src/notebook/cell.rs | 4 +- crates/rpc/src/proto_client.rs | 49 +++++----- crates/search/src/project_search.rs | 98 +++++++++---------- crates/ui/src/components/indent_guides.rs | 8 +- crates/ui/src/components/scrollbar.rs | 2 +- crates/vim/src/test/vim_test_context.rs | 10 +- crates/vim/src/vim.rs | 12 ++- crates/workspace/src/item.rs | 4 +- crates/workspace/src/pane.rs | 10 +- crates/zeta/src/zeta.rs | 6 +- 40 files changed, 332 insertions(+), 327 deletions(-) diff --git a/crates/assistant2/src/assistant_panel.rs b/crates/assistant2/src/assistant_panel.rs index 055ff5449e..45f3d15a81 100644 --- a/crates/assistant2/src/assistant_panel.rs +++ b/crates/assistant2/src/assistant_panel.rs @@ -442,7 +442,7 @@ impl AssistantPanel { fn handle_assistant_configuration_event( &mut self, - _model: &Entity, + _entity: &Entity, event: &AssistantConfigurationEvent, window: &mut Window, cx: &mut Context, diff --git a/crates/assistant2/src/context_store.rs b/crates/assistant2/src/context_store.rs index 9fd4ebd23f..e979f5e24d 100644 --- a/crates/assistant2/src/context_store.rs +++ b/crates/assistant2/src/context_store.rs @@ -79,8 +79,8 @@ impl ContextStore { project.open_buffer(project_path.clone(), cx) })?; - let buffer_model = open_buffer_task.await?; - let buffer_id = this.update(&mut cx, |_, cx| buffer_model.read(cx).remote_id())?; + let buffer_entity = open_buffer_task.await?; + let buffer_id = this.update(&mut cx, |_, cx| buffer_entity.read(cx).remote_id())?; let already_included = this.update(&mut cx, |this, _cx| { match this.will_include_buffer(buffer_id, &project_path.path) { @@ -98,10 +98,10 @@ impl ContextStore { } let (buffer_info, text_task) = this.update(&mut cx, |_, cx| { - let buffer = buffer_model.read(cx); + let buffer = buffer_entity.read(cx); collect_buffer_info_and_text( project_path.path.clone(), - buffer_model, + buffer_entity, buffer, cx.to_async(), ) @@ -119,18 +119,18 @@ impl ContextStore { pub fn add_file_from_buffer( &mut self, - buffer_model: Entity, + buffer_entity: Entity, cx: &mut Context, ) -> Task> { cx.spawn(|this, mut cx| async move { let (buffer_info, text_task) = this.update(&mut cx, |_, cx| { - let buffer = buffer_model.read(cx); + let buffer = buffer_entity.read(cx); let Some(file) = buffer.file() else { return Err(anyhow!("Buffer has no path.")); }; Ok(collect_buffer_info_and_text( file.path().clone(), - buffer_model, + buffer_entity, buffer, cx.to_async(), )) @@ -207,11 +207,11 @@ impl ContextStore { let mut buffer_infos = Vec::new(); let mut text_tasks = Vec::new(); this.update(&mut cx, |_, cx| { - for (path, buffer_model) in files.into_iter().zip(buffers) { - let buffer_model = buffer_model?; - let buffer = buffer_model.read(cx); + for (path, buffer_entity) in files.into_iter().zip(buffers) { + let buffer_entity = buffer_entity?; + let buffer = buffer_entity.read(cx); let (buffer_info, text_task) = - collect_buffer_info_and_text(path, buffer_model, buffer, cx.to_async()); + collect_buffer_info_and_text(path, buffer_entity, buffer, cx.to_async()); buffer_infos.push(buffer_info); text_tasks.push(text_task); } @@ -429,7 +429,7 @@ pub enum FileInclusion { // ContextBuffer without text. struct BufferInfo { - buffer_model: Entity, + buffer_entity: Entity, id: BufferId, version: clock::Global, } @@ -437,7 +437,7 @@ struct BufferInfo { fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer { ContextBuffer { id: info.id, - buffer: info.buffer_model, + buffer: info.buffer_entity, version: info.version, text, } @@ -445,13 +445,13 @@ fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer { fn collect_buffer_info_and_text( path: Arc, - buffer_model: Entity, + buffer_entity: Entity, buffer: &Buffer, cx: AsyncApp, ) -> (BufferInfo, Task) { let buffer_info = BufferInfo { id: buffer.remote_id(), - buffer_model, + buffer_entity, version: buffer.version(), }; // Important to collect version at the same time as content so that staleness logic is correct. diff --git a/crates/assistant2/src/context_strip.rs b/crates/assistant2/src/context_strip.rs index 97e9b633d3..d7b1503713 100644 --- a/crates/assistant2/src/context_strip.rs +++ b/crates/assistant2/src/context_strip.rs @@ -92,8 +92,8 @@ impl ContextStrip { let active_item = workspace.read(cx).active_item(cx)?; let editor = active_item.to_any().downcast::().ok()?.read(cx); - let active_buffer_model = editor.buffer().read(cx).as_singleton()?; - let active_buffer = active_buffer_model.read(cx); + let active_buffer_entity = editor.buffer().read(cx).as_singleton()?; + let active_buffer = active_buffer_entity.read(cx); let path = active_buffer.file()?.path(); @@ -115,7 +115,7 @@ impl ContextStrip { Some(SuggestedContext::File { name, - buffer: active_buffer_model.downgrade(), + buffer: active_buffer_entity.downgrade(), icon_path, }) } @@ -393,9 +393,9 @@ impl Render for ContextStrip { .on_action(cx.listener(Self::remove_focused_context)) .on_action(cx.listener(Self::accept_suggested_context)) .on_children_prepainted({ - let model = cx.entity().downgrade(); + let entity = cx.entity().downgrade(); move |children_bounds, _window, cx| { - model + entity .update(cx, |this, _| { this.children_bounds = Some(children_bounds); }) diff --git a/crates/assistant_context_editor/src/context_store.rs b/crates/assistant_context_editor/src/context_store.rs index 91a1553193..c359ffb358 100644 --- a/crates/assistant_context_editor/src/context_store.rs +++ b/crates/assistant_context_editor/src/context_store.rs @@ -31,11 +31,11 @@ use std::{ use util::{ResultExt, TryFutureExt}; pub(crate) fn init(client: &AnyProtoClient) { - client.add_model_message_handler(ContextStore::handle_advertise_contexts); - client.add_model_request_handler(ContextStore::handle_open_context); - client.add_model_request_handler(ContextStore::handle_create_context); - client.add_model_message_handler(ContextStore::handle_update_context); - client.add_model_request_handler(ContextStore::handle_synchronize_contexts); + client.add_entity_message_handler(ContextStore::handle_advertise_contexts); + client.add_entity_request_handler(ContextStore::handle_open_context); + client.add_entity_request_handler(ContextStore::handle_create_context); + client.add_entity_message_handler(ContextStore::handle_update_context); + client.add_entity_request_handler(ContextStore::handle_synchronize_contexts); } #[derive(Clone)] @@ -310,7 +310,7 @@ impl ContextStore { .client .subscribe_to_entity(remote_id) .log_err() - .map(|subscription| subscription.set_model(&cx.entity(), &mut cx.to_async())); + .map(|subscription| subscription.set_entity(&cx.entity(), &mut cx.to_async())); self.advertise_contexts(cx); } else { self.client_subscription = None; diff --git a/crates/channel/src/channel_buffer.rs b/crates/channel/src/channel_buffer.rs index 3ccfb0503c..31bac60210 100644 --- a/crates/channel/src/channel_buffer.rs +++ b/crates/channel/src/channel_buffer.rs @@ -15,8 +15,8 @@ use util::ResultExt; pub const ACKNOWLEDGE_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(250); pub(crate) fn init(client: &AnyProtoClient) { - client.add_model_message_handler(ChannelBuffer::handle_update_channel_buffer); - client.add_model_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators); + client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer); + client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators); } pub struct ChannelBuffer { @@ -81,7 +81,7 @@ impl ChannelBuffer { collaborators: Default::default(), acknowledge_task: None, channel_id: channel.id, - subscription: Some(subscription.set_model(&cx.entity(), &mut cx.to_async())), + subscription: Some(subscription.set_entity(&cx.entity(), &mut cx.to_async())), user_store, channel_store, }; diff --git a/crates/channel/src/channel_chat.rs b/crates/channel/src/channel_chat.rs index 7707d300f7..e16e27ac36 100644 --- a/crates/channel/src/channel_chat.rs +++ b/crates/channel/src/channel_chat.rs @@ -95,9 +95,9 @@ pub enum ChannelChatEvent { impl EventEmitter for ChannelChat {} pub fn init(client: &AnyProtoClient) { - client.add_model_message_handler(ChannelChat::handle_message_sent); - client.add_model_message_handler(ChannelChat::handle_message_removed); - client.add_model_message_handler(ChannelChat::handle_message_updated); + client.add_entity_message_handler(ChannelChat::handle_message_sent); + client.add_entity_message_handler(ChannelChat::handle_message_removed); + client.add_entity_message_handler(ChannelChat::handle_message_updated); } impl ChannelChat { @@ -132,7 +132,7 @@ impl ChannelChat { last_acknowledged_id: None, rng: StdRng::from_entropy(), first_loaded_message_id: None, - _subscription: subscription.set_model(&cx.entity(), &mut cx.to_async()), + _subscription: subscription.set_entity(&cx.entity(), &mut cx.to_async()), } })?; Self::handle_loaded_messages( diff --git a/crates/channel/src/channel_store.rs b/crates/channel/src/channel_store.rs index 8ba015f572..bb11487a0e 100644 --- a/crates/channel/src/channel_store.rs +++ b/crates/channel/src/channel_store.rs @@ -39,8 +39,8 @@ pub struct ChannelStore { channel_states: HashMap, outgoing_invites: HashSet<(ChannelId, UserId)>, update_channels_tx: mpsc::UnboundedSender, - opened_buffers: HashMap>, - opened_chats: HashMap>, + opened_buffers: HashMap>, + opened_chats: HashMap>, client: Arc, did_subscribe: bool, user_store: Entity, @@ -142,7 +142,7 @@ pub enum ChannelEvent { impl EventEmitter for ChannelStore {} -enum OpenedModelHandle { +enum OpenEntityHandle { Open(WeakEntity), Loading(Shared, Arc>>>), } @@ -292,7 +292,7 @@ impl ChannelStore { pub fn has_open_channel_buffer(&self, channel_id: ChannelId, _cx: &App) -> bool { if let Some(buffer) = self.opened_buffers.get(&channel_id) { - if let OpenedModelHandle::Open(buffer) = buffer { + if let OpenEntityHandle::Open(buffer) = buffer { return buffer.upgrade().is_some(); } } @@ -453,7 +453,7 @@ impl ChannelStore { fn open_channel_resource( &mut self, channel_id: ChannelId, - get_map: fn(&mut Self) -> &mut HashMap>, + get_map: fn(&mut Self) -> &mut HashMap>, load: F, cx: &mut Context, ) -> Task>> @@ -465,15 +465,15 @@ impl ChannelStore { let task = loop { match get_map(self).entry(channel_id) { hash_map::Entry::Occupied(e) => match e.get() { - OpenedModelHandle::Open(model) => { - if let Some(model) = model.upgrade() { - break Task::ready(Ok(model)).shared(); + OpenEntityHandle::Open(entity) => { + if let Some(entity) = entity.upgrade() { + break Task::ready(Ok(entity)).shared(); } else { get_map(self).remove(&channel_id); continue; } } - OpenedModelHandle::Loading(task) => { + OpenEntityHandle::Loading(task) => { break task.clone(); } }, @@ -490,7 +490,7 @@ impl ChannelStore { }) .shared(); - e.insert(OpenedModelHandle::Loading(task.clone())); + e.insert(OpenEntityHandle::Loading(task.clone())); cx.spawn({ let task = task.clone(); move |this, mut cx| async move { @@ -499,7 +499,7 @@ impl ChannelStore { Ok(model) => { get_map(this).insert( channel_id, - OpenedModelHandle::Open(model.downgrade()), + OpenEntityHandle::Open(model.downgrade()), ); } Err(_) => { @@ -900,7 +900,7 @@ impl ChannelStore { self.disconnect_channel_buffers_task.take(); for chat in self.opened_chats.values() { - if let OpenedModelHandle::Open(chat) = chat { + if let OpenEntityHandle::Open(chat) = chat { if let Some(chat) = chat.upgrade() { chat.update(cx, |chat, cx| { chat.rejoin(cx); @@ -911,7 +911,7 @@ impl ChannelStore { let mut buffer_versions = Vec::new(); for buffer in self.opened_buffers.values() { - if let OpenedModelHandle::Open(buffer) = buffer { + if let OpenEntityHandle::Open(buffer) = buffer { if let Some(buffer) = buffer.upgrade() { let channel_buffer = buffer.read(cx); let buffer = channel_buffer.buffer().read(cx); @@ -937,7 +937,7 @@ impl ChannelStore { this.update(&mut cx, |this, cx| { this.opened_buffers.retain(|_, buffer| match buffer { - OpenedModelHandle::Open(channel_buffer) => { + OpenEntityHandle::Open(channel_buffer) => { let Some(channel_buffer) = channel_buffer.upgrade() else { return false; }; @@ -998,7 +998,7 @@ impl ChannelStore { false }) } - OpenedModelHandle::Loading(_) => true, + OpenEntityHandle::Loading(_) => true, }); }) .ok(); @@ -1018,7 +1018,7 @@ impl ChannelStore { if let Some(this) = this.upgrade() { this.update(&mut cx, |this, cx| { for (_, buffer) in this.opened_buffers.drain() { - if let OpenedModelHandle::Open(buffer) = buffer { + if let OpenEntityHandle::Open(buffer) = buffer { if let Some(buffer) = buffer.upgrade() { buffer.update(cx, |buffer, cx| buffer.disconnect(cx)); } @@ -1082,7 +1082,7 @@ impl ChannelStore { { continue; } - if let Some(OpenedModelHandle::Open(buffer)) = + if let Some(OpenEntityHandle::Open(buffer)) = self.opened_buffers.remove(&channel_id) { if let Some(buffer) = buffer.upgrade() { @@ -1098,7 +1098,7 @@ impl ChannelStore { let channel_changed = index.insert(channel); if channel_changed { - if let Some(OpenedModelHandle::Open(buffer)) = self.opened_buffers.get(&id) { + if let Some(OpenEntityHandle::Open(buffer)) = self.opened_buffers.get(&id) { if let Some(buffer) = buffer.upgrade() { buffer.update(cx, ChannelBuffer::channel_changed); } diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs index 0bc71cb2da..e6b86a4e52 100644 --- a/crates/client/src/client.rs +++ b/crates/client/src/client.rs @@ -379,7 +379,7 @@ pub struct PendingEntitySubscription { } impl PendingEntitySubscription { - pub fn set_model(mut self, model: &Entity, cx: &AsyncApp) -> Subscription { + pub fn set_entity(mut self, entity: &Entity, cx: &AsyncApp) -> Subscription { self.consumed = true; let mut handlers = self.client.handler_set.lock(); let id = (TypeId::of::(), self.remote_id); @@ -392,7 +392,7 @@ impl PendingEntitySubscription { handlers.entities_by_type_and_remote_id.insert( id, EntityMessageSubscriber::Entity { - handle: model.downgrade().into(), + handle: entity.downgrade().into(), }, ); drop(handlers); @@ -686,8 +686,8 @@ impl Client { H: 'static + Sync + Fn(Entity, TypedEnvelope, AsyncApp) -> F + Send + Sync, F: 'static + Future>, { - self.add_message_handler_impl(entity, move |model, message, _, cx| { - handler(model, message, cx) + self.add_message_handler_impl(entity, move |entity, message, _, cx| { + handler(entity, message, cx) }) } @@ -709,7 +709,7 @@ impl Client { let message_type_id = TypeId::of::(); let mut state = self.handler_set.lock(); state - .models_by_message_type + .entities_by_message_type .insert(message_type_id, entity.into()); let prev_handler = state.message_handlers.insert( @@ -738,7 +738,7 @@ impl Client { pub fn add_request_handler( self: &Arc, - model: WeakEntity, + entity: WeakEntity, handler: H, ) -> Subscription where @@ -747,7 +747,7 @@ impl Client { H: 'static + Sync + Fn(Entity, TypedEnvelope, AsyncApp) -> F + Send + Sync, F: 'static + Future>, { - self.add_message_handler_impl(model, move |handle, envelope, this, cx| { + self.add_message_handler_impl(entity, move |handle, envelope, this, cx| { Self::respond_to_request(envelope.receipt(), handler(handle, envelope, cx), this) }) } @@ -1948,9 +1948,9 @@ mod tests { let (done_tx1, done_rx1) = smol::channel::unbounded(); let (done_tx2, done_rx2) = smol::channel::unbounded(); - AnyProtoClient::from(client.clone()).add_model_message_handler( - move |model: Entity, _: TypedEnvelope, mut cx| { - match model.update(&mut cx, |model, _| model.id).unwrap() { + AnyProtoClient::from(client.clone()).add_entity_message_handler( + move |entity: Entity, _: TypedEnvelope, mut cx| { + match entity.update(&mut cx, |entity, _| entity.id).unwrap() { 1 => done_tx1.try_send(()).unwrap(), 2 => done_tx2.try_send(()).unwrap(), _ => unreachable!(), @@ -1958,15 +1958,15 @@ mod tests { async { Ok(()) } }, ); - let model1 = cx.new(|_| TestModel { + let entity1 = cx.new(|_| TestEntity { id: 1, subscription: None, }); - let model2 = cx.new(|_| TestModel { + let entity2 = cx.new(|_| TestEntity { id: 2, subscription: None, }); - let model3 = cx.new(|_| TestModel { + let entity3 = cx.new(|_| TestEntity { id: 3, subscription: None, }); @@ -1974,17 +1974,17 @@ mod tests { let _subscription1 = client .subscribe_to_entity(1) .unwrap() - .set_model(&model1, &mut cx.to_async()); + .set_entity(&entity1, &mut cx.to_async()); let _subscription2 = client .subscribe_to_entity(2) .unwrap() - .set_model(&model2, &mut cx.to_async()); + .set_entity(&entity2, &mut cx.to_async()); // Ensure dropping a subscription for the same entity type still allows receiving of // messages for other entity IDs of the same type. let subscription3 = client .subscribe_to_entity(3) .unwrap() - .set_model(&model3, &mut cx.to_async()); + .set_entity(&entity3, &mut cx.to_async()); drop(subscription3); server.send(proto::JoinProject { project_id: 1 }); @@ -2006,11 +2006,11 @@ mod tests { }); let server = FakeServer::for_client(user_id, &client, cx).await; - let model = cx.new(|_| TestModel::default()); + let entity = cx.new(|_| TestEntity::default()); let (done_tx1, _done_rx1) = smol::channel::unbounded(); let (done_tx2, done_rx2) = smol::channel::unbounded(); let subscription1 = client.add_message_handler( - model.downgrade(), + entity.downgrade(), move |_, _: TypedEnvelope, _| { done_tx1.try_send(()).unwrap(); async { Ok(()) } @@ -2018,7 +2018,7 @@ mod tests { ); drop(subscription1); let _subscription2 = client.add_message_handler( - model.downgrade(), + entity.downgrade(), move |_, _: TypedEnvelope, _| { done_tx2.try_send(()).unwrap(); async { Ok(()) } @@ -2041,27 +2041,27 @@ mod tests { }); let server = FakeServer::for_client(user_id, &client, cx).await; - let model = cx.new(|_| TestModel::default()); + let entity = cx.new(|_| TestEntity::default()); let (done_tx, done_rx) = smol::channel::unbounded(); let subscription = client.add_message_handler( - model.clone().downgrade(), - move |model: Entity, _: TypedEnvelope, mut cx| { - model - .update(&mut cx, |model, _| model.subscription.take()) + entity.clone().downgrade(), + move |entity: Entity, _: TypedEnvelope, mut cx| { + entity + .update(&mut cx, |entity, _| entity.subscription.take()) .unwrap(); done_tx.try_send(()).unwrap(); async { Ok(()) } }, ); - model.update(cx, |model, _| { - model.subscription = Some(subscription); + entity.update(cx, |entity, _| { + entity.subscription = Some(subscription); }); server.send(proto::Ping {}); done_rx.recv().await.unwrap(); } #[derive(Default)] - struct TestModel { + struct TestEntity { id: usize, subscription: Option, } diff --git a/crates/collab/src/tests/channel_buffer_tests.rs b/crates/collab/src/tests/channel_buffer_tests.rs index 83bb8966b7..c253acf54b 100644 --- a/crates/collab/src/tests/channel_buffer_tests.rs +++ b/crates/collab/src/tests/channel_buffer_tests.rs @@ -342,7 +342,7 @@ async fn test_multiple_handles_to_channel_buffer( future::try_join3(channel_buffer_1, channel_buffer_2, channel_buffer_3) .await .unwrap(); - let channel_buffer_model_id = channel_buffer.entity_id(); + let channel_buffer_entity_id = channel_buffer.entity_id(); assert_eq!(channel_buffer, channel_buffer_2); assert_eq!(channel_buffer, channel_buffer_3); @@ -366,7 +366,7 @@ async fn test_multiple_handles_to_channel_buffer( .update(cx_a, |store, cx| store.open_channel_buffer(channel_id, cx)) .await .unwrap(); - assert_ne!(channel_buffer.entity_id(), channel_buffer_model_id); + assert_ne!(channel_buffer.entity_id(), channel_buffer_entity_id); channel_buffer.update(cx_a, |buffer, cx| { buffer.buffer().update(cx, |buffer, _| { assert_eq!(buffer.text(), "hello"); diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs index e3d2ffb079..8da497a678 100644 --- a/crates/collab/src/tests/test_server.rs +++ b/crates/collab/src/tests/test_server.rs @@ -849,10 +849,10 @@ impl TestClient { ) -> (Entity, &'a mut VisualTestContext) { let window = cx.update(|cx| cx.active_window().unwrap().downcast::().unwrap()); - let model = window.root(cx).unwrap(); + let entity = window.root(cx).unwrap(); let cx = VisualTestContext::from_window(*window.deref(), cx).as_mut(); // it might be nice to try and cleanup these at the end of each test. - (model, cx) + (entity, cx) } } @@ -861,9 +861,9 @@ pub fn open_channel_notes( cx: &mut VisualTestContext, ) -> Task>> { let window = cx.update(|_, cx| cx.active_window().unwrap().downcast::().unwrap()); - let model = window.root(cx).unwrap(); + let entity = window.root(cx).unwrap(); - cx.update(|window, cx| ChannelView::open(channel_id, None, model.clone(), window, cx)) + cx.update(|window, cx| ChannelView::open(channel_id, None, entity.clone(), window, cx)) } impl Drop for TestClient { diff --git a/crates/collab_ui/src/chat_panel.rs b/crates/collab_ui/src/chat_panel.rs index 306bcd53bb..c17f3ff052 100644 --- a/crates/collab_ui/src/chat_panel.rs +++ b/crates/collab_ui/src/chat_panel.rs @@ -97,14 +97,14 @@ impl ChatPanel { }); cx.new(|cx| { - let model = cx.entity().downgrade(); + let entity = cx.entity().downgrade(); let message_list = ListState::new( 0, gpui::ListAlignment::Bottom, px(1000.), move |ix, window, cx| { - if let Some(model) = model.upgrade() { - model.update(cx, |this: &mut Self, cx| { + if let Some(entity) = entity.upgrade() { + entity.update(cx, |this: &mut Self, cx| { this.render_message(ix, window, cx).into_any_element() }) } else { diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs index c9eaec4e3b..e9afd32487 100644 --- a/crates/collab_ui/src/collab_panel.rs +++ b/crates/collab_ui/src/collab_panel.rs @@ -239,14 +239,14 @@ impl CollabPanel { ) .detach(); - let model = cx.entity().downgrade(); + let entity = cx.entity().downgrade(); let list_state = ListState::new( 0, gpui::ListAlignment::Top, px(1000.), move |ix, window, cx| { - if let Some(model) = model.upgrade() { - model.update(cx, |this, cx| this.render_list_entry(ix, window, cx)) + if let Some(entity) = entity.upgrade() { + entity.update(cx, |this, cx| this.render_list_entry(ix, window, cx)) } else { div().into_any() } diff --git a/crates/collab_ui/src/notification_panel.rs b/crates/collab_ui/src/notification_panel.rs index 3b9ba33d6d..eafe7eaf6e 100644 --- a/crates/collab_ui/src/notification_panel.rs +++ b/crates/collab_ui/src/notification_panel.rs @@ -110,13 +110,13 @@ impl NotificationPanel { }) .detach(); - let model = cx.entity().downgrade(); + let entity = cx.entity().downgrade(); let notification_list = ListState::new(0, ListAlignment::Top, px(1000.), move |ix, window, cx| { - model + entity .upgrade() - .and_then(|model| { - model.update(cx, |this, cx| this.render_notification(ix, window, cx)) + .and_then(|entity| { + entity.update(cx, |this, cx| this.render_notification(ix, window, cx)) }) .unwrap_or_else(|| div().into_any()) }); @@ -323,9 +323,9 @@ impl NotificationPanel { .justify_end() .child(Button::new("decline", "Decline").on_click({ let notification = notification.clone(); - let model = cx.entity().clone(); + let entity = cx.entity().clone(); move |_, _, cx| { - model.update(cx, |this, cx| { + entity.update(cx, |this, cx| { this.respond_to_notification( notification.clone(), false, @@ -336,9 +336,9 @@ impl NotificationPanel { })) .child(Button::new("accept", "Accept").on_click({ let notification = notification.clone(); - let model = cx.entity().clone(); + let entity = cx.entity().clone(); move |_, _, cx| { - model.update(cx, |this, cx| { + entity.update(cx, |this, cx| { this.respond_to_notification( notification.clone(), true, diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 70d614d9ef..2ce221fbda 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -62,9 +62,9 @@ fn test_edit_events(cx: &mut TestAppContext) { let editor1 = cx.add_window({ let events = events.clone(); |window, cx| { - let model = cx.entity().clone(); + let entity = cx.entity().clone(); cx.subscribe_in( - &model, + &entity, window, move |_, _, event: &EditorEvent, _, _| match event { EditorEvent::Edited { .. } => events.borrow_mut().push(("editor1", "edited")), @@ -10196,15 +10196,15 @@ async fn test_following(cx: &mut gpui::TestAppContext) { let is_still_following = Rc::new(RefCell::new(true)); let follower_edit_event_count = Rc::new(RefCell::new(0)); let pending_update = Rc::new(RefCell::new(None)); - let leader_model = leader.root(cx).unwrap(); - let follower_model = follower.root(cx).unwrap(); + let leader_entity = leader.root(cx).unwrap(); + let follower_entity = follower.root(cx).unwrap(); _ = follower.update(cx, { let update = pending_update.clone(); let is_still_following = is_still_following.clone(); let follower_edit_event_count = follower_edit_event_count.clone(); |_, window, cx| { cx.subscribe_in( - &leader_model, + &leader_entity, window, move |_, leader, event, window, cx| { leader.read(cx).add_event_to_update_proto( @@ -10218,7 +10218,7 @@ async fn test_following(cx: &mut gpui::TestAppContext) { .detach(); cx.subscribe_in( - &follower_model, + &follower_entity, window, move |_, _, event: &EditorEvent, _window, _cx| { if matches!(Editor::to_follow_event(event), Some(FollowEvent::Unfollow)) { @@ -10384,11 +10384,11 @@ async fn test_following_with_multiple_excerpts(cx: &mut gpui::TestAppContext) { // Start following the editor when it has no excerpts. let mut state_message = leader.update_in(cx, |leader, window, cx| leader.to_state_proto(window, cx)); - let workspace_model = workspace.root(cx).unwrap(); + let workspace_entity = workspace.root(cx).unwrap(); let follower_1 = cx .update_window(*workspace.deref(), |_, window, cx| { Editor::from_state_proto( - workspace_model, + workspace_entity, ViewId { creator: Default::default(), id: 0, @@ -10486,11 +10486,11 @@ async fn test_following_with_multiple_excerpts(cx: &mut gpui::TestAppContext) { // Start following separately after it already has excerpts. let mut state_message = leader.update_in(cx, |leader, window, cx| leader.to_state_proto(window, cx)); - let workspace_model = workspace.root(cx).unwrap(); + let workspace_entity = workspace.root(cx).unwrap(); let follower_2 = cx .update_window(*workspace.deref(), |_, window, cx| { Editor::from_state_proto( - workspace_model, + workspace_entity, ViewId { creator: Default::default(), id: 0, diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 4b0f4e2337..718a2272e2 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -321,7 +321,7 @@ impl GitPanel { current_modifiers: window.modifiers(), width: Some(px(360.)), scrollbar_state: ScrollbarState::new(scroll_handle.clone()) - .parent_model(&cx.entity()), + .parent_entity(&cx.entity()), repository_selector, selected_entry: None, show_scrollbar: false, diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index ceebc3547e..cc525e4b59 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -821,13 +821,13 @@ impl Element for MarkdownElement { let mut context = KeyContext::default(); context.add("Markdown"); window.set_key_context(context); - let model = self.markdown.clone(); + let entity = self.markdown.clone(); window.on_action(std::any::TypeId::of::(), { let text = rendered_markdown.text.clone(); move |_, phase, window, cx| { let text = text.clone(); if phase == DispatchPhase::Bubble { - model.update(cx, move |this, cx| this.copy(&text, window, cx)) + entity.update(cx, move |this, cx| this.copy(&text, window, cx)) } } }); diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs index 723f1e19f3..212d13555f 100644 --- a/crates/outline_panel/src/outline_panel.rs +++ b/crates/outline_panel/src/outline_panel.rs @@ -796,9 +796,9 @@ impl OutlinePanel { show_scrollbar: !Self::should_autohide_scrollbar(cx), hide_scrollbar_task: None, vertical_scrollbar_state: ScrollbarState::new(scroll_handle.clone()) - .parent_model(&cx.entity()), + .parent_entity(&cx.entity()), horizontal_scrollbar_state: ScrollbarState::new(scroll_handle.clone()) - .parent_model(&cx.entity()), + .parent_entity(&cx.entity()), max_width_item_index: None, scroll_handle, focus_handle, diff --git a/crates/picker/src/picker.rs b/crates/picker/src/picker.rs index c3eb255581..cf7793730c 100644 --- a/crates/picker/src/picker.rs +++ b/crates/picker/src/picker.rs @@ -281,16 +281,16 @@ impl Picker { ElementContainer::UniformList(UniformListScrollHandle::new()) } ContainerKind::List => { - let model = cx.entity().downgrade(); + let entity = cx.entity().downgrade(); ElementContainer::List(ListState::new( 0, gpui::ListAlignment::Top, px(1000.), move |ix, window, cx| { - model + entity .upgrade() - .map(|model| { - model.update(cx, |this, cx| { + .map(|entity| { + entity.update(cx, |this, cx| { this.render_element(window, cx, ix).into_any_element() }) }) diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs index 01c3878d6c..1bfc2025a9 100644 --- a/crates/project/src/buffer_store.rs +++ b/crates/project/src/buffer_store.rs @@ -894,15 +894,15 @@ impl LocalBufferStore { impl BufferStore { pub fn init(client: &AnyProtoClient) { - client.add_model_message_handler(Self::handle_buffer_reloaded); - client.add_model_message_handler(Self::handle_buffer_saved); - client.add_model_message_handler(Self::handle_update_buffer_file); - client.add_model_request_handler(Self::handle_save_buffer); - client.add_model_request_handler(Self::handle_blame_buffer); - client.add_model_request_handler(Self::handle_reload_buffers); - client.add_model_request_handler(Self::handle_get_permalink_to_line); - client.add_model_request_handler(Self::handle_get_staged_text); - client.add_model_message_handler(Self::handle_update_diff_base); + client.add_entity_message_handler(Self::handle_buffer_reloaded); + client.add_entity_message_handler(Self::handle_buffer_saved); + client.add_entity_message_handler(Self::handle_update_buffer_file); + client.add_entity_request_handler(Self::handle_save_buffer); + client.add_entity_request_handler(Self::handle_blame_buffer); + client.add_entity_request_handler(Self::handle_reload_buffers); + client.add_entity_request_handler(Self::handle_get_permalink_to_line); + client.add_entity_request_handler(Self::handle_get_staged_text); + client.add_entity_message_handler(Self::handle_update_diff_base); } /// Creates a buffer store, optionally retaining its buffers. diff --git a/crates/project/src/debounced_delay.rs b/crates/project/src/debounced_delay.rs index f54026bbd3..6e5767c522 100644 --- a/crates/project/src/debounced_delay.rs +++ b/crates/project/src/debounced_delay.rs @@ -35,7 +35,7 @@ impl DebouncedDelay { self.cancel_channel = Some(sender); let previous_task = self.task.take(); - self.task = Some(cx.spawn(move |model, mut cx| async move { + self.task = Some(cx.spawn(move |entity, mut cx| async move { let mut timer = cx.background_executor().timer(delay).fuse(); if let Some(previous_task) = previous_task { previous_task.await; @@ -46,7 +46,7 @@ impl DebouncedDelay { _ = timer => {} } - if let Ok(task) = model.update(&mut cx, |project, cx| (func)(project, cx)) { + if let Ok(task) = entity.update(&mut cx, |project, cx| (func)(project, cx)) { task.await; } })); diff --git a/crates/project/src/image_store.rs b/crates/project/src/image_store.rs index 1b5d47da76..84f6c7cd94 100644 --- a/crates/project/src/image_store.rs +++ b/crates/project/src/image_store.rs @@ -387,18 +387,18 @@ impl ImageStoreImpl for Entity { let LoadedBinaryFile { file, content } = load_file.await?; let image = create_gpui_image(content)?; - let model = cx.new(|cx| ImageItem { + let entity = cx.new(|cx| ImageItem { id: cx.entity_id().as_non_zero_u64().into(), file: file.clone(), image, reload_task: None, })?; - let image_id = cx.read_entity(&model, |model, _| model.id)?; + let image_id = cx.read_entity(&entity, |model, _| model.id)?; this.update(&mut cx, |this, cx| { image_store.update(cx, |image_store, cx| { - image_store.add_image(model.clone(), cx) + image_store.add_image(entity.clone(), cx) })??; this.local_image_ids_by_path.insert( ProjectPath { @@ -415,7 +415,7 @@ impl ImageStoreImpl for Entity { anyhow::Ok(()) })??; - Ok(model) + Ok(entity) }) } diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index f5097e6f8c..8fbae75515 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -2854,37 +2854,37 @@ struct CoreSymbol { impl LspStore { pub fn init(client: &AnyProtoClient) { - client.add_model_request_handler(Self::handle_multi_lsp_query); - client.add_model_request_handler(Self::handle_restart_language_servers); - client.add_model_request_handler(Self::handle_cancel_language_server_work); - client.add_model_message_handler(Self::handle_start_language_server); - client.add_model_message_handler(Self::handle_update_language_server); - client.add_model_message_handler(Self::handle_language_server_log); - client.add_model_message_handler(Self::handle_update_diagnostic_summary); - client.add_model_request_handler(Self::handle_format_buffers); - client.add_model_request_handler(Self::handle_resolve_completion_documentation); - client.add_model_request_handler(Self::handle_apply_code_action); - client.add_model_request_handler(Self::handle_inlay_hints); - client.add_model_request_handler(Self::handle_get_project_symbols); - client.add_model_request_handler(Self::handle_resolve_inlay_hint); - client.add_model_request_handler(Self::handle_open_buffer_for_symbol); - client.add_model_request_handler(Self::handle_refresh_inlay_hints); - client.add_model_request_handler(Self::handle_on_type_formatting); - client.add_model_request_handler(Self::handle_apply_additional_edits_for_completion); - client.add_model_request_handler(Self::handle_register_buffer_with_language_servers); - client.add_model_request_handler(Self::handle_rename_project_entry); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); - client.add_model_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_multi_lsp_query); + client.add_entity_request_handler(Self::handle_restart_language_servers); + client.add_entity_request_handler(Self::handle_cancel_language_server_work); + client.add_entity_message_handler(Self::handle_start_language_server); + client.add_entity_message_handler(Self::handle_update_language_server); + client.add_entity_message_handler(Self::handle_language_server_log); + client.add_entity_message_handler(Self::handle_update_diagnostic_summary); + client.add_entity_request_handler(Self::handle_format_buffers); + client.add_entity_request_handler(Self::handle_resolve_completion_documentation); + client.add_entity_request_handler(Self::handle_apply_code_action); + client.add_entity_request_handler(Self::handle_inlay_hints); + client.add_entity_request_handler(Self::handle_get_project_symbols); + client.add_entity_request_handler(Self::handle_resolve_inlay_hint); + client.add_entity_request_handler(Self::handle_open_buffer_for_symbol); + client.add_entity_request_handler(Self::handle_refresh_inlay_hints); + client.add_entity_request_handler(Self::handle_on_type_formatting); + client.add_entity_request_handler(Self::handle_apply_additional_edits_for_completion); + client.add_entity_request_handler(Self::handle_register_buffer_with_language_servers); + client.add_entity_request_handler(Self::handle_rename_project_entry); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); + client.add_entity_request_handler(Self::handle_lsp_command::); } pub fn as_remote(&self) -> Option<&RemoteLspStore> { diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 47515084d7..5827ef22e0 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -592,25 +592,25 @@ impl Project { Self::init_settings(cx); let client: AnyProtoClient = client.clone().into(); - client.add_model_message_handler(Self::handle_add_collaborator); - client.add_model_message_handler(Self::handle_update_project_collaborator); - client.add_model_message_handler(Self::handle_remove_collaborator); - client.add_model_message_handler(Self::handle_update_project); - client.add_model_message_handler(Self::handle_unshare_project); - client.add_model_request_handler(Self::handle_update_buffer); - client.add_model_message_handler(Self::handle_update_worktree); - client.add_model_request_handler(Self::handle_synchronize_buffers); + client.add_entity_message_handler(Self::handle_add_collaborator); + client.add_entity_message_handler(Self::handle_update_project_collaborator); + client.add_entity_message_handler(Self::handle_remove_collaborator); + client.add_entity_message_handler(Self::handle_update_project); + client.add_entity_message_handler(Self::handle_unshare_project); + client.add_entity_request_handler(Self::handle_update_buffer); + client.add_entity_message_handler(Self::handle_update_worktree); + client.add_entity_request_handler(Self::handle_synchronize_buffers); - client.add_model_request_handler(Self::handle_search_candidate_buffers); - client.add_model_request_handler(Self::handle_open_buffer_by_id); - client.add_model_request_handler(Self::handle_open_buffer_by_path); - client.add_model_request_handler(Self::handle_open_new_buffer); - client.add_model_message_handler(Self::handle_create_buffer_for_peer); + client.add_entity_request_handler(Self::handle_search_candidate_buffers); + client.add_entity_request_handler(Self::handle_open_buffer_by_id); + client.add_entity_request_handler(Self::handle_open_buffer_by_path); + client.add_entity_request_handler(Self::handle_open_new_buffer); + client.add_entity_message_handler(Self::handle_create_buffer_for_peer); - client.add_model_request_handler(Self::handle_stage); - client.add_model_request_handler(Self::handle_unstage); - client.add_model_request_handler(Self::handle_commit); - client.add_model_request_handler(Self::handle_open_commit_message_buffer); + client.add_entity_request_handler(Self::handle_stage); + client.add_entity_request_handler(Self::handle_unstage); + client.add_entity_request_handler(Self::handle_commit); + client.add_entity_request_handler(Self::handle_open_commit_message_buffer); WorktreeStore::init(&client); BufferStore::init(&client); @@ -893,13 +893,13 @@ impl Project { ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.lsp_store); ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.settings_observer); - ssh_proto.add_model_message_handler(Self::handle_create_buffer_for_peer); - ssh_proto.add_model_message_handler(Self::handle_update_worktree); - ssh_proto.add_model_message_handler(Self::handle_update_project); - ssh_proto.add_model_message_handler(Self::handle_toast); - ssh_proto.add_model_request_handler(Self::handle_language_server_prompt_request); - ssh_proto.add_model_message_handler(Self::handle_hide_toast); - ssh_proto.add_model_request_handler(Self::handle_update_buffer_from_ssh); + ssh_proto.add_entity_message_handler(Self::handle_create_buffer_for_peer); + ssh_proto.add_entity_message_handler(Self::handle_update_worktree); + ssh_proto.add_entity_message_handler(Self::handle_update_project); + ssh_proto.add_entity_message_handler(Self::handle_toast); + ssh_proto.add_entity_request_handler(Self::handle_language_server_prompt_request); + ssh_proto.add_entity_message_handler(Self::handle_hide_toast); + ssh_proto.add_entity_request_handler(Self::handle_update_buffer_from_ssh); BufferStore::init(&ssh_proto); LspStore::init(&ssh_proto); SettingsObserver::init(&ssh_proto); @@ -1110,17 +1110,19 @@ impl Project { .into_iter() .map(|s| match s { EntitySubscription::BufferStore(subscription) => { - subscription.set_model(&buffer_store, &mut cx) + subscription.set_entity(&buffer_store, &mut cx) } EntitySubscription::WorktreeStore(subscription) => { - subscription.set_model(&worktree_store, &mut cx) + subscription.set_entity(&worktree_store, &mut cx) } EntitySubscription::SettingsObserver(subscription) => { - subscription.set_model(&settings_observer, &mut cx) + subscription.set_entity(&settings_observer, &mut cx) + } + EntitySubscription::Project(subscription) => { + subscription.set_entity(&this, &mut cx) } - EntitySubscription::Project(subscription) => subscription.set_model(&this, &mut cx), EntitySubscription::LspStore(subscription) => { - subscription.set_model(&lsp_store, &mut cx) + subscription.set_entity(&lsp_store, &mut cx) } }) .collect::>(); @@ -1631,19 +1633,19 @@ impl Project { self.client_subscriptions.extend([ self.client .subscribe_to_entity(project_id)? - .set_model(&cx.entity(), &mut cx.to_async()), + .set_entity(&cx.entity(), &mut cx.to_async()), self.client .subscribe_to_entity(project_id)? - .set_model(&self.worktree_store, &mut cx.to_async()), + .set_entity(&self.worktree_store, &mut cx.to_async()), self.client .subscribe_to_entity(project_id)? - .set_model(&self.buffer_store, &mut cx.to_async()), + .set_entity(&self.buffer_store, &mut cx.to_async()), self.client .subscribe_to_entity(project_id)? - .set_model(&self.lsp_store, &mut cx.to_async()), + .set_entity(&self.lsp_store, &mut cx.to_async()), self.client .subscribe_to_entity(project_id)? - .set_model(&self.settings_observer, &mut cx.to_async()), + .set_entity(&self.settings_observer, &mut cx.to_async()), ]); self.buffer_store.update(cx, |buffer_store, cx| { diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs index 71d7f22b97..642418e3f1 100644 --- a/crates/project/src/project_settings.rs +++ b/crates/project/src/project_settings.rs @@ -240,7 +240,7 @@ pub struct SettingsObserver { /// upstream. impl SettingsObserver { pub fn init(client: &AnyProtoClient) { - client.add_model_message_handler(Self::handle_update_worktree_settings); + client.add_entity_message_handler(Self::handle_update_worktree_settings); } pub fn new_local( diff --git a/crates/project/src/task_store.rs b/crates/project/src/task_store.rs index 7fd3bd186c..925575c033 100644 --- a/crates/project/src/task_store.rs +++ b/crates/project/src/task_store.rs @@ -51,7 +51,7 @@ impl EventEmitter for TaskStore {} impl TaskStore { pub fn init(client: Option<&AnyProtoClient>) { if let Some(client) = client { - client.add_model_request_handler(Self::handle_task_context_for_location); + client.add_entity_request_handler(Self::handle_task_context_for_location); } } diff --git a/crates/project/src/toolchain_store.rs b/crates/project/src/toolchain_store.rs index 131cdfa726..4fc1134272 100644 --- a/crates/project/src/toolchain_store.rs +++ b/crates/project/src/toolchain_store.rs @@ -26,9 +26,9 @@ enum ToolchainStoreInner { impl EventEmitter for ToolchainStore {} impl ToolchainStore { pub fn init(client: &AnyProtoClient) { - client.add_model_request_handler(Self::handle_activate_toolchain); - client.add_model_request_handler(Self::handle_list_toolchains); - client.add_model_request_handler(Self::handle_active_toolchain); + client.add_entity_request_handler(Self::handle_activate_toolchain); + client.add_entity_request_handler(Self::handle_list_toolchains); + client.add_entity_request_handler(Self::handle_active_toolchain); } pub fn local( @@ -37,16 +37,16 @@ impl ToolchainStore { project_environment: Entity, cx: &mut Context, ) -> Self { - let model = cx.new(|_| LocalToolchainStore { + let entity = cx.new(|_| LocalToolchainStore { languages, worktree_store, project_environment, active_toolchains: Default::default(), }); - let subscription = cx.subscribe(&model, |_, _, e: &ToolchainStoreEvent, cx| { + let subscription = cx.subscribe(&entity, |_, _, e: &ToolchainStoreEvent, cx| { cx.emit(e.clone()) }); - Self(ToolchainStoreInner::Local(model, subscription)) + Self(ToolchainStoreInner::Local(entity, subscription)) } pub(super) fn remote(project_id: u64, client: AnyProtoClient, cx: &mut App) -> Self { Self(ToolchainStoreInner::Remote( diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs index 498b76659f..95d88384fe 100644 --- a/crates/project/src/worktree_store.rs +++ b/crates/project/src/worktree_store.rs @@ -72,13 +72,13 @@ impl EventEmitter for WorktreeStore {} impl WorktreeStore { pub fn init(client: &AnyProtoClient) { - client.add_model_request_handler(Self::handle_create_project_entry); - client.add_model_request_handler(Self::handle_copy_project_entry); - client.add_model_request_handler(Self::handle_delete_project_entry); - client.add_model_request_handler(Self::handle_expand_project_entry); - client.add_model_request_handler(Self::handle_expand_all_for_project_entry); - client.add_model_request_handler(Self::handle_git_branches); - client.add_model_request_handler(Self::handle_update_branch); + client.add_entity_request_handler(Self::handle_create_project_entry); + client.add_entity_request_handler(Self::handle_copy_project_entry); + client.add_entity_request_handler(Self::handle_delete_project_entry); + client.add_entity_request_handler(Self::handle_expand_project_entry); + client.add_entity_request_handler(Self::handle_expand_all_for_project_entry); + client.add_entity_request_handler(Self::handle_git_branches); + client.add_entity_request_handler(Self::handle_update_branch); } pub fn local(retain_worktrees: bool, fs: Arc) -> Self { diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index f1cc83f698..7baee66f69 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -445,9 +445,9 @@ impl ProjectPanel { show_scrollbar: !Self::should_autohide_scrollbar(cx), hide_scrollbar_task: None, vertical_scrollbar_state: ScrollbarState::new(scroll_handle.clone()) - .parent_model(&cx.entity()), + .parent_entity(&cx.entity()), horizontal_scrollbar_state: ScrollbarState::new(scroll_handle.clone()) - .parent_model(&cx.entity()), + .parent_entity(&cx.entity()), max_width_item_index: None, diagnostics: Default::default(), scroll_handle, diff --git a/crates/recent_projects/src/remote_servers.rs b/crates/recent_projects/src/remote_servers.rs index fc3e8bb17a..5b4e3f083a 100644 --- a/crates/recent_projects/src/remote_servers.rs +++ b/crates/recent_projects/src/remote_servers.rs @@ -1263,7 +1263,7 @@ impl RemoteServerProjects { state = new_state.clone(); } } - let scroll_state = state.scrollbar.parent_model(&cx.entity()); + let scroll_state = state.scrollbar.parent_entity(&cx.entity()); let connect_button = div() .id("ssh-connect-new-server-container") .track_focus(&state.add_new_server.focus_handle) diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs index d9af25173d..aa761e5f1c 100644 --- a/crates/remote_server/src/headless_project.rs +++ b/crates/remote_server/src/headless_project.rs @@ -185,21 +185,21 @@ impl HeadlessProject { client.add_request_handler(cx.weak_entity(), Self::handle_shutdown_remote_server); client.add_request_handler(cx.weak_entity(), Self::handle_ping); - client.add_model_request_handler(Self::handle_add_worktree); + client.add_entity_request_handler(Self::handle_add_worktree); client.add_request_handler(cx.weak_entity(), Self::handle_remove_worktree); - client.add_model_request_handler(Self::handle_open_buffer_by_path); - client.add_model_request_handler(Self::handle_open_new_buffer); - client.add_model_request_handler(Self::handle_find_search_candidates); - client.add_model_request_handler(Self::handle_open_server_settings); + client.add_entity_request_handler(Self::handle_open_buffer_by_path); + client.add_entity_request_handler(Self::handle_open_new_buffer); + client.add_entity_request_handler(Self::handle_find_search_candidates); + client.add_entity_request_handler(Self::handle_open_server_settings); - client.add_model_request_handler(BufferStore::handle_update_buffer); - client.add_model_message_handler(BufferStore::handle_close_buffer); + client.add_entity_request_handler(BufferStore::handle_update_buffer); + client.add_entity_message_handler(BufferStore::handle_close_buffer); - client.add_model_request_handler(Self::handle_stage); - client.add_model_request_handler(Self::handle_unstage); - client.add_model_request_handler(Self::handle_commit); - client.add_model_request_handler(Self::handle_open_commit_message_buffer); + client.add_entity_request_handler(Self::handle_stage); + client.add_entity_request_handler(Self::handle_unstage); + client.add_entity_request_handler(Self::handle_commit); + client.add_entity_request_handler(Self::handle_open_commit_message_buffer); client.add_request_handler( extensions.clone().downgrade(), diff --git a/crates/repl/src/notebook/cell.rs b/crates/repl/src/notebook/cell.rs index 4d674ac489..41f820a99e 100644 --- a/crates/repl/src/notebook/cell.rs +++ b/crates/repl/src/notebook/cell.rs @@ -127,7 +127,7 @@ impl Cell { } => { let source = source.join(""); - let model = cx.new(|cx| { + let entity = cx.new(|cx| { let markdown_parsing_task = { let languages = languages.clone(); let source = source.clone(); @@ -159,7 +159,7 @@ impl Cell { } }); - Cell::Markdown(model) + Cell::Markdown(entity) } nbformat::v4::Cell::Code { id, diff --git a/crates/rpc/src/proto_client.rs b/crates/rpc/src/proto_client.rs index 40e2a97d6a..205c572609 100644 --- a/crates/rpc/src/proto_client.rs +++ b/crates/rpc/src/proto_client.rs @@ -53,7 +53,7 @@ pub struct ProtoMessageHandlerSet { pub entity_types_by_message_type: HashMap, pub entities_by_type_and_remote_id: HashMap<(TypeId, u64), EntityMessageSubscriber>, pub entity_id_extractors: HashMap u64>, - pub models_by_message_type: HashMap, + pub entities_by_message_type: HashMap, pub message_handlers: HashMap, } @@ -71,7 +71,7 @@ pub type ProtoMessageHandler = Arc< impl ProtoMessageHandlerSet { pub fn clear(&mut self) { self.message_handlers.clear(); - self.models_by_message_type.clear(); + self.entities_by_message_type.clear(); self.entities_by_type_and_remote_id.clear(); self.entity_id_extractors.clear(); } @@ -79,10 +79,11 @@ impl ProtoMessageHandlerSet { fn add_message_handler( &mut self, message_type_id: TypeId, - model: gpui::AnyWeakEntity, + entity: gpui::AnyWeakEntity, handler: ProtoMessageHandler, ) { - self.models_by_message_type.insert(message_type_id, model); + self.entities_by_message_type + .insert(message_type_id, entity); let prev_handler = self.message_handlers.insert(message_type_id, handler); if prev_handler.is_some() { panic!("registered handler for the same message twice"); @@ -92,7 +93,7 @@ impl ProtoMessageHandlerSet { fn add_entity_message_handler( &mut self, message_type_id: TypeId, - model_type_id: TypeId, + entity_type_id: TypeId, entity_id_extractor: fn(&dyn AnyTypedEnvelope) -> u64, handler: ProtoMessageHandler, ) { @@ -100,7 +101,7 @@ impl ProtoMessageHandlerSet { .entry(message_type_id) .or_insert(entity_id_extractor); self.entity_types_by_message_type - .insert(message_type_id, model_type_id); + .insert(message_type_id, entity_type_id); let prev_handler = self.message_handlers.insert(message_type_id, handler); if prev_handler.is_some() { panic!("registered handler for the same message twice"); @@ -116,7 +117,7 @@ impl ProtoMessageHandlerSet { let payload_type_id = message.payload_type_id(); let mut this = this.lock(); let handler = this.message_handlers.get(&payload_type_id)?.clone(); - let entity = if let Some(entity) = this.models_by_message_type.get(&payload_type_id) { + let entity = if let Some(entity) = this.entities_by_message_type.get(&payload_type_id) { entity.upgrade()? } else { let extract_entity_id = *this.entity_id_extractors.get(&payload_type_id)?; @@ -207,7 +208,7 @@ impl AnyProtoClient { self.0.send(envelope, T::NAME) } - pub fn add_request_handler(&self, model: gpui::WeakEntity, handler: H) + pub fn add_request_handler(&self, entity: gpui::WeakEntity, handler: H) where M: RequestMessage, E: 'static, @@ -216,12 +217,12 @@ impl AnyProtoClient { { self.0.message_handler_set().lock().add_message_handler( TypeId::of::(), - model.into(), - Arc::new(move |model, envelope, client, cx| { - let model = model.downcast::().unwrap(); + entity.into(), + Arc::new(move |entity, envelope, client, cx| { + let entity = entity.downcast::().unwrap(); let envelope = envelope.into_any().downcast::>().unwrap(); let request_id = envelope.message_id(); - handler(model, *envelope, cx) + handler(entity, *envelope, cx) .then(move |result| async move { match result { Ok(response) => { @@ -239,7 +240,7 @@ impl AnyProtoClient { ) } - pub fn add_model_request_handler(&self, handler: H) + pub fn add_entity_request_handler(&self, handler: H) where M: EnvelopedMessage + RequestMessage + EntityMessage, E: 'static, @@ -247,7 +248,7 @@ impl AnyProtoClient { F: 'static + Future>, { let message_type_id = TypeId::of::(); - let model_type_id = TypeId::of::(); + let entity_type_id = TypeId::of::(); let entity_id_extractor = |envelope: &dyn AnyTypedEnvelope| { envelope .as_any() @@ -261,13 +262,13 @@ impl AnyProtoClient { .lock() .add_entity_message_handler( message_type_id, - model_type_id, + entity_type_id, entity_id_extractor, - Arc::new(move |model, envelope, client, cx| { - let model = model.downcast::().unwrap(); + Arc::new(move |entity, envelope, client, cx| { + let entity = entity.downcast::().unwrap(); let envelope = envelope.into_any().downcast::>().unwrap(); let request_id = envelope.message_id(); - handler(model, *envelope, cx) + handler(entity, *envelope, cx) .then(move |result| async move { match result { Ok(response) => { @@ -285,7 +286,7 @@ impl AnyProtoClient { ); } - pub fn add_model_message_handler(&self, handler: H) + pub fn add_entity_message_handler(&self, handler: H) where M: EnvelopedMessage + EntityMessage, E: 'static, @@ -293,7 +294,7 @@ impl AnyProtoClient { F: 'static + Future>, { let message_type_id = TypeId::of::(); - let model_type_id = TypeId::of::(); + let entity_type_id = TypeId::of::(); let entity_id_extractor = |envelope: &dyn AnyTypedEnvelope| { envelope .as_any() @@ -307,12 +308,12 @@ impl AnyProtoClient { .lock() .add_entity_message_handler( message_type_id, - model_type_id, + entity_type_id, entity_id_extractor, - Arc::new(move |model, envelope, _, cx| { - let model = model.downcast::().unwrap(); + Arc::new(move |entity, envelope, _, cx| { + let entity = entity.downcast::().unwrap(); let envelope = envelope.into_any().downcast::>().unwrap(); - handler(model, *envelope, cx).boxed_local() + handler(entity, *envelope, cx).boxed_local() }), ); } diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs index 35f872d0e8..3c40eecb2f 100644 --- a/crates/search/src/project_search.rs +++ b/crates/search/src/project_search.rs @@ -154,7 +154,7 @@ enum InputPanel { pub struct ProjectSearchView { workspace: WeakEntity, focus_handle: FocusHandle, - model: Entity, + entity: Entity, query_editor: Entity, replacement_editor: Entity, results_editor: Entity, @@ -337,7 +337,7 @@ impl Render for ProjectSearchView { .track_focus(&self.focus_handle(cx)) .child(self.results_editor.clone()) } else { - let model = self.model.read(cx); + let model = self.entity.read(cx); let has_no_results = model.no_results.unwrap_or(false); let is_search_underway = model.pending_search.is_some(); @@ -436,7 +436,7 @@ impl Item for ProjectSearchView { fn tab_content_text(&self, _: &Window, cx: &App) -> Option { let last_query: Option = self - .model + .entity .read(cx) .last_search_query_text .as_ref() @@ -520,7 +520,7 @@ impl Item for ProjectSearchView { where Self: Sized, { - let model = self.model.update(cx, |model, cx| model.clone(cx)); + let model = self.entity.update(cx, |model, cx| model.clone(cx)); Some(cx.new(|cx| Self::new(self.workspace.clone(), model, window, cx, None))) } @@ -585,14 +585,14 @@ impl Item for ProjectSearchView { impl ProjectSearchView { pub fn get_matches(&self, cx: &App) -> Vec> { - self.model.read(cx).match_ranges.clone() + self.entity.read(cx).match_ranges.clone() } fn toggle_filters(&mut self, cx: &mut Context) { self.filters_enabled = !self.filters_enabled; ActiveSettings::update_global(cx, |settings, cx| { settings.0.insert( - self.model.read(cx).project.downgrade(), + self.entity.read(cx).project.downgrade(), self.current_settings(), ); }); @@ -609,7 +609,7 @@ impl ProjectSearchView { self.search_options.toggle(option); ActiveSettings::update_global(cx, |settings, cx| { settings.0.insert( - self.model.read(cx).project.downgrade(), + self.entity.read(cx).project.downgrade(), self.current_settings(), ); }); @@ -620,19 +620,19 @@ impl ProjectSearchView { } fn replace_next(&mut self, _: &ReplaceNext, window: &mut Window, cx: &mut Context) { - if self.model.read(cx).match_ranges.is_empty() { + if self.entity.read(cx).match_ranges.is_empty() { return; } let Some(active_index) = self.active_match_index else { return; }; - let query = self.model.read(cx).active_query.clone(); + let query = self.entity.read(cx).active_query.clone(); if let Some(query) = query { let query = query.with_replacement(self.replacement(cx)); // TODO: Do we need the clone here? - let mat = self.model.read(cx).match_ranges[active_index].clone(); + let mat = self.entity.read(cx).match_ranges[active_index].clone(); self.results_editor.update(cx, |editor, cx| { editor.replace(&mat, &query, window, cx); }); @@ -647,13 +647,13 @@ impl ProjectSearchView { return; } - let Some(query) = self.model.read(cx).active_query.as_ref() else { + let Some(query) = self.entity.read(cx).active_query.as_ref() else { return; }; let query = query.clone().with_replacement(self.replacement(cx)); let match_ranges = self - .model + .entity .update(cx, |model, _| mem::take(&mut model.match_ranges)); if match_ranges.is_empty() { return; @@ -663,14 +663,14 @@ impl ProjectSearchView { editor.replace_all(&mut match_ranges.iter(), &query, window, cx); }); - self.model.update(cx, |model, _cx| { + self.entity.update(cx, |model, _cx| { model.match_ranges = match_ranges; }); } pub fn new( workspace: WeakEntity, - model: Entity, + entity: Entity, window: &mut Window, cx: &mut Context, settings: Option, @@ -691,17 +691,17 @@ impl ProjectSearchView { }; { - let model = model.read(cx); - project = model.project.clone(); - excerpts = model.excerpts.clone(); - if let Some(active_query) = model.active_query.as_ref() { + let entity = entity.read(cx); + project = entity.project.clone(); + excerpts = entity.excerpts.clone(); + if let Some(active_query) = entity.active_query.as_ref() { query_text = active_query.as_str().to_string(); replacement_text = active_query.replacement().map(ToOwned::to_owned); options = SearchOptions::from_query(active_query); } } - subscriptions.push(cx.observe_in(&model, window, |this, _, window, cx| { - this.model_changed(window, cx) + subscriptions.push(cx.observe_in(&entity, window, |this, _, window, cx| { + this.entity_changed(window, cx) })); let query_editor = cx.new(|cx| { @@ -796,8 +796,8 @@ impl ProjectSearchView { workspace, focus_handle, replacement_editor, - search_id: model.read(cx).search_id, - model, + search_id: entity.read(cx).search_id, + entity, query_editor, results_editor, search_options: options, @@ -810,7 +810,7 @@ impl ProjectSearchView { included_opened_only: false, _subscriptions: subscriptions, }; - this.model_changed(window, cx); + this.entity_changed(window, cx); this } @@ -826,8 +826,8 @@ impl ProjectSearchView { let weak_workspace = cx.entity().downgrade(); - let model = cx.new(|cx| ProjectSearch::new(workspace.project().clone(), cx)); - let search = cx.new(|cx| ProjectSearchView::new(weak_workspace, model, window, cx, None)); + let entity = cx.new(|cx| ProjectSearch::new(workspace.project().clone(), cx)); + let search = cx.new(|cx| ProjectSearchView::new(weak_workspace, entity, window, cx, None)); workspace.add_item_to_active_pane(Box::new(search.clone()), None, true, window, cx); search.update(cx, |search, cx| { search @@ -868,7 +868,7 @@ impl ProjectSearchView { let new_query = search_view.update(cx, |search_view, cx| { let new_query = search_view.build_search_query(cx); if new_query.is_some() { - if let Some(old_query) = search_view.model.read(cx).active_query.clone() { + if let Some(old_query) = search_view.entity.read(cx).active_query.clone() { search_view.query_editor.update(cx, |editor, cx| { editor.set_text(old_query.as_str(), window, cx); }); @@ -878,18 +878,16 @@ impl ProjectSearchView { new_query }); if let Some(new_query) = new_query { - let model = cx.new(|cx| { - let mut model = ProjectSearch::new(workspace.project().clone(), cx); - model.search(new_query, cx); - model + let entity = cx.new(|cx| { + let mut entity = ProjectSearch::new(workspace.project().clone(), cx); + entity.search(new_query, cx); + entity }); let weak_workspace = cx.entity().downgrade(); workspace.add_item_to_active_pane( - Box::new( - cx.new(|cx| { - ProjectSearchView::new(weak_workspace, model, window, cx, None) - }), - ), + Box::new(cx.new(|cx| { + ProjectSearchView::new(weak_workspace, entity, window, cx, None) + })), None, true, window, @@ -969,7 +967,7 @@ impl ProjectSearchView { fn search(&mut self, cx: &mut Context) { if let Some(query) = self.build_search_query(cx) { - self.model.update(cx, |model, cx| model.search(query, cx)); + self.entity.update(cx, |model, cx| model.search(query, cx)); } } @@ -1111,7 +1109,7 @@ impl ProjectSearchView { fn select_match(&mut self, direction: Direction, window: &mut Window, cx: &mut Context) { if let Some(index) = self.active_match_index { - let match_ranges = self.model.read(cx).match_ranges.clone(); + let match_ranges = self.entity.read(cx).match_ranges.clone(); if !EditorSettings::get_global(cx).search_wrap && ((direction == Direction::Next && index + 1 >= match_ranges.len()) @@ -1182,14 +1180,14 @@ impl ProjectSearchView { window.focus(&results_handle); } - fn model_changed(&mut self, window: &mut Window, cx: &mut Context) { - let match_ranges = self.model.read(cx).match_ranges.clone(); + fn entity_changed(&mut self, window: &mut Window, cx: &mut Context) { + let match_ranges = self.entity.read(cx).match_ranges.clone(); if match_ranges.is_empty() { self.active_match_index = None; } else { self.active_match_index = Some(0); self.update_match_index(cx); - let prev_search_id = mem::replace(&mut self.search_id, self.model.read(cx).search_id); + let prev_search_id = mem::replace(&mut self.search_id, self.entity.read(cx).search_id); let is_new_search = self.search_id != prev_search_id; self.results_editor.update(cx, |editor, cx| { if is_new_search { @@ -1219,7 +1217,7 @@ impl ProjectSearchView { fn update_match_index(&mut self, cx: &mut Context) { let results_editor = self.results_editor.read(cx); let new_index = active_match_index( - &self.model.read(cx).match_ranges, + &self.entity.read(cx).match_ranges, &results_editor.selections.newest_anchor().head(), &results_editor.buffer().read(cx).snapshot(cx), ); @@ -1324,7 +1322,7 @@ impl ProjectSearchView { fn move_focus_to_results(&mut self, window: &mut Window, cx: &mut Context) { if !self.results_editor.focus_handle(cx).is_focused(window) - && !self.model.read(cx).match_ranges.is_empty() + && !self.entity.read(cx).match_ranges.is_empty() { cx.stop_propagation(); self.focus_results_editor(window, cx) @@ -1454,7 +1452,7 @@ impl ProjectSearchBar { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { search_view.toggle_search_option(option, cx); - if search_view.model.read(cx).active_query.is_some() { + if search_view.entity.read(cx).active_query.is_some() { search_view.search(cx); } }); @@ -1505,7 +1503,7 @@ impl ProjectSearchBar { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { search_view.toggle_opened_only(window, cx); - if search_view.model.read(cx).active_query.is_some() { + if search_view.entity.read(cx).active_query.is_some() { search_view.search(cx); } }); @@ -1562,7 +1560,7 @@ impl ProjectSearchBar { ), ] { if editor.focus_handle(cx).is_focused(window) { - let new_query = search_view.model.update(cx, |model, cx| { + let new_query = search_view.entity.update(cx, |model, cx| { let project = model.project.clone(); if let Some(new_query) = project.update(cx, |project, _| { @@ -1606,12 +1604,12 @@ impl ProjectSearchBar { if editor.focus_handle(cx).is_focused(window) { if editor.read(cx).text(cx).is_empty() { if let Some(new_query) = search_view - .model + .entity .read(cx) .project .read(cx) .search_history(kind) - .current(search_view.model.read(cx).cursor(kind)) + .current(search_view.entity.read(cx).cursor(kind)) .map(str::to_string) { search_view.set_search_editor(kind, &new_query, window, cx); @@ -1619,7 +1617,7 @@ impl ProjectSearchBar { } } - if let Some(new_query) = search_view.model.update(cx, |model, cx| { + if let Some(new_query) = search_view.entity.update(cx, |model, cx| { let project = model.project.clone(); project.update(cx, |project, _| { project @@ -1806,13 +1804,13 @@ impl Render for ProjectSearchBar { }), ); - let limit_reached = search.model.read(cx).limit_reached; + let limit_reached = search.entity.read(cx).limit_reached; let match_text = search .active_match_index .and_then(|index| { let index = index + 1; - let match_quantity = search.model.read(cx).match_ranges.len(); + let match_quantity = search.entity.read(cx).match_ranges.len(); if match_quantity > 0 { debug_assert!(match_quantity >= index); if limit_reached { diff --git a/crates/ui/src/components/indent_guides.rs b/crates/ui/src/components/indent_guides.rs index c29c326c13..87c390ef77 100644 --- a/crates/ui/src/components/indent_guides.rs +++ b/crates/ui/src/components/indent_guides.rs @@ -47,14 +47,14 @@ pub struct IndentGuides { } pub fn indent_guides( - model: Entity, + entity: Entity, indent_size: Pixels, colors: IndentGuideColors, compute_indents_fn: impl Fn(&mut V, Range, &mut Window, &mut Context) -> SmallVec<[usize; 64]> + 'static, ) -> IndentGuides { let compute_indents_fn = Box::new(move |range, window: &mut Window, cx: &mut App| { - model.update(cx, |this, cx| compute_indents_fn(this, range, window, cx)) + entity.update(cx, |this, cx| compute_indents_fn(this, range, window, cx)) }); IndentGuides { colors, @@ -78,7 +78,7 @@ impl IndentGuides { /// Sets a custom callback that will be called when the indent guides need to be rendered. pub fn with_render_fn( mut self, - model: Entity, + entity: Entity, render_fn: impl Fn( &mut V, RenderIndentGuideParams, @@ -88,7 +88,7 @@ impl IndentGuides { + 'static, ) -> Self { let render_fn = move |params, window: &mut Window, cx: &mut App| { - model.update(cx, |this, cx| render_fn(this, params, window, cx)) + entity.update(cx, |this, cx| render_fn(this, params, window, cx)) }; self.render_fn = Some(Box::new(render_fn)); self diff --git a/crates/ui/src/components/scrollbar.rs b/crates/ui/src/components/scrollbar.rs index 6db51f65c4..a9793adea8 100644 --- a/crates/ui/src/components/scrollbar.rs +++ b/crates/ui/src/components/scrollbar.rs @@ -114,7 +114,7 @@ impl ScrollbarState { } /// Set a parent model which should be notified whenever this Scrollbar gets a scroll event. - pub fn parent_model(mut self, v: &Entity) -> Self { + pub fn parent_entity(mut self, v: &Entity) -> Self { self.parent_id = Some(v.entity_id()); self } diff --git a/crates/vim/src/test/vim_test_context.rs b/crates/vim/src/test/vim_test_context.rs index a9b9f40352..7e24756c23 100644 --- a/crates/vim/src/test/vim_test_context.rs +++ b/crates/vim/src/test/vim_test_context.rs @@ -95,14 +95,14 @@ impl VimTestContext { Self { cx } } - pub fn update_entity(&mut self, model: Entity, update: F) -> R + pub fn update_entity(&mut self, entity: Entity, update: F) -> R where T: 'static, F: FnOnce(&mut T, &mut Window, &mut Context) -> R + 'static, { let window = self.window; self.update_window(window, move |_, window, cx| { - model.update(cx, |t, cx| update(t, window, cx)) + entity.update(cx, |t, cx| update(t, window, cx)) }) .unwrap() } @@ -131,7 +131,7 @@ impl VimTestContext { } pub fn mode(&mut self) -> Mode { - self.update_editor(|editor, _, cx| editor.addon::().unwrap().model.read(cx).mode) + self.update_editor(|editor, _, cx| editor.addon::().unwrap().entity.read(cx).mode) } pub fn active_operator(&mut self) -> Option { @@ -139,7 +139,7 @@ impl VimTestContext { editor .addon::() .unwrap() - .model + .entity .read(cx) .operator_stack .last() @@ -153,7 +153,7 @@ impl VimTestContext { self.update_editor(|editor, _window, _cx| editor.addon::().cloned().unwrap()); self.update(|window, cx| { - vim.model.update(cx, |vim, cx| { + vim.entity.update(cx, |vim, cx| { vim.switch_mode(mode, true, window, cx); }); }); diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs index f50da3afbb..1e47a08d2a 100644 --- a/crates/vim/src/vim.rs +++ b/crates/vim/src/vim.rs @@ -173,7 +173,7 @@ pub fn init(cx: &mut App) { .and_then(|item| item.act_as::(cx)) .and_then(|editor| editor.read(cx).addon::().cloned()); let Some(vim) = vim else { return }; - vim.model.update(cx, |_, cx| { + vim.entity.update(cx, |_, cx| { cx.defer_in(window, |vim, window, cx| vim.search_submit(window, cx)) }) }); @@ -183,12 +183,12 @@ pub fn init(cx: &mut App) { #[derive(Clone)] pub(crate) struct VimAddon { - pub(crate) model: Entity, + pub(crate) entity: Entity, } impl editor::Addon for VimAddon { fn extend_key_context(&self, key_context: &mut KeyContext, cx: &App) { - self.model.read(cx).extend_key_context(key_context, cx) + self.entity.read(cx).extend_key_context(key_context, cx) } fn to_any(&self) -> &dyn std::any::Any { @@ -298,7 +298,7 @@ impl Vim { if toggle { let is_relative = editor .addon::() - .map(|vim| vim.model.read(cx).mode != Mode::Insert); + .map(|vim| vim.entity.read(cx).mode != Mode::Insert); editor.set_relative_line_number(is_relative, cx) } else { editor.set_relative_line_number(None, cx) @@ -324,7 +324,9 @@ impl Vim { fn activate(editor: &mut Editor, window: &mut Window, cx: &mut Context) { let vim = Vim::new(window, cx); - editor.register_addon(VimAddon { model: vim.clone() }); + editor.register_addon(VimAddon { + entity: vim.clone(), + }); vim.update(cx, |_, cx| { Vim::action(editor, cx, |vim, action: &SwitchMode, window, cx| { diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs index a78d4b6adb..825a7cae99 100644 --- a/crates/workspace/src/item.rs +++ b/crates/workspace/src/item.rs @@ -1504,8 +1504,8 @@ pub mod test { _window: &mut Window, cx: &mut App, ) -> Task>> { - let model = cx.new(|cx| Self::new_deserialized(workspace_id, cx)); - Task::ready(Ok(model)) + let entity = cx.new(|cx| Self::new_deserialized(workspace_id, cx)); + Task::ready(Ok(entity)) } fn cleanup( diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index 098faf8897..f161501e23 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -2540,8 +2540,10 @@ impl Pane { let navigate_backward = IconButton::new("navigate_backward", IconName::ArrowLeft) .icon_size(IconSize::Small) .on_click({ - let model = cx.entity().clone(); - move |_, window, cx| model.update(cx, |pane, cx| pane.navigate_backward(window, cx)) + let entity = cx.entity().clone(); + move |_, window, cx| { + entity.update(cx, |pane, cx| pane.navigate_backward(window, cx)) + } }) .disabled(!self.can_navigate_backward()) .tooltip({ @@ -2554,8 +2556,8 @@ impl Pane { let navigate_forward = IconButton::new("navigate_forward", IconName::ArrowRight) .icon_size(IconSize::Small) .on_click({ - let model = cx.entity().clone(); - move |_, window, cx| model.update(cx, |pane, cx| pane.navigate_forward(window, cx)) + let entity = cx.entity().clone(); + move |_, window, cx| entity.update(cx, |pane, cx| pane.navigate_forward(window, cx)) }) .disabled(!self.can_navigate_forward()) .tooltip({ diff --git a/crates/zeta/src/zeta.rs b/crates/zeta/src/zeta.rs index 774183ec76..135a38297d 100644 --- a/crates/zeta/src/zeta.rs +++ b/crates/zeta/src/zeta.rs @@ -230,9 +230,9 @@ impl Zeta { cx: &mut App, ) -> Entity { let this = Self::global(cx).unwrap_or_else(|| { - let model = cx.new(|cx| Self::new(client, user_store, cx)); - cx.set_global(ZetaGlobal(model.clone())); - model + let entity = cx.new(|cx| Self::new(client, user_store, cx)); + cx.set_global(ZetaGlobal(entity.clone())); + entity }); this.update(cx, move |this, cx| {