use crate::prelude::*;
use nu_ansi_term::{build_all_gradient_text, gradient::TargetGround, Gradient, Rgb};
use nu_engine::WholeStreamCommand;
use nu_errors::ShellError;
use nu_protocol::ShellTypeName;
use nu_protocol::{Primitive, Signature, SyntaxShape, UntaggedValue, Value};
use nu_source::Tag;
pub struct SubCommand;
impl WholeStreamCommand for SubCommand {
fn name(&self) -> &str {
"ansi gradient"
}
fn signature(&self) -> Signature {
Signature::build("ansi gradient")
.named(
"fgstart",
SyntaxShape::String,
"foreground gradient start color in hex (0x123456)",
Some('a'),
)
.named(
"fgend",
SyntaxShape::String,
"foreground gradient end color in hex",
Some('b'),
)
.named(
"bgstart",
SyntaxShape::String,
"background gradient start color in hex",
Some('c'),
)
.named(
"bgend",
SyntaxShape::String,
"background gradient end color in hex",
Some('d'),
)
.rest(
"rest",
SyntaxShape::ColumnPath,
"optionally, draw gradients using text from column paths",
)
}
fn usage(&self) -> &str {
"draw text with a provided start and end code making a gradient"
}
fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
operate(args)
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
description: "draw text in a gradient with foreground start and end colors",
example:
"echo 'Hello, Nushell! This is a gradient.' | ansi gradient --fgstart 0x40c9ff --fgend 0xe81cff",
result: None,
},
Example {
description: "draw text in a gradient with foreground start and end colors and background start and end colors",
example:
"echo 'Hello, Nushell! This is a gradient.' | ansi gradient --fgstart 0x40c9ff --fgend 0xe81cff --bgstart 0xe81cff --bgend 0x40c9ff",
result: None,
},
Example {
description: "draw text in a gradient by specifying foreground start color - end color is assumed to be black",
example:
"echo 'Hello, Nushell! This is a gradient.' | ansi gradient --fgstart 0x40c9ff",
result: None,
},
Example {
description: "draw text in a gradient by specifying foreground end color - start color is assumed to be black",
example:
"echo 'Hello, Nushell! This is a gradient.' | ansi gradient --fgend 0xe81cff",
result: None,
},
]
}
}
fn operate(args: CommandArgs) -> Result<OutputStream, ShellError> {
let fgstart: Option<Value> = args.get_flag("fgstart")?;
let fgend: Option<Value> = args.get_flag("fgend")?;
let bgstart: Option<Value> = args.get_flag("bgstart")?;
let bgend: Option<Value> = args.get_flag("bgend")?;
let column_paths: Vec<_> = args.rest(0)?;
let fgs_hex = fgstart.map(|color| Rgb::from_hex_string(color.convert_to_string()));
let fge_hex = fgend.map(|color| Rgb::from_hex_string(color.convert_to_string()));
let bgs_hex = bgstart.map(|color| Rgb::from_hex_string(color.convert_to_string()));
let bge_hex = bgend.map(|color| Rgb::from_hex_string(color.convert_to_string()));
let result: Vec<Value> = args
.input
.map(move |v| {
if column_paths.is_empty() {
action(&v, v.tag(), fgs_hex, fge_hex, bgs_hex, bge_hex)
} else {
let mut ret = v;
for path in &column_paths {
ret = ret.swap_data_by_column_path(
path,
Box::new(move |old| {
action(old, old.tag(), fgs_hex, fge_hex, bgs_hex, bge_hex)
}),
)?;
}
Ok(ret)
}
})
.collect::<Result<Vec<Value>, _>>()?;
Ok(OutputStream::from_stream(result.into_iter()))
}
fn action(
input: &Value,
tag: impl Into<Tag>,
fg_start: Option<Rgb>,
fg_end: Option<Rgb>,
bg_start: Option<Rgb>,
bg_end: Option<Rgb>,
) -> Result<Value, ShellError> {
let tag = tag.into();
match &input.value {
UntaggedValue::Primitive(Primitive::String(astring)) => {
match (fg_start, fg_end, bg_start, bg_end) {
(None, None, None, None) => {
Err(ShellError::labeled_error(
"please supply color parameters",
"please supply foreground and/or background color parameters",
Tag::unknown(),
))
}
(None, None, None, Some(bg_end)) => {
let bg_start = Rgb::new(0, 0, 0);
let gradient = Gradient::new(bg_start, bg_end);
let gradient_string = gradient.build(astring, TargetGround::Background);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(None, None, Some(bg_start), None) => {
let bg_end = Rgb::new(0, 0, 0);
let gradient = Gradient::new(bg_start, bg_end);
let gradient_string = gradient.build(astring, TargetGround::Background);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(None, None, Some(bg_start), Some(bg_end)) => {
let gradient = Gradient::new(bg_start, bg_end);
let gradient_string = gradient.build(astring, TargetGround::Background);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(None, Some(fg_end), None, None) => {
let fg_start = Rgb::new(0, 0, 0);
let gradient = Gradient::new(fg_start, fg_end);
let gradient_string = gradient.build(astring, TargetGround::Foreground);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(None, Some(fg_end), None, Some(bg_end)) => {
let fg_start = Rgb::new(0, 0, 0);
let bg_start = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(None, Some(fg_end), Some(bg_start), None) => {
let fg_start = Rgb::new(0, 0, 0);
let bg_end = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(None, Some(fg_end), Some(bg_start), Some(bg_end)) => {
let fg_start = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), None, None, None) => {
let fg_end = Rgb::new(0, 0, 0);
let gradient = Gradient::new(fg_start, fg_end);
let gradient_string = gradient.build(astring, TargetGround::Foreground);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), None, None, Some(bg_end)) => {
let fg_end = Rgb::new(0, 0, 0);
let bg_start = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), None, Some(bg_start), None) => {
let fg_end = Rgb::new(0, 0, 0);
let bg_end = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), None, Some(bg_start), Some(bg_end)) => {
let fg_end = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), Some(fg_end), None, None) => {
let gradient = Gradient::new(fg_start, fg_end);
let gradient_string = gradient.build(astring, TargetGround::Foreground);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), Some(fg_end), None, Some(bg_end)) => {
let bg_start = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), Some(fg_end), Some(bg_start), None) => {
let bg_end = Rgb::new(0, 0, 0);
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
(Some(fg_start), Some(fg_end), Some(bg_start), Some(bg_end)) => {
let fg_gradient = Gradient::new(fg_start, fg_end);
let bg_gradient = Gradient::new(bg_start, bg_end);
let gradient_string =
build_all_gradient_text(astring, fg_gradient, bg_gradient);
Ok(UntaggedValue::string(gradient_string).into_value(tag))
}
}
}
other => {
let got = format!("got {}", other.type_name());
Err(ShellError::labeled_error(
"value is not string",
got,
tag.span,
))
}
}
}
#[cfg(test)]
mod tests {
use super::ShellError;
use super::{action, SubCommand};
use nu_ansi_term::Rgb;
use nu_protocol::UntaggedValue;
use nu_source::Tag;
#[test]
fn examples_work_as_expected() -> Result<(), ShellError> {
use crate::examples::test as test_examples;
test_examples(SubCommand {})
}
#[test]
fn test_fg_gradient() {
let input_string = UntaggedValue::string("Hello, World!").into_untagged_value();
let expected = UntaggedValue::string("\u{1b}[38;2;64;201;255mH\u{1b}[38;2;76;187;254me\u{1b}[38;2;89;174;254ml\u{1b}[38;2;102;160;254ml\u{1b}[38;2;115;147;254mo\u{1b}[38;2;128;133;254m,\u{1b}[38;2;141;120;254m \u{1b}[38;2;153;107;254mW\u{1b}[38;2;166;94;254mo\u{1b}[38;2;179;80;254mr\u{1b}[38;2;192;67;254ml\u{1b}[38;2;205;53;254md\u{1b}[38;2;218;40;254m!\u{1b}[0m").into_untagged_value();
let fg_start = Rgb::from_hex_string("0x40c9ff".to_string());
let fg_end = Rgb::from_hex_string("0xe81cff".to_string());
let actual = action(
&input_string,
Tag::unknown(),
Some(fg_start),
Some(fg_end),
None,
None,
)
.unwrap();
assert_eq!(actual, expected);
}
}