holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Back to working state

Browse Source
This commit is contained in:
JT
2021-09-03 06:21:37 +12:00
parent e1be8f61fc
commit 94687a7603
28 changed files with 170 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/nu-parser/src/errors.rs
View File

@ -1,4 +1,4 @@
use nu_protocol::{Span, StateWorkingSet, Type};
use nu_protocol::{engine::StateWorkingSet, Span, Type};
use std::ops::Range;
#[derive(Debug)]

4
crates/nu-parser/src/flatten.rs
View File

@ -1,5 +1,5 @@
use nu_protocol::Span;
use nu_protocol::{Block, Expr, Expression, Pipeline, StateWorkingSet, Statement};
use nu_protocol::ast::{Block, Expr, Expression, Pipeline, Statement};
use nu_protocol::{engine::StateWorkingSet, Span};
#[derive(Debug)]
pub enum FlatShape {

4
crates/nu-parser/src/lib.rs
View File

@ -6,7 +6,7 @@ mod parser;
mod type_check;
pub use errors::ParseError;
pub use flatten::FlatShape;
pub use flatten::{flatten_block, FlatShape};
pub use lex::{lex, Token, TokenContents};
pub use lite_parse::{lite_parse, LiteBlock};
pub use parser::{Import, VarDecl};
pub use parser::{parse_file, parse_source, Import, VarDecl};

5
crates/nu-parser/src/parser.rs
View File

@ -5,8 +5,9 @@ use crate::{
};
use nu_protocol::{
span, Block, BlockId, Call, DeclId, Expr, Expression, Flag, Operator, Pipeline, PositionalArg,
Signature, Span, StateWorkingSet, Statement, SyntaxShape, Type, VarId,
ast::{Block, Call, Expr, Expression, Operator, Pipeline, Statement},
engine::StateWorkingSet,
span, BlockId, DeclId, Flag, PositionalArg, Signature, Span, SyntaxShape, Type, VarId,
};
#[derive(Debug, Clone)]

6
crates/nu-parser/src/type_check.rs
View File

@ -1,5 +1,9 @@
use crate::ParseError;
use nu_protocol::{Expr, Expression, Operator, StateWorkingSet, Type};
use nu_protocol::{
ast::{Expr, Expression, Operator},
engine::StateWorkingSet,
Type,
};
pub fn type_compatible(lhs: &Type, rhs: &Type) -> bool {
match (lhs, rhs) {

40
crates/nu-parser/tests/test_parser.rs
View File

@ -1,13 +1,17 @@
use nu_parser::ParseError;
use nu_parser::*;
use nu_protocol::{EngineState, Signature, SyntaxShape};
use nu_protocol::{
ast::{Expr, Expression, Statement},
engine::{EngineState, StateWorkingSet},
Signature, SyntaxShape,
};
#[test]
pub fn parse_int() {
let engine_state = EngineState::new();
let mut working_set = StateWorkingSet::new(&engine_state);
let (block, err) = working_set.parse_source(b"3", true);
let (block, err) = parse_source(&mut working_set, b"3", true);
assert!(err.is_none());
assert!(block.len() == 1);
@ -26,9 +30,9 @@ pub fn parse_call() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'));
working_set.add_decl(sig.into());
working_set.add_decl(sig.predeclare());
let (block, err) = working_set.parse_source(b"foo", true);
let (block, err) = parse_source(&mut working_set, b"foo", true);
assert!(err.is_none());
assert!(block.len() == 1);
@ -50,9 +54,9 @@ pub fn parse_call_missing_flag_arg() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'));
working_set.add_decl(sig.into());
working_set.add_decl(sig.predeclare());
let (_, err) = working_set.parse_source(b"foo --jazz", true);
let (_, err) = parse_source(&mut working_set, b"foo --jazz", true);
assert!(matches!(err, Some(ParseError::MissingFlagParam(..))));
}
@ -62,9 +66,9 @@ pub fn parse_call_missing_short_flag_arg() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'));
working_set.add_decl(sig.into());
working_set.add_decl(sig.predeclare());
let (_, err) = working_set.parse_source(b"foo -j", true);
let (_, err) = parse_source(&mut working_set, b"foo -j", true);
assert!(matches!(err, Some(ParseError::MissingFlagParam(..))));
}
@ -76,8 +80,8 @@ pub fn parse_call_too_many_shortflag_args() {
let sig = Signature::build("foo")
.named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'))
.named("--math", SyntaxShape::Int, "math!!", Some('m'));
working_set.add_decl(sig.into());
let (_, err) = working_set.parse_source(b"foo -mj", true);
working_set.add_decl(sig.predeclare());
let (_, err) = parse_source(&mut working_set, b"foo -mj", true);
assert!(matches!(
err,
Some(ParseError::ShortFlagBatchCantTakeArg(..))
@ -90,8 +94,8 @@ pub fn parse_call_unknown_shorthand() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").switch("--jazz", "jazz!!", Some('j'));
working_set.add_decl(sig.into());
let (_, err) = working_set.parse_source(b"foo -mj", true);
working_set.add_decl(sig.predeclare());
let (_, err) = parse_source(&mut working_set, b"foo -mj", true);
assert!(matches!(err, Some(ParseError::UnknownFlag(..))));
}
@ -101,8 +105,8 @@ pub fn parse_call_extra_positional() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").switch("--jazz", "jazz!!", Some('j'));
working_set.add_decl(sig.into());
let (_, err) = working_set.parse_source(b"foo -j 100", true);
working_set.add_decl(sig.predeclare());
let (_, err) = parse_source(&mut working_set, b"foo -j 100", true);
assert!(matches!(err, Some(ParseError::ExtraPositional(..))));
}
@ -112,8 +116,8 @@ pub fn parse_call_missing_req_positional() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").required("jazz", SyntaxShape::Int, "jazz!!");
working_set.add_decl(sig.into());
let (_, err) = working_set.parse_source(b"foo", true);
working_set.add_decl(sig.predeclare());
let (_, err) = parse_source(&mut working_set, b"foo", true);
assert!(matches!(err, Some(ParseError::MissingPositional(..))));
}
@ -123,7 +127,7 @@ pub fn parse_call_missing_req_flag() {
let mut working_set = StateWorkingSet::new(&engine_state);
let sig = Signature::build("foo").required_named("--jazz", SyntaxShape::Int, "jazz!!", None);
working_set.add_decl(sig.into());
let (_, err) = working_set.parse_source(b"foo", true);
working_set.add_decl(sig.predeclare());
let (_, err) = parse_source(&mut working_set, b"foo", true);
assert!(matches!(err, Some(ParseError::MissingRequiredFlag(..))));
}