extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-06-30 14:40:06 +02:00
Code Issues Packages Projects Releases Wiki Activity

Change import pattern delimiter to space

Browse Source 
Subcommands and module imports will have the same syntax now.
This commit is contained in:
Jakub Žádník
2021-10-27 00:06:08 +03:00
parent 595fc7a7f6
commit bd6c550470
4 changed files with 53 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/nu-command/src/core_commands/use_.rs
View File

@ -15,7 +15,7 @@ impl Command for Use {
}
fn signature(&self) -> nu_protocol::Signature {
Signature::build("use").required("pattern", SyntaxShape::String, "import pattern")
Signature::build("use").rest("pattern", SyntaxShape::String, "import pattern parts")
}
fn run(

16
crates/nu-parser/src/parse_keywords.rs
View File

@ -495,7 +495,7 @@ pub fn parse_use(
let (module_name_expr, err) = parse_string(working_set, spans[1]);
error = error.or(err);
let (import_pattern, err) = parse_import_pattern(working_set, spans[1]);
let (import_pattern, err) = parse_import_pattern(working_set, &spans[1..]);
error = error.or(err);
let (import_pattern, exports) =
@ -548,8 +548,7 @@ pub fn parse_use(
.into_iter()
.map(|(name, id)| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b':');
new_name.push(b':');
new_name.push(b' ');
new_name.extend(&name);
(new_name, id)
})
@ -634,7 +633,7 @@ pub fn parse_hide(
let (name_expr, err) = parse_string(working_set, spans[1]);
error = error.or(err);
let (import_pattern, err) = parse_import_pattern(working_set, spans[1]);
let (import_pattern, err) = parse_import_pattern(working_set, &spans[1..]);
error = error.or(err);
let exported_names: Vec<Vec<u8>> =
@ -664,8 +663,7 @@ pub fn parse_hide(
.into_iter()
.map(|name| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b':');
new_name.push(b':');
new_name.push(b' ');
new_name.extend(&name);
new_name
})
@ -676,8 +674,7 @@ pub fn parse_hide(
.filter(|n| n == name)
.map(|n| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b':');
new_name.push(b':');
new_name.push(b' ');
new_name.extend(&n);
new_name
})
@ -698,8 +695,7 @@ pub fn parse_hide(
.filter_map(|n| if n == name { Some(n.clone()) } else { None })
.map(|n| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b':');
new_name.push(b':');
new_name.push(b' ');
new_name.extend(n);
new_name
})

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

@ -1693,70 +1693,54 @@ pub fn parse_type(_working_set: &StateWorkingSet, bytes: &[u8]) -> Type {
pub fn parse_import_pattern(
working_set: &mut StateWorkingSet,
span: Span,
spans: &[Span],
) -> (ImportPattern, Option<ParseError>) {
let source = working_set.get_span_contents(span);
let mut error = None;
let (tokens, err) = lex(source, span.start, &[], &[b':']);
error = error.or(err);
// return (
// ImportPattern {
// head: vec![],
// members: vec![],
// },
// Some(ParseError::MissingImportPattern(span)),
// );
if tokens.is_empty() {
return (
ImportPattern {
head: vec![],
members: vec![],
},
Some(ParseError::MissingImportPattern(span)),
);
}
// return (
// ImportPattern {
// head: vec![],
// members: vec![],
// },
// Some(ParseError::WrongImportPattern(span)),
// );
// We can have either "head" or "head::tail"
if (tokens.len() != 1) && (tokens.len() != 4) {
return (
ImportPattern {
head: vec![],
members: vec![],
},
Some(ParseError::WrongImportPattern(span)),
);
}
// Check if the second : of the :: is really a :
let has_second_colon = if let Some(t) = tokens.get(2) {
let potential_colon = working_set.get_span_contents(t.span);
potential_colon == b":"
let head = if let Some(head_span) = spans.get(0) {
let (head_expr, err) = parse_string(working_set, *head_span);
error = error.or(err);
working_set.get_span_contents(head_expr.span).to_vec()
} else {
false
return (
ImportPattern {
head: vec![],
members: vec![],
},
Some(ParseError::WrongImportPattern(span(spans))),
);
};
if (tokens.len() == 4) && !has_second_colon {
// Applies only to the "head::tail" structure; "head" only doesn't have :
return (
ImportPattern {
head: vec![],
members: vec![],
},
Some(ParseError::WrongImportPattern(span)),
);
}
let head = working_set.get_span_contents(tokens[0].span).to_vec();
if let Some(tail) = tokens.get(3) {
if let Some(tail_span) = spans.get(1) {
// FIXME: expand this to handle deeper imports once we support module imports
let tail_span = tail.span;
let tail = working_set.get_span_contents(tail.span);
let tail = working_set.get_span_contents(*tail_span);
if tail == b"*" {
(
ImportPattern {
head,
members: vec![ImportPatternMember::Glob { span: tail_span }],
members: vec![ImportPatternMember::Glob { span: *tail_span }],
},
error,
)
} else if tail.starts_with(b"[") {
let (result, err) = parse_list_expression(working_set, tail_span, &SyntaxShape::String);
let (result, err) =
parse_list_expression(working_set, *tail_span, &SyntaxShape::String);
error = error.or(err);
let mut output = vec![];
@ -1793,7 +1777,7 @@ pub fn parse_import_pattern(
head,
members: vec![ImportPatternMember::Name {
name: tail.to_vec(),
span: tail_span,
span: *tail_span,
}],
},
error,