58c6fea60b
# Description Close: #9673 Close: #8277 Close: #10944 This pr introduces the following syntax: 1. `e>|`, pipe stderr to next command. Example: `$env.FOO=bar nu --testbin echo_env_stderr FOO e>| str length` 2. `o+e>|` and `e+o>|`, pipe both stdout and stderr to next command, example: `$env.FOO=bar nu --testbin echo_env_mixed out-err FOO FOO e+o>| str length` Note: it only works for external commands. ~There is no different for internal commands, that is, the following three commands do the same things:~ Edit: it raises errors if we want to pipes for internal commands ``` ❯ ls e>| str length Error: × `e>|` only works with external streams ╭─[entry #1:1:1] 1 │ ls e>| str length · ─┬─ · ╰── `e>|` only works on external streams ╰──── ❯ ls e+o>| str length Error: × `o+e>|` only works with external streams ╭─[entry #2:1:1] 1 │ ls e+o>| str length · ──┬── · ╰── `o+e>|` only works on external streams ╰──── ``` This can help us to avoid some strange issues like the following: `$env.FOO=bar (nu --testbin echo_env_stderr FOO) e>| str length` Which is hard to understand and hard to explain to users. # User-Facing Changes Nan # Tests + Formatting To be done # After Submitting Maybe update documentation about these syntax.
102 lines
2.7 KiB
Rust
102 lines
2.7 KiB
Rust
use super::Pipeline;
|
|
use crate::{ast::PipelineElement, Signature, Span, Type, VarId};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::ops::{Index, IndexMut};
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Block {
|
|
pub signature: Box<Signature>,
|
|
pub pipelines: Vec<Pipeline>,
|
|
pub captures: Vec<VarId>,
|
|
pub redirect_env: bool,
|
|
pub span: Option<Span>, // None option encodes no span to avoid using test_span()
|
|
}
|
|
|
|
impl Block {
|
|
pub fn len(&self) -> usize {
|
|
self.pipelines.len()
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
self.pipelines.is_empty()
|
|
}
|
|
}
|
|
|
|
impl Index<usize> for Block {
|
|
type Output = Pipeline;
|
|
|
|
fn index(&self, index: usize) -> &Self::Output {
|
|
&self.pipelines[index]
|
|
}
|
|
}
|
|
|
|
impl IndexMut<usize> for Block {
|
|
fn index_mut(&mut self, index: usize) -> &mut Self::Output {
|
|
&mut self.pipelines[index]
|
|
}
|
|
}
|
|
|
|
impl Default for Block {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Block {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
signature: Box::new(Signature::new("")),
|
|
pipelines: vec![],
|
|
captures: vec![],
|
|
redirect_env: false,
|
|
span: None,
|
|
}
|
|
}
|
|
|
|
pub fn new_with_capacity(capacity: usize) -> Self {
|
|
Self {
|
|
signature: Box::new(Signature::new("")),
|
|
pipelines: Vec::with_capacity(capacity),
|
|
captures: vec![],
|
|
redirect_env: false,
|
|
span: None,
|
|
}
|
|
}
|
|
|
|
pub fn output_type(&self) -> Type {
|
|
if let Some(last) = self.pipelines.last() {
|
|
if let Some(last) = last.elements.last() {
|
|
match last {
|
|
PipelineElement::Expression(_, expr) => expr.ty.clone(),
|
|
PipelineElement::ErrPipedExpression(_, expr) => expr.ty.clone(),
|
|
PipelineElement::OutErrPipedExpression(_, expr) => expr.ty.clone(),
|
|
PipelineElement::Redirection(_, _, _, _) => Type::Any,
|
|
PipelineElement::SeparateRedirection { .. } => Type::Any,
|
|
PipelineElement::SameTargetRedirection { .. } => Type::Any,
|
|
PipelineElement::And(_, expr) => expr.ty.clone(),
|
|
PipelineElement::Or(_, expr) => expr.ty.clone(),
|
|
}
|
|
} else {
|
|
Type::Nothing
|
|
}
|
|
} else {
|
|
Type::Nothing
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> From<T> for Block
|
|
where
|
|
T: Iterator<Item = Pipeline>,
|
|
{
|
|
fn from(pipelines: T) -> Self {
|
|
Self {
|
|
signature: Box::new(Signature::new("")),
|
|
pipelines: pipelines.collect(),
|
|
captures: vec![],
|
|
redirect_env: false,
|
|
span: None,
|
|
}
|
|
}
|
|
}
|