235 lines
6.7 KiB
Rust
235 lines
6.7 KiB
Rust
use super::*;
|
|
|
|
#[test]
|
|
fn parse_simple() {
|
|
let input = "echo hello world";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_pipeline() {
|
|
let input = "echo foo | sed s/foo/bar";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_conjunction() {
|
|
let input = "echo foo && echo bar";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_conjunction_and_pipeline() {
|
|
let input = "echo foo | sed s/foo/bar/ && echo bar | sed s/bar/foo/ || echo foo bar | sed s/foo bar/bar foo/";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_multiline() {
|
|
let input = "
|
|
echo hello world
|
|
echo foo bar
|
|
echo boo biz";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_if_simple() {
|
|
let input = "if foo; then echo bar; fi";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_if_with_elif() {
|
|
let input = "if foo; then echo bar; elif bar; then echo foo; fi";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_if_multiple_elif() {
|
|
let input = "if foo; then echo bar; elif bar; then echo foo; elif biz; then echo baz; fi";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_if_multiline() {
|
|
let input = "
|
|
if foo; then
|
|
echo bar
|
|
elif bar; then
|
|
echo foo;
|
|
elif biz; then
|
|
echo baz
|
|
fi";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_loop_simple() {
|
|
let input = "while foo; do bar; done";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_loop_until() {
|
|
let input = "until foo; do bar; done";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_loop_multiline() {
|
|
let input = "
|
|
until foo; do
|
|
bar
|
|
done";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_case_simple() {
|
|
let input = "case foo in foo) bar;; bar) foo;; biz) baz;; esac";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_case_multiline() {
|
|
let input = "case foo in
|
|
foo) bar
|
|
;;
|
|
bar) foo
|
|
;;
|
|
biz) baz
|
|
;;
|
|
esac";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_case_nested() {
|
|
let input = "case foo in
|
|
foo)
|
|
if true; then
|
|
while true; do
|
|
echo foo
|
|
done
|
|
fi
|
|
;;
|
|
bar)
|
|
if false; then
|
|
until false; do
|
|
case foo in
|
|
foo)
|
|
if true; then
|
|
echo foo
|
|
fi
|
|
;;
|
|
bar)
|
|
if false; then
|
|
echo foo
|
|
fi
|
|
;;
|
|
esac
|
|
done
|
|
fi
|
|
;;
|
|
esac";
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn parse_cursed() {
|
|
let input = "if if if if case foo in foo) if true; then true; fi;; esac; then case foo in foo) until true; do true; done;; esac; fi; then until if case foo in foo) true;; esac; then if true; then true; fi; fi; do until until true; do true; done; do case foo in foo) true;; esac; done; done; fi; then until until case foo in foo) true;; esac; do if true; then true; fi; done; do until true; do true; done; done; fi; then until case foo in foo) case foo in foo) true;; esac;; esac; do if if true; then true; fi; then until true; do true; done; fi; done; elif until until case foo in foo) true;; esac; do if true; then true; fi; done; do case foo in foo) until true; do true; done;; esac; done; then case foo in foo) if case foo in foo) true;; esac; then if true; then true; fi; fi;; esac; else case foo in foo) until until true; do true; done; do case foo in foo) true;; esac; done;; esac; fi";
|
|
|
|
let tk_stream: Vec<_> = LexStream::new(Arc::new(input.to_string()), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
let nodes: Vec<_> = ParseStream::new(tk_stream).collect();
|
|
|
|
// 15,000 line snapshot file btw
|
|
insta::assert_debug_snapshot!(nodes)
|
|
}
|
|
#[test]
|
|
fn test_node_operation() {
|
|
let input = String::from("echo hello world; echo foo bar");
|
|
let mut check_nodes = vec![];
|
|
let tokens: Vec<Tk> = LexStream::new(input.into(), LexFlags::empty())
|
|
.map(|tk| tk.unwrap())
|
|
.collect();
|
|
|
|
let nodes = ParseStream::new(tokens)
|
|
.map(|nd| nd.unwrap());
|
|
|
|
for mut node in nodes {
|
|
node_operation(&mut node,
|
|
&|node: &Node| matches!(node.class, NdRule::Command {..}),
|
|
&mut |node: &mut Node| check_nodes.push(node.clone()),
|
|
);
|
|
}
|
|
insta::assert_debug_snapshot!(check_nodes)
|
|
}
|