diff --git a/crates/nu-cli/src/menus/help_completions.rs b/crates/nu-cli/src/menus/help_completions.rs index de381e0805..bb239dae36 100644 --- a/crates/nu-cli/src/menus/help_completions.rs +++ b/crates/nu-cli/src/menus/help_completions.rs @@ -57,7 +57,7 @@ impl NuHelpCompleter { let _ = write!(long_desc, "Usage:\r\n > {}\r\n", sig.call_signature()); if !sig.named.is_empty() { - long_desc.push_str(&get_flags_section(sig, |v| { + long_desc.push_str(&get_flags_section(Some(&*self.0.clone()), sig, |v| { v.into_string_parsable(", ", &self.0.config) })) } diff --git a/crates/nu-engine/src/documentation.rs b/crates/nu-engine/src/documentation.rs index 6ca56750c3..f29af455d7 100644 --- a/crates/nu-engine/src/documentation.rs +++ b/crates/nu-engine/src/documentation.rs @@ -1,7 +1,9 @@ +use nu_protocol::ast::{Argument, Expr, Expression}; use nu_protocol::{ ast::Call, engine::{EngineState, Stack}, - record, Category, Example, IntoPipelineData, PipelineData, Signature, Span, SyntaxShape, Value, + record, Category, Example, IntoPipelineData, PipelineData, Signature, Span, SyntaxShape, Type, + Value, }; use std::{collections::HashMap, fmt::Write}; @@ -68,10 +70,15 @@ fn get_documentation( ) -> String { // Create ansi colors //todo make these configurable -- pull from enginestate.config - const G: &str = "\x1b[32m"; // green - const C: &str = "\x1b[36m"; // cyan - // was const BB: &str = "\x1b[1;34m"; // bold blue - const BB: &str = "\x1b[94m"; // light blue (nobold, should be bolding the *names*) + let help_section_name: String = + get_ansi_color_for_component_or_default(engine_state, "shape_string", "\x1b[32m"); // default: green + + let help_subcolor_one: String = + get_ansi_color_for_component_or_default(engine_state, "shape_external", "\x1b[36m"); // default: cyan + // was const bb: &str = "\x1b[1;34m"; // bold blue + let help_subcolor_two: String = + get_ansi_color_for_component_or_default(engine_state, "shape_block", "\x1b[94m"); // default: light blue (nobold, should be bolding the *names*) + const RESET: &str = "\x1b[0m"; // reset let cmd_name = &sig.name; @@ -97,32 +104,40 @@ fn get_documentation( // Don't display removed/deprecated commands in the Subcommands list && !matches!(sig.category, Category::Removed) { - subcommands.push(format!(" {C}{}{RESET} - {}", sig.name, sig.usage)); + subcommands.push(format!( + " {help_subcolor_one}{}{RESET} - {}", + sig.name, sig.usage + )); } } } if !sig.search_terms.is_empty() { let text = format!( - "{G}Search terms{RESET}: {C}{}{}\n\n", + "{help_section_name}Search terms{RESET}: {help_subcolor_one}{}{}\n\n", sig.search_terms.join(", "), RESET ); let _ = write!(long_desc, "{text}"); } - let text = format!("{}Usage{}:\n > {}\n", G, RESET, sig.call_signature()); + let text = format!( + "{}Usage{}:\n > {}\n", + help_section_name, + RESET, + sig.call_signature() + ); let _ = write!(long_desc, "{text}"); if !subcommands.is_empty() { - let _ = write!(long_desc, "\n{G}Subcommands{RESET}:\n"); + let _ = write!(long_desc, "\n{help_section_name}Subcommands{RESET}:\n"); subcommands.sort(); long_desc.push_str(&subcommands.join("\n")); long_desc.push('\n'); } if !sig.named.is_empty() { - long_desc.push_str(&get_flags_section(sig, |v| { + long_desc.push_str(&get_flags_section(Some(engine_state), sig, |v| { nu_highlight_string( &v.into_string_parsable(", ", &engine_state.config), engine_state, @@ -135,12 +150,12 @@ fn get_documentation( || !sig.optional_positional.is_empty() || sig.rest_positional.is_some() { - let _ = write!(long_desc, "\n{G}Parameters{RESET}:\n"); + let _ = write!(long_desc, "\n{help_section_name}Parameters{RESET}:\n"); for positional in &sig.required_positional { let text = match &positional.shape { SyntaxShape::Keyword(kw, shape) => { format!( - " {C}\"{}\" + {RESET}<{BB}{}{RESET}>: {}", + " {help_subcolor_one}\"{}\" + {RESET}<{help_subcolor_two}{}{RESET}>: {}", String::from_utf8_lossy(kw), document_shape(*shape.clone()), positional.desc @@ -148,7 +163,7 @@ fn get_documentation( } _ => { format!( - " {C}{}{RESET} <{BB}{}{RESET}>: {}", + " {help_subcolor_one}{}{RESET} <{help_subcolor_two}{}{RESET}>: {}", positional.name, document_shape(positional.shape.clone()), positional.desc @@ -161,7 +176,7 @@ fn get_documentation( let text = match &positional.shape { SyntaxShape::Keyword(kw, shape) => { format!( - " {C}\"{}\" + {RESET}<{BB}{}{RESET}>: {} (optional)", + " {help_subcolor_one}\"{}\" + {RESET}<{help_subcolor_two}{}{RESET}>: {} (optional)", String::from_utf8_lossy(kw), document_shape(*shape.clone()), positional.desc @@ -182,7 +197,7 @@ fn get_documentation( }; format!( - " {C}{}{RESET} <{BB}{}{RESET}>: {}{}", + " {help_subcolor_one}{}{RESET} <{help_subcolor_two}{}{RESET}>: {}{}", positional.name, document_shape(positional.shape.clone()), positional.desc, @@ -195,7 +210,7 @@ fn get_documentation( if let Some(rest_positional) = &sig.rest_positional { let text = format!( - " ...{C}{}{RESET} <{BB}{}{RESET}>: {}", + " ...{help_subcolor_one}{}{RESET} <{help_subcolor_two}{}{RESET}>: {}", rest_positional.name, document_shape(rest_positional.shape.clone()), rest_positional.desc @@ -234,7 +249,7 @@ fn get_documentation( PipelineData::Value(Value::list(vals, span), None), ) { if let Ok((str, ..)) = result.collect_string_strict(span) { - let _ = writeln!(long_desc, "\n{G}Input/output types{RESET}:"); + let _ = writeln!(long_desc, "\n{help_section_name}Input/output types{RESET}:"); for line in str.lines() { let _ = writeln!(long_desc, " {line}"); } @@ -244,7 +259,7 @@ fn get_documentation( } if !examples.is_empty() { - let _ = write!(long_desc, "\n{G}Examples{RESET}:"); + let _ = write!(long_desc, "\n{help_section_name}Examples{RESET}:"); } for example in examples { @@ -318,6 +333,93 @@ fn get_documentation( } } +fn get_ansi_color_for_component_or_default( + engine_state: &EngineState, + theme_component: &str, + default: &str, +) -> String { + if let Some(color) = &engine_state.get_config().color_config.get(theme_component) { + let mut caller_stack = Stack::new(); + let span = Span::unknown(); + + let argument_opt = get_argument_for_color_value(engine_state, color, span); + + // Call ansi command using argument + if let Some(argument) = argument_opt { + if let Some(decl_id) = engine_state.find_decl(b"ansi", &[]) { + if let Ok(result) = eval_call( + engine_state, + &mut caller_stack, + &Call { + decl_id, + head: span, + arguments: vec![argument], + redirect_stdout: true, + redirect_stderr: true, + parser_info: HashMap::new(), + }, + PipelineData::Empty, + ) { + if let Ok((str, ..)) = result.collect_string_strict(span) { + return str; + } + } + } + } + } + + default.to_string() +} + +fn get_argument_for_color_value( + engine_state: &EngineState, + color: &&Value, + span: Span, +) -> Option { + match color { + Value::Record { val, .. } => { + let record_exp: Vec<(Expression, Expression)> = val + .into_iter() + .map(|(k, v)| { + ( + Expression { + expr: Expr::String(k.clone()), + span, + ty: Type::String, + custom_completion: None, + }, + Expression { + expr: Expr::String( + v.clone().into_string("", engine_state.get_config()), + ), + span, + ty: Type::String, + custom_completion: None, + }, + ) + }) + .collect(); + + Some(Argument::Positional(Expression { + span: Span::unknown(), + ty: Type::Record(vec![ + ("fg".to_string(), Type::String), + ("attr".to_string(), Type::String), + ]), + expr: Expr::Record(record_exp), + custom_completion: None, + })) + } + Value::String { val, .. } => Some(Argument::Positional(Expression { + span: Span::unknown(), + ty: Type::String, + expr: Expr::String(val.clone()), + custom_completion: None, + })), + _ => None, + } +} + // document shape helps showing more useful information pub fn document_shape(shape: SyntaxShape) -> SyntaxShape { match shape { @@ -327,6 +429,7 @@ pub fn document_shape(shape: SyntaxShape) -> SyntaxShape { } pub fn get_flags_section( + engine_state_opt: Option<&EngineState>, signature: &Signature, mut value_formatter: F, // format default Value (because some calls cant access config or nu-highlight) ) -> String @@ -334,18 +437,38 @@ where F: FnMut(&nu_protocol::Value) -> String, { //todo make these configurable -- pull from enginestate.config - const G: &str = "\x1b[32m"; // green - const C: &str = "\x1b[36m"; // cyan - // was const BB: &str = "\x1b[1;34m"; // bold blue - const BB: &str = "\x1b[94m"; // light blue (nobold, should be bolding the *names*) + let help_section_name: String; + let help_subcolor_one: String; + let help_subcolor_two: String; + + // Sometimes we want to get the flags without engine_state + // For example, in nu-plugin. In that case, we fall back on default values + if let Some(engine_state) = engine_state_opt { + help_section_name = + get_ansi_color_for_component_or_default(engine_state, "shape_string", "\x1b[32m"); // default: green + help_subcolor_one = + get_ansi_color_for_component_or_default(engine_state, "shape_external", "\x1b[36m"); // default: cyan + // was const bb: &str = "\x1b[1;34m"; // bold blue + help_subcolor_two = + get_ansi_color_for_component_or_default(engine_state, "shape_block", "\x1b[94m"); + // default: light blue (nobold, should be bolding the *names*) + } else { + help_section_name = "\x1b[32m".to_string(); + help_subcolor_one = "\x1b[36m".to_string(); + help_subcolor_two = "\x1b[94m".to_string(); + } + const RESET: &str = "\x1b[0m"; // reset const D: &str = "\x1b[39m"; // default let mut long_desc = String::new(); - let _ = write!(long_desc, "\n{G}Flags{RESET}:\n"); + let _ = write!(long_desc, "\n{help_section_name}Flags{RESET}:\n"); for flag in &signature.named { let default_str = if let Some(value) = &flag.default_value { - format!(" (default: {BB}{}{RESET})", &value_formatter(value)) + format!( + " (default: {help_subcolor_two}{}{RESET})", + &value_formatter(value) + ) } else { "".to_string() }; @@ -354,10 +477,10 @@ where if let Some(short) = flag.short { if flag.required { format!( - " {C}-{}{}{RESET} (required parameter) {:?} - {}{}\n", + " {help_subcolor_one}-{}{}{RESET} (required parameter) {:?} - {}{}\n", short, if !flag.long.is_empty() { - format!("{D},{RESET} {C}--{}", flag.long) + format!("{D},{RESET} {help_subcolor_one}--{}", flag.long) } else { "".into() }, @@ -367,10 +490,10 @@ where ) } else { format!( - " {C}-{}{}{RESET} <{BB}{:?}{RESET}> - {}{}\n", + " {help_subcolor_one}-{}{}{RESET} <{help_subcolor_two}{:?}{RESET}> - {}{}\n", short, if !flag.long.is_empty() { - format!("{D},{RESET} {C}--{}", flag.long) + format!("{D},{RESET} {help_subcolor_one}--{}", flag.long) } else { "".into() }, @@ -381,22 +504,22 @@ where } } else if flag.required { format!( - " {C}--{}{RESET} (required parameter) <{BB}{:?}{RESET}> - {}{}\n", + " {help_subcolor_one}--{}{RESET} (required parameter) <{help_subcolor_two}{:?}{RESET}> - {}{}\n", flag.long, arg, flag.desc, default_str, ) } else { format!( - " {C}--{}{RESET} <{BB}{:?}{RESET}> - {}{}\n", + " {help_subcolor_one}--{}{RESET} <{help_subcolor_two}{:?}{RESET}> - {}{}\n", flag.long, arg, flag.desc, default_str, ) } } else if let Some(short) = flag.short { if flag.required { format!( - " {C}-{}{}{RESET} (required parameter) - {}{}\n", + " {help_subcolor_one}-{}{}{RESET} (required parameter) - {}{}\n", short, if !flag.long.is_empty() { - format!("{D},{RESET} {C}--{}", flag.long) + format!("{D},{RESET} {help_subcolor_one}--{}", flag.long) } else { "".into() }, @@ -405,10 +528,10 @@ where ) } else { format!( - " {C}-{}{}{RESET} - {}{}\n", + " {help_subcolor_one}-{}{}{RESET} - {}{}\n", short, if !flag.long.is_empty() { - format!("{D},{RESET} {C}--{}", flag.long) + format!("{D},{RESET} {help_subcolor_one}--{}", flag.long) } else { "".into() }, @@ -418,11 +541,14 @@ where } } else if flag.required { format!( - " {C}--{}{RESET} (required parameter) - {}{}\n", + " {help_subcolor_one}--{}{RESET} (required parameter) - {}{}\n", flag.long, flag.desc, default_str, ) } else { - format!(" {C}--{}{RESET} - {}\n", flag.long, flag.desc) + format!( + " {help_subcolor_one}--{}{RESET} - {}\n", + flag.long, flag.desc + ) }; long_desc.push_str(&msg); } diff --git a/crates/nu-plugin/src/plugin/mod.rs b/crates/nu-plugin/src/plugin/mod.rs index eaebeaa492..a68bff60c3 100644 --- a/crates/nu-plugin/src/plugin/mod.rs +++ b/crates/nu-plugin/src/plugin/mod.rs @@ -385,7 +385,7 @@ fn print_help(plugin: &mut impl Plugin, encoder: impl PluginEncoder) { } }) .and_then(|_| { - let flags = get_flags_section(&signature.sig, |v| format!("{:#?}", v)); + let flags = get_flags_section(None, &signature.sig, |v| format!("{:#?}", v)); write!(help, "{flags}") }) .and_then(|_| writeln!(help, "\nParameters:")) diff --git a/crates/nu_plugin_query/src/query.rs b/crates/nu_plugin_query/src/query.rs index 2a374598fc..d0da236a4c 100644 --- a/crates/nu_plugin_query/src/query.rs +++ b/crates/nu_plugin_query/src/query.rs @@ -71,6 +71,8 @@ pub fn get_brief_subcommand_help(sigs: &[PluginSignature]) -> String { let _ = writeln!(help, " {} - {}", x.1.sig.name, x.1.sig.usage); } - help.push_str(&get_flags_section(&sigs[0].sig, |v| format!("{:#?}", v))); + help.push_str(&get_flags_section(None, &sigs[0].sig, |v| { + format!("{:#?}", v) + })); help }