use std::rc::Rc; use crate::{settings_store::parse_json_with_comments, SettingsAssets};use anyhow::anyhow;use collections::{BTreeMap, HashMap, IndexMap};use gpui::{ Action, ActionBuildError, AppContext, InvalidKeystrokeError, KeyBinding, KeyBindingContextPredicate, NoAction, SharedString, KEYSTROKE_PARSE_EXPECTED_MESSAGE,};use schemars::{ gen::{SchemaGenerator, SchemaSettings}, schema::{ArrayValidation, InstanceType, Schema, SchemaObject, SubschemaValidation}, JsonSchema,};use serde::Deserialize;use serde_json::Value;use std::fmt::Write;use util::{asset_str, markdown::MarkdownString}; #[derive(Debug, Deserialize, Default, Clone, JsonSchema)]#[serde(transparent)]pub struct KeymapFile(Vec<KeymapSection>); #[derive(Debug, Deserialize, Default, Clone, JsonSchema)]pub struct KeymapSection { #[serde(default)] context: String, #[serde(default)] use_key_equivalents: bool, #[serde(default)] bindings: Option<BTreeMap<String, KeymapAction>>, #[serde(flatten)] unrecognized_fields: IndexMap<String, Value>,} impl KeymapSection { pub fn bindings(&self) -> impl Iterator<Item = (&String, &KeymapAction)> { self.bindings.iter().flatten() }} /// Keymap action as a JSON value, since it can either be null for no action, or the name of the/// action, or an array of the name of the action and the action input.////// Unlike the other deserializable types here, this doc-comment will not be included in the/// generated JSON schema, as it manually defines its `JsonSchema` impl. The actual schema used for/// it is automatically generated in `KeymapFile::generate_json_schema`.#[derive(Debug, Deserialize, Default, Clone)]#[serde(transparent)]pub struct KeymapAction(Value); impl std::fmt::Display for KeymapAction { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match &self.0 { Value::String(s) => write!(f, "{}", s), Value::Array(arr) => { let strings: Vec<String> = arr.iter().map(|v| v.to_string()).collect(); write!(f, "{}", strings.join(", ")) } _ => write!(f, "{}", self.0), } }} impl JsonSchema for KeymapAction { /// This is used when generating the JSON schema for the `KeymapAction` type, so that it can /// reference the keymap action schema. fn schema_name() -> String { "KeymapAction".into() } /// This schema will be replaced with the full action schema in /// `KeymapFile::generate_json_schema`. fn json_schema(_: &mut SchemaGenerator) -> Schema { Schema::Bool(true) }} #[derive(Debug)]#[must_use]pub enum KeymapFileLoadResult { Success { key_bindings: Vec<KeyBinding>, }, SomeFailedToLoad { key_bindings: Vec<KeyBinding>, error_message: MarkdownString, }, AllFailedToLoad { error_message: MarkdownString, }, JsonParseFailure { error: anyhow::Error, },} impl KeymapFile { pub fn parse(content: &str) -> anyhow::Result<Self> { parse_json_with_comments::<Self>(content) } pub fn load_asset(asset_path: &str, cx: &AppContext) -> anyhow::Result<Vec<KeyBinding>> { match Self::load(asset_str::<SettingsAssets>(asset_path).as_ref(), cx) { KeymapFileLoadResult::Success { key_bindings, .. } => Ok(key_bindings), KeymapFileLoadResult::SomeFailedToLoad { error_message, .. } | KeymapFileLoadResult::AllFailedToLoad { error_message } => Err(anyhow!( "Error loading built-in keymap \"{asset_path}\": {error_message}" )), KeymapFileLoadResult::JsonParseFailure { error } => Err(anyhow!( "JSON parse error in built-in keymap \"{asset_path}\": {error}" )), } } #[cfg(feature = "test-support")] pub fn load_asset_allow_partial_failure( asset_path: &str, cx: &AppContext, ) -> anyhow::Result<Vec<KeyBinding>> { match Self::load(asset_str::<SettingsAssets>(asset_path).as_ref(), cx) { KeymapFileLoadResult::Success { key_bindings, .. } | KeymapFileLoadResult::SomeFailedToLoad { key_bindings, .. } => Ok(key_bindings), KeymapFileLoadResult::AllFailedToLoad { error_message } => Err(anyhow!( "Error loading built-in keymap \"{asset_path}\": {error_message}" )), KeymapFileLoadResult::JsonParseFailure { error } => Err(anyhow!( "JSON parse error in built-in keymap \"{asset_path}\": {error}" )), } } #[cfg(feature = "test-support")] pub fn load_panic_on_failure(content: &str, cx: &AppContext) -> Vec<KeyBinding> { match Self::load(content, cx) { KeymapFileLoadResult::Success { key_bindings } => key_bindings, KeymapFileLoadResult::SomeFailedToLoad { error_message, .. } | KeymapFileLoadResult::AllFailedToLoad { error_message, .. } => { panic!("{error_message}"); } KeymapFileLoadResult::JsonParseFailure { error } => { panic!("JSON parse error: {error}"); } } } pub fn load(content: &str, cx: &AppContext) -> KeymapFileLoadResult { let key_equivalents = crate::key_equivalents::get_key_equivalents(&cx.keyboard_layout()); if content.is_empty() { return KeymapFileLoadResult::Success { key_bindings: Vec::new(), }; } let keymap_file = match parse_json_with_comments::<Self>(content) { Ok(keymap_file) => keymap_file, Err(error) => { return KeymapFileLoadResult::JsonParseFailure { error }; } }; // Accumulate errors in order to support partial load of user keymap in the presence of // errors in context and binding parsing. let mut errors = Vec::new(); let mut key_bindings = Vec::new(); for KeymapSection { context, use_key_equivalents, bindings, unrecognized_fields, } in keymap_file.0.iter() { let context_predicate: Option<Rc<KeyBindingContextPredicate>> = if context.is_empty() { None } else { match KeyBindingContextPredicate::parse(context) { Ok(context_predicate) => Some(context_predicate.into()), Err(err) => { // Leading space is to separate from the message indicating which section // the error occurred in. errors.push(( context, format!(" Parse error in section `context` field: {}", err), )); continue; } } }; let key_equivalents = if *use_key_equivalents { key_equivalents.as_ref() } else { None }; let mut section_errors = String::new(); if !unrecognized_fields.is_empty() { write!( section_errors, "\n\n - Unrecognized fields: {}", MarkdownString::inline_code(&format!("{:?}", unrecognized_fields.keys())) ) .unwrap(); } if let Some(bindings) = bindings { for binding in bindings { let (keystrokes, action) = binding; let result = Self::load_keybinding( keystrokes, action, context_predicate.clone(), key_equivalents, cx, ); match result { Ok(key_binding) => { key_bindings.push(key_binding); } Err(err) => { write!( section_errors, "\n\n - In binding {}, {err}", inline_code_string(keystrokes), ) .unwrap(); } } } } if !section_errors.is_empty() { errors.push((context, section_errors)) } } if errors.is_empty() { KeymapFileLoadResult::Success { key_bindings } } else { let mut error_message = "Errors in user keymap file.\n".to_owned(); for (context, section_errors) in errors { if context.is_empty() { write!(error_message, "\n\nIn section without context predicate:").unwrap() } else { write!( error_message, "\n\nIn section with {}:", MarkdownString::inline_code(&format!("context = \"{}\"", context)) ) .unwrap() } write!(error_message, "{section_errors}").unwrap(); } KeymapFileLoadResult::SomeFailedToLoad { key_bindings, error_message: MarkdownString(error_message), } } } fn load_keybinding( keystrokes: &str, action: &KeymapAction, context: Option<Rc<KeyBindingContextPredicate>>, key_equivalents: Option<&HashMap<char, char>>, cx: &AppContext, ) -> std::result::Result<KeyBinding, String> { let (build_result, action_input_string) = match &action.0 { Value::Array(items) => { if items.len() != 2 { return Err(format!( "expected two-element array of `[name, input]`. \ Instead found {}.", MarkdownString::inline_code(&action.0.to_string()) )); } let serde_json::Value::String(ref name) = items[0] else { return Err(format!( "expected two-element array of `[name, input]`, \ but the first element is not a string in {}.", MarkdownString::inline_code(&action.0.to_string()) )); }; let action_input = items[1].clone(); let action_input_string = action_input.to_string(); ( cx.build_action(&name, Some(action_input)), Some(action_input_string), ) } Value::String(name) => (cx.build_action(&name, None), None), Value::Null => (Ok(NoAction.boxed_clone()), None), _ => { return Err(format!( "expected two-element array of `[name, input]`. \ Instead found {}.", MarkdownString::inline_code(&action.0.to_string()) )); } }; let action = match build_result { Ok(action) => action, Err(ActionBuildError::NotFound { name }) => { return Err(format!( "didn't find an action named {}.", inline_code_string(&name) )) } Err(ActionBuildError::BuildError { name, error }) => match action_input_string { Some(action_input_string) => { return Err(format!( "can't build {} action from input value {}: {}", inline_code_string(&name), MarkdownString::inline_code(&action_input_string), MarkdownString::escape(&error.to_string()) )) } None => { return Err(format!( "can't build {} action - it requires input data via [name, input]: {}", inline_code_string(&name), MarkdownString::escape(&error.to_string()) )) } }, }; match KeyBinding::load(keystrokes, action, context, key_equivalents) { Ok(binding) => Ok(binding), Err(InvalidKeystrokeError { keystroke }) => Err(format!( "invalid keystroke {}. {}", inline_code_string(&keystroke), KEYSTROKE_PARSE_EXPECTED_MESSAGE )), } } pub fn generate_json_schema_for_registered_actions(cx: &mut AppContext) -> Value { let mut generator = SchemaSettings::draft07() .with(|settings| settings.option_add_null_type = false) .into_generator(); let action_schemas = cx.action_schemas(&mut generator); let deprecations = cx.action_deprecations(); KeymapFile::generate_json_schema(generator, action_schemas, deprecations) } fn generate_json_schema( generator: SchemaGenerator, action_schemas: Vec<(SharedString, Option<Schema>)>, deprecations: &HashMap<SharedString, SharedString>, ) -> serde_json::Value { fn set<I, O>(input: I) -> Option<O> where I: Into<O>, { Some(input.into()) } fn add_deprecation(schema_object: &mut SchemaObject, message: String) { schema_object.extensions.insert( // deprecationMessage is not part of the JSON Schema spec, // but json-language-server recognizes it. "deprecationMessage".to_owned(), Value::String(message), ); } fn add_deprecation_preferred_name(schema_object: &mut SchemaObject, new_name: &str) { add_deprecation(schema_object, format!("Deprecated, use {new_name}")); } fn add_description(schema_object: &mut SchemaObject, description: String) { schema_object .metadata .get_or_insert(Default::default()) .description = Some(description); } let empty_object: SchemaObject = SchemaObject { instance_type: set(InstanceType::Object), ..Default::default() }; // This is a workaround for a json-language-server issue where it matches the first // alternative that matches the value's shape and uses that for documentation. // // In the case of the array validations, it would even provide an error saying that the name // must match the name of the first alternative. let mut plain_action = SchemaObject { instance_type: set(InstanceType::String), const_value: Some(Value::String("".to_owned())), ..Default::default() }; let no_action_message = "No action named this."; add_description(&mut plain_action, no_action_message.to_owned()); add_deprecation(&mut plain_action, no_action_message.to_owned()); let mut matches_action_name = SchemaObject { const_value: Some(Value::String("".to_owned())), ..Default::default() }; let no_action_message = "No action named this that takes input."; add_description(&mut matches_action_name, no_action_message.to_owned()); add_deprecation(&mut matches_action_name, no_action_message.to_owned()); let action_with_input = SchemaObject { instance_type: set(InstanceType::Array), array: set(ArrayValidation { items: set(vec![ matches_action_name.into(), // Accept any value, as we want this to be the preferred match when there is a // typo in the name. Schema::Bool(true), ]), min_items: Some(2), max_items: Some(2), ..Default::default() }), ..Default::default() }; let mut keymap_action_alternatives = vec![plain_action.into(), action_with_input.into()]; for (name, action_schema) in action_schemas.iter() { let schema = if let Some(Schema::Object(schema)) = action_schema { Some(schema.clone()) } else { None }; let description = schema.as_ref().and_then(|schema| { schema .metadata .as_ref() .and_then(|metadata| metadata.description.clone()) }); let deprecation = if name == NoAction.name() { Some("null") } else { deprecations.get(name).map(|new_name| new_name.as_ref()) }; // Add an alternative for plain action names. let mut plain_action = SchemaObject { instance_type: set(InstanceType::String), const_value: Some(Value::String(name.to_string())), ..Default::default() }; if let Some(new_name) = deprecation { add_deprecation_preferred_name(&mut plain_action, new_name); } if let Some(description) = description.clone() { add_description(&mut plain_action, description); } keymap_action_alternatives.push(plain_action.into()); // Add an alternative for actions with data specified as a [name, data] array. // // When a struct with no deserializable fields is added with impl_actions! / // impl_actions_as! an empty object schema is produced. The action should be invoked // without data in this case. if let Some(schema) = schema { if schema != empty_object { let mut matches_action_name = SchemaObject { const_value: Some(Value::String(name.to_string())), ..Default::default() }; if let Some(description) = description.clone() { add_description(&mut matches_action_name, description.to_string()); } if let Some(new_name) = deprecation { add_deprecation_preferred_name(&mut matches_action_name, new_name); } let action_with_input = SchemaObject { instance_type: set(InstanceType::Array), array: set(ArrayValidation { items: set(vec![matches_action_name.into(), schema.into()]), min_items: Some(2), max_items: Some(2), ..Default::default() }), ..Default::default() }; keymap_action_alternatives.push(action_with_input.into()); } } } // Placing null first causes json-language-server to default assuming actions should be // null, so place it last. keymap_action_alternatives.push( SchemaObject { instance_type: set(InstanceType::Null), ..Default::default() } .into(), ); let action_schema = SchemaObject {Lines 1–500 of 549. Load more
use std::rc::Rc; use crate::{settings_store::parse_json_with_comments, SettingsAssets}; use anyhow::anyhow; use collections::{BTreeMap, HashMap, IndexMap}; use gpui::{ Action, ActionBuildError, AppContext, InvalidKeystrokeError, KeyBinding, KeyBindingContextPredicate, NoAction, SharedString, KEYSTROKE_PARSE_EXPECTED_MESSAGE, }; use schemars::{ gen::{SchemaGenerator, SchemaSettings}, schema::{ArrayValidation, InstanceType, Schema, SchemaObject, SubschemaValidation}, JsonSchema, }; use serde::Deserialize; use serde_json::Value; use std::fmt::Write; use util::{asset_str, markdown::MarkdownString}; #[derive(Debug, Deserialize, Default, Clone, JsonSchema)] #[serde(transparent)] pub struct KeymapFile(Vec<KeymapSection>); #[derive(Debug, Deserialize, Default, Clone, JsonSchema)] pub struct KeymapSection { #[serde(default)] context: String, #[serde(default)] use_key_equivalents: bool, #[serde(default)] bindings: Option<BTreeMap<String, KeymapAction>>, #[serde(flatten)] unrecognized_fields: IndexMap<String, Value>, } impl KeymapSection { pub fn bindings(&self) -> impl Iterator<Item = (&String, &KeymapAction)> { self.bindings.iter().flatten() } } /// Keymap action as a JSON value, since it can either be null for no action, or the name of the /// action, or an array of the name of the action and the action input. /// /// Unlike the other deserializable types here, this doc-comment will not be included in the /// generated JSON schema, as it manually defines its `JsonSchema` impl. The actual schema used for /// it is automatically generated in `KeymapFile::generate_json_schema`. #[derive(Debug, Deserialize, Default, Clone)] #[serde(transparent)] pub struct KeymapAction(Value); impl std::fmt::Display for KeymapAction { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match &self.0 { Value::String(s) => write!(f, "{}", s), Value::Array(arr) => { let strings: Vec<String> = arr.iter().map(|v| v.to_string()).collect(); write!(f, "{}", strings.join(", ")) } _ => write!(f, "{}", self.0), } } } impl JsonSchema for KeymapAction { /// This is used when generating the JSON schema for the `KeymapAction` type, so that it can /// reference the keymap action schema. fn schema_name() -> String { "KeymapAction".into() } /// This schema will be replaced with the full action schema in /// `KeymapFile::generate_json_schema`. fn json_schema(_: &mut SchemaGenerator) -> Schema { Schema::Bool(true) } } #[derive(Debug)] #[must_use] pub enum KeymapFileLoadResult { Success { key_bindings: Vec<KeyBinding>, }, SomeFailedToLoad { key_bindings: Vec<KeyBinding>, error_message: MarkdownString, }, AllFailedToLoad { error_message: MarkdownString, }, JsonParseFailure { error: anyhow::Error, }, } impl KeymapFile { pub fn parse(content: &str) -> anyhow::Result<Self> { parse_json_with_comments::<Self>(content) } pub fn load_asset(asset_path: &str, cx: &AppContext) -> anyhow::Result<Vec<KeyBinding>> { match Self::load(asset_str::<SettingsAssets>(asset_path).as_ref(), cx) { KeymapFileLoadResult::Success { key_bindings, .. } => Ok(key_bindings), KeymapFileLoadResult::SomeFailedToLoad { error_message, .. } | KeymapFileLoadResult::AllFailedToLoad { error_message } => Err(anyhow!( "Error loading built-in keymap \"{asset_path}\": {error_message}" )), KeymapFileLoadResult::JsonParseFailure { error } => Err(anyhow!( "JSON parse error in built-in keymap \"{asset_path}\": {error}" )), } } #[cfg(feature = "test-support")] pub fn load_asset_allow_partial_failure( asset_path: &str, cx: &AppContext, ) -> anyhow::Result<Vec<KeyBinding>> { match Self::load(asset_str::<SettingsAssets>(asset_path).as_ref(), cx) { KeymapFileLoadResult::Success { key_bindings, .. } | KeymapFileLoadResult::SomeFailedToLoad { key_bindings, .. } => Ok(key_bindings), KeymapFileLoadResult::AllFailedToLoad { error_message } => Err(anyhow!( "Error loading built-in keymap \"{asset_path}\": {error_message}" )), KeymapFileLoadResult::JsonParseFailure { error } => Err(anyhow!( "JSON parse error in built-in keymap \"{asset_path}\": {error}" )), } } #[cfg(feature = "test-support")] pub fn load_panic_on_failure(content: &str, cx: &AppContext) -> Vec<KeyBinding> { match Self::load(content, cx) { KeymapFileLoadResult::Success { key_bindings } => key_bindings, KeymapFileLoadResult::SomeFailedToLoad { error_message, .. } | KeymapFileLoadResult::AllFailedToLoad { error_message, .. } => { panic!("{error_message}"); } KeymapFileLoadResult::JsonParseFailure { error } => { panic!("JSON parse error: {error}"); } } } pub fn load(content: &str, cx: &AppContext) -> KeymapFileLoadResult { let key_equivalents = crate::key_equivalents::get_key_equivalents(&cx.keyboard_layout()); if content.is_empty() { return KeymapFileLoadResult::Success { key_bindings: Vec::new(), }; } let keymap_file = match parse_json_with_comments::<Self>(content) { Ok(keymap_file) => keymap_file, Err(error) => { return KeymapFileLoadResult::JsonParseFailure { error }; } }; // Accumulate errors in order to support partial load of user keymap in the presence of // errors in context and binding parsing. let mut errors = Vec::new(); let mut key_bindings = Vec::new(); for KeymapSection { context, use_key_equivalents, bindings, unrecognized_fields, } in keymap_file.0.iter() { let context_predicate: Option<Rc<KeyBindingContextPredicate>> = if context.is_empty() { None } else { match KeyBindingContextPredicate::parse(context) { Ok(context_predicate) => Some(context_predicate.into()), Err(err) => { // Leading space is to separate from the message indicating which section // the error occurred in. errors.push(( context, format!(" Parse error in section `context` field: {}", err), )); continue; } } }; let key_equivalents = if *use_key_equivalents { key_equivalents.as_ref() } else { None }; let mut section_errors = String::new(); if !unrecognized_fields.is_empty() { write!( section_errors, "\n\n - Unrecognized fields: {}", MarkdownString::inline_code(&format!("{:?}", unrecognized_fields.keys())) ) .unwrap(); } if let Some(bindings) = bindings { for binding in bindings { let (keystrokes, action) = binding; let result = Self::load_keybinding( keystrokes, action, context_predicate.clone(), key_equivalents, cx, ); match result { Ok(key_binding) => { key_bindings.push(key_binding); } Err(err) => { write!( section_errors, "\n\n - In binding {}, {err}", inline_code_string(keystrokes), ) .unwrap(); } } } } if !section_errors.is_empty() { errors.push((context, section_errors)) } } if errors.is_empty() { KeymapFileLoadResult::Success { key_bindings } } else { let mut error_message = "Errors in user keymap file.\n".to_owned(); for (context, section_errors) in errors { if context.is_empty() { write!(error_message, "\n\nIn section without context predicate:").unwrap() } else { write!( error_message, "\n\nIn section with {}:", MarkdownString::inline_code(&format!("context = \"{}\"", context)) ) .unwrap() } write!(error_message, "{section_errors}").unwrap(); } KeymapFileLoadResult::SomeFailedToLoad { key_bindings, error_message: MarkdownString(error_message), } } } fn load_keybinding( keystrokes: &str, action: &KeymapAction, context: Option<Rc<KeyBindingContextPredicate>>, key_equivalents: Option<&HashMap<char, char>>, cx: &AppContext, ) -> std::result::Result<KeyBinding, String> { let (build_result, action_input_string) = match &action.0 { Value::Array(items) => { if items.len() != 2 { return Err(format!( "expected two-element array of `[name, input]`. \ Instead found {}.", MarkdownString::inline_code(&action.0.to_string()) )); } let serde_json::Value::String(ref name) = items[0] else { return Err(format!( "expected two-element array of `[name, input]`, \ but the first element is not a string in {}.", MarkdownString::inline_code(&action.0.to_string()) )); }; let action_input = items[1].clone(); let action_input_string = action_input.to_string(); ( cx.build_action(&name, Some(action_input)), Some(action_input_string), ) } Value::String(name) => (cx.build_action(&name, None), None), Value::Null => (Ok(NoAction.boxed_clone()), None), _ => { return Err(format!( "expected two-element array of `[name, input]`. \ Instead found {}.", MarkdownString::inline_code(&action.0.to_string()) )); } }; let action = match build_result { Ok(action) => action, Err(ActionBuildError::NotFound { name }) => { return Err(format!( "didn't find an action named {}.", inline_code_string(&name) )) } Err(ActionBuildError::BuildError { name, error }) => match action_input_string { Some(action_input_string) => { return Err(format!( "can't build {} action from input value {}: {}", inline_code_string(&name), MarkdownString::inline_code(&action_input_string), MarkdownString::escape(&error.to_string()) )) } None => { return Err(format!( "can't build {} action - it requires input data via [name, input]: {}", inline_code_string(&name), MarkdownString::escape(&error.to_string()) )) } }, }; match KeyBinding::load(keystrokes, action, context, key_equivalents) { Ok(binding) => Ok(binding), Err(InvalidKeystrokeError { keystroke }) => Err(format!( "invalid keystroke {}. {}", inline_code_string(&keystroke), KEYSTROKE_PARSE_EXPECTED_MESSAGE )), } } pub fn generate_json_schema_for_registered_actions(cx: &mut AppContext) -> Value { let mut generator = SchemaSettings::draft07() .with(|settings| settings.option_add_null_type = false) .into_generator(); let action_schemas = cx.action_schemas(&mut generator); let deprecations = cx.action_deprecations(); KeymapFile::generate_json_schema(generator, action_schemas, deprecations) } fn generate_json_schema( generator: SchemaGenerator, action_schemas: Vec<(SharedString, Option<Schema>)>, deprecations: &HashMap<SharedString, SharedString>, ) -> serde_json::Value { fn set<I, O>(input: I) -> Option<O> where I: Into<O>, { Some(input.into()) } fn add_deprecation(schema_object: &mut SchemaObject, message: String) { schema_object.extensions.insert( // deprecationMessage is not part of the JSON Schema spec, // but json-language-server recognizes it. "deprecationMessage".to_owned(), Value::String(message), ); } fn add_deprecation_preferred_name(schema_object: &mut SchemaObject, new_name: &str) { add_deprecation(schema_object, format!("Deprecated, use {new_name}")); } fn add_description(schema_object: &mut SchemaObject, description: String) { schema_object .metadata .get_or_insert(Default::default()) .description = Some(description); } let empty_object: SchemaObject = SchemaObject { instance_type: set(InstanceType::Object), ..Default::default() }; // This is a workaround for a json-language-server issue where it matches the first // alternative that matches the value's shape and uses that for documentation. // // In the case of the array validations, it would even provide an error saying that the name // must match the name of the first alternative. let mut plain_action = SchemaObject { instance_type: set(InstanceType::String), const_value: Some(Value::String("".to_owned())), ..Default::default() }; let no_action_message = "No action named this."; add_description(&mut plain_action, no_action_message.to_owned()); add_deprecation(&mut plain_action, no_action_message.to_owned()); let mut matches_action_name = SchemaObject { const_value: Some(Value::String("".to_owned())), ..Default::default() }; let no_action_message = "No action named this that takes input."; add_description(&mut matches_action_name, no_action_message.to_owned()); add_deprecation(&mut matches_action_name, no_action_message.to_owned()); let action_with_input = SchemaObject { instance_type: set(InstanceType::Array), array: set(ArrayValidation { items: set(vec![ matches_action_name.into(), // Accept any value, as we want this to be the preferred match when there is a // typo in the name. Schema::Bool(true), ]), min_items: Some(2), max_items: Some(2), ..Default::default() }), ..Default::default() }; let mut keymap_action_alternatives = vec![plain_action.into(), action_with_input.into()]; for (name, action_schema) in action_schemas.iter() { let schema = if let Some(Schema::Object(schema)) = action_schema { Some(schema.clone()) } else { None }; let description = schema.as_ref().and_then(|schema| { schema .metadata .as_ref() .and_then(|metadata| metadata.description.clone()) }); let deprecation = if name == NoAction.name() { Some("null") } else { deprecations.get(name).map(|new_name| new_name.as_ref()) }; // Add an alternative for plain action names. let mut plain_action = SchemaObject { instance_type: set(InstanceType::String), const_value: Some(Value::String(name.to_string())), ..Default::default() }; if let Some(new_name) = deprecation { add_deprecation_preferred_name(&mut plain_action, new_name); } if let Some(description) = description.clone() { add_description(&mut plain_action, description); } keymap_action_alternatives.push(plain_action.into()); // Add an alternative for actions with data specified as a [name, data] array. // // When a struct with no deserializable fields is added with impl_actions! / // impl_actions_as! an empty object schema is produced. The action should be invoked // without data in this case. if let Some(schema) = schema { if schema != empty_object { let mut matches_action_name = SchemaObject { const_value: Some(Value::String(name.to_string())), ..Default::default() }; if let Some(description) = description.clone() { add_description(&mut matches_action_name, description.to_string()); } if let Some(new_name) = deprecation { add_deprecation_preferred_name(&mut matches_action_name, new_name); } let action_with_input = SchemaObject { instance_type: set(InstanceType::Array), array: set(ArrayValidation { items: set(vec![matches_action_name.into(), schema.into()]), min_items: Some(2), max_items: Some(2), ..Default::default() }), ..Default::default() }; keymap_action_alternatives.push(action_with_input.into()); } } } // Placing null first causes json-language-server to default assuming actions should be // null, so place it last. keymap_action_alternatives.push( SchemaObject { instance_type: set(InstanceType::Null), ..Default::default() } .into(), ); let action_schema = SchemaObject {