use crate::SharedString;use anyhow::{anyhow, Result};use collections::HashMap;pub use no_action::{is_no_action, NoAction};use serde_json::json;use std::{ any::{Any, TypeId}, fmt::Display,}; /// Actions are used to implement keyboard-driven UI./// When you declare an action, you can bind keys to the action in the keymap and/// listeners for that action in the element tree.////// To declare a list of simple actions, you can use the actions! macro, which defines a simple unit struct/// action for each listed action name in the given namespace./// ```rust/// actions!(editor, [MoveUp, MoveDown, MoveLeft, MoveRight, Newline]);/// ```/// More complex data types can also be actions, providing they implement Clone, PartialEq,/// and serde_derive::Deserialize./// Use `impl_actions!` to automatically implement the action in the given namespace./// ```/// #[derive(Clone, PartialEq, serde_derive::Deserialize)]/// pub struct SelectNext {/// pub replace_newest: bool,/// }/// impl_actions!(editor, [SelectNext]);/// ```////// If you want to control the behavior of the action trait manually, you can use the lower-level `#[register_action]`/// macro, which only generates the code needed to register your action before `main`.////// ```/// #[derive(gpui::private::serde::Deserialize, std::cmp::PartialEq, std::clone::Clone)]/// pub struct Paste {/// pub content: SharedString,/// }////// impl gpui::Action for Paste {/// ///.../// }/// register_action!(Paste);/// ```pub trait Action: 'static + Send { /// Clone the action into a new box fn boxed_clone(&self) -> Box<dyn Action>; /// Cast the action to the any type fn as_any(&self) -> &dyn Any; /// Do a partial equality check on this action and the other fn partial_eq(&self, action: &dyn Action) -> bool; /// Get the name of this action, for displaying in UI fn name(&self) -> &str; /// Get the name of this action for debugging fn debug_name() -> &'static str where Self: Sized; /// Build this action from a JSON value. This is used to construct actions from the keymap. /// A value of `{}` will be passed for actions that don't have any parameters. fn build(value: serde_json::Value) -> Result<Box<dyn Action>> where Self: Sized; /// Optional JSON schema for the action's input data. fn action_json_schema( _: &mut schemars::gen::SchemaGenerator, ) -> Option<schemars::schema::Schema> where Self: Sized, { None } /// A list of alternate, deprecated names for this action. fn deprecated_aliases() -> &'static [&'static str] where Self: Sized, { &[] }} impl std::fmt::Debug for dyn Action { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("dyn Action") .field("name", &self.name()) .finish() }} impl dyn Action { /// Get the type id of this action pub fn type_id(&self) -> TypeId { self.as_any().type_id() }} /// Error type for `Keystroke::parse`. This is used instead of `anyhow::Error` so that Zed can use/// markdown to display it.#[derive(Debug)]pub enum ActionBuildError { /// Indicates that an action with this name has not been registered. NotFound { /// Name of the action that was not found. name: String, }, /// Indicates that an error occurred while building the action, typically a JSON deserialization /// error. BuildError { /// Name of the action that was attempting to be built. name: String, /// Error that occurred while building the action. error: anyhow::Error, },} impl std::error::Error for ActionBuildError { fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { match self { ActionBuildError::NotFound { .. } => None, ActionBuildError::BuildError { error, .. } => error.source(), } }} impl Display for ActionBuildError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ActionBuildError::NotFound { name } => { write!(f, "Didn't find an action named \"{name}\"") } ActionBuildError::BuildError { name, error } => { write!(f, "Error while building action \"{name}\": {error}") } } }} type ActionBuilder = fn(json: serde_json::Value) -> anyhow::Result<Box<dyn Action>>; pub(crate) struct ActionRegistry { by_name: HashMap<SharedString, ActionData>, names_by_type_id: HashMap<TypeId, SharedString>, all_names: Vec<SharedString>, // So we can return a static slice. deprecations: HashMap<SharedString, SharedString>,} impl Default for ActionRegistry { fn default() -> Self { let mut this = ActionRegistry { by_name: Default::default(), names_by_type_id: Default::default(), all_names: Default::default(), deprecations: Default::default(), }; this.load_actions(); this }} struct ActionData { pub build: ActionBuilder, pub json_schema: fn(&mut schemars::gen::SchemaGenerator) -> Option<schemars::schema::Schema>,} /// This type must be public so that our macros can build it in other crates./// But this is an implementation detail and should not be used directly.#[doc(hidden)]pub struct MacroActionBuilder(pub fn() -> MacroActionData); /// This type must be public so that our macros can build it in other crates./// But this is an implementation detail and should not be used directly.#[doc(hidden)]pub struct MacroActionData { pub name: &'static str, pub aliases: &'static [&'static str], pub type_id: TypeId, pub build: ActionBuilder, pub json_schema: fn(&mut schemars::gen::SchemaGenerator) -> Option<schemars::schema::Schema>,} inventory::collect!(MacroActionBuilder); impl ActionRegistry { /// Load all registered actions into the registry. pub(crate) fn load_actions(&mut self) { for builder in inventory::iter::<MacroActionBuilder> { let action = builder.0(); self.insert_action(action); } } #[cfg(test)] pub(crate) fn load_action<A: Action>(&mut self) { self.insert_action(MacroActionData { name: A::debug_name(), aliases: A::deprecated_aliases(), type_id: TypeId::of::<A>(), build: A::build, json_schema: A::action_json_schema, }); } fn insert_action(&mut self, action: MacroActionData) { let name: SharedString = action.name.into(); self.by_name.insert( name.clone(), ActionData { build: action.build, json_schema: action.json_schema, }, ); for &alias in action.aliases { let alias: SharedString = alias.into(); self.by_name.insert( alias.clone(), ActionData { build: action.build, json_schema: action.json_schema, }, ); self.deprecations.insert(alias.clone(), name.clone()); self.all_names.push(alias); } self.names_by_type_id.insert(action.type_id, name.clone()); self.all_names.push(name); } /// Construct an action based on its name and optional JSON parameters sourced from the keymap. pub fn build_action_type(&self, type_id: &TypeId) -> Result<Box<dyn Action>> { let name = self .names_by_type_id .get(type_id) .ok_or_else(|| anyhow!("no action type registered for {:?}", type_id))? .clone(); Ok(self.build_action(&name, None)?) } /// Construct an action based on its name and optional JSON parameters sourced from the keymap. pub fn build_action( &self, name: &str, params: Option<serde_json::Value>, ) -> std::result::Result<Box<dyn Action>, ActionBuildError> { let build_action = self .by_name .get(name) .ok_or_else(|| ActionBuildError::NotFound { name: name.to_owned(), })? .build; (build_action)(params.unwrap_or_else(|| json!({}))).map_err(|e| { ActionBuildError::BuildError { name: name.to_owned(), error: e, } }) } pub fn all_action_names(&self) -> &[SharedString] { self.all_names.as_slice() } pub fn action_schemas( &self, generator: &mut schemars::gen::SchemaGenerator, ) -> Vec<(SharedString, Option<schemars::schema::Schema>)> { // Use the order from all_names so that the resulting schema has sensible order. self.all_names .iter() .map(|name| { let action_data = self .by_name .get(name) .expect("All actions in all_names should be registered"); (name.clone(), (action_data.json_schema)(generator)) }) .collect::<Vec<_>>() } pub fn action_deprecations(&self) -> &HashMap<SharedString, SharedString> { &self.deprecations }} /// Defines and registers unit structs that can be used as actions.////// To use more complex data types as actions, use `impl_actions!`#[macro_export]macro_rules! actions { ($namespace:path, [ $($name:ident),* $(,)? ]) => { $( // Unfortunately rust-analyzer doesn't display the name due to // https://github.com/rust-lang/rust-analyzer/issues/8092 #[doc = stringify!($name)] #[doc = "action generated by `gpui::actions!`"] #[derive(::std::clone::Clone,::std::cmp::PartialEq, ::std::default::Default)] pub struct $name; gpui::__impl_action!($namespace, $name, $name, fn build(_: gpui::private::serde_json::Value) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(Box::new(Self)) }, fn action_json_schema( _: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None } ); gpui::register_action!($name); )* };} /// Defines and registers a unit struct that can be used as an actions, with a name that differs/// from it's type name.////// To use more complex data types as actions, and rename them use `impl_action_as!`#[macro_export]macro_rules! action_as { ($namespace:path, $name:ident as $visual_name:ident) => { // Unfortunately rust-analyzer doesn't display the name due to // https://github.com/rust-lang/rust-analyzer/issues/8092 #[doc = stringify!($name)] #[doc = "action generated by `gpui::action_as!`"] #[derive( ::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug, ::std::cmp::PartialEq, )] pub struct $name; gpui::__impl_action!( $namespace, $name, $visual_name, fn build( _: gpui::private::serde_json::Value, ) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(Box::new(Self)) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None } ); gpui::register_action!($name); };} /// Defines and registers a unit struct that can be used as an action, with some deprecated aliases.#[macro_export]macro_rules! action_with_deprecated_aliases { ($namespace:path, $name:ident, [$($alias:literal),* $(,)?]) => { // Unfortunately rust-analyzer doesn't display the name due to // https://github.com/rust-lang/rust-analyzer/issues/8092 #[doc = stringify!($name)] #[doc = "action, generated by `gpui::action_with_deprecated_aliases!`"] #[derive( ::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug, ::std::cmp::PartialEq, )] pub struct $name; gpui::__impl_action!( $namespace, $name, $name, fn build( _: gpui::private::serde_json::Value, ) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(Box::new(Self)) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None }, fn deprecated_aliases() -> &'static [&'static str] { &[ $($alias),* ] } ); gpui::register_action!($name); };} /// Registers the action and implements the Action trait for any struct that implements Clone,/// Default, PartialEq, serde_deserialize::Deserialize, and schemars::JsonSchema.////// Fields and variants that don't make sense for user configuration should be annotated with/// #[serde(skip)].#[macro_export]macro_rules! impl_actions { ($namespace:path, [ $($name:ident),* $(,)? ]) => { $( gpui::__impl_action!($namespace, $name, $name, fn build(value: gpui::private::serde_json::Value) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(std::boxed::Box::new(gpui::private::serde_json::from_value::<Self>(value)?)) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { Some(<Self as gpui::private::schemars::JsonSchema>::json_schema( generator, )) } ); gpui::register_action!($name); )* };} /// Implements the Action trait for internal action structs that implement Clone, Default,/// PartialEq. The purpose of this is to conveniently define values that can be passed in `dyn/// Action`.////// These actions are internal and so are not registered and do not support deserialization.#[macro_export]macro_rules! impl_internal_actions { ($namespace:path, [ $($name:ident),* $(,)? ]) => { $( gpui::__impl_action!($namespace, $name, $name, fn build(value: gpui::private::serde_json::Value) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { gpui::Result::Err(gpui::private::anyhow::anyhow!( concat!( stringify!($namespace), "::", stringify!($visual_name), " is an internal action, so cannot be built from JSON." ))) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None } ); )* };} /// Implements the Action trait for a struct that implements Clone, Default, PartialEq, and/// serde_deserialize::Deserialize. Allows you to rename the action visually, without changing the/// struct's name.////// Fields and variants that don't make sense for user configuration should be annotated with/// #[serde(skip)].#[macro_export]macro_rules! impl_action_as { ($namespace:path, $name:ident as $visual_name:tt ) => { gpui::__impl_action!( $namespace, $name, $visual_name, fn build( value: gpui::private::serde_json::Value, ) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(std::boxed::Box::new( gpui::private::serde_json::from_value::<Self>(value)?, )) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { Some(<Self as gpui::private::schemars::JsonSchema>::json_schema( generator, )) } ); gpui::register_action!($name); };} #[doc(hidden)]#[macro_export]macro_rules! __impl_action { ($namespace:path, $name:ident, $visual_name:tt, $($items:item),*) => { impl gpui::Action for $name { fn name(&self) -> &'static str { concat!( stringify!($namespace), "::", stringify!($visual_name), ) }Lines 1–500 of 543. Load more
use crate::SharedString; use anyhow::{anyhow, Result}; use collections::HashMap; pub use no_action::{is_no_action, NoAction}; use serde_json::json; use std::{ any::{Any, TypeId}, fmt::Display, }; /// Actions are used to implement keyboard-driven UI. /// When you declare an action, you can bind keys to the action in the keymap and /// listeners for that action in the element tree. /// /// To declare a list of simple actions, you can use the actions! macro, which defines a simple unit struct /// action for each listed action name in the given namespace. /// ```rust /// actions!(editor, [MoveUp, MoveDown, MoveLeft, MoveRight, Newline]); /// ``` /// More complex data types can also be actions, providing they implement Clone, PartialEq, /// and serde_derive::Deserialize. /// Use `impl_actions!` to automatically implement the action in the given namespace. /// ``` /// #[derive(Clone, PartialEq, serde_derive::Deserialize)] /// pub struct SelectNext { /// pub replace_newest: bool, /// } /// impl_actions!(editor, [SelectNext]); /// ``` /// /// If you want to control the behavior of the action trait manually, you can use the lower-level `#[register_action]` /// macro, which only generates the code needed to register your action before `main`. /// /// ``` /// #[derive(gpui::private::serde::Deserialize, std::cmp::PartialEq, std::clone::Clone)] /// pub struct Paste { /// pub content: SharedString, /// } /// /// impl gpui::Action for Paste { /// ///... /// } /// register_action!(Paste); /// ``` pub trait Action: 'static + Send { /// Clone the action into a new box fn boxed_clone(&self) -> Box<dyn Action>; /// Cast the action to the any type fn as_any(&self) -> &dyn Any; /// Do a partial equality check on this action and the other fn partial_eq(&self, action: &dyn Action) -> bool; /// Get the name of this action, for displaying in UI fn name(&self) -> &str; /// Get the name of this action for debugging fn debug_name() -> &'static str where Self: Sized; /// Build this action from a JSON value. This is used to construct actions from the keymap. /// A value of `{}` will be passed for actions that don't have any parameters. fn build(value: serde_json::Value) -> Result<Box<dyn Action>> where Self: Sized; /// Optional JSON schema for the action's input data. fn action_json_schema( _: &mut schemars::gen::SchemaGenerator, ) -> Option<schemars::schema::Schema> where Self: Sized, { None } /// A list of alternate, deprecated names for this action. fn deprecated_aliases() -> &'static [&'static str] where Self: Sized, { &[] } } impl std::fmt::Debug for dyn Action { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("dyn Action") .field("name", &self.name()) .finish() } } impl dyn Action { /// Get the type id of this action pub fn type_id(&self) -> TypeId { self.as_any().type_id() } } /// Error type for `Keystroke::parse`. This is used instead of `anyhow::Error` so that Zed can use /// markdown to display it. #[derive(Debug)] pub enum ActionBuildError { /// Indicates that an action with this name has not been registered. NotFound { /// Name of the action that was not found. name: String, }, /// Indicates that an error occurred while building the action, typically a JSON deserialization /// error. BuildError { /// Name of the action that was attempting to be built. name: String, /// Error that occurred while building the action. error: anyhow::Error, }, } impl std::error::Error for ActionBuildError { fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { match self { ActionBuildError::NotFound { .. } => None, ActionBuildError::BuildError { error, .. } => error.source(), } } } impl Display for ActionBuildError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ActionBuildError::NotFound { name } => { write!(f, "Didn't find an action named \"{name}\"") } ActionBuildError::BuildError { name, error } => { write!(f, "Error while building action \"{name}\": {error}") } } } } type ActionBuilder = fn(json: serde_json::Value) -> anyhow::Result<Box<dyn Action>>; pub(crate) struct ActionRegistry { by_name: HashMap<SharedString, ActionData>, names_by_type_id: HashMap<TypeId, SharedString>, all_names: Vec<SharedString>, // So we can return a static slice. deprecations: HashMap<SharedString, SharedString>, } impl Default for ActionRegistry { fn default() -> Self { let mut this = ActionRegistry { by_name: Default::default(), names_by_type_id: Default::default(), all_names: Default::default(), deprecations: Default::default(), }; this.load_actions(); this } } struct ActionData { pub build: ActionBuilder, pub json_schema: fn(&mut schemars::gen::SchemaGenerator) -> Option<schemars::schema::Schema>, } /// This type must be public so that our macros can build it in other crates. /// But this is an implementation detail and should not be used directly. #[doc(hidden)] pub struct MacroActionBuilder(pub fn() -> MacroActionData); /// This type must be public so that our macros can build it in other crates. /// But this is an implementation detail and should not be used directly. #[doc(hidden)] pub struct MacroActionData { pub name: &'static str, pub aliases: &'static [&'static str], pub type_id: TypeId, pub build: ActionBuilder, pub json_schema: fn(&mut schemars::gen::SchemaGenerator) -> Option<schemars::schema::Schema>, } inventory::collect!(MacroActionBuilder); impl ActionRegistry { /// Load all registered actions into the registry. pub(crate) fn load_actions(&mut self) { for builder in inventory::iter::<MacroActionBuilder> { let action = builder.0(); self.insert_action(action); } } #[cfg(test)] pub(crate) fn load_action<A: Action>(&mut self) { self.insert_action(MacroActionData { name: A::debug_name(), aliases: A::deprecated_aliases(), type_id: TypeId::of::<A>(), build: A::build, json_schema: A::action_json_schema, }); } fn insert_action(&mut self, action: MacroActionData) { let name: SharedString = action.name.into(); self.by_name.insert( name.clone(), ActionData { build: action.build, json_schema: action.json_schema, }, ); for &alias in action.aliases { let alias: SharedString = alias.into(); self.by_name.insert( alias.clone(), ActionData { build: action.build, json_schema: action.json_schema, }, ); self.deprecations.insert(alias.clone(), name.clone()); self.all_names.push(alias); } self.names_by_type_id.insert(action.type_id, name.clone()); self.all_names.push(name); } /// Construct an action based on its name and optional JSON parameters sourced from the keymap. pub fn build_action_type(&self, type_id: &TypeId) -> Result<Box<dyn Action>> { let name = self .names_by_type_id .get(type_id) .ok_or_else(|| anyhow!("no action type registered for {:?}", type_id))? .clone(); Ok(self.build_action(&name, None)?) } /// Construct an action based on its name and optional JSON parameters sourced from the keymap. pub fn build_action( &self, name: &str, params: Option<serde_json::Value>, ) -> std::result::Result<Box<dyn Action>, ActionBuildError> { let build_action = self .by_name .get(name) .ok_or_else(|| ActionBuildError::NotFound { name: name.to_owned(), })? .build; (build_action)(params.unwrap_or_else(|| json!({}))).map_err(|e| { ActionBuildError::BuildError { name: name.to_owned(), error: e, } }) } pub fn all_action_names(&self) -> &[SharedString] { self.all_names.as_slice() } pub fn action_schemas( &self, generator: &mut schemars::gen::SchemaGenerator, ) -> Vec<(SharedString, Option<schemars::schema::Schema>)> { // Use the order from all_names so that the resulting schema has sensible order. self.all_names .iter() .map(|name| { let action_data = self .by_name .get(name) .expect("All actions in all_names should be registered"); (name.clone(), (action_data.json_schema)(generator)) }) .collect::<Vec<_>>() } pub fn action_deprecations(&self) -> &HashMap<SharedString, SharedString> { &self.deprecations } } /// Defines and registers unit structs that can be used as actions. /// /// To use more complex data types as actions, use `impl_actions!` #[macro_export] macro_rules! actions { ($namespace:path, [ $($name:ident),* $(,)? ]) => { $( // Unfortunately rust-analyzer doesn't display the name due to // https://github.com/rust-lang/rust-analyzer/issues/8092 #[doc = stringify!($name)] #[doc = "action generated by `gpui::actions!`"] #[derive(::std::clone::Clone,::std::cmp::PartialEq, ::std::default::Default)] pub struct $name; gpui::__impl_action!($namespace, $name, $name, fn build(_: gpui::private::serde_json::Value) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(Box::new(Self)) }, fn action_json_schema( _: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None } ); gpui::register_action!($name); )* }; } /// Defines and registers a unit struct that can be used as an actions, with a name that differs /// from it's type name. /// /// To use more complex data types as actions, and rename them use `impl_action_as!` #[macro_export] macro_rules! action_as { ($namespace:path, $name:ident as $visual_name:ident) => { // Unfortunately rust-analyzer doesn't display the name due to // https://github.com/rust-lang/rust-analyzer/issues/8092 #[doc = stringify!($name)] #[doc = "action generated by `gpui::action_as!`"] #[derive( ::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug, ::std::cmp::PartialEq, )] pub struct $name; gpui::__impl_action!( $namespace, $name, $visual_name, fn build( _: gpui::private::serde_json::Value, ) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(Box::new(Self)) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None } ); gpui::register_action!($name); }; } /// Defines and registers a unit struct that can be used as an action, with some deprecated aliases. #[macro_export] macro_rules! action_with_deprecated_aliases { ($namespace:path, $name:ident, [$($alias:literal),* $(,)?]) => { // Unfortunately rust-analyzer doesn't display the name due to // https://github.com/rust-lang/rust-analyzer/issues/8092 #[doc = stringify!($name)] #[doc = "action, generated by `gpui::action_with_deprecated_aliases!`"] #[derive( ::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug, ::std::cmp::PartialEq, )] pub struct $name; gpui::__impl_action!( $namespace, $name, $name, fn build( _: gpui::private::serde_json::Value, ) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(Box::new(Self)) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None }, fn deprecated_aliases() -> &'static [&'static str] { &[ $($alias),* ] } ); gpui::register_action!($name); }; } /// Registers the action and implements the Action trait for any struct that implements Clone, /// Default, PartialEq, serde_deserialize::Deserialize, and schemars::JsonSchema. /// /// Fields and variants that don't make sense for user configuration should be annotated with /// #[serde(skip)]. #[macro_export] macro_rules! impl_actions { ($namespace:path, [ $($name:ident),* $(,)? ]) => { $( gpui::__impl_action!($namespace, $name, $name, fn build(value: gpui::private::serde_json::Value) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(std::boxed::Box::new(gpui::private::serde_json::from_value::<Self>(value)?)) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { Some(<Self as gpui::private::schemars::JsonSchema>::json_schema( generator, )) } ); gpui::register_action!($name); )* }; } /// Implements the Action trait for internal action structs that implement Clone, Default, /// PartialEq. The purpose of this is to conveniently define values that can be passed in `dyn /// Action`. /// /// These actions are internal and so are not registered and do not support deserialization. #[macro_export] macro_rules! impl_internal_actions { ($namespace:path, [ $($name:ident),* $(,)? ]) => { $( gpui::__impl_action!($namespace, $name, $name, fn build(value: gpui::private::serde_json::Value) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { gpui::Result::Err(gpui::private::anyhow::anyhow!( concat!( stringify!($namespace), "::", stringify!($visual_name), " is an internal action, so cannot be built from JSON." ))) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { None } ); )* }; } /// Implements the Action trait for a struct that implements Clone, Default, PartialEq, and /// serde_deserialize::Deserialize. Allows you to rename the action visually, without changing the /// struct's name. /// /// Fields and variants that don't make sense for user configuration should be annotated with /// #[serde(skip)]. #[macro_export] macro_rules! impl_action_as { ($namespace:path, $name:ident as $visual_name:tt ) => { gpui::__impl_action!( $namespace, $name, $visual_name, fn build( value: gpui::private::serde_json::Value, ) -> gpui::Result<::std::boxed::Box<dyn gpui::Action>> { Ok(std::boxed::Box::new( gpui::private::serde_json::from_value::<Self>(value)?, )) }, fn action_json_schema( generator: &mut gpui::private::schemars::gen::SchemaGenerator, ) -> Option<gpui::private::schemars::schema::Schema> { Some(<Self as gpui::private::schemars::JsonSchema>::json_schema( generator, )) } ); gpui::register_action!($name); }; } #[doc(hidden)] #[macro_export] macro_rules! __impl_action { ($namespace:path, $name:ident, $visual_name:tt, $($items:item),*) => { impl gpui::Action for $name { fn name(&self) -> &'static str { concat!( stringify!($namespace), "::", stringify!($visual_name), ) }