# Description This PR changes the `ast` command to be able to output `--json` as well as `nuon` (default) with "pretty" and "minified" output. I'm hoping this functionality will be usable in the vscode extension for semantic tokenization and highlighting. # User-Facing Changes There's a new `--json`/`-j` option. Prior version output of nuon is maintained as default. # 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 - `cargo run -- crates/nu-std/tests/run.nu` to run the tests for the standard library > **Note** > from `nushell` you can also use the `toolkit` as follows > ```bash > use toolkit.nu # or use an `env_change` hook to activate it automatically > toolkit check pr > ``` --> # 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. -->
159 lines
4.8 KiB
Rust
159 lines
4.8 KiB
Rust
use crate::{ast::Expression, engine::StateWorkingSet, Span, VarId};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::ops::{Index, IndexMut};
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub enum Redirection {
|
|
Stdout,
|
|
Stderr,
|
|
StdoutAndStderr,
|
|
}
|
|
|
|
// Note: Span in the below is for the span of the connector not the whole element
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub enum PipelineElement {
|
|
Expression(Option<Span>, Expression),
|
|
Redirection(Span, Redirection, Expression),
|
|
SeparateRedirection {
|
|
out: (Span, Expression),
|
|
err: (Span, Expression),
|
|
},
|
|
And(Span, Expression),
|
|
Or(Span, Expression),
|
|
}
|
|
|
|
impl PipelineElement {
|
|
pub fn expression(&self) -> &Expression {
|
|
match self {
|
|
PipelineElement::Expression(_, expression) => expression,
|
|
PipelineElement::Redirection(_, _, expression) => expression,
|
|
PipelineElement::SeparateRedirection {
|
|
out: (_, expression),
|
|
..
|
|
} => expression,
|
|
PipelineElement::And(_, expression) => expression,
|
|
PipelineElement::Or(_, expression) => expression,
|
|
}
|
|
}
|
|
|
|
pub fn span(&self) -> Span {
|
|
match self {
|
|
PipelineElement::Expression(None, expression) => expression.span,
|
|
PipelineElement::Expression(Some(span), expression)
|
|
| PipelineElement::Redirection(span, _, expression)
|
|
| PipelineElement::SeparateRedirection {
|
|
out: (span, expression),
|
|
..
|
|
}
|
|
| PipelineElement::And(span, expression)
|
|
| PipelineElement::Or(span, expression) => Span {
|
|
start: span.start,
|
|
end: expression.span.end,
|
|
},
|
|
}
|
|
}
|
|
pub fn has_in_variable(&self, working_set: &StateWorkingSet) -> bool {
|
|
match self {
|
|
PipelineElement::Expression(_, expression)
|
|
| PipelineElement::Redirection(_, _, expression)
|
|
| PipelineElement::And(_, expression)
|
|
| PipelineElement::Or(_, expression) => expression.has_in_variable(working_set),
|
|
PipelineElement::SeparateRedirection {
|
|
out: (_, out_expr),
|
|
err: (_, err_expr),
|
|
} => out_expr.has_in_variable(working_set) || err_expr.has_in_variable(working_set),
|
|
}
|
|
}
|
|
|
|
pub fn replace_in_variable(&mut self, working_set: &mut StateWorkingSet, new_var_id: VarId) {
|
|
match self {
|
|
PipelineElement::Expression(_, expression)
|
|
| PipelineElement::Redirection(_, _, expression)
|
|
| PipelineElement::And(_, expression)
|
|
| PipelineElement::Or(_, expression) => {
|
|
expression.replace_in_variable(working_set, new_var_id)
|
|
}
|
|
PipelineElement::SeparateRedirection {
|
|
out: (_, out_expr),
|
|
err: (_, err_expr),
|
|
} => {
|
|
if out_expr.has_in_variable(working_set) {
|
|
out_expr.replace_in_variable(working_set, new_var_id)
|
|
}
|
|
if err_expr.has_in_variable(working_set) {
|
|
err_expr.replace_in_variable(working_set, new_var_id)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn replace_span(
|
|
&mut self,
|
|
working_set: &mut StateWorkingSet,
|
|
replaced: Span,
|
|
new_span: Span,
|
|
) {
|
|
match self {
|
|
PipelineElement::Expression(_, expression)
|
|
| PipelineElement::Redirection(_, _, expression)
|
|
| PipelineElement::And(_, expression)
|
|
| PipelineElement::Or(_, expression)
|
|
| PipelineElement::SeparateRedirection {
|
|
out: (_, expression),
|
|
..
|
|
} => expression.replace_span(working_set, replaced, new_span),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Pipeline {
|
|
pub elements: Vec<PipelineElement>,
|
|
}
|
|
|
|
impl Default for Pipeline {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Pipeline {
|
|
pub fn new() -> Self {
|
|
Self { elements: vec![] }
|
|
}
|
|
|
|
pub fn from_vec(expressions: Vec<Expression>) -> Pipeline {
|
|
Self {
|
|
elements: expressions
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(idx, x)| {
|
|
PipelineElement::Expression(if idx == 0 { None } else { Some(x.span) }, x)
|
|
})
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
pub fn len(&self) -> usize {
|
|
self.elements.len()
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
self.elements.is_empty()
|
|
}
|
|
}
|
|
|
|
impl Index<usize> for Pipeline {
|
|
type Output = PipelineElement;
|
|
|
|
fn index(&self, index: usize) -> &Self::Output {
|
|
&self.elements[index]
|
|
}
|
|
}
|
|
|
|
impl IndexMut<usize> for Pipeline {
|
|
fn index_mut(&mut self, index: usize) -> &mut Self::Output {
|
|
&mut self.elements[index]
|
|
}
|
|
}
|