2021-12-15 23:08:12 +00:00
|
|
|
mod char_;
|
2022-01-30 12:52:24 +00:00
|
|
|
mod detect_columns;
|
2022-06-25 21:35:23 +00:00
|
|
|
mod encode_decode;
|
2023-08-03 18:06:00 +00:00
|
|
|
mod format;
|
2024-03-26 05:57:55 +00:00
|
|
|
mod guess_width;
|
2021-11-15 18:27:15 +00:00
|
|
|
mod parse;
|
2021-10-09 01:02:01 +00:00
|
|
|
mod split;
|
2021-11-06 17:55:25 +00:00
|
|
|
mod str_;
|
2021-09-29 18:25:05 +00:00
|
|
|
|
2021-12-15 23:08:12 +00:00
|
|
|
pub use char_::Char;
|
2022-01-30 12:52:24 +00:00
|
|
|
pub use detect_columns::*;
|
2022-06-25 21:35:23 +00:00
|
|
|
pub use encode_decode::*;
|
2023-08-10 18:01:47 +00:00
|
|
|
pub use format::*;
|
2021-11-15 18:27:15 +00:00
|
|
|
pub use parse::*;
|
2021-10-09 01:02:01 +00:00
|
|
|
pub use split::*;
|
2021-11-06 17:55:25 +00:00
|
|
|
pub use str_::*;
|
2023-01-20 07:16:18 +00:00
|
|
|
|
Add `command_prelude` module (#12291)
# Description
When implementing a `Command`, one must also import all the types
present in the function signatures for `Command`. This makes it so that
we often import the same set of types in each command implementation
file. E.g., something like this:
```rust
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EngineState, Stack};
use nu_protocol::{
record, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
ShellError, Signature, Span, Type, Value,
};
```
This PR adds the `nu_engine::command_prelude` module which contains the
necessary and commonly used types to implement a `Command`:
```rust
// command_prelude.rs
pub use crate::CallExt;
pub use nu_protocol::{
ast::{Call, CellPath},
engine::{Command, EngineState, Stack},
record, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, IntoSpanned,
PipelineData, Record, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
};
```
This should reduce the boilerplate needed to implement a command and
also gives us a place to track the breadth of the `Command` API. I tried
to be conservative with what went into the prelude modules, since it
might be hard/annoying to remove items from the prelude in the future.
Let me know if something should be included or excluded.
2024-03-26 21:17:30 +00:00
|
|
|
use nu_engine::CallExt;
|
2024-01-11 15:19:48 +00:00
|
|
|
use nu_protocol::{
|
|
|
|
ast::Call,
|
|
|
|
engine::{EngineState, Stack, StateWorkingSet},
|
|
|
|
ShellError,
|
|
|
|
};
|
2023-01-20 07:16:18 +00:00
|
|
|
|
|
|
|
// For handling the grapheme_cluster related flags on some commands.
|
|
|
|
// This ensures the error messages are consistent.
|
2024-01-11 15:19:48 +00:00
|
|
|
pub fn grapheme_flags(
|
|
|
|
engine_state: &EngineState,
|
|
|
|
stack: &mut Stack,
|
|
|
|
call: &Call,
|
|
|
|
) -> Result<bool, ShellError> {
|
|
|
|
let g_flag = call.has_flag(engine_state, stack, "grapheme-clusters")?;
|
2023-01-20 07:16:18 +00:00
|
|
|
// Check for the other flags and produce errors if they exist.
|
2023-01-28 21:22:56 +00:00
|
|
|
// Note that Nushell already prevents nonexistent flags from being used with commands,
|
2023-01-20 07:16:18 +00:00
|
|
|
// so this function can be reused for both the --utf-8-bytes commands and the --code-points commands.
|
2024-01-11 15:19:48 +00:00
|
|
|
if g_flag && call.has_flag(engine_state, stack, "utf-8-bytes")? {
|
2023-03-06 10:31:07 +00:00
|
|
|
Err(ShellError::IncompatibleParametersSingle {
|
|
|
|
msg: "Incompatible flags: --grapheme-clusters (-g) and --utf-8-bytes (-b)".to_string(),
|
|
|
|
span: call.head,
|
|
|
|
})?
|
2023-01-20 07:16:18 +00:00
|
|
|
}
|
2024-01-11 15:19:48 +00:00
|
|
|
if g_flag && call.has_flag(engine_state, stack, "code-points")? {
|
2023-03-06 10:31:07 +00:00
|
|
|
Err(ShellError::IncompatibleParametersSingle {
|
|
|
|
msg: "Incompatible flags: --grapheme-clusters (-g) and --utf-8-bytes (-b)".to_string(),
|
|
|
|
span: call.head,
|
|
|
|
})?
|
2023-01-20 07:16:18 +00:00
|
|
|
}
|
|
|
|
// Grapheme cluster usage is decided by the non-default -g flag
|
|
|
|
Ok(g_flag)
|
|
|
|
}
|
2024-01-11 15:19:48 +00:00
|
|
|
|
|
|
|
// Const version of grapheme_flags
|
|
|
|
pub fn grapheme_flags_const(
|
|
|
|
working_set: &StateWorkingSet,
|
|
|
|
call: &Call,
|
|
|
|
) -> Result<bool, ShellError> {
|
|
|
|
let g_flag = call.has_flag_const(working_set, "grapheme-clusters")?;
|
|
|
|
if g_flag && call.has_flag_const(working_set, "utf-8-bytes")? {
|
|
|
|
Err(ShellError::IncompatibleParametersSingle {
|
|
|
|
msg: "Incompatible flags: --grapheme-clusters (-g) and --utf-8-bytes (-b)".to_string(),
|
|
|
|
span: call.head,
|
|
|
|
})?
|
|
|
|
}
|
|
|
|
if g_flag && call.has_flag_const(working_set, "code-points")? {
|
|
|
|
Err(ShellError::IncompatibleParametersSingle {
|
|
|
|
msg: "Incompatible flags: --grapheme-clusters (-g) and --utf-8-bytes (-b)".to_string(),
|
|
|
|
span: call.head,
|
|
|
|
})?
|
|
|
|
}
|
|
|
|
Ok(g_flag)
|
|
|
|
}
|