mirror of
https://github.com/nushell/nushell
synced 2025-01-04 09:18:57 +00:00
e4226def16
This commit extracts five new crates:
- nu-source, which contains the core source-code handling logic in Nu,
including Text, Span, and also the pretty.rs-based debug logic
- nu-parser, which is the parser and expander logic
- nu-protocol, which is the bulk of the types and basic conveniences
used by plugins
- nu-errors, which contains ShellError, ParseError and error handling
conveniences
- nu-textview, which is the textview plugin extracted into a crate
One of the major consequences of this refactor is that it's no longer
possible to `impl X for Spanned<Y>` outside of the `nu-source` crate, so
a lot of types became more concrete (Value became a concrete type
instead of Spanned<Value>, for example).
This also turned a number of inherent methods in the main nu crate into
plain functions (impl Value {} became a bunch of functions in the
`value` namespace in `crate::data::value`).
98 lines
2.5 KiB
Rust
98 lines
2.5 KiB
Rust
pub mod classified;
|
|
|
|
use crate::commands::classified::ClassifiedCommand;
|
|
use crate::hir::expand_external_tokens::ExternalTokensShape;
|
|
use crate::hir::syntax_shape::{expand_syntax, ExpandContext};
|
|
use crate::hir::tokens_iterator::TokensIterator;
|
|
use nu_errors::ParseError;
|
|
use nu_source::{b, DebugDocBuilder, HasSpan, PrettyDebug, Span, Spanned, Tag, Tagged};
|
|
|
|
// Classify this command as an external command, which doesn't give special meaning
|
|
// to nu syntactic constructs, and passes all arguments to the external command as
|
|
// strings.
|
|
pub(crate) fn external_command(
|
|
tokens: &mut TokensIterator,
|
|
context: &ExpandContext,
|
|
name: Tagged<&str>,
|
|
) -> Result<ClassifiedCommand, ParseError> {
|
|
let Spanned { item, span } = expand_syntax(&ExternalTokensShape, tokens, context)?.tokens;
|
|
|
|
Ok(ClassifiedCommand::External(ExternalCommand {
|
|
name: name.to_string(),
|
|
name_tag: name.tag(),
|
|
args: ExternalArgs {
|
|
list: item
|
|
.iter()
|
|
.map(|x| ExternalArg {
|
|
tag: x.span.into(),
|
|
arg: x.item.clone(),
|
|
})
|
|
.collect(),
|
|
span,
|
|
},
|
|
}))
|
|
}
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq)]
|
|
pub struct ExternalArg {
|
|
pub arg: String,
|
|
pub tag: Tag,
|
|
}
|
|
|
|
impl std::ops::Deref for ExternalArg {
|
|
type Target = str;
|
|
|
|
fn deref(&self) -> &str {
|
|
&self.arg
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq)]
|
|
pub struct ExternalArgs {
|
|
pub list: Vec<ExternalArg>,
|
|
pub span: Span,
|
|
}
|
|
|
|
impl ExternalArgs {
|
|
pub fn iter(&self) -> impl Iterator<Item = &ExternalArg> {
|
|
self.list.iter()
|
|
}
|
|
}
|
|
|
|
impl std::ops::Deref for ExternalArgs {
|
|
type Target = [ExternalArg];
|
|
|
|
fn deref(&self) -> &[ExternalArg] {
|
|
&self.list
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq)]
|
|
pub struct ExternalCommand {
|
|
pub name: String,
|
|
|
|
pub name_tag: Tag,
|
|
pub args: ExternalArgs,
|
|
}
|
|
|
|
impl PrettyDebug for ExternalCommand {
|
|
fn pretty(&self) -> DebugDocBuilder {
|
|
b::typed(
|
|
"external command",
|
|
b::description(&self.name)
|
|
+ b::preceded(
|
|
b::space(),
|
|
b::intersperse(
|
|
self.args.iter().map(|a| b::primitive(format!("{}", a.arg))),
|
|
b::space(),
|
|
),
|
|
),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl HasSpan for ExternalCommand {
|
|
fn span(&self) -> Span {
|
|
self.name_tag.span.until(self.args.span)
|
|
}
|
|
}
|