forked from extern/nushell
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`).
76 lines
1.9 KiB
Rust
76 lines
1.9 KiB
Rust
use crate::TokenNode;
|
|
use derive_new::new;
|
|
use getset::Getters;
|
|
use nu_source::{b, DebugDocBuilder, PrettyDebugWithSource, Span, Spanned, HasSpan};
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Getters, new)]
|
|
pub struct Pipeline {
|
|
#[get = "pub"]
|
|
pub(crate) parts: Vec<PipelineElement>,
|
|
pub(crate) span: Span,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Getters, new)]
|
|
pub struct Tokens {
|
|
pub(crate) tokens: Vec<TokenNode>,
|
|
pub(crate) span: Span,
|
|
}
|
|
|
|
impl Tokens {
|
|
pub fn iter(&self) -> impl Iterator<Item = &TokenNode> {
|
|
self.tokens.iter()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
|
pub struct PipelineElement {
|
|
pub pipe: Option<Span>,
|
|
pub tokens: Tokens,
|
|
}
|
|
|
|
impl HasSpan for PipelineElement {
|
|
fn span(&self) -> Span {
|
|
match self.pipe {
|
|
Option::None => self.tokens.span,
|
|
Option::Some(pipe) => pipe.until(self.tokens.span),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PipelineElement {
|
|
pub fn new(pipe: Option<Span>, tokens: Spanned<Vec<TokenNode>>) -> PipelineElement {
|
|
PipelineElement {
|
|
pipe,
|
|
tokens: Tokens {
|
|
tokens: tokens.item,
|
|
span: tokens.span,
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn tokens(&self) -> &[TokenNode] {
|
|
&self.tokens.tokens
|
|
}
|
|
}
|
|
|
|
impl PrettyDebugWithSource for Pipeline {
|
|
fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
|
|
b::intersperse(
|
|
self.parts.iter().map(|token| token.pretty_debug(source)),
|
|
b::operator(" | "),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl PrettyDebugWithSource for PipelineElement {
|
|
fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
|
|
b::intersperse(
|
|
self.tokens.iter().map(|token| match token {
|
|
TokenNode::Whitespace(_) => b::blank(),
|
|
token => token.pretty_debug(source),
|
|
}),
|
|
b::space(),
|
|
)
|
|
}
|
|
}
|