holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

A fill command to replace str lpad and str rpad (#7846)

Browse Source 
# Description

The point of this command is to allow you to be able to format ints,
floats, filesizes, and strings with an alignment, padding, and a fill
character, as strings. It's meant to take the place of `str lpad` and
`str rpad`.

```
> help fill
Fill and Align

Search terms: display, render, format, pad, align

Usage:
  > fill {flags}

Flags:
  -h, --help - Display the help message for this command
  -w, --width <Int> - The width of the output. Defaults to 1
  -a, --alignment <String> - The alignment of the output. Defaults to Left (Left(l), Right(r), Center(c/m), MiddleRight(cr/mr))
  -c, --character <String> - The character to fill with. Defaults to ' ' (space)

Signatures:
  <number> | fill -> <string>
  <string> | fill -> <string>

Examples:
  Fill a string on the left side to a width of 15 with the character '─'
  > 'nushell' | fill -a l -c '─' -w 15

  Fill a string on the right side to a width of 15 with the character '─'
  > 'nushell' | fill -a r -c '─' -w 15

  Fill a string on both sides to a width of 15 with the character '─'
  > 'nushell' | fill -a m -c '─' -w 15

  Fill a number on the left side to a width of 5 with the character '0'
  > 1 | fill --alignment right --character 0 --width 5

  Fill a filesize on the left side to a width of 5 with the character '0'
  > 1kib | fill --alignment middle --character 0 --width 10
```

![image](https://user-images.githubusercontent.com/343840/214133752-6fc93fa7-4003-4eb4-96ed-cd967312e244.png)

# User-Facing Changes

Deprecated `str lpad` and `str rpad`.

# Tests + Formatting

Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# After Submitting

If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
This commit is contained in:
Darren Schroeder
2023-02-09 14:56:52 -06:00
committed by GitHub
parent c31225fdcf
commit 00601f1835
13 changed files with 358 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
crates/nu-command/src/strings/str_/lpad.rs
View File

@ -1,165 +0,0 @@
use crate::input_handler::{operate, CmdArgument};
use nu_engine::CallExt;
use nu_protocol::ast::Call;
use nu_protocol::ast::CellPath;
use nu_protocol::engine::{Command, EngineState, Stack};
use nu_protocol::Category;
use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
struct Arguments {
length: Option<i64>,
character: Option<String>,
cell_paths: Option<Vec<CellPath>>,
}
impl CmdArgument for Arguments {
fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
self.cell_paths.take()
}
}
#[derive(Clone)]
pub struct SubCommand;
impl Command for SubCommand {
fn name(&self) -> &str {
"str lpad"
}
fn signature(&self) -> Signature {
Signature::build("str lpad")
.input_output_types(vec![(Type::String, Type::String)])
.vectorizes_over_list(true)
.required_named("length", SyntaxShape::Int, "length to pad to", Some('l'))
.required_named(
"character",
SyntaxShape::String,
"character to pad with",
Some('c'),
)
.rest(
"rest",
SyntaxShape::CellPath,
"For a data structure input, pad strings at the given cell paths",
)
.category(Category::Strings)
}
fn usage(&self) -> &str {
"Left-pad a string to a specific length"
}
fn search_terms(&self) -> Vec<&str> {
vec!["append", "truncate", "padding"]
}
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
let args = Arguments {
length: call.get_flag(engine_state, stack, "length")?,
character: call.get_flag(engine_state, stack, "character")?,
cell_paths,
};
if args.length.expect("this exists") < 0 {
return Err(ShellError::TypeMismatch(
String::from("The length of the string cannot be negative"),
call.head,
));
}
operate(action, args, input, call.head, engine_state.ctrlc.clone())
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
description: "Left-pad a string with asterisks until it's 10 characters wide",
example: "'nushell' | str lpad -l 10 -c '*'",
result: Some(Value::test_string("***nushell")),
},
Example {
description: "Left-pad a string with zeroes until it's 10 character wide",
example: "'123' | str lpad -l 10 -c '0'",
result: Some(Value::test_string("0000000123")),
},
Example {
description: "Use lpad to truncate a string to its last three characters",
example: "'123456789' | str lpad -l 3 -c '0'",
result: Some(Value::test_string("789")),
},
Example {
description: "Use lpad to pad Unicode",
example: "'▉' | str lpad -l 10 -c '▉'",
result: Some(Value::test_string("▉▉▉▉▉▉▉▉▉▉")),
},
]
}
}
fn action(
input: &Value,
Arguments {
character, length, ..
}: &Arguments,
head: Span,
) -> Value {
match &input {
Value::String { val, .. } => match length {
Some(x) => {
let s = *x as usize;
if s < val.len() {
Value::String {
val: val
.chars()
.rev()
.take(s)
.collect::<String>()
.chars()
.rev()
.collect::<String>(),
span: head,
}
} else {
let c = character.as_ref().expect("we already know this flag needs to exist because the command is type checked before we call the action function");
let mut res = c.repeat(s - val.chars().count());
res += val;
Value::String {
val: res,
span: head,
}
}
}
None => Value::Error {
error: ShellError::TypeMismatch(String::from("Length argument is missing"), head),
},
},
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_examples() {
use crate::test_examples;
test_examples(SubCommand {})
}
}

4
crates/nu-command/src/strings/str_/mod.rs
View File

@ -6,10 +6,8 @@ mod ends_with;
mod index_of;
mod join;
mod length;
mod lpad;
mod replace;
mod reverse;
mod rpad;
mod starts_with;
mod substring;
mod trim;
@ -22,10 +20,8 @@ pub use ends_with::SubCommand as StrEndswith;
pub use index_of::SubCommand as StrIndexOf;
pub use join::*;
pub use length::SubCommand as StrLength;
pub use lpad::SubCommand as StrLpad;
pub use replace::SubCommand as StrReplace;
pub use reverse::SubCommand as StrReverse;
pub use rpad::SubCommand as StrRpad;
pub use starts_with::SubCommand as StrStartsWith;
pub use substring::SubCommand as StrSubstring;
pub use trim::Trim as StrTrim;

157
crates/nu-command/src/strings/str_/rpad.rs
View File

@ -1,157 +0,0 @@
use crate::input_handler::{operate, CmdArgument};
use nu_engine::CallExt;
use nu_protocol::ast::Call;
use nu_protocol::ast::CellPath;
use nu_protocol::engine::{Command, EngineState, Stack};
use nu_protocol::Category;
use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
struct Arguments {
length: Option<i64>,
character: Option<String>,
cell_paths: Option<Vec<CellPath>>,
}
impl CmdArgument for Arguments {
fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
self.cell_paths.take()
}
}
#[derive(Clone)]
pub struct SubCommand;
impl Command for SubCommand {
fn name(&self) -> &str {
"str rpad"
}
fn signature(&self) -> Signature {
Signature::build("str rpad")
.input_output_types(vec![(Type::String, Type::String)])
.vectorizes_over_list(true)
.required_named("length", SyntaxShape::Int, "length to pad to", Some('l'))
.required_named(
"character",
SyntaxShape::String,
"character to pad with",
Some('c'),
)
.rest(
"rest",
SyntaxShape::CellPath,
"For a data structure input, pad strings at the given cell paths",
)
.category(Category::Strings)
}
fn usage(&self) -> &str {
"Right-pad a string to a specific length"
}
fn search_terms(&self) -> Vec<&str> {
vec!["append", "truncate", "padding"]
}
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
let args = Arguments {
length: call.get_flag(engine_state, stack, "length")?,
character: call.get_flag(engine_state, stack, "character")?,
cell_paths,
};
if args.length.expect("this exists") < 0 {
return Err(ShellError::TypeMismatch(
String::from("The length of the string cannot be negative"),
call.head,
));
}
operate(action, args, input, call.head, engine_state.ctrlc.clone())
}
fn examples(&self) -> Vec<Example> {
vec![
Example {
description: "Right-pad a string with asterisks until it's 10 characters wide",
example: "'nushell' | str rpad -l 10 -c '*'",
result: Some(Value::test_string("nushell***")),
},
Example {
description: "Right-pad a string with zeroes until it's 10 characters wide",
example: "'123' | str rpad -l 10 -c '0'",
result: Some(Value::test_string("1230000000")),
},
Example {
description: "Use rpad to truncate a string to its first three characters",
example: "'123456789' | str rpad -l 3 -c '0'",
result: Some(Value::test_string("123")),
},
Example {
description: "Use rpad to pad Unicode",
example: "'▉' | str rpad -l 10 -c '▉'",
result: Some(Value::test_string("▉▉▉▉▉▉▉▉▉▉")),
},
]
}
}
fn action(
input: &Value,
Arguments {
character, length, ..
}: &Arguments,
head: Span,
) -> Value {
match &input {
Value::String { val, .. } => match length {
Some(x) => {
let s = *x as usize;
if s < val.len() {
Value::String {
val: val.chars().take(s).collect::<String>(),
span: head,
}
} else {
let mut res = val.to_string();
res += &character.as_ref().expect("we already know this flag needs to exist because the command is type checked before we call the action function").repeat(s - val.chars().count());
Value::String {
val: res,
span: head,
}
}
}
None => Value::Error {
error: ShellError::TypeMismatch(String::from("Length argument is missing"), head),
},
},
Value::Error { .. } => input.clone(),
_ => Value::Error {
error: ShellError::OnlySupportsThisInputType(
"string".into(),
input.get_type().to_string(),
head,
input.expect_span(),
),
},
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_examples() {
use crate::test_examples;
test_examples(SubCommand {})
}
}