extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-08-10 06:18:21 +02:00
Code Issues Packages Projects Releases Wiki Activity

REFACTOR: move the 0% commands to nu-cmd-extra (#9404)

Browse Source 
requires
- https://github.com/nushell/nushell/pull/9455

# ⚙️ Description
in this PR i move the commands we've all agreed, in the core team, to
move out of the core Nushell to the `extra` feature.

> **Warning**
> in the first commits here, i've
> - moved the implementations to `nu-cmd-extra`
> - removed the declaration of all the commands below from `nu-command`
> - made sure the commands were not available anymore with `cargo run --
-n`

## the list of commands to move
with the current command table downloaded as `commands.csv`, i've run
```bash
let commands = (
    open commands.csv
    | where is_plugin == "FALSE" and category != "deprecated"
    | select name category "approv. %"
    | rename name category approval
    | insert treated {|it| (
        ($it.approval == 100) or                # all the core team agreed on them
        ($it.name | str starts-with "bits") or  # see https://github.com/nushell/nushell/pull/9241
        ($it.name | str starts-with "dfr")      # see https://github.com/nushell/nushell/pull/9327
    )}
)
```
to preprocess them and then
```bash
$commands | where {|it| (not $it.treated) and ($it.approval == 0)}
```
to get all untreated commands with no approval, which gives
```
╭────┬───────────────┬─────────┬─────────────┬──────────╮
│  # │     name      │ treated │  category   │ approval │
├────┼───────────────┼─────────┼─────────────┼──────────┤
│  0 │ fmt           │ false   │ conversions │        0 │
│  1 │ each while    │ false   │ filters     │        0 │
│  2 │ roll          │ false   │ filters     │        0 │
│  3 │ roll down     │ false   │ filters     │        0 │
│  4 │ roll left     │ false   │ filters     │        0 │
│  5 │ roll right    │ false   │ filters     │        0 │
│  6 │ roll up       │ false   │ filters     │        0 │
│  7 │ rotate        │ false   │ filters     │        0 │
│  8 │ update cells  │ false   │ filters     │        0 │
│  9 │ decode hex    │ false   │ formats     │        0 │
│ 10 │ encode hex    │ false   │ formats     │        0 │
│ 11 │ from url      │ false   │ formats     │        0 │
│ 12 │ to html       │ false   │ formats     │        0 │
│ 13 │ ansi gradient │ false   │ platform    │        0 │
│ 14 │ ansi link     │ false   │ platform    │        0 │
│ 15 │ format        │ false   │ strings     │        0 │
╰────┴───────────────┴─────────┴─────────────┴──────────╯
```
# 🖌️ User-Facing Changes
```
$nothing
```

# 🧪 Tests + Formatting
- ⚫ `toolkit fmt`
- ⚫ `toolkit clippy`
- ⚫ `toolkit test`
- ⚫ `toolkit test stdlib`

# 📖 After Submitting
```
$nothing
```

# 🔍 For reviewers
```bash
$commands | where {|it| (not $it.treated) and ($it.approval == 0)} | each {|command|
    try {
        help $command.name | ignore
    } catch {|e|
        $"($command.name): ($e.msg)"
    }
}
```
should give no output in `cargo run --features extra -- -n` and a table
with 16 lines in `cargo run -- -n`
This commit is contained in:
Antoine Stevan
2023-07-06 17:31:31 +02:00
committed by GitHub
parent fbc1408913
commit 504eff73f0
56 changed files with 558 additions and 448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
crates/nu-command/src/platform/ansi/gradient.rs
View File

@ -1,329 +0,0 @@
use nu_ansi_term::{build_all_gradient_text, gradient::TargetGround, Gradient, Rgb};
use nu_engine::CallExt;
use nu_protocol::{
ast::Call, ast::CellPath, engine::Command, engine::EngineState, engine::Stack, Category,
Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
};
#[derive(Clone)]
pub struct SubCommand;
impl Command 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(
"cell path",
SyntaxShape::CellPath,
"for a data structure input, add a gradient to strings at the given cell paths",
)
.input_output_types(vec![
(Type::String, Type::String),
(Type::Table(vec![]), Type::Table(vec![])),
])
.vectorizes_over_list(true)
.allow_variants_without_examples(true)
.category(Category::Platform)
}
fn usage(&self) -> &str {
"Add a color gradient (using ANSI color codes) to the given string."
}
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
operate(engine_state, stack, call, input)
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
description: "draw text in a gradient with foreground start and end colors",
example:
"'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:
"'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:
"'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:
"'Hello, Nushell! This is a gradient.' | ansi gradient --fgend '0xe81cff'",
result: None,
},
]
}
}
fn value_to_color(v: Option<Value>) -> Result<Option<Rgb>, ShellError> {
let s = match v {
None => return Ok(None),
Some(x) => x.as_string()?,
};
Ok(Some(Rgb::from_hex_string(s)))
}
fn operate(
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let fgstart: Option<Value> = call.get_flag(engine_state, stack, "fgstart")?;
let fgend: Option<Value> = call.get_flag(engine_state, stack, "fgend")?;
let bgstart: Option<Value> = call.get_flag(engine_state, stack, "bgstart")?;
let bgend: Option<Value> = call.get_flag(engine_state, stack, "bgend")?;
let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
let fgs_hex = value_to_color(fgstart)?;
let fge_hex = value_to_color(fgend)?;
let bgs_hex = value_to_color(bgstart)?;
let bge_hex = value_to_color(bgend)?;
let head = call.head;
input.map(
move |v| {
if column_paths.is_empty() {
action(&v, fgs_hex, fge_hex, bgs_hex, bge_hex, &head)
} else {
let mut ret = v;
for path in &column_paths {
let r = ret.update_cell_path(
&path.members,
Box::new(move |old| action(old, fgs_hex, fge_hex, bgs_hex, bge_hex, &head)),
);
if let Err(error) = r {
return Value::Error {
error: Box::new(error),
};
}
}
ret
}
},
engine_state.ctrlc.clone(),
)
}
fn action(
input: &Value,
fg_start: Option<Rgb>,
fg_end: Option<Rgb>,
bg_start: Option<Rgb>,
bg_end: Option<Rgb>,
command_span: &Span,
) -> Value {
match input {
Value::String { val, span } => {
match (fg_start, fg_end, bg_start, bg_end) {
(None, None, None, None) => {
// Error - no colors
Value::Error {
error: Box::new(ShellError::MissingParameter {
param_name:
"please supply foreground and/or background color parameters".into(),
span: *command_span,
}),
}
}
(None, None, None, Some(bg_end)) => {
// Error - missing bg_start, so assume black
let bg_start = Rgb::new(0, 0, 0);
let gradient = Gradient::new(bg_start, bg_end);
let gradient_string = gradient.build(val, TargetGround::Background);
Value::string(gradient_string, *span)
}
(None, None, Some(bg_start), None) => {
// Error - missing bg_end, so assume black
let bg_end = Rgb::new(0, 0, 0);
let gradient = Gradient::new(bg_start, bg_end);
let gradient_string = gradient.build(val, TargetGround::Background);
Value::string(gradient_string, *span)
}
(None, None, Some(bg_start), Some(bg_end)) => {
// Background Only
let gradient = Gradient::new(bg_start, bg_end);
let gradient_string = gradient.build(val, TargetGround::Background);
Value::string(gradient_string, *span)
}
(None, Some(fg_end), None, None) => {
// Error - missing fg_start, so assume black
let fg_start = Rgb::new(0, 0, 0);
let gradient = Gradient::new(fg_start, fg_end);
let gradient_string = gradient.build(val, TargetGround::Foreground);
Value::string(gradient_string, *span)
}
(None, Some(fg_end), None, Some(bg_end)) => {
// missing fg_start and bg_start, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(None, Some(fg_end), Some(bg_start), None) => {
// Error - missing fg_start and bg_end
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(None, Some(fg_end), Some(bg_start), Some(bg_end)) => {
// Error - missing fg_start, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(Some(fg_start), None, None, None) => {
// Error - missing fg_end, so assume black
let fg_end = Rgb::new(0, 0, 0);
let gradient = Gradient::new(fg_start, fg_end);
let gradient_string = gradient.build(val, TargetGround::Foreground);
Value::string(gradient_string, *span)
}
(Some(fg_start), None, None, Some(bg_end)) => {
// Error - missing fg_end, bg_start, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(Some(fg_start), None, Some(bg_start), None) => {
// Error - missing fg_end, bg_end, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(Some(fg_start), None, Some(bg_start), Some(bg_end)) => {
// Error - missing fg_end, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(Some(fg_start), Some(fg_end), None, None) => {
// Foreground Only
let gradient = Gradient::new(fg_start, fg_end);
let gradient_string = gradient.build(val, TargetGround::Foreground);
Value::string(gradient_string, *span)
}
(Some(fg_start), Some(fg_end), None, Some(bg_end)) => {
// Error - missing bg_start, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(Some(fg_start), Some(fg_end), Some(bg_start), None) => {
// Error - missing bg_end, so assume black
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
(Some(fg_start), Some(fg_end), Some(bg_start), Some(bg_end)) => {
// Foreground and Background Gradient
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(val, fg_gradient, bg_gradient);
Value::string(gradient_string, *span)
}
}
}
other => {
let got = format!("value is {}, not string", other.get_type());
Value::Error {
error: Box::new(ShellError::TypeMismatch {
err_message: got,
span: other.span().unwrap_or(*command_span),
}),
}
}
}
}
#[cfg(test)]
mod tests {
use super::{action, SubCommand};
use nu_ansi_term::Rgb;
use nu_protocol::{Span, Value};
#[test]
fn examples_work_as_expected() {
use crate::test_examples;
test_examples(SubCommand {})
}
#[test]
fn test_fg_gradient() {
let input_string = Value::test_string("Hello, World!");
let expected = Value::test_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");
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,
Some(fg_start),
Some(fg_end),
None,
None,
&Span::test_data(),
);
assert_eq!(actual, expected);
}
}

167
crates/nu-command/src/platform/ansi/link.rs
View File

@ -1,167 +0,0 @@
use nu_engine::CallExt;
use nu_protocol::{
ast::{Call, CellPath},
engine::Command,
engine::EngineState,
engine::Stack,
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
Value,
};
#[derive(Clone)]
pub struct SubCommand;
impl Command for SubCommand {
fn name(&self) -> &str {
"ansi link"
}
fn signature(&self) -> Signature {
Signature::build("ansi link")
.input_output_types(vec![
(Type::String, Type::String),
(
Type::List(Box::new(Type::String)),
Type::List(Box::new(Type::String)),
),
(Type::Table(vec![]), Type::Table(vec![])),
(Type::Record(vec![]), Type::Record(vec![])),
])
.named(
"text",
SyntaxShape::String,
"Link text. Uses uri as text if absent. In case of
tables, records and lists applies this text to all elements",
Some('t'),
)
.rest(
"cell path",
SyntaxShape::CellPath,
"for a data structure input, add links to all strings at the given cell paths",
)
.vectorizes_over_list(true)
.allow_variants_without_examples(true)
.category(Category::Platform)
}
fn usage(&self) -> &str {
"Add a link (using OSC 8 escape sequence) to the given string."
}
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
operate(engine_state, stack, call, input)
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
description: "Create a link to open some file",
example: "'file:///file.txt' | ansi link --text 'Open Me!'",
result: Some(Value::string(
"\u{1b}]8;;file:///file.txt\u{1b}\\Open Me!\u{1b}]8;;\u{1b}\\",
Span::unknown(),
)),
},
Example {
description: "Create a link without text",
example: "'https://www.nushell.sh/' | ansi link",
result: Some(Value::string(
"\u{1b}]8;;https://www.nushell.sh/\u{1b}\\https://www.nushell.sh/\u{1b}]8;;\u{1b}\\",
Span::unknown(),
)),
},
Example {
description: "Format a table column into links",
example: "[[url text]; [https://example.com Text]] | ansi link url",
result: None,
},
]
}
}
fn operate(
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let text: Option<Spanned<String>> = call.get_flag(engine_state, stack, "text")?;
let text = text.map(|e| e.item);
let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
let command_span = call.head;
if column_paths.is_empty() {
input.map(
move |v| process_value(&v, &text, &command_span),
engine_state.ctrlc.clone(),
)
} else {
input.map(
move |v| process_each_path(v, &column_paths, &text, &command_span),
engine_state.ctrlc.clone(),
)
}
}
fn process_each_path(
mut value: Value,
column_paths: &Vec<CellPath>,
text: &Option<String>,
command_span: &Span,
) -> Value {
for path in column_paths {
let ret = value.update_cell_path(
&path.members,
Box::new(|v| process_value(v, text, command_span)),
);
if let Err(error) = ret {
return Value::Error {
error: Box::new(error),
};
}
}
value
}
fn process_value(value: &Value, text: &Option<String>, command_span: &Span) -> Value {
match value {
Value::String { val, span } => {
let text = text.as_deref().unwrap_or(val.as_str());
let result = add_osc_link(text, val.as_str());
Value::string(result, *span)
}
other => {
let got = format!("value is {}, not string", other.get_type());
Value::Error {
error: Box::new(ShellError::TypeMismatch {
err_message: got,
span: other.span().unwrap_or(*command_span),
}),
}
}
}
}
fn add_osc_link(text: &str, link: &str) -> String {
format!("\u{1b}]8;;{link}\u{1b}\\{text}\u{1b}]8;;\u{1b}\\")
}
#[cfg(test)]
mod tests {
use super::SubCommand;
#[test]
fn examples_work_as_expected() {
use crate::test_examples;
test_examples(SubCommand {})
}
}

4
crates/nu-command/src/platform/ansi/mod.rs
View File

@ -1,9 +1,5 @@
mod ansi_;
mod gradient;
mod link;
mod strip;
pub use ansi_::AnsiCommand as Ansi;
pub use gradient::SubCommand as AnsiGradient;
pub use link::SubCommand as AnsiLink;
pub use strip::SubCommand as AnsiStrip;

2
crates/nu-command/src/platform/mod.rs
View File

@ -7,7 +7,7 @@ mod kill;
mod sleep;
mod term_size;
pub use ansi::{Ansi, AnsiGradient, AnsiLink, AnsiStrip};
pub use ansi::{Ansi, AnsiStrip};
pub use clear::Clear;
pub use dir_info::{DirBuilder, DirInfo, FileInfo};
pub use du::Du;