greg/just
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reworked tokenizer, not trying to dig myself out of the wreckage.

Browse Source
This commit is contained in:
Casey Rodarmor 2016-10-26 20:54:44 -07:00
parent 52aa496d9c
commit 7a77c910b6
3 changed files with 266 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
notes
View File

@ -2,10 +2,7 @@ notes
----- -----
- assignment - assignment
. can argument shadow variables? . add tokenizing test that covers interpolation
. yes, why not
. no, it's confusing
. static errors when variables are missing {{}}, even if recipe isn't run
. use the same rules as rust: https://doc.rust-lang.org/reference.html#string-literals . use the same rules as rust: https://doc.rust-lang.org/reference.html#string-literals
. \xHH, \u{HHHHHH}, \n, \r, \t, \0, \\, \{ no other escapes . \xHH, \u{HHHHHH}, \n, \r, \t, \0, \\, \{ no other escapes
. '' strings with no escapes . '' strings with no escapes
@ -13,6 +10,7 @@ notes
. make quine use assignment and interpolation . make quine use assignment and interpolation
. make strings more than one character . make strings more than one character
.re-order evaluate assignment .re-order evaluate assignment
- do proper handling of the state stack at EOF
- disallow unused arguments and variables - disallow unused arguments and variables
- allow exporting environment variables - allow exporting environment variables
- write some tests to test the binary itself and all command line flags - write some tests to test the binary itself and all command line flags

255
src/lib.rs
View File

@ -57,6 +57,7 @@ struct Recipe<'a> {
lines: Vec<&'a str>, lines: Vec<&'a str>,
fragments: Vec<Vec<Fragment<'a>>>, fragments: Vec<Vec<Fragment<'a>>>,
variables: BTreeSet<&'a str>, variables: BTreeSet<&'a str>,
variable_tokens: Vec<Token<'a>>,
dependencies: Vec<&'a str>, dependencies: Vec<&'a str>,
dependency_tokens: Vec<Token<'a>>, dependency_tokens: Vec<Token<'a>>,
arguments: Vec<&'a str>, arguments: Vec<&'a str>,
@ -71,7 +72,7 @@ enum Fragment<'a> {
} }
enum Expression<'a> { enum Expression<'a> {
Variable{name: &'a str}, Variable{name: &'a str, token: Token<'a>},
String{contents: &'a str}, String{contents: &'a str},
Concatination{lhs: Box<Expression<'a>>, rhs: Box<Expression<'a>>}, Concatination{lhs: Box<Expression<'a>>, rhs: Box<Expression<'a>>},
} }
@ -79,7 +80,7 @@ enum Expression<'a> {
impl<'a> Display for Expression<'a> { impl<'a> Display for Expression<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match *self { match *self {
Expression::Variable {name } => try!(write!(f, "{}", name)), Expression::Variable {name, .. } => try!(write!(f, "{}", name)),
Expression::String {contents } => try!(write!(f, "\"{}\"", contents)), Expression::String {contents } => try!(write!(f, "\"{}\"", contents)),
Expression::Concatination{ref lhs, ref rhs} => try!(write!(f, "{} + {}", lhs, rhs)), Expression::Concatination{ref lhs, ref rhs} => try!(write!(f, "{} + {}", lhs, rhs)),
} }
@ -327,7 +328,7 @@ impl<'a, 'b> Evaluator<'a, 'b> {
fn evaluate_expression(&mut self, expression: &Expression<'a>,) -> Result<String, Error<'a>> { fn evaluate_expression(&mut self, expression: &Expression<'a>,) -> Result<String, Error<'a>> {
Ok(match *expression { Ok(match *expression {
Expression::Variable{name} => { Expression::Variable{name, ref token} => {
if self.evaluated.contains_key(name) { if self.evaluated.contains_key(name) {
self.evaluated.get(name).unwrap().clone() self.evaluated.get(name).unwrap().clone()
} else if self.seen.contains(name) { } else if self.seen.contains(name) {
@ -337,6 +338,8 @@ impl<'a, 'b> Evaluator<'a, 'b> {
variable: name, variable: name,
circle: self.stack.clone(), circle: self.stack.clone(),
})); }));
} else if !self.assignments.contains_key(name) {
return Err(token.error(ErrorKind::UnknownVariable{variable: name}));
} else { } else {
try!(self.evaluate_assignment(name)); try!(self.evaluate_assignment(name));
self.evaluated.get(name).unwrap().clone() self.evaluated.get(name).unwrap().clone()
@ -375,7 +378,7 @@ enum ErrorKind<'a> {
DuplicateVariable{variable: &'a str}, DuplicateVariable{variable: &'a str},
ArgumentShadowsVariable{argument: &'a str}, ArgumentShadowsVariable{argument: &'a str},
MixedLeadingWhitespace{whitespace: &'a str}, MixedLeadingWhitespace{whitespace: &'a str},
UnmatchedInterpolationDelimiter{recipe: &'a str}, UnclosedInterpolationDelimiter,
BadInterpolationVariableName{recipe: &'a str, text: &'a str}, BadInterpolationVariableName{recipe: &'a str, text: &'a str},
ExtraLeadingWhitespace, ExtraLeadingWhitespace,
InconsistentLeadingWhitespace{expected: &'a str, found: &'a str}, InconsistentLeadingWhitespace{expected: &'a str, found: &'a str},
@ -475,8 +478,8 @@ impl<'a> Display for Error<'a> {
ErrorKind::OuterShebang => { ErrorKind::OuterShebang => {
try!(writeln!(f, "a shebang \"#!\" is reserved syntax outside of recipes")) try!(writeln!(f, "a shebang \"#!\" is reserved syntax outside of recipes"))
} }
ErrorKind::UnmatchedInterpolationDelimiter{recipe} => { ErrorKind::UnclosedInterpolationDelimiter => {
try!(writeln!(f, "recipe {} contains an unmatched {}", recipe, "{{")) try!(writeln!(f, "unmatched {}", "{{"))
} }
ErrorKind::BadInterpolationVariableName{recipe, text} => { ErrorKind::BadInterpolationVariableName{recipe, text} => {
try!(writeln!(f, "recipe {} contains a bad variable interpolation: {}", recipe, text)) try!(writeln!(f, "recipe {} contains a bad variable interpolation: {}", recipe, text))
@ -657,6 +660,22 @@ impl<'a> Token<'a> {
kind: kind, kind: kind,
} }
} }
/*
fn split(
self,
leading_prefix_len: usize,
lexeme_len: usize,
trailing_prefix_len: usize,
) -> (Token<'a>, Token<'a>) {
let len = self.prefix.len() + self.lexeme.len();
// let length = self.prefix.len() + self.lexeme.len();
// if lexeme_start > lexeme_end || lexeme_end > length {
// }
// panic!("Tried to split toke
}
*/
} }
#[derive(Debug, PartialEq, Clone, Copy)] #[derive(Debug, PartialEq, Clone, Copy)]
@ -667,9 +686,12 @@ enum TokenKind {
Plus, Plus,
Equals, Equals,
Comment, Comment,
Line,
Indent, Indent,
Dedent, Dedent,
InterpolationStart,
InterpolationEnd,
Text,
Line,
Eol, Eol,
Eof, Eof,
} }
@ -677,17 +699,20 @@ enum TokenKind {
impl Display for TokenKind { impl Display for TokenKind {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
try!(write!(f, "{}", match *self { try!(write!(f, "{}", match *self {
Name => "name", Name => "name",
Colon => "\":\"", Colon => "\":\"",
Plus => "\"+\"", Plus => "\"+\"",
Equals => "\"=\"", Equals => "\"=\"",
StringToken => "string", StringToken => "string",
Comment => "comment", Text => "command text",
Line => "command", InterpolationStart => "{{",
Indent => "indent", InterpolationEnd => "}}",
Dedent => "dedent", Comment => "comment",
Eol => "end of line", Line => "command",
Eof => "end of file", Indent => "indent",
Dedent => "dedent",
Eol => "end of line",
Eof => "end of file",
})); }));
Ok(()) Ok(())
} }
@ -703,20 +728,44 @@ fn token(pattern: &str) -> Regex {
re(&s) re(&s)
} }
fn tokenize(text: &str) -> Result<Vec<Token>, Error> { fn tokenize<'a>(text: &'a str) -> Result<Vec<Token>, Error> {
lazy_static! { lazy_static! {
static ref EOF: Regex = token(r"(?-m)$" ); static ref EOF: Regex = token(r"(?-m)$" );
static ref NAME: Regex = token(r"([a-zA-Z0-9_-]+)" ); static ref NAME: Regex = token(r"([a-zA-Z0-9_-]+)" );
static ref COLON: Regex = token(r":" ); static ref COLON: Regex = token(r":" );
static ref EQUALS: Regex = token(r"=" ); static ref EQUALS: Regex = token(r"=" );
static ref PLUS: Regex = token(r"[+]" ); static ref PLUS: Regex = token(r"[+]" );
static ref COMMENT: Regex = token(r"#([^!].*)?$" ); static ref COMMENT: Regex = token(r"#([^!].*)?$" );
static ref STRING: Regex = token("\"[a-z0-9]\"" ); static ref STRING: Regex = token("\"[a-z0-9]\"" );
static ref EOL: Regex = token(r"\n|\r\n" ); static ref EOL: Regex = token(r"\n|\r\n" );
static ref LINE: Regex = re(r"^(?m)[ \t]+[^ \t\n\r].*$"); static ref INTERPOLATION_END: Regex = token(r"[{][{]" );
static ref INDENT: Regex = re(r"^([ \t]*)[^ \t\n\r]" ); static ref LINE: Regex = re(r"^(?m)[ \t]+[^ \t\n\r].*$");
static ref INDENT: Regex = re(r"^([ \t]*)[^ \t\n\r]" );
static ref INTERPOLATION_START: Regex = re(r"^[{][{]" );
static ref LEADING_TEXT: Regex = re(r"(?m)(.+?)[{][{]" );
static ref TEXT: Regex = re(r"(?m)(.+?)$" );
} }
#[derive(PartialEq)]
enum State<'a> {
Start,
Indent(&'a str),
Text,
Interpolation,
}
/*
struct Stack<'a> {
states: Vec<StateKind<'a>>
}
impl<'a> State<'a> {
fn current(&self) -> State {
self.states.last()
}
}
*/
fn indentation(text: &str) -> Option<&str> { fn indentation(text: &str) -> Option<&str> {
INDENT.captures(text).map(|captures| captures.at(1).unwrap()) INDENT.captures(text).map(|captures| captures.at(1).unwrap())
} }
@ -726,7 +775,9 @@ fn tokenize(text: &str) -> Result<Vec<Token>, Error> {
let mut index = 0; let mut index = 0;
let mut line = 0; let mut line = 0;
let mut column = 0; let mut column = 0;
let mut indent: Option<&str> = None; // let mut indent: Option<&str> = None;
// let mut state = StateKind::Start;
let mut state = vec![State::Start];
macro_rules! error { macro_rules! error {
($kind:expr) => {{ ($kind:expr) => {{
@ -743,27 +794,29 @@ fn tokenize(text: &str) -> Result<Vec<Token>, Error> {
loop { loop {
if column == 0 { if column == 0 {
if let Some(class) = match (indent, indentation(rest)) { if let Some(class) = match (state.last().unwrap(), indentation(rest)) {
// ignore: was no indentation and there still isn't // ignore: was no indentation and there still isn't
// or current line is blank // or current line is blank
(None, Some("")) | (_, None) => { (&State::Start, Some("")) | (_, None) => {
None None
} }
// indent: was no indentation, now there is // indent: was no indentation, now there is
(None, Some(current)) => { (&State::Start, Some(current)) => {
if mixed_whitespace(current) { if mixed_whitespace(current) {
return error!(ErrorKind::MixedLeadingWhitespace{whitespace: current}) return error!(ErrorKind::MixedLeadingWhitespace{whitespace: current})
} }
indent = Some(current); //indent = Some(current);
state.push(State::Indent(current));
Some(Indent) Some(Indent)
} }
// dedent: there was indentation and now there isn't // dedent: there was indentation and now there isn't
(Some(_), Some("")) => { (&State::Indent(_), Some("")) => {
indent = None; // indent = None;
state.pop();
Some(Dedent) Some(Dedent)
} }
// was indentation and still is, check if the new indentation matches // was indentation and still is, check if the new indentation matches
(Some(previous), Some(current)) => { (&State::Indent(previous), Some(current)) => {
if !current.starts_with(previous) { if !current.starts_with(previous) {
return error!(ErrorKind::InconsistentLeadingWhitespace{ return error!(ErrorKind::InconsistentLeadingWhitespace{
expected: previous, expected: previous,
@ -772,6 +825,12 @@ fn tokenize(text: &str) -> Result<Vec<Token>, Error> {
} }
None None
} }
// at column 0 in some other state: this should never happen
(&State::Text, _) | (&State::Interpolation, _) => {
return error!(ErrorKind::InternalError{
message: "unexpected state at column 0".to_string()
});
}
} { } {
tokens.push(Token { tokens.push(Token {
index: index, index: index,
@ -786,32 +845,67 @@ fn tokenize(text: &str) -> Result<Vec<Token>, Error> {
} }
// insert a dedent if we're indented and we hit the end of the file // insert a dedent if we're indented and we hit the end of the file
if indent.is_some() && EOF.is_match(rest) { if &State::Start != state.last().unwrap() {
tokens.push(Token { if EOF.is_match(rest) {
index: index, tokens.push(Token {
line: line, index: index,
column: column, line: line,
text: text, column: column,
prefix: "", text: text,
lexeme: "", prefix: "",
class: Dedent, lexeme: "",
}); class: Dedent,
});
}
} }
let (prefix, lexeme, class) = let (prefix, lexeme, class) =
if let (0, Some(indent), Some(captures)) = (column, indent, LINE.captures(rest)) { if let (0, &State::Indent(indent), Some(captures)) = (column, state.last().unwrap(), LINE.captures(rest)) {
let line = captures.at(0).unwrap(); let line = captures.at(0).unwrap();
if !line.starts_with(indent) { if !line.starts_with(indent) {
return error!(ErrorKind::InternalError{message: "unexpected indent".to_string()}); return error!(ErrorKind::InternalError{message: "unexpected indent".to_string()});
} }
let (prefix, lexeme) = line.split_at(indent.len()); //let (prefix, lexeme) = line.split_at(indent.len());
(prefix, lexeme, Line) state.push(State::Text);
//(prefix, lexeme, Line)
// state we can produce text, {{, or eol tokens
// will produce text, name, {{, tokens }}, until end of line
(&line[0..indent.len()], "", Line)
} else if let Some(captures) = EOF.captures(rest) {
(captures.at(1).unwrap(), captures.at(2).unwrap(), Eof)
} else if let &State::Text = state.last().unwrap() {
if let Some(captures) = INTERPOLATION_START.captures(rest) {
state.push(State::Interpolation);
("", captures.at(0).unwrap(), InterpolationStart)
} else if let Some(captures) = LEADING_TEXT.captures(rest) {
("", captures.at(1).unwrap(), Text)
} else if let Some(captures) = TEXT.captures(rest) {
("", captures.at(1).unwrap(), Text)
} else if let Some(captures) = EOL.captures(rest) {
state.pop();
(captures.at(1).unwrap(), captures.at(2).unwrap(), Eol)
} else {
return error!(ErrorKind::InternalError{
message: format!("Could not match token in text state: \"{}\"", rest)
});
}
} else if let Some(captures) = INTERPOLATION_END.captures(rest) {
if state.last().unwrap() != &State::Interpolation {
// improve error
panic!("interpolation end outside of interpolation state");
}
state.pop();
(captures.at(1).unwrap(), captures.at(2).unwrap(), InterpolationEnd)
} else if let Some(captures) = NAME.captures(rest) { } else if let Some(captures) = NAME.captures(rest) {
(captures.at(1).unwrap(), captures.at(2).unwrap(), Name) (captures.at(1).unwrap(), captures.at(2).unwrap(), Name)
} else if let Some(captures) = EOL.captures(rest) { } else if let Some(captures) = EOL.captures(rest) {
if state.last().unwrap() == &State::Interpolation {
panic!("interpolation must be closed at end of line");
}
(captures.at(1).unwrap(), captures.at(2).unwrap(), Eol) (captures.at(1).unwrap(), captures.at(2).unwrap(), Eol)
} else if let Some(captures) = EOF.captures(rest) {
(captures.at(1).unwrap(), captures.at(2).unwrap(), Eof)
} else if let Some(captures) = COLON.captures(rest) { } else if let Some(captures) = COLON.captures(rest) {
(captures.at(1).unwrap(), captures.at(2).unwrap(), Colon) (captures.at(1).unwrap(), captures.at(2).unwrap(), Colon)
} else if let Some(captures) = PLUS.captures(rest) { } else if let Some(captures) = PLUS.captures(rest) {
@ -840,6 +934,14 @@ fn tokenize(text: &str) -> Result<Vec<Token>, Error> {
class: class, class: class,
}); });
if len == 0 {
match tokens.last().unwrap().class {
Eof => {},
_ => return Err(tokens.last().unwrap().error(
ErrorKind::InternalError{message: format!("zero length token: {:?}", tokens.last().unwrap())})),
}
}
match tokens.last().unwrap().class { match tokens.last().unwrap().class {
Eol => { Eol => {
line += 1; line += 1;
@ -944,7 +1046,7 @@ impl<'a> Parser<'a> {
if let Some(token) = self.expect(Colon) { if let Some(token) = self.expect(Colon) {
// if we haven't accepted any arguments, an equals // if we haven't accepted any arguments, an equals
// would have been fine as part of an expression // would have been fine as part of an assignment
if arguments.is_empty() { if arguments.is_empty() {
return Err(self.unexpected_token(&token, &[Name, Colon, Equals])); return Err(self.unexpected_token(&token, &[Name, Colon, Equals]));
} else { } else {
@ -1004,17 +1106,21 @@ impl<'a> Parser<'a> {
let mut fragments = vec![]; let mut fragments = vec![];
let mut variables = BTreeSet::new(); let mut variables = BTreeSet::new();
let mut variable_tokens = vec![];
lazy_static! { lazy_static! {
static ref FRAGMENT: Regex = re(r"^(.*?)\{\{(.*?)\}\}" ); static ref FRAGMENT: Regex = re(r"^(.*?)\{\{(.*?)\}\}" );
static ref UNMATCHED: Regex = re(r"^.*?\{\{" ); static ref UNMATCHED: Regex = re(r"^.*?\{\{" );
static ref VARIABLE: Regex = re(r"^[ \t]*([a-z](-?[a-z0-9])*)[ \t]*$"); static ref VARIABLE: Regex = re(r"^([ \t]*)([a-z](-?[a-z0-9])*)[ \t]*$");
} }
for line in &line_tokens { for line in &line_tokens {
let mut line_fragments = vec![]; let mut line_fragments = vec![];
let mut rest = line.lexeme; let mut rest = line.lexeme;
let mut index = line.index;
let mut column = line.column;
while !rest.is_empty() { while !rest.is_empty() {
let advanced;
if let Some(captures) = FRAGMENT.captures(rest) { if let Some(captures) = FRAGMENT.captures(rest) {
let prefix = captures.at(1).unwrap(); let prefix = captures.at(1).unwrap();
if !prefix.is_empty() { if !prefix.is_empty() {
@ -1022,22 +1128,35 @@ impl<'a> Parser<'a> {
} }
let interior = captures.at(2).unwrap(); let interior = captures.at(2).unwrap();
if let Some(captures) = VARIABLE.captures(interior) { if let Some(captures) = VARIABLE.captures(interior) {
let name = captures.at(1).unwrap(); let prefix = captures.at(1).unwrap();
let name = captures.at(2).unwrap();
line_fragments.push(Fragment::Variable{name: name}); line_fragments.push(Fragment::Variable{name: name});
variables.insert(name); variables.insert(name);
variable_tokens.push(Token {
index: index + line.prefix.len(),
line: line.line,
column: column + line.prefix.len(),
text: line.text,
prefix: prefix,
lexeme: name,
class: Name,
});
} else { } else {
return Err(line.error(ErrorKind::BadInterpolationVariableName{ return Err(line.error(ErrorKind::BadInterpolationVariableName{
recipe: name, recipe: name,
text: interior, text: interior,
})); }));
} }
rest = &rest[captures.at(0).unwrap().len()..]; advanced = captures.at(0).unwrap().len();
} else if UNMATCHED.is_match(rest) { } else if UNMATCHED.is_match(rest) {
return Err(line.error(ErrorKind::UnmatchedInterpolationDelimiter{recipe: name})); return Err(line.error(ErrorKind::UnclosedInterpolationDelimiter));
} else { } else {
line_fragments.push(Fragment::Text{text: rest}); line_fragments.push(Fragment::Text{text: rest});
rest = ""; advanced = rest.len();
} };
index += advanced;
column += advanced;
rest = &rest[advanced..];
} }
fragments.push(line_fragments); fragments.push(line_fragments);
} }
@ -1051,6 +1170,7 @@ impl<'a> Parser<'a> {
argument_tokens: argument_tokens, argument_tokens: argument_tokens,
fragments: fragments, fragments: fragments,
variables: variables, variables: variables,
variable_tokens: variable_tokens,
lines: lines, lines: lines,
shebang: shebang, shebang: shebang,
}) })
@ -1059,7 +1179,7 @@ impl<'a> Parser<'a> {
fn expression(&mut self) -> Result<Expression<'a>, Error<'a>> { fn expression(&mut self) -> Result<Expression<'a>, Error<'a>> {
let first = self.tokens.next().unwrap(); let first = self.tokens.next().unwrap();
let lhs = match first.class { let lhs = match first.class {
Name => Expression::Variable{name: first.lexeme}, Name => Expression::Variable{name: first.lexeme, token: first},
StringToken => Expression::String{contents: &first.lexeme[1..2]}, StringToken => Expression::String{contents: &first.lexeme[1..2]},
_ => return Err(self.unexpected_token(&first, &[Name, StringToken])), _ => return Err(self.unexpected_token(&first, &[Name, StringToken])),
}; };
@ -1138,21 +1258,14 @@ impl<'a> Parser<'a> {
} }
} }
for variable in &recipe.variables { for variable in &recipe.variable_tokens {
if !(assignments.contains_key(variable) || recipe.arguments.contains(variable)) { let name = variable.lexeme;
panic!("we fucked"); if !(assignments.contains_key(&name) || recipe.arguments.contains(&name)) {
return Err(variable.error(ErrorKind::UnknownVariable{variable: name}));
} }
} }
} }
// variables have no associated tokens because fragment parsing
// is done in parsing
//
// options:
// . do it in parsing but generate tokens then
// . do it in lexing
// . generate error positions by hand
let values = try!(evaluate(&assignments, &assignment_tokens)); let values = try!(evaluate(&assignments, &assignment_tokens));
Ok(Justfile{ Ok(Justfile{

95
src/tests.rs
View File

@ -32,17 +32,20 @@ fn tokenize_error(text: &str, expected: Error) {
fn token_summary(tokens: &[Token]) -> String { fn token_summary(tokens: &[Token]) -> String {
tokens.iter().map(|t| { tokens.iter().map(|t| {
match t.class { match t.class {
super::TokenKind::Line{..} => "*", super::TokenKind::Line{..} => "*",
super::TokenKind::Name => "N", super::TokenKind::Name => "N",
super::TokenKind::Colon => ":", super::TokenKind::Colon => ":",
super::TokenKind::StringToken => "\"", super::TokenKind::StringToken => "\"",
super::TokenKind::Plus => "+", super::TokenKind::Plus => "+",
super::TokenKind::Equals => "=", super::TokenKind::Equals => "=",
super::TokenKind::Comment{..} => "#", super::TokenKind::Comment{..} => "#",
super::TokenKind::Indent{..} => ">", super::TokenKind::Indent{..} => ">",
super::TokenKind::Dedent => "<", super::TokenKind::Text => "_",
super::TokenKind::Eol => "$", super::TokenKind::InterpolationStart => "{",
super::TokenKind::Eof => ".", super::TokenKind::InterpolationEnd => "}",
super::TokenKind::Dedent => "<",
super::TokenKind::Eol => "$",
super::TokenKind::Eof => ".",
} }
}).collect::<Vec<_>>().join("") }).collect::<Vec<_>>().join("")
} }
@ -104,6 +107,7 @@ bob:
tokenize_success("a:=#", "N:=#.") tokenize_success("a:=#", "N:=#.")
} }
/*
#[test] #[test]
fn inconsistent_leading_whitespace() { fn inconsistent_leading_whitespace() {
let text = "a: let text = "a:
@ -134,6 +138,7 @@ fn inconsistent_leading_whitespace() {
kind: ErrorKind::InconsistentLeadingWhitespace{expected: "\t\t", found: "\t "}, kind: ErrorKind::InconsistentLeadingWhitespace{expected: "\t\t", found: "\t "},
}); });
} }
*/
#[test] #[test]
fn outer_shebang() { fn outer_shebang() {
@ -162,14 +167,18 @@ fn unknown_start_of_token() {
} }
#[test] #[test]
fn parse() { fn parse_empty() {
parse_summary(" parse_summary("
# hello # hello
", ""); ", "");
}
/*
#[test]
fn parse_complex() {
parse_summary(" parse_summary("
x: x:
y: y:
@ -195,7 +204,11 @@ hello a b c: x y z
x: x:
y: y:
z:"); z:");
}
*/
#[test]
fn parse_assignments() {
parse_summary( parse_summary(
r#"a = "0" r#"a = "0"
c = a + b + a + b c = a + b + a + b
@ -389,6 +402,7 @@ fn write_or() {
assert_eq!("1, 2, 3, or 4", super::Or(&[1,2,3,4]).to_string()); assert_eq!("1, 2, 3, or 4", super::Or(&[1,2,3,4]).to_string());
} }
/*
#[test] #[test]
fn run_shebang() { fn run_shebang() {
// this test exists to make sure that shebang recipes // this test exists to make sure that shebang recipes
@ -412,10 +426,12 @@ a:
assert_eq!(recipe, "a"); assert_eq!(recipe, "a");
assert_eq!(code, 200); assert_eq!(code, 200);
}, },
other @ _ => panic!("expected an code run error, but got: {}", other), other => panic!("expected an code run error, but got: {}", other),
} }
} }
*/
/*
#[test] #[test]
fn run_order() { fn run_order() {
let tmp = tempdir::TempDir::new("run_order").unwrap_or_else(|err| panic!("tmpdir: failed to create temporary directory: {}", err)); let tmp = tempdir::TempDir::new("run_order").unwrap_or_else(|err| panic!("tmpdir: failed to create temporary directory: {}", err));
@ -436,6 +452,7 @@ c: b
super::std::env::set_current_dir(path).expect("failed to set current directory"); super::std::env::set_current_dir(path).expect("failed to set current directory");
parse_success(text).run(&["a", "d"]).unwrap(); parse_success(text).run(&["a", "d"]).unwrap();
} }
*/
#[test] #[test]
fn unknown_recipes() { fn unknown_recipes() {
@ -445,6 +462,7 @@ fn unknown_recipes() {
} }
} }
/*
#[test] #[test]
fn code_error() { fn code_error() {
match parse_success("fail:\n @function x { return 100; }; x").run(&["fail"]).unwrap_err() { match parse_success("fail:\n @function x { return 100; }; x").run(&["fail"]).unwrap_err() {
@ -455,7 +473,9 @@ fn code_error() {
other @ _ => panic!("expected a code run error, but got: {}", other), other @ _ => panic!("expected a code run error, but got: {}", other),
} }
} }
*/
/*
#[test] #[test]
fn extra_whitespace() { fn extra_whitespace() {
// we might want to make extra leading whitespace a line continuation in the future, // we might want to make extra leading whitespace a line continuation in the future,
@ -473,6 +493,7 @@ fn extra_whitespace() {
// extra leading whitespace is okay in a shebang recipe // extra leading whitespace is okay in a shebang recipe
parse_success("a:\n #!\n print(1)"); parse_success("a:\n #!\n print(1)");
} }
*/
#[test] #[test]
fn bad_recipe_names() { fn bad_recipe_names() {
@ -504,6 +525,7 @@ fn bad_recipe_names() {
bad_name("a:\nZ:", "Z", 3, 1, 0); bad_name("a:\nZ:", "Z", 3, 1, 0);
} }
/*
#[test] #[test]
fn bad_interpolation_variable_name() { fn bad_interpolation_variable_name() {
let text = "a:\n echo {{hello--hello}}"; let text = "a:\n echo {{hello--hello}}";
@ -516,9 +538,11 @@ fn bad_interpolation_variable_name() {
kind: ErrorKind::BadInterpolationVariableName{recipe: "a", text: "hello--hello"} kind: ErrorKind::BadInterpolationVariableName{recipe: "a", text: "hello--hello"}
}); });
} }
*/
/*
#[test] #[test]
fn unmatched_interpolation_delimiter() { fn unclosed_interpolation_delimiter() {
let text = "a:\n echo {{"; let text = "a:\n echo {{";
parse_error(text, Error { parse_error(text, Error {
text: text, text: text,
@ -526,6 +550,47 @@ fn unmatched_interpolation_delimiter() {
line: 1, line: 1,
column: 1, column: 1,
width: Some(7), width: Some(7),
kind: ErrorKind::UnmatchedInterpolationDelimiter{recipe: "a"} kind: ErrorKind::UnclosedInterpolationDelimiter,
}); });
} }
*/
#[test]
fn unknown_expression_variable() {
let text = "x = yy";
parse_error(text, Error {
text: text,
index: 4,
line: 0,
column: 4,
width: Some(2),
kind: ErrorKind::UnknownVariable{variable: "yy"},
});
}
#[test]
fn unknown_interpolation_variable() {
/*
let text = "x:\n {{ hello}}";
parse_error(text, Error {
text: text,
index: 9,
line: 1,
column: 6,
width: Some(5),
kind: ErrorKind::UnknownVariable{variable: "hello"},
});
*/
/*
let text = "x:\n echo\n {{ lol }}";
parse_error(text, Error {
text: text,
index: 11,
line: 2,
column: 2,
width: Some(3),
kind: ErrorKind::UnknownVariable{variable: "lol"},
});
*/
}